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
|
2005-06-21 22:45:44 +02:00
|
|
|
* $PostgreSQL: pgsql/src/bin/pg_dump/pg_backup_db.c,v 1.62 2005/06/21 20:45:44 tgl 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.h"
|
|
|
|
#include "pg_backup_archiver.h"
|
|
|
|
#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>
|
2000-07-21 13:43:26 +02:00
|
|
|
#include <ctype.h>
|
|
|
|
|
|
|
|
#ifdef HAVE_TERMIOS_H
|
|
|
|
#include <termios.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "libpq-fe.h"
|
2001-02-10 03:31:31 +01:00
|
|
|
#include "libpq/libpq-fs.h"
|
2000-07-21 13:43:26 +02:00
|
|
|
#ifndef HAVE_STRDUP
|
|
|
|
#include "strdup.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
|
|
|
|
2001-03-22 05:01:46 +01:00
|
|
|
static void _check_database_version(ArchiveHandle *AH, bool ignoreVersion);
|
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
|
|
|
|
2004-08-29 07:07:03 +02:00
|
|
|
static int _isIdentChar(unsigned char c);
|
|
|
|
static int _isDQChar(unsigned char c, int 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
|
|
|
|
_check_database_version(ArchiveHandle *AH, bool ignoreVersion)
|
|
|
|
{
|
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;
|
|
|
|
|
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);
|
2000-07-21 13:43:26 +02:00
|
|
|
if (ignoreVersion)
|
2001-06-27 23:21:37 +02:00
|
|
|
write_msg(NULL, "proceeding despite version mismatch\n");
|
2000-07-21 13:43:26 +02:00
|
|
|
else
|
2001-06-27 23:21:37 +02:00
|
|
|
die_horribly(AH, NULL, "aborting because of version mismatch (Use the -i option to proceed anyway.)\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.
|
|
|
|
*/
|
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
|
|
|
{
|
|
|
|
int need_pass;
|
2001-03-22 05:01:46 +01:00
|
|
|
PGconn *newConn;
|
2001-05-17 23:12:49 +02:00
|
|
|
char *password = NULL;
|
2000-07-24 08:24:26 +02:00
|
|
|
int badPwd = 0;
|
|
|
|
int noPwd = 0;
|
2001-03-22 05:01:46 +01:00
|
|
|
char *newdb;
|
|
|
|
char *newuser;
|
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
|
2001-03-22 05:01:46 +01:00
|
|
|
newdb = (char *) reqdb;
|
2000-08-01 17:51:45 +02:00
|
|
|
|
|
|
|
if (!requser || (strlen(requser) == 0))
|
|
|
|
newuser = PQuser(AH->connection);
|
|
|
|
else
|
2001-03-22 05:01:46 +01:00
|
|
|
newuser = (char *) requser;
|
2000-08-01 17:51:45 +02:00
|
|
|
|
2003-07-23 10:47:41 +02:00
|
|
|
ahlog(AH, 1, "connecting to database \"%s\" as user \"%s\"\n", newdb, newuser);
|
2000-07-24 08:24:26 +02:00
|
|
|
|
2001-05-17 23:12:49 +02:00
|
|
|
if (AH->requirePassword)
|
|
|
|
{
|
|
|
|
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
|
|
|
|
{
|
2000-08-01 17:51:45 +02:00
|
|
|
need_pass = false;
|
|
|
|
newConn = PQsetdbLogin(PQhost(AH->connection), PQport(AH->connection),
|
2001-03-22 05:01:46 +01:00
|
|
|
NULL, NULL, newdb,
|
2001-05-17 23:12:49 +02:00
|
|
|
newuser, password);
|
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)
|
|
|
|
{
|
2001-05-17 23:12:49 +02:00
|
|
|
noPwd = (strcmp(PQerrorMessage(newConn),
|
2004-10-16 05:10:17 +02:00
|
|
|
PQnoPasswordSupplied) == 0);
|
2001-05-17 23:12:49 +02:00
|
|
|
badPwd = (strncmp(PQerrorMessage(newConn),
|
2001-10-25 07:50:21 +02:00
|
|
|
"Password authentication failed for user", 39) == 0);
|
2000-08-01 17:51:45 +02:00
|
|
|
|
2001-03-22 05:01:46 +01:00
|
|
|
if (noPwd || badPwd)
|
2000-08-01 17:51:45 +02:00
|
|
|
{
|
|
|
|
if (badPwd)
|
|
|
|
fprintf(stderr, "Password incorrect\n");
|
2000-07-24 08:24:26 +02:00
|
|
|
|
2001-05-17 23:12:49 +02:00
|
|
|
fprintf(stderr, "Connecting to %s as %s\n",
|
2004-10-01 19:25:55 +02:00
|
|
|
newdb, newuser);
|
2000-07-24 08:24:26 +02:00
|
|
|
|
2000-08-01 17:51:45 +02:00
|
|
|
need_pass = true;
|
2001-05-17 23:12:49 +02:00
|
|
|
if (password)
|
|
|
|
free(password);
|
|
|
|
password = simple_prompt("Password: ", 100, false);
|
2000-07-24 08:24:26 +02:00
|
|
|
}
|
2000-08-01 17:51:45 +02:00
|
|
|
else
|
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);
|
2000-08-01 17:51:45 +02:00
|
|
|
}
|
2000-07-24 08:24:26 +02:00
|
|
|
} while (need_pass);
|
|
|
|
|
2001-05-17 23:12:49 +02:00
|
|
|
if (password)
|
|
|
|
free(password);
|
|
|
|
|
2003-02-14 20:40:42 +01:00
|
|
|
/* check for version mismatch */
|
|
|
|
_check_database_version(AH, true);
|
|
|
|
|
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.
|
|
|
|
*/
|
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,
|
2001-03-22 05:01:46 +01:00
|
|
|
const int reqPwd,
|
|
|
|
const int ignoreVersion)
|
2000-07-21 13:43:26 +02:00
|
|
|
{
|
2001-03-22 05:01:46 +01:00
|
|
|
ArchiveHandle *AH = (ArchiveHandle *) AHX;
|
2001-05-17 23:12:49 +02:00
|
|
|
char *password = NULL;
|
|
|
|
bool need_pass = false;
|
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
|
|
|
|
|
|
|
if (reqPwd)
|
|
|
|
{
|
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
|
|
|
AH->requirePassword = true;
|
2000-07-21 13:43:26 +02:00
|
|
|
}
|
2001-05-17 23:12:49 +02:00
|
|
|
else
|
|
|
|
AH->requirePassword = false;
|
|
|
|
|
|
|
|
/*
|
2001-10-25 07:50:21 +02:00
|
|
|
* Start the connection. Loop until we have a password if requested
|
|
|
|
* by backend.
|
2001-05-17 23:12:49 +02:00
|
|
|
*/
|
|
|
|
do
|
|
|
|
{
|
|
|
|
need_pass = false;
|
2002-08-10 18:57:32 +02:00
|
|
|
AH->connection = PQsetdbLogin(pghost, pgport, NULL, NULL,
|
|
|
|
dbname, username, password);
|
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 &&
|
2004-10-16 05:10:17 +02:00
|
|
|
strcmp(PQerrorMessage(AH->connection), PQnoPasswordSupplied) == 0 &&
|
2001-05-17 23:12:49 +02:00
|
|
|
!feof(stdin))
|
|
|
|
{
|
|
|
|
PQfinish(AH->connection);
|
|
|
|
need_pass = true;
|
|
|
|
free(password);
|
|
|
|
password = NULL;
|
|
|
|
password = simple_prompt("Password: ", 100, false);
|
|
|
|
}
|
|
|
|
} while (need_pass);
|
|
|
|
|
|
|
|
if (password)
|
|
|
|
free(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",
|
2004-10-01 19:25:55 +02:00
|
|
|
dbname, PQerrorMessage(AH->connection));
|
2000-07-21 13:43:26 +02:00
|
|
|
|
|
|
|
/* check for version mismatch */
|
|
|
|
_check_database_version(AH, ignoreVersion);
|
|
|
|
|
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 */
|
2001-03-22 05:01:46 +01:00
|
|
|
int
|
2005-06-21 22:45:44 +02:00
|
|
|
ExecuteSqlCommand(ArchiveHandle *AH, PQExpBuffer qry, 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
|
|
|
|
|
|
|
/* fprintf(stderr, "Executing: '%s'\n\n", qry->data); */
|
2000-08-01 17:51:45 +02:00
|
|
|
res = PQexec(conn, qry->data);
|
2000-07-21 13:43:26 +02:00
|
|
|
if (!res)
|
2001-07-03 22:21:50 +02:00
|
|
|
die_horribly(AH, modulename, "%s: no result from server\n", desc);
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2001-03-22 05:01:46 +01:00
|
|
|
if (PQresultStatus(res) != PGRES_COMMAND_OK && PQresultStatus(res) != PGRES_TUPLES_OK)
|
2000-07-21 13:43:26 +02:00
|
|
|
{
|
|
|
|
if (PQresultStatus(res) == PGRES_COPY_IN)
|
2000-08-01 17:51:45 +02:00
|
|
|
{
|
2000-07-21 13:43:26 +02:00
|
|
|
AH->pgCopyIn = 1;
|
2000-08-01 17:51:45 +02:00
|
|
|
}
|
2001-03-22 05:01:46 +01:00
|
|
|
else
|
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
|
|
|
{
|
|
|
|
strncpy(errStmt, qry->data, 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",
|
2004-08-29 07:07:03 +02:00
|
|
|
desc, PQerrorMessage(AH->connection),
|
|
|
|
errStmt);
|
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
|
|
|
}
|
2000-07-21 13:43:26 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
PQclear(res);
|
|
|
|
|
|
|
|
return strlen(qry->data);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
/*
|
|
|
|
* fprintf(stderr, "Found cr at %d, prev char was %c, next was
|
|
|
|
* %c\n", loc, qry[loc-1], qry[loc+1]);
|
|
|
|
*/
|
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
|
|
|
/*
|
2002-01-18 20:17:05 +01: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
|
|
|
|
2002-01-18 18:13:51 +01:00
|
|
|
/*---------
|
|
|
|
* fprintf(stderr, "Sending '%s' via
|
|
|
|
* COPY (at end = %d)\n\n", AH->pgCopyBuf->data, isEnd);
|
|
|
|
*---------
|
|
|
|
*/
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2002-01-18 18:13:51 +01:00
|
|
|
if (PQputline(AH->connection, AH->pgCopyBuf->data) != 0)
|
|
|
|
die_horribly(AH, modulename, "error returned by PQputline\n");
|
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
|
|
|
|
2002-01-18 18:13:51 +01:00
|
|
|
/*
|
2002-01-18 20:17:05 +01:00
|
|
|
* fprintf(stderr, "Buffer is '%s'\n", AH->pgCopyBuf->data);
|
2002-01-18 18:13:51 +01:00
|
|
|
*/
|
2001-01-12 05:32:07 +01:00
|
|
|
|
2002-01-18 18:13:51 +01:00
|
|
|
if (isEnd)
|
|
|
|
{
|
|
|
|
if (PQendcopy(AH->connection) != 0)
|
|
|
|
die_horribly(AH, modulename, "error returned by PQendcopy\n");
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2002-01-18 18:13:51 +01:00
|
|
|
AH->pgCopyIn = 0;
|
|
|
|
}
|
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
|
|
|
/*
|
2002-01-18 18:13:51 +01:00
|
|
|
* Used by ExecuteSqlCommandBuf to send one buffered line of SQL (not data for the copy command).
|
|
|
|
*/
|
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
|
|
|
int pos = 0; /* Current position */
|
2004-08-29 07:07:03 +02:00
|
|
|
char *sqlPtr;
|
|
|
|
int consumed;
|
2004-08-20 18:07:15 +02:00
|
|
|
int startDT = 0;
|
2000-07-21 13:43:26 +02:00
|
|
|
|
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
|
|
|
|
* 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,
|
|
|
|
* un commented semi-colon.
|
2002-01-18 18:13:51 +01:00
|
|
|
*/
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2002-01-18 18:13:51 +01:00
|
|
|
/*
|
2002-01-18 20:17:05 +01:00
|
|
|
* fprintf(stderr, "Buffer at start is: '%s'\n\n", AH->sqlBuf->data);
|
2002-01-18 18:13:51 +01:00
|
|
|
*/
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2002-01-18 18:13:51 +01:00
|
|
|
for (pos = 0; pos < (eos - qry); pos++)
|
|
|
|
{
|
|
|
|
appendPQExpBufferChar(AH->sqlBuf, qry[pos]);
|
|
|
|
/* fprintf(stderr, " %c",qry[pos]); */
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2004-08-20 18:07:15 +02:00
|
|
|
/* Loop until character consumed */
|
|
|
|
do
|
2002-01-18 18:13:51 +01:00
|
|
|
{
|
2004-08-29 07:07:03 +02:00
|
|
|
/*
|
|
|
|
* If a character needs to be scanned in a different state,
|
|
|
|
* consumed can be set to 0 to avoid advancing. Care must be
|
|
|
|
* taken to ensure internal state is not damaged.
|
2004-08-20 18:07:15 +02:00
|
|
|
*/
|
|
|
|
consumed = 1;
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2004-08-20 18:07:15 +02:00
|
|
|
switch (AH->sqlparse.state)
|
2004-08-29 07:07:03 +02:00
|
|
|
{
|
|
|
|
|
|
|
|
case SQL_SCAN: /* Default state == 0, set in _allocAH */
|
2004-08-20 18:07:15 +02:00
|
|
|
if (qry[pos] == ';' && AH->sqlparse.braceDepth == 0)
|
|
|
|
{
|
2004-08-29 07:07:03 +02:00
|
|
|
/*
|
|
|
|
* We've got the end of a statement. Send It &
|
|
|
|
* reset the buffer.
|
2004-08-20 18:07:15 +02:00
|
|
|
*/
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-08-20 18:07:15 +02:00
|
|
|
/*
|
|
|
|
* fprintf(stderr, " sending: '%s'\n\n",
|
|
|
|
* AH->sqlBuf->data);
|
|
|
|
*/
|
2005-06-21 22:45:44 +02:00
|
|
|
ExecuteSqlCommand(AH, AH->sqlBuf, "could not execute query");
|
2004-08-20 18:07:15 +02:00
|
|
|
resetPQExpBuffer(AH->sqlBuf);
|
|
|
|
AH->sqlparse.lastChar = '\0';
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-08-20 18:07:15 +02:00
|
|
|
/*
|
2004-08-29 07:07:03 +02:00
|
|
|
* Remove any following newlines - so that
|
|
|
|
* embedded COPY commands don't get a starting
|
|
|
|
* newline.
|
2004-08-20 18:07:15 +02:00
|
|
|
*/
|
|
|
|
pos++;
|
|
|
|
for (; pos < (eos - qry) && qry[pos] == '\n'; pos++);
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-08-20 18:07:15 +02:00
|
|
|
/* We've got our line, so exit */
|
|
|
|
return qry + pos;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2004-08-29 07:07:03 +02:00
|
|
|
/*
|
|
|
|
* Look for normal boring quote chars, or
|
|
|
|
* dollar-quotes. We make the assumption that
|
|
|
|
* $-quotes will not have an ident character
|
2004-08-20 18:07:15 +02:00
|
|
|
* before them in all pg_dump output.
|
|
|
|
*/
|
2004-08-29 07:07:03 +02:00
|
|
|
if (qry[pos] == '"'
|
|
|
|
|| qry[pos] == '\''
|
|
|
|
|| (qry[pos] == '$' && _isIdentChar(AH->sqlparse.lastChar) == 0)
|
|
|
|
)
|
2004-08-20 18:07:15 +02:00
|
|
|
{
|
|
|
|
/* fprintf(stderr,"[startquote]\n"); */
|
|
|
|
AH->sqlparse.state = SQL_IN_QUOTE;
|
|
|
|
AH->sqlparse.quoteChar = qry[pos];
|
|
|
|
AH->sqlparse.backSlash = 0;
|
|
|
|
if (qry[pos] == '$')
|
|
|
|
{
|
|
|
|
/* override the state */
|
|
|
|
AH->sqlparse.state = SQL_IN_DOLLARTAG;
|
|
|
|
/* Used for checking first char of tag */
|
|
|
|
startDT = 1;
|
|
|
|
/* We store the tag for later comparison. */
|
|
|
|
AH->sqlparse.tagBuf = createPQExpBuffer();
|
|
|
|
/* Get leading $ */
|
|
|
|
appendPQExpBufferChar(AH->sqlparse.tagBuf, qry[pos]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (qry[pos] == '-' && AH->sqlparse.lastChar == '-')
|
|
|
|
AH->sqlparse.state = SQL_IN_SQL_COMMENT;
|
|
|
|
else if (qry[pos] == '*' && AH->sqlparse.lastChar == '/')
|
|
|
|
AH->sqlparse.state = SQL_IN_EXT_COMMENT;
|
|
|
|
else if (qry[pos] == '(')
|
|
|
|
AH->sqlparse.braceDepth++;
|
|
|
|
else if (qry[pos] == ')')
|
|
|
|
AH->sqlparse.braceDepth--;
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-08-20 18:07:15 +02:00
|
|
|
AH->sqlparse.lastChar = qry[pos];
|
|
|
|
}
|
|
|
|
break;
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-08-20 18:07:15 +02:00
|
|
|
case SQL_IN_DOLLARTAG:
|
2004-08-29 07:07:03 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Like a quote, we look for a closing char *but* we
|
|
|
|
* only allow a very limited set of contained chars,
|
|
|
|
* and no escape chars. If invalid chars are found, we
|
|
|
|
* abort tag processing.
|
2002-01-18 18:13:51 +01:00
|
|
|
*/
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-08-20 18:07:15 +02:00
|
|
|
if (qry[pos] == '$')
|
|
|
|
{
|
|
|
|
/* fprintf(stderr,"[endquote]\n"); */
|
|
|
|
/* Get trailing $ */
|
|
|
|
appendPQExpBufferChar(AH->sqlparse.tagBuf, qry[pos]);
|
|
|
|
AH->sqlparse.state = SQL_IN_DOLLARQUOTE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2004-08-29 07:07:03 +02:00
|
|
|
if (_isDQChar(qry[pos], startDT))
|
2004-08-20 18:07:15 +02:00
|
|
|
{
|
|
|
|
/* Valid, so add */
|
|
|
|
appendPQExpBufferChar(AH->sqlparse.tagBuf, qry[pos]);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2004-08-29 07:07:03 +02:00
|
|
|
/*
|
|
|
|
* Jump back to 'scan' state, we're not really
|
|
|
|
* in a tag, and valid tag 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 set
|
|
|
|
* consumed = 0 so that this char gets
|
|
|
|
* rescanned in new state.
|
2004-08-20 18:07:15 +02:00
|
|
|
*/
|
|
|
|
destroyPQExpBuffer(AH->sqlparse.tagBuf);
|
|
|
|
AH->sqlparse.state = SQL_SCAN;
|
|
|
|
consumed = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
startDT = 0;
|
|
|
|
break;
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2002-01-18 18:13:51 +01:00
|
|
|
|
2004-08-20 18:07:15 +02:00
|
|
|
case SQL_IN_DOLLARQUOTE:
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2002-01-18 20:17:05 +01:00
|
|
|
/*
|
2004-08-29 07:07:03 +02:00
|
|
|
* Comparing the entire string backwards each time is
|
|
|
|
* NOT efficient, but dollar quotes in pg_dump are
|
|
|
|
* small and the code is a lot simpler.
|
2002-01-18 18:13:51 +01:00
|
|
|
*/
|
2004-08-20 18:07:15 +02:00
|
|
|
sqlPtr = AH->sqlBuf->data + AH->sqlBuf->len - AH->sqlparse.tagBuf->len;
|
2004-08-29 07:07:03 +02:00
|
|
|
|
|
|
|
if (strncmp(AH->sqlparse.tagBuf->data, sqlPtr, AH->sqlparse.tagBuf->len) == 0)
|
|
|
|
{
|
2004-08-20 18:07:15 +02:00
|
|
|
/* End of $-quote */
|
|
|
|
AH->sqlparse.state = SQL_SCAN;
|
|
|
|
destroyPQExpBuffer(AH->sqlparse.tagBuf);
|
|
|
|
}
|
|
|
|
break;
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-08-20 18:07:15 +02:00
|
|
|
case SQL_IN_SQL_COMMENT:
|
|
|
|
if (qry[pos] == '\n')
|
|
|
|
AH->sqlparse.state = SQL_SCAN;
|
|
|
|
break;
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-08-20 18:07:15 +02:00
|
|
|
case SQL_IN_EXT_COMMENT:
|
|
|
|
if (AH->sqlparse.lastChar == '*' && qry[pos] == '/')
|
|
|
|
AH->sqlparse.state = SQL_SCAN;
|
|
|
|
break;
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-08-20 18:07:15 +02:00
|
|
|
case SQL_IN_QUOTE:
|
|
|
|
|
|
|
|
if (!AH->sqlparse.backSlash && AH->sqlparse.quoteChar == qry[pos])
|
2000-07-21 13:43:26 +02:00
|
|
|
{
|
2004-08-20 18:07:15 +02:00
|
|
|
/* fprintf(stderr,"[endquote]\n"); */
|
|
|
|
AH->sqlparse.state = SQL_SCAN;
|
2000-07-21 13:43:26 +02:00
|
|
|
}
|
2004-08-20 18:07:15 +02:00
|
|
|
else
|
2002-01-18 18:13:51 +01:00
|
|
|
{
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-08-20 18:07:15 +02:00
|
|
|
if (qry[pos] == '\\')
|
|
|
|
{
|
|
|
|
if (AH->sqlparse.lastChar == '\\')
|
|
|
|
AH->sqlparse.backSlash = !AH->sqlparse.backSlash;
|
|
|
|
else
|
|
|
|
AH->sqlparse.backSlash = 1;
|
|
|
|
}
|
2001-03-22 05:01:46 +01:00
|
|
|
else
|
2004-08-20 18:07:15 +02:00
|
|
|
AH->sqlparse.backSlash = 0;
|
2000-07-21 13:43:26 +02:00
|
|
|
}
|
2004-08-20 18:07:15 +02:00
|
|
|
break;
|
2004-08-29 07:07:03 +02:00
|
|
|
|
2004-08-20 18:07:15 +02:00
|
|
|
}
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2004-08-20 18:07:15 +02:00
|
|
|
} while (consumed == 0);
|
|
|
|
|
2004-08-29 07:07:03 +02:00
|
|
|
AH->sqlparse.lastChar = qry[pos];
|
|
|
|
/* fprintf(stderr, "\n"); */
|
2002-01-18 18:13:51 +01:00
|
|
|
}
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2002-01-18 20:17:05 +01:00
|
|
|
/*
|
|
|
|
* If we get here, we've processed entire string with no complete SQL
|
|
|
|
* 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;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* fprintf(stderr, "\n\n*****\n
|
|
|
|
* Buffer:\n\n%s\n*******************\n\n", qry);
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Could switch between command and COPY IN mode at each line */
|
|
|
|
while (qry < eos)
|
|
|
|
{
|
2002-01-18 20:17:05 +01:00
|
|
|
if (AH->pgCopyIn)
|
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
|
|
|
{
|
2001-03-22 05:01:46 +01:00
|
|
|
PQExpBuffer qry = createPQExpBuffer();
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2004-03-03 22:28:55 +01:00
|
|
|
appendPQExpBuffer(qry, "BEGIN");
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2005-06-21 22:45:44 +02:00
|
|
|
ExecuteSqlCommand(AH, qry, "could not start database transaction");
|
2001-08-03 21:43:05 +02:00
|
|
|
|
|
|
|
destroyPQExpBuffer(qry);
|
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
|
|
|
{
|
2001-03-22 05:01:46 +01:00
|
|
|
PQExpBuffer qry = createPQExpBuffer();
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2004-03-03 22:28:55 +01:00
|
|
|
appendPQExpBuffer(qry, "COMMIT");
|
2000-07-21 13:43:26 +02:00
|
|
|
|
2005-06-21 22:45:44 +02:00
|
|
|
ExecuteSqlCommand(AH, qry, "could not commit database transaction");
|
2001-08-03 21:43:05 +02:00
|
|
|
|
|
|
|
destroyPQExpBuffer(qry);
|
2000-10-31 15:20:30 +01:00
|
|
|
}
|
2004-08-20 18:07:15 +02:00
|
|
|
|
2004-08-29 07:07:03 +02:00
|
|
|
static int
|
|
|
|
_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 == '$')
|
|
|
|
|| (c >= (unsigned char) '\200') /* no need to check <=
|
|
|
|
* \377 */
|
|
|
|
)
|
2004-08-20 18:07:15 +02:00
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-08-29 07:07:03 +02:00
|
|
|
static int
|
|
|
|
_isDQChar(unsigned char c, int 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 == '_')
|
|
|
|
|| (atStart == 0 && c >= '0' && c <= '9')
|
|
|
|
|| (c >= (unsigned char) '\200') /* no need to check <=
|
|
|
|
* \377 */
|
|
|
|
)
|
2004-08-20 18:07:15 +02:00
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|