*
* Copyright (c) 2000-2006, PostgreSQL Global Development Group
*
- * $PostgreSQL: pgsql/src/bin/psql/common.c,v 1.114 2006/03/05 15:58:51 momjian Exp $
+ * $PostgreSQL: pgsql/src/bin/psql/common.c,v 1.124 2006/08/13 21:10:04 tgl Exp $
*/
#include "postgres_fe.h"
#include "common.h"
#ifndef WIN32
#include <sys/time.h>
#include <unistd.h> /* for write() */
-#include <setjmp.h>
#else
#include <io.h> /* for _write() */
#include <win32.h>
#include <sys/timeb.h> /* for _ftime() */
#endif
-#include "libpq-fe.h"
#include "pqsignal.h"
#include "settings.h"
-#include "variables.h"
#include "command.h"
#include "copy.h"
-#include "prompt.h"
-#include "print.h"
-#include "mainloop.h"
#include "mb/pg_wchar.h"
((T)->millitm - (U)->millitm))
#endif
-extern bool prompt_state;
-
static bool command_no_begin(const char *query);
fflush(pset.queryFout);
if (pset.inputfile)
- fprintf(stderr, "%s:%s:%u: ", pset.progname, pset.inputfile, pset.lineno);
+ fprintf(stderr, "%s:%s:" UINT64_FORMAT ": ", pset.progname, pset.inputfile, pset.lineno);
va_start(ap, fmt);
vfprintf(stderr, _(fmt), ap);
va_end(ap);
/*
* Code to support query cancellation
*
- * Before we start a query, we enable a SIGINT signal catcher that sends a
+ * Before we start a query, we enable the SIGINT signal catcher to send a
* cancel request to the backend. Note that sending the cancel directly from
* the signal handler is safe because PQcancel() is written to make it
- * so. We use write() to print to stderr because it's better to use simple
+ * so. We use write() to report to stderr because it's better to use simple
* facilities in a signal handler.
*
* On win32, the signal cancelling happens on a separate thread, because
* that's how SetConsoleCtrlHandler works. The PQcancel function is safe
* for this (unlike PQrequestCancel). However, a CRITICAL_SECTION is required
- * to protect the PGcancel structure against being changed while the other
+ * to protect the PGcancel structure against being changed while the signal
* thread is using it.
+ *
+ * SIGINT is supposed to abort all long-running psql operations, not only
+ * database queries. In most places, this is accomplished by checking
+ * cancel_pressed during long-running loops. However, that won't work when
+ * blocked on user input (in readline() or fgets()). In those places, we
+ * set sigint_interrupt_enabled TRUE while blocked, instructing the signal
+ * catcher to longjmp through sigint_interrupt_jmp. We assume readline and
+ * fgets are coded to handle possible interruption. (XXX currently this does
+ * not work on win32, so control-C is less useful there)
*/
-static PGcancel *cancelConn = NULL;
+volatile bool sigint_interrupt_enabled = false;
+
+sigjmp_buf sigint_interrupt_jmp;
+
+static PGcancel * volatile cancelConn = NULL;
#ifdef WIN32
static CRITICAL_SECTION cancelConnLock;
#endif
-volatile bool cancel_pressed = false;
-
#define write_stderr(str) write(fileno(stderr), str, strlen(str))
#ifndef WIN32
-void
+static void
handle_sigint(SIGNAL_ARGS)
{
int save_errno = errno;
char errbuf[256];
- /* Don't muck around if prompting for a password. */
- if (prompt_state)
- return;
-
- if (cancelConn == NULL)
- siglongjmp(main_loop_jmp, 1);
+ /* if we are waiting for input, longjmp out of it */
+ if (sigint_interrupt_enabled)
+ {
+ sigint_interrupt_enabled = false;
+ siglongjmp(sigint_interrupt_jmp, 1);
+ }
+ /* else, set cancel flag to stop any long-running loops */
cancel_pressed = true;
- if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
- write_stderr("Cancel request sent\n");
- else
+ /* and send QueryCancel if we are processing a database query */
+ if (cancelConn != NULL)
{
- write_stderr("Could not send cancel request: ");
- write_stderr(errbuf);
+ if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
+ write_stderr("Cancel request sent\n");
+ else
+ {
+ write_stderr("Could not send cancel request: ");
+ write_stderr(errbuf);
+ }
}
+
errno = save_errno; /* just in case the write changed it */
}
+
+void
+setup_cancel_handler(void)
+{
+ pqsignal(SIGINT, handle_sigint);
+}
+
#else /* WIN32 */
static BOOL WINAPI
if (dwCtrlType == CTRL_C_EVENT ||
dwCtrlType == CTRL_BREAK_EVENT)
{
- if (prompt_state)
- return TRUE;
+ /*
+ * Can't longjmp here, because we are in wrong thread :-(
+ */
- /* Perform query cancel */
+ /* set cancel flag to stop any long-running loops */
+ cancel_pressed = true;
+
+ /* and send QueryCancel if we are processing a database query */
EnterCriticalSection(&cancelConnLock);
if (cancelConn != NULL)
{
- cancel_pressed = true;
-
if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
write_stderr("Cancel request sent\n");
else
return FALSE;
}
-void
-setup_win32_locks(void)
-{
- InitializeCriticalSection(&cancelConnLock);
-}
-
void
setup_cancel_handler(void)
{
- static bool done = false;
+ InitializeCriticalSection(&cancelConnLock);
- /* only need one handler per process */
- if (!done)
- {
- SetConsoleCtrlHandler(consoleHandler, TRUE);
- done = true;
- }
+ SetConsoleCtrlHandler(consoleHandler, TRUE);
}
+
#endif /* WIN32 */
*
* Set cancelConn to point to the current database connection.
*/
-static void
+void
SetCancelConn(void)
{
+ PGcancel *oldCancelConn;
+
#ifdef WIN32
EnterCriticalSection(&cancelConnLock);
#endif
/* Free the old one if we have one */
- if (cancelConn != NULL)
- PQfreeCancel(cancelConn);
+ oldCancelConn = cancelConn;
+ /* be sure handle_sigint doesn't use pointer while freeing */
+ cancelConn = NULL;
+
+ if (oldCancelConn != NULL)
+ PQfreeCancel(oldCancelConn);
cancelConn = PQgetCancel(pset.db);
void
ResetCancelConn(void)
{
+ PGcancel *oldCancelConn;
+
#ifdef WIN32
EnterCriticalSection(&cancelConnLock);
#endif
- if (cancelConn)
- PQfreeCancel(cancelConn);
-
+ oldCancelConn = cancelConn;
+ /* be sure handle_sigint doesn't use pointer while freeing */
cancelConn = NULL;
+ if (oldCancelConn != NULL)
+ PQfreeCancel(oldCancelConn);
+
#ifdef WIN32
LeaveCriticalSection(&cancelConnLock);
#endif
}
-/*
- * on errors, print syntax error position if available.
- *
- * the query is expected to be in the client encoding.
- */
-static void
-ReportSyntaxErrorPosition(const PGresult *result, const char *query)
-{
-#define DISPLAY_SIZE 60 /* screen width limit, in screen cols */
-#define MIN_RIGHT_CUT 10 /* try to keep this far away from EOL */
-
- int loc = 0;
- const char *sp;
- int clen,
- slen,
- i,
- w,
- *qidx,
- *scridx,
- qoffset,
- scroffset,
- ibeg,
- iend,
- loc_line;
- char *wquery;
- bool beg_trunc,
- end_trunc;
- PQExpBufferData msg;
-
- if (pset.verbosity == PQERRORS_TERSE)
- return;
-
- sp = PQresultErrorField(result, PG_DIAG_STATEMENT_POSITION);
- if (sp == NULL)
- {
- sp = PQresultErrorField(result, PG_DIAG_INTERNAL_POSITION);
- if (sp == NULL)
- return; /* no syntax error */
- query = PQresultErrorField(result, PG_DIAG_INTERNAL_QUERY);
- }
- if (query == NULL)
- return; /* nothing to reference location to */
-
- if (sscanf(sp, "%d", &loc) != 1)
- {
- psql_error("INTERNAL ERROR: unexpected statement position \"%s\"\n",
- sp);
- return;
- }
-
- /* Make a writable copy of the query, and a buffer for messages. */
- wquery = pg_strdup(query);
-
- initPQExpBuffer(&msg);
-
- /*
- * The returned cursor position is measured in logical characters. Each
- * character might occupy multiple physical bytes in the string, and in
- * some Far Eastern character sets it might take more than one screen
- * column as well. We compute the starting byte offset and starting
- * screen column of each logical character, and store these in qidx[] and
- * scridx[] respectively.
- */
-
- /* we need a safe allocation size... */
- slen = strlen(query) + 1;
-
- qidx = (int *) pg_malloc(slen * sizeof(int));
- scridx = (int *) pg_malloc(slen * sizeof(int));
-
- qoffset = 0;
- scroffset = 0;
- for (i = 0; query[qoffset] != '\0'; i++)
- {
- qidx[i] = qoffset;
- scridx[i] = scroffset;
- w = PQdsplen(&query[qoffset], pset.encoding);
- /* treat control chars as width 1; see tab hack below */
- if (w <= 0)
- w = 1;
- scroffset += w;
- qoffset += PQmblen(&query[qoffset], pset.encoding);
- }
- qidx[i] = qoffset;
- scridx[i] = scroffset;
- clen = i;
- psql_assert(clen < slen);
-
- /* convert loc to zero-based offset in qidx/scridx arrays */
- loc--;
-
- /* do we have something to show? */
- if (loc >= 0 && loc <= clen)
- {
- /* input line number of our syntax error. */
- loc_line = 1;
- /* first included char of extract. */
- ibeg = 0;
- /* last-plus-1 included char of extract. */
- iend = clen;
-
- /*
- * Replace tabs with spaces in the writable copy. (Later we might
- * want to think about coping with their variable screen width, but
- * not today.)
- *
- * Extract line number and begin and end indexes of line containing
- * error location. There will not be any newlines or carriage returns
- * in the selected extract.
- */
- for (i = 0; i < clen; i++)
- {
- /* character length must be 1 or it's not ASCII */
- if ((qidx[i + 1] - qidx[i]) == 1)
- {
- if (wquery[qidx[i]] == '\t')
- wquery[qidx[i]] = ' ';
- else if (wquery[qidx[i]] == '\r' || wquery[qidx[i]] == '\n')
- {
- if (i < loc)
- {
- /*
- * count lines before loc. Each \r or \n counts as a
- * line except when \r \n appear together.
- */
- if (wquery[qidx[i]] == '\r' ||
- i == 0 ||
- (qidx[i] - qidx[i - 1]) != 1 ||
- wquery[qidx[i - 1]] != '\r')
- loc_line++;
- /* extract beginning = last line start before loc. */
- ibeg = i + 1;
- }
- else
- {
- /* set extract end. */
- iend = i;
- /* done scanning. */
- break;
- }
- }
- }
- }
-
- /* If the line extracted is too long, we truncate it. */
- beg_trunc = false;
- end_trunc = false;
- if (scridx[iend] - scridx[ibeg] > DISPLAY_SIZE)
- {
- /*
- * We first truncate right if it is enough. This code might be
- * off a space or so on enforcing MIN_RIGHT_CUT if there's a wide
- * character right there, but that should be okay.
- */
- if (scridx[ibeg] + DISPLAY_SIZE >= scridx[loc] + MIN_RIGHT_CUT)
- {
- while (scridx[iend] - scridx[ibeg] > DISPLAY_SIZE)
- iend--;
- end_trunc = true;
- }
- else
- {
- /* Truncate right if not too close to loc. */
- while (scridx[loc] + MIN_RIGHT_CUT < scridx[iend])
- {
- iend--;
- end_trunc = true;
- }
-
- /* Truncate left if still too long. */
- while (scridx[iend] - scridx[ibeg] > DISPLAY_SIZE)
- {
- ibeg++;
- beg_trunc = true;
- }
- }
- }
-
- /* the extract MUST contain the target position! */
- psql_assert(ibeg <= loc && loc <= iend);
-
- /* truncate working copy at desired endpoint */
- wquery[qidx[iend]] = '\0';
-
- /* Begin building the finished message. */
- printfPQExpBuffer(&msg, _("LINE %d: "), loc_line);
- if (beg_trunc)
- appendPQExpBufferStr(&msg, "...");
-
- /*
- * While we have the prefix in the msg buffer, compute its screen
- * width.
- */
- scroffset = 0;
- for (i = 0; i < msg.len; i += PQmblen(&msg.data[i], pset.encoding))
- {
- w = PQdsplen(&msg.data[i], pset.encoding);
- if (w <= 0)
- w = 1;
- scroffset += w;
- }
-
- /* Finish and emit the message. */
- appendPQExpBufferStr(&msg, &wquery[qidx[ibeg]]);
- if (end_trunc)
- appendPQExpBufferStr(&msg, "...");
-
- psql_error("%s\n", msg.data);
-
- /* Now emit the cursor marker line. */
- scroffset += scridx[loc] - scridx[ibeg];
- resetPQExpBuffer(&msg);
- for (i = 0; i < scroffset; i++)
- appendPQExpBufferChar(&msg, ' ');
- appendPQExpBufferChar(&msg, '^');
-
- psql_error("%s\n", msg.data);
- }
-
- /* Clean up. */
- termPQExpBuffer(&msg);
-
- free(wquery);
- free(qidx);
- free(scridx);
-}
-
-
/*
* AcceptResult
*
case PGRES_TUPLES_OK:
case PGRES_EMPTY_QUERY:
case PGRES_COPY_IN:
- /* Fine, do nothing */
- break;
-
case PGRES_COPY_OUT:
- /*
- * Keep cancel connection active during copy out state.
- * The matching ResetCancelConn() is in handleCopyOut.
- */
- SetCancelConn();
+ /* Fine, do nothing */
break;
default:
if (strlen(error))
psql_error("%s", error);
- ReportSyntaxErrorPosition(result, query);
-
CheckConnection();
}
break;
case PGRES_COPY_OUT:
+ SetCancelConn();
success = handleCopyOut(pset.db, pset.queryFout);
+ ResetCancelConn();
break;
case PGRES_COPY_IN:
- success = handleCopyIn(pset.db, pset.cur_cmd_source);
+ SetCancelConn();
+ success = handleCopyIn(pset.db, pset.cur_cmd_source,
+ PQbinaryTuples(results));
+ ResetCancelConn();
break;
default:
}
+/*
+ * PrintQueryStatus: report command status as required
+ *
+ * Note: Utility function for use by PrintQueryResults() only.
+ */
+static void
+PrintQueryStatus(PGresult *results)
+{
+ char buf[16];
+
+ if (!QUIET())
+ {
+ 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));
+ }
+
+ if (pset.logfile)
+ fprintf(pset.logfile, "%s\n", PQcmdStatus(results));
+
+ snprintf(buf, sizeof(buf), "%u", (unsigned int) PQoidValue(results));
+ SetVariable(pset.vars, "LASTOID", buf);
+}
+
+
/*
* PrintQueryResults: print out query results as required
*
PrintQueryResults(PGresult *results)
{
bool success = false;
+ const char *cmdstatus;
if (!results)
return false;
switch (PQresultStatus(results))
{
case PGRES_TUPLES_OK:
+ /* print the data ... */
success = PrintQueryTuples(results);
+ /* if it's INSERT/UPDATE/DELETE RETURNING, also print status */
+ cmdstatus = PQcmdStatus(results);
+ if (strncmp(cmdstatus, "INSERT", 6) == 0 ||
+ strncmp(cmdstatus, "UPDATE", 6) == 0 ||
+ strncmp(cmdstatus, "DELETE", 6) == 0)
+ PrintQueryStatus(results);
break;
case PGRES_COMMAND_OK:
- {
- char buf[10];
-
- success = true;
- snprintf(buf, sizeof(buf),
- "%u", (unsigned int) PQoidValue(results));
- if (!QUIET())
- {
- 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));
- }
- if (pset.logfile)
- fprintf(pset.logfile, "%s\n", PQcmdStatus(results));
- SetVariable(pset.vars, "LASTOID", buf);
- break;
- }
+ PrintQueryStatus(results);
+ success = true;
+ break;
case PGRES_EMPTY_QUERY:
success = true;
if (OK)
OK = PrintQueryResults(results);
- PQclear(results);
-
/* If we made a temporary savepoint, possibly release/rollback */
if (on_error_rollback_savepoint)
{
+ PGresult *svptres;
+
transaction_status = PQtransactionStatus(pset.db);
/* We always rollback on an error */
if (transaction_status == PQTRANS_INERROR)
- results = PQexec(pset.db, "ROLLBACK TO pg_psql_temporary_savepoint");
+ svptres = PQexec(pset.db, "ROLLBACK TO pg_psql_temporary_savepoint");
/* If they are no longer in a transaction, then do nothing */
else if (transaction_status != PQTRANS_INTRANS)
- results = NULL;
+ svptres = NULL;
else
{
/*
if (strcmp(PQcmdStatus(results), "SAVEPOINT") == 0 ||
strcmp(PQcmdStatus(results), "RELEASE") == 0 ||
strcmp(PQcmdStatus(results), "ROLLBACK") == 0)
- results = NULL;
+ svptres = NULL;
else
- results = PQexec(pset.db, "RELEASE pg_psql_temporary_savepoint");
+ svptres = PQexec(pset.db, "RELEASE pg_psql_temporary_savepoint");
}
- if (PQresultStatus(results) != PGRES_COMMAND_OK)
+ if (svptres && PQresultStatus(svptres) != PGRES_COMMAND_OK)
{
psql_error("%s", PQerrorMessage(pset.db));
PQclear(results);
+ PQclear(svptres);
ResetCancelConn();
return false;
}
- PQclear(results);
+
+ PQclear(svptres);
}
+ PQclear(results);
+
/* Possible microtiming output */
if (OK && pset.timing)
printf(_("Time: %.3f ms\n"), DIFF_MSEC(&after, &before));
}
+/*
+ * Test if the current session uses standard string literals.
+ *
+ * Note: With a pre-protocol-3.0 connection this will always say "false",
+ * which should be the right answer.
+ */
+bool
+standard_strings(void)
+{
+ const char *val;
+
+ if (!pset.db)
+ return false;
+
+ val = PQparameterStatus(pset.db, "standard_conforming_strings");
+
+ if (val && strcmp(val, "on") == 0)
+ return true;
+
+ return false;
+}
+
+
/*
* Return the session user of the current connection.
*
projects / postgresql / blobdiff