2000-01-19 00:30:24 +01:00
|
|
|
/*
|
|
|
|
* psql - the PostgreSQL interactive terminal
|
|
|
|
*
|
2000-01-29 17:58:54 +01:00
|
|
|
* Copyright 2000 by PostgreSQL Global Development Group
|
2000-01-19 00:30:24 +01:00
|
|
|
*
|
2003-06-12 09:52:51 +02:00
|
|
|
* $Header: /cvsroot/pgsql/src/bin/psql/common.c,v 1.63 2003/06/12 07:52:51 momjian Exp $
|
2000-01-19 00:30:24 +01:00
|
|
|
*/
|
2001-02-10 03:31:31 +01:00
|
|
|
#include "postgres_fe.h"
|
1999-11-04 22:56:02 +01:00
|
|
|
#include "common.h"
|
|
|
|
|
2000-01-14 23:18:03 +01:00
|
|
|
#include <errno.h>
|
2000-01-19 00:30:24 +01:00
|
|
|
#include <stdarg.h>
|
1999-11-04 22:56:02 +01:00
|
|
|
#ifndef HAVE_STRDUP
|
|
|
|
#include <strdup.h>
|
|
|
|
#endif
|
|
|
|
#include <signal.h>
|
|
|
|
#ifndef WIN32
|
2002-10-03 19:09:42 +02:00
|
|
|
#include <sys/time.h>
|
1999-11-05 00:14:30 +01:00
|
|
|
#include <unistd.h> /* for write() */
|
2000-02-20 15:28:28 +01:00
|
|
|
#include <setjmp.h>
|
* Includes tab completion. It's not magic, but it's very cool. At any
rate
it's better than what used to be there.
* Does proper SQL "host variable" substitution as pointed out by Andreas
Zeugwetter (thanks): select * from :foo; Also some changes in how ':'
and ';' are treated (escape with \ to send to backend). This does
_not_
affect the '::' cast operator, but perhaps others that contain : or ;
(but there are none right now).
* To show description with a <something> listing, append '?' to command
name, e.g., \df?. This seemed to be the convenient and logical
solution.
Or append a '+' to see more useless information, e.g., \df+.
* Fixed fflush()'ing bug pointed out by Jan during the regression test
discussion.
* Added LastOid variable. This ought to take care of TODO item "Add a
function to return the last inserted oid, for use in psql scripts"
(under CLIENTS)
E.g.,
insert into foo values(...);
insert into bar values(..., :LastOid);
\echo $LastOid
* \d command shows constraints, rules, and triggers defined on the table
(in addition to indices)
* Various fixes, optimizations, corrections
* Documentation update as well
Note: This now requires snprintf(), which, if necessary, is taken from
src/backend/port. This is certainly a little weird, but it should
suffice
until a source tree cleanup is done.
Enjoy.
--
Peter Eisentraut Sernanders väg 10:115
1999-11-26 05:24:17 +01:00
|
|
|
#else
|
2000-04-12 19:17:23 +02:00
|
|
|
#include <io.h> /* for _write() */
|
2000-02-08 00:10:11 +01:00
|
|
|
#include <win32.h>
|
2002-10-03 19:09:42 +02:00
|
|
|
#include <sys/timeb.h> /* for _ftime() */
|
1999-11-04 22:56:02 +01:00
|
|
|
#endif
|
|
|
|
|
2000-02-16 14:15:26 +01:00
|
|
|
#include "libpq-fe.h"
|
|
|
|
#include "pqsignal.h"
|
1999-11-04 22:56:02 +01:00
|
|
|
|
|
|
|
#include "settings.h"
|
|
|
|
#include "variables.h"
|
|
|
|
#include "copy.h"
|
|
|
|
#include "prompt.h"
|
|
|
|
#include "print.h"
|
2000-02-20 15:28:28 +01:00
|
|
|
#include "mainloop.h"
|
1999-11-04 22:56:02 +01:00
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
|
|
|
|
/* Workarounds for Windows */
|
|
|
|
/* Probably to be moved up the source tree in the future, perhaps to be replaced by
|
|
|
|
* more specific checks like configure-style HAVE_GETTIMEOFDAY macros.
|
|
|
|
*/
|
|
|
|
#ifndef WIN32
|
|
|
|
|
|
|
|
typedef struct timeval TimevalStruct;
|
|
|
|
#define GETTIMEOFDAY(T) gettimeofday(T, NULL)
|
|
|
|
#define DIFF_MSEC(T, U) ((((T)->tv_sec - (U)->tv_sec) * 1000000.0 + (T)->tv_usec - (U)->tv_usec) / 1000.0)
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
typedef struct _timeb TimevalStruct;
|
|
|
|
#define GETTIMEOFDAY(T) _ftime(&T)
|
|
|
|
#define DIFF_MSEC(T, U) ((((T)->time - (U)->time) * 1000.0 + (T)->millitm - (U)->millitm))
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2002-07-06 22:12:30 +02:00
|
|
|
extern bool prompt_state;
|
1999-11-04 22:56:02 +01:00
|
|
|
|
2000-02-08 00:10:11 +01:00
|
|
|
/*
|
1999-11-04 22:56:02 +01:00
|
|
|
* "Safe" wrapper around strdup()
|
|
|
|
*/
|
1999-11-05 00:14:30 +01:00
|
|
|
char *
|
|
|
|
xstrdup(const char *string)
|
1999-11-04 22:56:02 +01:00
|
|
|
{
|
1999-11-05 00:14:30 +01:00
|
|
|
char *tmp;
|
|
|
|
|
|
|
|
if (!string)
|
|
|
|
{
|
2001-06-02 20:25:18 +02:00
|
|
|
fprintf(stderr, gettext("%s: xstrdup: cannot duplicate null pointer (internal error)\n"),
|
2000-04-12 19:17:23 +02:00
|
|
|
pset.progname);
|
1999-11-05 00:14:30 +01:00
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
tmp = strdup(string);
|
|
|
|
if (!tmp)
|
|
|
|
{
|
2000-04-12 19:17:23 +02:00
|
|
|
psql_error("out of memory\n");
|
1999-11-05 00:14:30 +01:00
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
return tmp;
|
1999-11-04 22:56:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* setQFout
|
|
|
|
* -- handler for -o command line option and \o command
|
|
|
|
*
|
|
|
|
* Tries to open file fname (or pipe if fname starts with '|')
|
|
|
|
* and stores the file handle in pset)
|
|
|
|
* Upon failure, sets stdout and returns false.
|
|
|
|
*/
|
|
|
|
bool
|
2000-01-14 23:18:03 +01:00
|
|
|
setQFout(const char *fname)
|
1999-11-04 22:56:02 +01:00
|
|
|
{
|
1999-11-05 00:14:30 +01:00
|
|
|
bool status = true;
|
1999-11-04 22:56:02 +01:00
|
|
|
|
1999-11-05 00:14:30 +01:00
|
|
|
/* Close old file/pipe */
|
2000-01-14 23:18:03 +01:00
|
|
|
if (pset.queryFout && pset.queryFout != stdout && pset.queryFout != stderr)
|
1999-11-05 00:14:30 +01:00
|
|
|
{
|
2000-01-14 23:18:03 +01:00
|
|
|
if (pset.queryFoutPipe)
|
|
|
|
pclose(pset.queryFout);
|
1999-11-05 00:14:30 +01:00
|
|
|
else
|
2000-01-14 23:18:03 +01:00
|
|
|
fclose(pset.queryFout);
|
1999-11-05 00:14:30 +01:00
|
|
|
}
|
1999-11-04 22:56:02 +01:00
|
|
|
|
1999-11-05 00:14:30 +01:00
|
|
|
/* If no filename, set stdout */
|
|
|
|
if (!fname || fname[0] == '\0')
|
|
|
|
{
|
2000-01-14 23:18:03 +01:00
|
|
|
pset.queryFout = stdout;
|
|
|
|
pset.queryFoutPipe = false;
|
1999-11-05 00:14:30 +01:00
|
|
|
}
|
|
|
|
else if (*fname == '|')
|
|
|
|
{
|
2000-01-14 23:18:03 +01:00
|
|
|
pset.queryFout = popen(fname + 1, "w");
|
|
|
|
pset.queryFoutPipe = true;
|
1999-11-05 00:14:30 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2000-01-14 23:18:03 +01:00
|
|
|
pset.queryFout = fopen(fname, "w");
|
|
|
|
pset.queryFoutPipe = false;
|
1999-11-05 00:14:30 +01:00
|
|
|
}
|
|
|
|
|
2000-01-14 23:18:03 +01:00
|
|
|
if (!(pset.queryFout))
|
1999-11-05 00:14:30 +01:00
|
|
|
{
|
2000-01-19 00:30:24 +01:00
|
|
|
psql_error("%s: %s\n", fname, strerror(errno));
|
2000-01-14 23:18:03 +01:00
|
|
|
pset.queryFout = stdout;
|
|
|
|
pset.queryFoutPipe = false;
|
1999-11-05 00:14:30 +01:00
|
|
|
status = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Direct signals */
|
2000-01-18 20:05:31 +01:00
|
|
|
#ifndef WIN32
|
2003-03-20 07:00:12 +01:00
|
|
|
pqsignal(SIGPIPE, pset.queryFoutPipe ? SIG_IGN : SIG_DFL);
|
2000-01-18 20:05:31 +01:00
|
|
|
#endif
|
1999-11-05 00:14:30 +01:00
|
|
|
|
|
|
|
return status;
|
1999-11-04 22:56:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2000-01-19 00:30:24 +01:00
|
|
|
/*
|
|
|
|
* Error reporting for scripts. Errors should look like
|
2000-04-12 19:17:23 +02:00
|
|
|
* psql:filename:lineno: message
|
2000-01-19 00:30:24 +01:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
void
|
2000-04-12 19:17:23 +02:00
|
|
|
psql_error(const char *fmt,...)
|
2000-01-19 00:30:24 +01:00
|
|
|
{
|
2000-04-12 19:17:23 +02:00
|
|
|
va_list ap;
|
2000-01-19 00:30:24 +01:00
|
|
|
|
2000-04-12 19:17:23 +02:00
|
|
|
fflush(stdout);
|
|
|
|
if (pset.queryFout != stdout)
|
|
|
|
fflush(pset.queryFout);
|
2000-01-19 00:30:24 +01:00
|
|
|
|
2000-04-12 19:17:23 +02:00
|
|
|
if (pset.inputfile)
|
|
|
|
fprintf(stderr, "%s:%s:%u: ", pset.progname, pset.inputfile, pset.lineno);
|
|
|
|
va_start(ap, fmt);
|
2001-06-02 20:25:18 +02:00
|
|
|
vfprintf(stderr, gettext(fmt), ap);
|
2000-04-12 19:17:23 +02:00
|
|
|
va_end(ap);
|
2000-01-19 00:30:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2000-02-08 00:10:11 +01:00
|
|
|
|
|
|
|
/*
|
2003-03-10 23:28:22 +01:00
|
|
|
* for backend Notice messages (INFO, WARNING, etc)
|
2000-02-08 00:10:11 +01:00
|
|
|
*/
|
2000-01-19 00:30:24 +01:00
|
|
|
void
|
2000-04-12 19:17:23 +02:00
|
|
|
NoticeProcessor(void *arg, const char *message)
|
2000-01-19 00:30:24 +01:00
|
|
|
{
|
2000-04-12 19:17:23 +02:00
|
|
|
(void) arg; /* not used */
|
|
|
|
psql_error("%s", message);
|
2000-01-19 00:30:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
1999-11-04 22:56:02 +01:00
|
|
|
/*
|
* Includes tab completion. It's not magic, but it's very cool. At any
rate
it's better than what used to be there.
* Does proper SQL "host variable" substitution as pointed out by Andreas
Zeugwetter (thanks): select * from :foo; Also some changes in how ':'
and ';' are treated (escape with \ to send to backend). This does
_not_
affect the '::' cast operator, but perhaps others that contain : or ;
(but there are none right now).
* To show description with a <something> listing, append '?' to command
name, e.g., \df?. This seemed to be the convenient and logical
solution.
Or append a '+' to see more useless information, e.g., \df+.
* Fixed fflush()'ing bug pointed out by Jan during the regression test
discussion.
* Added LastOid variable. This ought to take care of TODO item "Add a
function to return the last inserted oid, for use in psql scripts"
(under CLIENTS)
E.g.,
insert into foo values(...);
insert into bar values(..., :LastOid);
\echo $LastOid
* \d command shows constraints, rules, and triggers defined on the table
(in addition to indices)
* Various fixes, optimizations, corrections
* Documentation update as well
Note: This now requires snprintf(), which, if necessary, is taken from
src/backend/port. This is certainly a little weird, but it should
suffice
until a source tree cleanup is done.
Enjoy.
--
Peter Eisentraut Sernanders väg 10:115
1999-11-26 05:24:17 +01:00
|
|
|
* Code to support query cancellation
|
1999-11-04 22:56:02 +01:00
|
|
|
*
|
* Includes tab completion. It's not magic, but it's very cool. At any
rate
it's better than what used to be there.
* Does proper SQL "host variable" substitution as pointed out by Andreas
Zeugwetter (thanks): select * from :foo; Also some changes in how ':'
and ';' are treated (escape with \ to send to backend). This does
_not_
affect the '::' cast operator, but perhaps others that contain : or ;
(but there are none right now).
* To show description with a <something> listing, append '?' to command
name, e.g., \df?. This seemed to be the convenient and logical
solution.
Or append a '+' to see more useless information, e.g., \df+.
* Fixed fflush()'ing bug pointed out by Jan during the regression test
discussion.
* Added LastOid variable. This ought to take care of TODO item "Add a
function to return the last inserted oid, for use in psql scripts"
(under CLIENTS)
E.g.,
insert into foo values(...);
insert into bar values(..., :LastOid);
\echo $LastOid
* \d command shows constraints, rules, and triggers defined on the table
(in addition to indices)
* Various fixes, optimizations, corrections
* Documentation update as well
Note: This now requires snprintf(), which, if necessary, is taken from
src/backend/port. This is certainly a little weird, but it should
suffice
until a source tree cleanup is done.
Enjoy.
--
Peter Eisentraut Sernanders väg 10:115
1999-11-26 05:24:17 +01:00
|
|
|
* Before we start a query, we enable a SIGINT signal catcher that sends a
|
|
|
|
* cancel request to the backend. Note that sending the cancel directly from
|
|
|
|
* the signal handler is safe because PQrequestCancel() is written to make it
|
2000-02-08 00:10:11 +01:00
|
|
|
* so. We use write() to print to stdout because it's better to use simple
|
|
|
|
* facilities in a signal handler.
|
1999-11-04 22:56:02 +01:00
|
|
|
*/
|
2003-03-20 07:00:12 +01:00
|
|
|
static PGconn *volatile cancelConn = NULL;
|
|
|
|
|
|
|
|
volatile bool cancel_pressed = false;
|
|
|
|
|
1999-11-04 22:56:02 +01:00
|
|
|
|
2000-03-05 14:30:20 +01:00
|
|
|
#ifndef WIN32
|
|
|
|
|
* Includes tab completion. It's not magic, but it's very cool. At any
rate
it's better than what used to be there.
* Does proper SQL "host variable" substitution as pointed out by Andreas
Zeugwetter (thanks): select * from :foo; Also some changes in how ':'
and ';' are treated (escape with \ to send to backend). This does
_not_
affect the '::' cast operator, but perhaps others that contain : or ;
(but there are none right now).
* To show description with a <something> listing, append '?' to command
name, e.g., \df?. This seemed to be the convenient and logical
solution.
Or append a '+' to see more useless information, e.g., \df+.
* Fixed fflush()'ing bug pointed out by Jan during the regression test
discussion.
* Added LastOid variable. This ought to take care of TODO item "Add a
function to return the last inserted oid, for use in psql scripts"
(under CLIENTS)
E.g.,
insert into foo values(...);
insert into bar values(..., :LastOid);
\echo $LastOid
* \d command shows constraints, rules, and triggers defined on the table
(in addition to indices)
* Various fixes, optimizations, corrections
* Documentation update as well
Note: This now requires snprintf(), which, if necessary, is taken from
src/backend/port. This is certainly a little weird, but it should
suffice
until a source tree cleanup is done.
Enjoy.
--
Peter Eisentraut Sernanders väg 10:115
1999-11-26 05:24:17 +01:00
|
|
|
#define write_stderr(String) write(fileno(stderr), String, strlen(String))
|
1999-11-04 22:56:02 +01:00
|
|
|
|
2000-02-20 15:28:28 +01:00
|
|
|
void
|
2000-08-29 11:36:51 +02:00
|
|
|
handle_sigint(SIGNAL_ARGS)
|
1999-11-04 22:56:02 +01:00
|
|
|
{
|
2000-12-18 18:33:42 +01:00
|
|
|
int save_errno = errno;
|
|
|
|
|
2000-04-12 19:17:23 +02:00
|
|
|
/* Don't muck around if copying in or prompting for a password. */
|
|
|
|
if ((copy_in_state && pset.cur_cmd_interactive) || prompt_state)
|
|
|
|
return;
|
2000-02-21 20:40:42 +01:00
|
|
|
|
1999-11-05 00:14:30 +01:00
|
|
|
if (cancelConn == NULL)
|
2000-04-12 19:17:23 +02:00
|
|
|
siglongjmp(main_loop_jmp, 1);
|
2000-02-20 15:28:28 +01:00
|
|
|
|
2000-04-12 19:17:23 +02:00
|
|
|
cancel_pressed = true;
|
2000-03-01 22:10:05 +01:00
|
|
|
|
1999-11-05 00:14:30 +01:00
|
|
|
if (PQrequestCancel(cancelConn))
|
2000-03-01 22:10:05 +01:00
|
|
|
write_stderr("Cancel request sent\n");
|
1999-11-05 00:14:30 +01:00
|
|
|
else
|
|
|
|
{
|
2000-03-01 22:10:05 +01:00
|
|
|
write_stderr("Could not send cancel request: ");
|
* Includes tab completion. It's not magic, but it's very cool. At any
rate
it's better than what used to be there.
* Does proper SQL "host variable" substitution as pointed out by Andreas
Zeugwetter (thanks): select * from :foo; Also some changes in how ':'
and ';' are treated (escape with \ to send to backend). This does
_not_
affect the '::' cast operator, but perhaps others that contain : or ;
(but there are none right now).
* To show description with a <something> listing, append '?' to command
name, e.g., \df?. This seemed to be the convenient and logical
solution.
Or append a '+' to see more useless information, e.g., \df+.
* Fixed fflush()'ing bug pointed out by Jan during the regression test
discussion.
* Added LastOid variable. This ought to take care of TODO item "Add a
function to return the last inserted oid, for use in psql scripts"
(under CLIENTS)
E.g.,
insert into foo values(...);
insert into bar values(..., :LastOid);
\echo $LastOid
* \d command shows constraints, rules, and triggers defined on the table
(in addition to indices)
* Various fixes, optimizations, corrections
* Documentation update as well
Note: This now requires snprintf(), which, if necessary, is taken from
src/backend/port. This is certainly a little weird, but it should
suffice
until a source tree cleanup is done.
Enjoy.
--
Peter Eisentraut Sernanders väg 10:115
1999-11-26 05:24:17 +01:00
|
|
|
write_stderr(PQerrorMessage(cancelConn));
|
1999-11-05 00:14:30 +01:00
|
|
|
}
|
2000-12-18 18:33:42 +01:00
|
|
|
errno = save_errno; /* just in case the write changed it */
|
1999-11-04 22:56:02 +01:00
|
|
|
}
|
2001-11-05 18:46:40 +01:00
|
|
|
#endif /* not WIN32 */
|
1999-11-04 22:56:02 +01:00
|
|
|
|
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
|
|
|
|
/* ConnectionUp
|
|
|
|
*
|
|
|
|
* Returns whether our backend connection is still there.
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
ConnectionUp()
|
|
|
|
{
|
|
|
|
return PQstatus(pset.db) != CONNECTION_BAD;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* CheckConnection
|
|
|
|
*
|
|
|
|
* Verify that we still have a good connection to the backend, and if not,
|
|
|
|
* see if it can be restored.
|
|
|
|
*
|
|
|
|
* Returns true if either the connection was still there, or it could be
|
|
|
|
* restored successfully; false otherwise. If, however, there was no
|
|
|
|
* connection and the session is non-interactive, this will exit the program
|
|
|
|
* with a code of EXIT_BADCONN.
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
CheckConnection()
|
|
|
|
{
|
|
|
|
bool OK;
|
|
|
|
|
|
|
|
OK = ConnectionUp();
|
|
|
|
if (!OK)
|
|
|
|
{
|
|
|
|
if (!pset.cur_cmd_interactive)
|
|
|
|
{
|
|
|
|
psql_error("connection to server was lost\n");
|
|
|
|
exit(EXIT_BADCONN);
|
|
|
|
}
|
|
|
|
|
|
|
|
fputs(gettext("The connection to the server was lost. Attempting reset: "), stderr);
|
|
|
|
PQreset(pset.db);
|
|
|
|
OK = ConnectionUp();
|
|
|
|
if (!OK)
|
|
|
|
{
|
|
|
|
fputs(gettext("Failed.\n"), stderr);
|
|
|
|
PQfinish(pset.db);
|
|
|
|
pset.db = NULL;
|
|
|
|
ResetCancelConn();
|
|
|
|
SetVariable(pset.vars, "DBNAME", NULL);
|
|
|
|
SetVariable(pset.vars, "HOST", NULL);
|
|
|
|
SetVariable(pset.vars, "PORT", NULL);
|
|
|
|
SetVariable(pset.vars, "USER", NULL);
|
|
|
|
SetVariable(pset.vars, "ENCODING", NULL);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
fputs(gettext("Succeeded.\n"), stderr);
|
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SetCancelConn
|
|
|
|
*
|
|
|
|
* Set cancelConn to point to the current database connection.
|
|
|
|
*/
|
|
|
|
static void SetCancelConn(void)
|
|
|
|
{
|
|
|
|
cancelConn = pset.db;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ResetCancelConn
|
|
|
|
*
|
|
|
|
* Set cancelConn to NULL. I don't know what this means exactly, but it saves
|
|
|
|
* having to export the variable.
|
|
|
|
*/
|
|
|
|
void ResetCancelConn(void)
|
|
|
|
{
|
|
|
|
cancelConn = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* AcceptResult
|
|
|
|
*
|
|
|
|
* Checks whether a result is valid, giving an error message if necessary;
|
|
|
|
* (re)sets copy_in_state and cancelConn as needed, and ensures that the
|
|
|
|
* connection to the backend is still up.
|
|
|
|
*
|
|
|
|
* Returns true for valid result, false for error state.
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
AcceptResult(const PGresult *result)
|
|
|
|
{
|
|
|
|
bool OK = true;
|
|
|
|
|
|
|
|
ResetCancelConn();
|
|
|
|
|
|
|
|
if (!result)
|
|
|
|
{
|
|
|
|
OK = false;
|
|
|
|
}
|
|
|
|
else switch (PQresultStatus(result))
|
|
|
|
{
|
|
|
|
case PGRES_COPY_IN:
|
|
|
|
copy_in_state = true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PGRES_COMMAND_OK:
|
|
|
|
case PGRES_TUPLES_OK:
|
|
|
|
/* Fine, do nothing */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PGRES_COPY_OUT:
|
|
|
|
/* keep cancel connection for copy out state */
|
|
|
|
SetCancelConn();
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
OK = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!OK)
|
|
|
|
{
|
|
|
|
CheckConnection();
|
|
|
|
psql_error("%s", PQerrorMessage(pset.db));
|
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
1999-11-05 00:14:30 +01:00
|
|
|
/*
|
|
|
|
* PSQLexec
|
1999-11-04 22:56:02 +01:00
|
|
|
*
|
|
|
|
* This is the way to send "backdoor" queries (those not directly entered
|
2000-01-14 23:18:03 +01:00
|
|
|
* by the user). It is subject to -E but not -e.
|
2002-10-15 04:24:16 +02:00
|
|
|
*
|
|
|
|
* If the given querystring generates multiple PGresults, normally the last
|
|
|
|
* one is returned to the caller. However, if ignore_command_ok is TRUE,
|
|
|
|
* then PGresults with status PGRES_COMMAND_OK are ignored. This is intended
|
|
|
|
* mainly to allow locutions such as "begin; select ...; commit".
|
1999-11-04 22:56:02 +01:00
|
|
|
*/
|
2001-10-25 07:50:21 +02:00
|
|
|
PGresult *
|
2002-10-15 04:24:16 +02:00
|
|
|
PSQLexec(const char *query, bool ignore_command_ok)
|
1999-11-04 22:56:02 +01:00
|
|
|
{
|
2002-10-15 04:24:16 +02:00
|
|
|
PGresult *res = NULL;
|
|
|
|
PGresult *newres;
|
2003-03-20 07:43:35 +01:00
|
|
|
int echo_hidden;
|
2002-10-15 04:24:16 +02:00
|
|
|
ExecStatusType rstatus;
|
1999-11-05 00:14:30 +01:00
|
|
|
|
2000-01-14 23:18:03 +01:00
|
|
|
if (!pset.db)
|
1999-11-05 00:14:30 +01:00
|
|
|
{
|
2000-04-12 19:17:23 +02:00
|
|
|
psql_error("You are currently not connected to a database.\n");
|
1999-11-05 00:14:30 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2003-03-20 07:43:35 +01:00
|
|
|
echo_hidden = SwitchVariable(pset.vars, "ECHO_HIDDEN", "noexec", NULL);
|
|
|
|
if (echo_hidden != var_notset)
|
1999-11-05 00:14:30 +01:00
|
|
|
{
|
2001-06-02 20:25:18 +02:00
|
|
|
printf("********* QUERY **********\n"
|
|
|
|
"%s\n"
|
|
|
|
"**************************\n\n", query);
|
1999-11-05 00:14:30 +01:00
|
|
|
fflush(stdout);
|
|
|
|
|
2003-03-20 07:43:35 +01:00
|
|
|
if (echo_hidden == 1)
|
1999-11-05 00:14:30 +01:00
|
|
|
return NULL;
|
2003-03-20 07:43:35 +01:00
|
|
|
}
|
1999-11-05 00:14:30 +01:00
|
|
|
|
2002-10-15 18:44:21 +02:00
|
|
|
/* discard any uneaten results of past queries */
|
|
|
|
while ((newres = PQgetResult(pset.db)) != NULL)
|
|
|
|
PQclear(newres);
|
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
SetCancelConn();
|
|
|
|
if (!PQsendQuery(pset.db, query))
|
2002-10-15 04:24:16 +02:00
|
|
|
{
|
2003-03-20 07:00:12 +01:00
|
|
|
psql_error("%s", PQerrorMessage(pset.db));
|
|
|
|
ResetCancelConn();
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
rstatus = PGRES_EMPTY_QUERY;
|
|
|
|
|
|
|
|
while (rstatus != PGRES_COPY_IN &&
|
|
|
|
rstatus != PGRES_COPY_OUT &&
|
|
|
|
(newres = PQgetResult(pset.db)))
|
2002-10-15 04:24:16 +02:00
|
|
|
{
|
2002-10-15 18:44:21 +02:00
|
|
|
rstatus = PQresultStatus(newres);
|
2003-03-20 07:00:12 +01:00
|
|
|
if (!ignore_command_ok || rstatus != PGRES_COMMAND_OK)
|
2002-10-15 04:24:16 +02:00
|
|
|
{
|
2003-03-20 07:00:12 +01:00
|
|
|
PGresult *tempRes = res;
|
2003-02-21 22:34:27 +01:00
|
|
|
res = newres;
|
2003-03-20 07:00:12 +01:00
|
|
|
newres = tempRes;
|
2002-10-15 04:24:16 +02:00
|
|
|
}
|
2003-03-20 07:00:12 +01:00
|
|
|
PQclear(newres);
|
2002-10-15 04:24:16 +02:00
|
|
|
}
|
2003-03-20 07:00:12 +01:00
|
|
|
|
|
|
|
if (!AcceptResult(res) && res)
|
2003-02-19 04:54:39 +01:00
|
|
|
{
|
2003-02-21 22:34:27 +01:00
|
|
|
PQclear(res);
|
2003-03-20 07:00:12 +01:00
|
|
|
res = NULL;
|
2003-02-21 22:34:27 +01:00
|
|
|
}
|
2003-02-19 04:54:39 +01:00
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
return res;
|
1999-11-04 22:56:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
2003-03-20 07:00:12 +01:00
|
|
|
* PrintNotifications: check for asynchronous notifications, and print them out
|
1999-11-04 22:56:02 +01:00
|
|
|
*
|
|
|
|
*/
|
2003-03-20 07:00:12 +01:00
|
|
|
static void
|
|
|
|
PrintNotifications(void)
|
1999-11-04 22:56:02 +01:00
|
|
|
{
|
2003-02-21 22:34:27 +01:00
|
|
|
PGnotify *notify;
|
1999-11-05 00:14:30 +01:00
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
while ((notify = PQnotifies(pset.db)))
|
2000-04-12 19:17:23 +02:00
|
|
|
{
|
2003-03-20 07:00:12 +01:00
|
|
|
fprintf(pset.queryFout, gettext("Asynchronous NOTIFY '%s' from backend with pid %d received.\n"),
|
|
|
|
notify->relname, notify->be_pid);
|
2003-03-25 03:44:36 +01:00
|
|
|
PQfreemem(notify);
|
2003-03-20 07:00:12 +01:00
|
|
|
fflush(pset.queryFout);
|
2000-04-12 19:17:23 +02:00
|
|
|
}
|
2003-03-20 07:00:12 +01:00
|
|
|
}
|
1999-11-04 22:56:02 +01:00
|
|
|
|
1999-11-05 00:14:30 +01:00
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
/*
|
|
|
|
* PrintQueryTuples: assuming query result is OK, print its tuples
|
|
|
|
*
|
|
|
|
* Returns true if successful, false otherwise.
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
PrintQueryTuples(const PGresult *results)
|
|
|
|
{
|
2003-02-21 22:34:27 +01:00
|
|
|
/* write output to \g argument, if any */
|
|
|
|
if (pset.gfname)
|
|
|
|
{
|
|
|
|
FILE *queryFout_copy = pset.queryFout;
|
|
|
|
bool queryFoutPipe_copy = pset.queryFoutPipe;
|
|
|
|
|
|
|
|
pset.queryFout = stdout; /* so it doesn't get
|
|
|
|
* closed */
|
|
|
|
|
|
|
|
/* open file/pipe */
|
|
|
|
if (!setQFout(pset.gfname))
|
|
|
|
{
|
|
|
|
pset.queryFout = queryFout_copy;
|
|
|
|
pset.queryFoutPipe = queryFoutPipe_copy;
|
2003-03-20 07:00:12 +01:00
|
|
|
return false;
|
2003-02-21 22:34:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
printQuery(results, &pset.popt, pset.queryFout);
|
|
|
|
|
|
|
|
/* close file/pipe, restore old setting */
|
|
|
|
setQFout(NULL);
|
|
|
|
|
|
|
|
pset.queryFout = queryFout_copy;
|
|
|
|
pset.queryFoutPipe = queryFoutPipe_copy;
|
|
|
|
|
|
|
|
free(pset.gfname);
|
|
|
|
pset.gfname = NULL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
printQuery(results, &pset.popt, pset.queryFout);
|
|
|
|
}
|
2003-03-20 07:00:12 +01:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* PrintQueryResults: analyze query results and print them out
|
|
|
|
*
|
|
|
|
* Note: Utility function for use by SendQuery() only.
|
|
|
|
*
|
|
|
|
* Returns true if the query executed successfully, false otherwise.
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
PrintQueryResults(PGresult *results,
|
|
|
|
const TimevalStruct *before,
|
|
|
|
const TimevalStruct *after)
|
|
|
|
{
|
|
|
|
bool success = false;
|
|
|
|
|
|
|
|
if (!results)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
switch (PQresultStatus(results))
|
|
|
|
{
|
|
|
|
case PGRES_TUPLES_OK:
|
|
|
|
success = PrintQueryTuples(results);
|
2003-02-21 22:34:27 +01:00
|
|
|
break;
|
|
|
|
case PGRES_EMPTY_QUERY:
|
|
|
|
success = true;
|
|
|
|
break;
|
|
|
|
case PGRES_COMMAND_OK:
|
|
|
|
{
|
|
|
|
char buf[10];
|
|
|
|
|
|
|
|
success = true;
|
|
|
|
sprintf(buf, "%u", (unsigned int) PQoidValue(results));
|
|
|
|
if (!QUIET())
|
2003-06-12 09:52:51 +02:00
|
|
|
{
|
|
|
|
if (pset.popt.topt.format == PRINT_HTML)
|
|
|
|
{
|
|
|
|
fputs("<p>", pset.queryFout);
|
|
|
|
html_escaped_print(PQcmdStatus(results), pset.queryFout);
|
|
|
|
fputs("</p>\n", pset.queryFout);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
fprintf(pset.queryFout, "%s\n", PQcmdStatus(results));
|
|
|
|
}
|
|
|
|
}
|
2003-02-21 22:34:27 +01:00
|
|
|
SetVariable(pset.vars, "LASTOID", buf);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case PGRES_COPY_OUT:
|
|
|
|
success = handleCopyOut(pset.db, pset.queryFout);
|
|
|
|
break;
|
2002-03-05 01:01:03 +01:00
|
|
|
|
2003-02-21 22:34:27 +01:00
|
|
|
case PGRES_COPY_IN:
|
|
|
|
if (pset.cur_cmd_interactive && !QUIET())
|
|
|
|
puts(gettext("Enter data to be copied followed by a newline.\n"
|
|
|
|
"End with a backslash and a period on a line by itself."));
|
|
|
|
|
|
|
|
success = handleCopyIn(pset.db, pset.cur_cmd_source,
|
|
|
|
pset.cur_cmd_interactive ? get_prompt(PROMPT_COPY) : NULL);
|
|
|
|
break;
|
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
default:
|
2003-02-21 22:34:27 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
fflush(pset.queryFout);
|
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
if (!CheckConnection()) return false;
|
|
|
|
|
|
|
|
/* Possible microtiming output */
|
|
|
|
if (pset.timing && success)
|
|
|
|
printf(gettext("Time: %.2f ms\n"), DIFF_MSEC(after, before));
|
|
|
|
|
|
|
|
return success;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* SendQuery: send the query string to the backend
|
|
|
|
* (and print out results)
|
|
|
|
*
|
|
|
|
* Note: This is the "front door" way to send a query. That is, use it to
|
|
|
|
* send queries actually entered by the user. These queries will be subject to
|
|
|
|
* single step mode.
|
|
|
|
* To send "back door" queries (generated by slash commands, etc.) in a
|
|
|
|
* controlled way, use PSQLexec().
|
|
|
|
*
|
|
|
|
* Returns true if the query executed successfully, false otherwise.
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
SendQuery(const char *query)
|
|
|
|
{
|
|
|
|
PGresult *results;
|
|
|
|
TimevalStruct before, after;
|
|
|
|
bool OK;
|
|
|
|
|
|
|
|
if (!pset.db)
|
2003-03-20 07:43:35 +01:00
|
|
|
{
|
2003-03-20 07:00:12 +01:00
|
|
|
psql_error("You are currently not connected to a database.\n");
|
|
|
|
return false;
|
2003-03-20 07:43:35 +01:00
|
|
|
}
|
2003-03-20 07:00:12 +01:00
|
|
|
|
|
|
|
if (GetVariableBool(pset.vars, "SINGLESTEP"))
|
2003-03-20 07:43:35 +01:00
|
|
|
{
|
2003-03-20 07:00:12 +01:00
|
|
|
char buf[3];
|
|
|
|
|
|
|
|
printf(gettext("***(Single step mode: Verify query)*********************************************\n"
|
|
|
|
"%s\n"
|
|
|
|
"***(press return to proceed or enter x and return to cancel)********************\n"),
|
|
|
|
query);
|
|
|
|
fflush(stdout);
|
|
|
|
if (fgets(buf, sizeof(buf), stdin) != NULL)
|
|
|
|
if (buf[0] == 'x')
|
2003-02-21 22:34:27 +01:00
|
|
|
return false;
|
|
|
|
}
|
2003-03-20 07:43:35 +01:00
|
|
|
else if (VariableEquals(pset.vars, "ECHO", "queries"))
|
|
|
|
puts(query);
|
2003-02-21 22:34:27 +01:00
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
SetCancelConn();
|
2003-02-21 22:34:27 +01:00
|
|
|
|
2003-03-20 07:00:12 +01:00
|
|
|
if (pset.timing)
|
|
|
|
GETTIMEOFDAY(&before);
|
|
|
|
results = PQexec(pset.db, query);
|
|
|
|
if (pset.timing)
|
|
|
|
GETTIMEOFDAY(&after);
|
|
|
|
|
|
|
|
OK = (AcceptResult(results) && PrintQueryResults(results, &before, &after));
|
|
|
|
PQclear(results);
|
|
|
|
|
|
|
|
PrintNotifications();
|
|
|
|
return OK;
|
1999-11-04 22:56:02 +01:00
|
|
|
}
|
2003-03-20 07:43:35 +01:00
|
|
|
|
|
|
|
|
|
|
|
char parse_char(char **buf)
|
|
|
|
{
|
|
|
|
long l;
|
|
|
|
|
|
|
|
l = strtol(*buf, buf, 0);
|
2003-03-20 16:39:53 +01:00
|
|
|
--*buf;
|
2003-03-20 07:43:35 +01:00
|
|
|
return (char)l;
|
|
|
|
}
|
|
|
|
|
|
|
|
|