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
|
|
|
*
|
2002-08-10 21:35:01 +02:00
|
|
|
* $Header: /cvsroot/pgsql/src/bin/psql/common.c,v 1.42 2002/08/10 19:35:00 tgl 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>
|
2002-03-05 01:01:03 +01:00
|
|
|
#include <sys/time.h>
|
1999-11-04 22:56:02 +01:00
|
|
|
#ifndef HAVE_STRDUP
|
|
|
|
#include <strdup.h>
|
|
|
|
#endif
|
|
|
|
#include <signal.h>
|
|
|
|
#ifndef WIN32
|
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>
|
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
|
|
|
|
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
|
2000-01-14 23:18:03 +01:00
|
|
|
if (pset.queryFoutPipe)
|
1999-11-05 00:14:30 +01:00
|
|
|
pqsignal(SIGPIPE, SIG_IGN);
|
|
|
|
else
|
|
|
|
pqsignal(SIGPIPE, 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
|
|
|
|
|
|
|
/*
|
2002-03-06 07:10:59 +01:00
|
|
|
* for backend INFO, WARNING, ERROR
|
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
|
|
|
*/
|
2000-04-12 19:17:23 +02:00
|
|
|
PGconn *cancelConn;
|
2000-02-20 15:28:28 +01:00
|
|
|
volatile bool cancel_pressed;
|
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
|
|
|
|
|
|
|
|
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.
|
1999-11-04 22:56:02 +01:00
|
|
|
*/
|
2001-10-25 07:50:21 +02:00
|
|
|
PGresult *
|
2000-01-14 23:18:03 +01:00
|
|
|
PSQLexec(const char *query)
|
1999-11-04 22:56:02 +01:00
|
|
|
{
|
1999-11-05 00:14:30 +01:00
|
|
|
PGresult *res;
|
|
|
|
const char *var;
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2000-01-14 23:18:03 +01:00
|
|
|
var = GetVariable(pset.vars, "ECHO_HIDDEN");
|
1999-11-05 00:14:30 +01:00
|
|
|
if (var)
|
|
|
|
{
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (var && strcmp(var, "noexec") == 0)
|
|
|
|
return NULL;
|
|
|
|
|
2000-01-14 23:18:03 +01:00
|
|
|
cancelConn = pset.db;
|
|
|
|
res = PQexec(pset.db, query);
|
2000-04-12 19:17:23 +02:00
|
|
|
if (PQresultStatus(res) == PGRES_COPY_IN)
|
|
|
|
copy_in_state = true;
|
|
|
|
/* keep cancel connection for copy out state */
|
|
|
|
if (PQresultStatus(res) != PGRES_COPY_OUT)
|
|
|
|
cancelConn = NULL;
|
1999-11-05 00:14:30 +01:00
|
|
|
|
2000-01-14 23:18:03 +01:00
|
|
|
if (res && (PQresultStatus(res) == PGRES_COMMAND_OK ||
|
|
|
|
PQresultStatus(res) == PGRES_TUPLES_OK ||
|
|
|
|
PQresultStatus(res) == PGRES_COPY_IN ||
|
|
|
|
PQresultStatus(res) == PGRES_COPY_OUT)
|
|
|
|
)
|
|
|
|
return res;
|
|
|
|
else
|
2000-01-14 06:28:31 +01:00
|
|
|
{
|
2000-04-12 19:17:23 +02:00
|
|
|
psql_error("%s", PQerrorMessage(pset.db));
|
2000-01-14 23:18:03 +01:00
|
|
|
PQclear(res);
|
2000-12-15 18:54:43 +01:00
|
|
|
|
|
|
|
if (PQstatus(pset.db) == CONNECTION_BAD)
|
|
|
|
{
|
|
|
|
if (!pset.cur_cmd_interactive)
|
|
|
|
{
|
|
|
|
psql_error("connection to server was lost\n");
|
|
|
|
exit(EXIT_BADCONN);
|
|
|
|
}
|
2001-06-02 20:25:18 +02:00
|
|
|
fputs(gettext("The connection to the server was lost. Attempting reset: "), stderr);
|
2000-12-15 18:54:43 +01:00
|
|
|
PQreset(pset.db);
|
|
|
|
if (PQstatus(pset.db) == CONNECTION_BAD)
|
|
|
|
{
|
2001-06-02 20:25:18 +02:00
|
|
|
fputs(gettext("Failed.\n"), stderr);
|
2000-12-15 18:54:43 +01:00
|
|
|
PQfinish(pset.db);
|
|
|
|
pset.db = NULL;
|
|
|
|
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
|
2001-06-02 20:25:18 +02:00
|
|
|
fputs(gettext("Succeeded.\n"), stderr);
|
2000-12-15 18:54:43 +01:00
|
|
|
}
|
|
|
|
|
2000-01-14 23:18:03 +01:00
|
|
|
return NULL;
|
2000-01-14 06:28:31 +01:00
|
|
|
}
|
1999-11-04 22:56:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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
|
2000-01-14 23:18:03 +01:00
|
|
|
SendQuery(const char *query)
|
1999-11-04 22:56:02 +01:00
|
|
|
{
|
1999-11-05 00:14:30 +01:00
|
|
|
bool success = false;
|
|
|
|
PGresult *results;
|
|
|
|
PGnotify *notify;
|
2002-03-05 01:01:03 +01:00
|
|
|
struct timeval before,after;
|
|
|
|
struct timezone tz;
|
1999-11-04 22:56:02 +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 false;
|
1999-11-04 22:56:02 +01:00
|
|
|
}
|
|
|
|
|
2000-01-14 23:18:03 +01:00
|
|
|
if (GetVariableBool(pset.vars, "SINGLESTEP"))
|
1999-11-04 22:56:02 +01:00
|
|
|
{
|
1999-11-05 00:14:30 +01:00
|
|
|
char buf[3];
|
|
|
|
|
2001-06-02 20:25:18 +02:00
|
|
|
printf(gettext("***(Single step mode: Verify query)*********************************************\n"
|
|
|
|
"%s\n"
|
|
|
|
"***(press return to proceed or enter x and return to cancel)********************\n"),
|
2000-04-12 19:17:23 +02:00
|
|
|
query);
|
1999-11-05 00:14:30 +01:00
|
|
|
fflush(stdout);
|
2000-11-27 03:20:36 +01:00
|
|
|
if (fgets(buf, sizeof(buf), stdin) != NULL)
|
|
|
|
if (buf[0] == 'x')
|
|
|
|
return false;
|
1999-11-04 22:56:02 +01:00
|
|
|
}
|
2000-04-12 19:17:23 +02:00
|
|
|
else
|
|
|
|
{
|
|
|
|
const char *var = GetVariable(pset.vars, "ECHO");
|
|
|
|
|
|
|
|
if (var && strncmp(var, "queries", strlen(var)) == 0)
|
|
|
|
puts(query);
|
|
|
|
}
|
1999-11-04 22:56:02 +01:00
|
|
|
|
2000-01-14 23:18:03 +01:00
|
|
|
cancelConn = pset.db;
|
2002-03-05 01:01:03 +01:00
|
|
|
if (pset.timing)
|
|
|
|
{
|
|
|
|
gettimeofday(&before, &tz);
|
|
|
|
}
|
2000-01-14 23:18:03 +01:00
|
|
|
results = PQexec(pset.db, query);
|
2002-03-05 01:01:03 +01:00
|
|
|
if (pset.timing)
|
|
|
|
{
|
|
|
|
gettimeofday(&after, &tz);
|
|
|
|
}
|
2000-04-12 19:17:23 +02:00
|
|
|
if (PQresultStatus(results) == PGRES_COPY_IN)
|
|
|
|
copy_in_state = true;
|
|
|
|
/* keep cancel connection for copy out state */
|
|
|
|
if (PQresultStatus(results) != PGRES_COPY_OUT)
|
|
|
|
cancelConn = NULL;
|
1999-11-05 00:14:30 +01:00
|
|
|
|
|
|
|
if (results == NULL)
|
1999-11-04 22:56:02 +01:00
|
|
|
{
|
2000-01-14 23:18:03 +01:00
|
|
|
fputs(PQerrorMessage(pset.db), pset.queryFout);
|
1999-11-05 00:14:30 +01:00
|
|
|
success = false;
|
1999-11-04 22:56:02 +01:00
|
|
|
}
|
1999-11-05 00:14:30 +01:00
|
|
|
else
|
|
|
|
{
|
|
|
|
switch (PQresultStatus(results))
|
|
|
|
{
|
|
|
|
case PGRES_TUPLES_OK:
|
2000-04-12 19:17:23 +02:00
|
|
|
/* write output to \g argument, if any */
|
2000-01-14 23:18:03 +01:00
|
|
|
if (pset.gfname)
|
1999-11-05 00:14:30 +01:00
|
|
|
{
|
2000-04-12 19:17:23 +02:00
|
|
|
FILE *queryFout_copy = pset.queryFout;
|
|
|
|
bool queryFoutPipe_copy = pset.queryFoutPipe;
|
1999-11-05 00:14:30 +01:00
|
|
|
|
2001-03-01 19:34:29 +01:00
|
|
|
pset.queryFout = stdout; /* so it doesn't get
|
2000-04-12 19:17:23 +02:00
|
|
|
* closed */
|
|
|
|
|
|
|
|
/* open file/pipe */
|
2000-01-14 23:18:03 +01:00
|
|
|
if (!setQFout(pset.gfname))
|
1999-11-05 00:14:30 +01:00
|
|
|
{
|
2001-03-01 19:34:29 +01:00
|
|
|
pset.queryFout = queryFout_copy;
|
|
|
|
pset.queryFoutPipe = queryFoutPipe_copy;
|
1999-11-05 00:14:30 +01:00
|
|
|
success = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2000-01-14 23:18:03 +01:00
|
|
|
printQuery(results, &pset.popt, pset.queryFout);
|
1999-11-05 00:14:30 +01:00
|
|
|
|
2001-03-01 19:34:29 +01:00
|
|
|
/* close file/pipe, restore old setting */
|
2000-01-14 23:18:03 +01:00
|
|
|
setQFout(NULL);
|
1999-11-05 00:14:30 +01:00
|
|
|
|
2000-01-14 23:18:03 +01:00
|
|
|
pset.queryFout = queryFout_copy;
|
2000-04-12 19:17:23 +02:00
|
|
|
pset.queryFoutPipe = queryFoutPipe_copy;
|
1999-11-05 00:14:30 +01:00
|
|
|
|
2001-03-01 19:34:29 +01:00
|
|
|
free(pset.gfname);
|
|
|
|
pset.gfname = NULL;
|
|
|
|
|
1999-11-05 00:14:30 +01:00
|
|
|
success = true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2000-01-14 23:18:03 +01:00
|
|
|
printQuery(results, &pset.popt, pset.queryFout);
|
2001-03-01 19:34:29 +01:00
|
|
|
success = true;
|
1999-11-05 00:14:30 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PGRES_EMPTY_QUERY:
|
|
|
|
success = true;
|
|
|
|
break;
|
|
|
|
case PGRES_COMMAND_OK:
|
2000-04-12 19:17:23 +02:00
|
|
|
{
|
|
|
|
char buf[10];
|
2000-01-14 23:18:03 +01:00
|
|
|
|
2000-04-12 19:17:23 +02:00
|
|
|
success = true;
|
|
|
|
sprintf(buf, "%u", (unsigned int) PQoidValue(results));
|
|
|
|
if (!QUIET())
|
|
|
|
fprintf(pset.queryFout, "%s\n", PQcmdStatus(results));
|
|
|
|
SetVariable(pset.vars, "LASTOID", buf);
|
|
|
|
break;
|
|
|
|
}
|
1999-11-05 00:14:30 +01:00
|
|
|
case PGRES_COPY_OUT:
|
2000-01-14 23:18:03 +01:00
|
|
|
success = handleCopyOut(pset.db, pset.queryFout);
|
1999-11-05 00:14:30 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case PGRES_COPY_IN:
|
2000-01-14 23:18:03 +01:00
|
|
|
if (pset.cur_cmd_interactive && !QUIET())
|
2001-06-02 20:25:18 +02:00
|
|
|
puts(gettext("Enter data to be copied followed by a newline.\n"
|
2001-10-25 07:50:21 +02:00
|
|
|
"End with a backslash and a period on a line by itself."));
|
1999-11-05 00:14:30 +01:00
|
|
|
|
2000-01-14 23:18:03 +01:00
|
|
|
success = handleCopyIn(pset.db, pset.cur_cmd_source,
|
|
|
|
pset.cur_cmd_interactive ? get_prompt(PROMPT_COPY) : NULL);
|
1999-11-05 00:14:30 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case PGRES_NONFATAL_ERROR:
|
|
|
|
case PGRES_FATAL_ERROR:
|
|
|
|
case PGRES_BAD_RESPONSE:
|
|
|
|
success = false;
|
2000-04-12 19:17:23 +02:00
|
|
|
psql_error("%s", PQerrorMessage(pset.db));
|
1999-11-05 00:14:30 +01:00
|
|
|
break;
|
|
|
|
}
|
1999-11-04 22:56:02 +01:00
|
|
|
|
2000-04-12 19:17:23 +02:00
|
|
|
fflush(pset.queryFout);
|
1999-12-10 04:59:30 +01:00
|
|
|
|
2000-01-14 23:18:03 +01:00
|
|
|
if (PQstatus(pset.db) == CONNECTION_BAD)
|
1999-11-05 00:14:30 +01:00
|
|
|
{
|
2000-04-12 19:17:23 +02:00
|
|
|
if (!pset.cur_cmd_interactive)
|
|
|
|
{
|
|
|
|
psql_error("connection to server was lost\n");
|
|
|
|
exit(EXIT_BADCONN);
|
|
|
|
}
|
2001-06-02 20:25:18 +02:00
|
|
|
fputs(gettext("The connection to the server was lost. Attempting reset: "), stderr);
|
2000-01-14 23:18:03 +01:00
|
|
|
PQreset(pset.db);
|
|
|
|
if (PQstatus(pset.db) == CONNECTION_BAD)
|
1999-11-05 00:14:30 +01:00
|
|
|
{
|
2001-06-02 20:25:18 +02:00
|
|
|
fputs(gettext("Failed.\n"), stderr);
|
2000-01-14 23:18:03 +01:00
|
|
|
PQfinish(pset.db);
|
2000-01-14 06:28:31 +01:00
|
|
|
PQclear(results);
|
2000-01-14 23:18:03 +01:00
|
|
|
pset.db = NULL;
|
2000-04-12 19:17:23 +02:00
|
|
|
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);
|
1999-11-05 00:14:30 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else
|
2001-06-02 20:25:18 +02:00
|
|
|
fputs(gettext("Succeeded.\n"), stderr);
|
1999-11-05 00:14:30 +01:00
|
|
|
}
|
2000-04-12 19:17:23 +02:00
|
|
|
|
1999-11-05 00:14:30 +01:00
|
|
|
/* check for asynchronous notification returns */
|
2000-01-14 23:18:03 +01:00
|
|
|
while ((notify = PQnotifies(pset.db)) != NULL)
|
1999-11-05 00:14:30 +01:00
|
|
|
{
|
2001-06-09 01:53:48 +02:00
|
|
|
fprintf(pset.queryFout, gettext("Asynchronous NOTIFY '%s' from backend with pid %d received.\n"),
|
1999-11-05 00:14:30 +01:00
|
|
|
notify->relname, notify->be_pid);
|
|
|
|
free(notify);
|
2000-04-12 19:17:23 +02:00
|
|
|
fflush(pset.queryFout);
|
1999-11-05 00:14:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (results)
|
|
|
|
PQclear(results);
|
2002-03-06 07:10:59 +01:00
|
|
|
}
|
2002-03-05 01:01:03 +01:00
|
|
|
|
|
|
|
/* Possible microtiming output */
|
|
|
|
if (pset.timing && success)
|
2002-08-10 21:35:01 +02:00
|
|
|
printf(gettext("Total time: %.2f msec\n"),
|
|
|
|
((after.tv_sec-before.tv_sec)*1000000 + after.tv_usec - before.tv_usec) / 1000.0);
|
1999-11-04 22:56:02 +01:00
|
|
|
|
1999-11-05 00:14:30 +01:00
|
|
|
return success;
|
1999-11-04 22:56:02 +01:00
|
|
|
}
|