/*
* psql - the PostgreSQL interactive terminal
*
- * Copyright 2000 by PostgreSQL Global Development Group
+ * Copyright (c) 2000-2010, PostgreSQL Global Development Group
*
- * $Header: /cvsroot/pgsql/src/bin/psql/common.c,v 1.52 2002/11/08 19:12:21 momjian Exp $
+ * $PostgreSQL: pgsql/src/bin/psql/common.c,v 1.147 2010/07/28 04:39:14 petere Exp $
*/
#include "postgres_fe.h"
#include "common.h"
-#include <errno.h>
-#include <stdarg.h>
-#ifndef HAVE_STRDUP
-#include <strdup.h>
-#endif
+#include <ctype.h>
#include <signal.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
-
-#ifndef WIN32
-#include <sys/ioctl.h> /* for ioctl() */
#endif
-#ifdef HAVE_TERMIOS_H
-#include <termios.h>
-#endif
+#include "portability/instr_time.h"
-#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 "mbprint.h"
+
-extern bool prompt_state;
+
+static bool ExecQueryUsingCursor(const char *query, double *elapsed_msec);
+static bool command_no_begin(const char *query);
+static bool is_select_command(const char *query);
/*
* "Safe" wrapper around strdup()
*/
char *
-xstrdup(const char *string)
+pg_strdup(const char *string)
{
char *tmp;
if (!string)
{
- fprintf(stderr, gettext("%s: xstrdup: cannot duplicate null pointer (internal error)\n"),
+ fprintf(stderr, _("%s: pg_strdup: cannot duplicate null pointer (internal error)\n"),
pset.progname);
exit(EXIT_FAILURE);
}
return tmp;
}
+void *
+pg_malloc(size_t size)
+{
+ void *tmp;
+
+ tmp = malloc(size);
+ if (!tmp)
+ {
+ psql_error("out of memory\n");
+ exit(EXIT_FAILURE);
+ }
+ return tmp;
+}
+
+void *
+pg_malloc_zero(size_t size)
+{
+ void *tmp;
+
+ tmp = pg_malloc(size);
+ memset(tmp, 0, size);
+ return tmp;
+}
+
+void *
+pg_calloc(size_t nmemb, size_t size)
+{
+ void *tmp;
+ tmp = calloc(nmemb, size);
+ if (!tmp)
+ {
+ psql_error("out of memory");
+ exit(EXIT_FAILURE);
+ }
+ return tmp;
+}
/*
* setQFout
/* Direct signals */
#ifndef WIN32
- if (pset.queryFoutPipe)
- pqsignal(SIGPIPE, SIG_IGN);
- else
- pqsignal(SIGPIPE, SIG_DFL);
+ pqsignal(SIGPIPE, pset.queryFoutPipe ? SIG_IGN : SIG_DFL);
#endif
return status;
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, gettext(fmt), ap);
+ vfprintf(stderr, _(fmt), ap);
va_end(ap);
}
/*
- * for backend INFO, WARNING, ERROR
+ * for backend Notice messages (INFO, WARNING, etc)
*/
void
NoticeProcessor(void *arg, const char *message)
/*
* 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 PQrequestCancel() is written to make it
- * so. We use write() to print to stdout because it's better to use simple
+ * the signal handler is safe because PQcancel() is written to make it
+ * 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 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)
*/
-PGconn *cancelConn;
-volatile bool cancel_pressed;
+volatile bool sigint_interrupt_enabled = false;
-#ifndef WIN32
+sigjmp_buf sigint_interrupt_jmp;
-#define write_stderr(String) write(fileno(stderr), String, strlen(String))
+static PGcancel *volatile cancelConn = NULL;
-void
+#ifdef WIN32
+static CRITICAL_SECTION cancelConnLock;
+#endif
+
+#define write_stderr(str) write(fileno(stderr), str, strlen(str))
+
+
+#ifndef WIN32
+
+static void
handle_sigint(SIGNAL_ARGS)
{
int save_errno = errno;
+ char errbuf[256];
- /* Don't muck around if copying in or prompting for a password. */
- if ((copy_in_state && pset.cur_cmd_interactive) || 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 (PQrequestCancel(cancelConn))
- 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(PQerrorMessage(cancelConn));
+ 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 */
}
-#endif /* not WIN32 */
-
-/*
- * PSQLexec
- *
- * This is the way to send "backdoor" queries (those not directly entered
- * by the user). It is subject to -E but not -e.
- *
- * 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".
- */
-PGresult *
-PSQLexec(const char *query, bool ignore_command_ok)
+void
+setup_cancel_handler(void)
{
- PGresult *res = NULL;
- PGresult *newres;
- const char *var;
- ExecStatusType rstatus;
+ pqsignal(SIGINT, handle_sigint);
+}
+#else /* WIN32 */
- if (!pset.db)
- {
- psql_error("You are currently not connected to a database.\n");
- return NULL;
- }
+static BOOL WINAPI
+consoleHandler(DWORD dwCtrlType)
+{
+ char errbuf[256];
- var = GetVariable(pset.vars, "ECHO_HIDDEN");
- if (var)
+ if (dwCtrlType == CTRL_C_EVENT ||
+ dwCtrlType == CTRL_BREAK_EVENT)
{
- printf("********* QUERY **********\n"
- "%s\n"
- "**************************\n\n", query);
- fflush(stdout);
- }
-
- if (var && strcmp(var, "noexec") == 0)
- return NULL;
+ /*
+ * Can't longjmp here, because we are in wrong thread :-(
+ */
- /* discard any uneaten results of past queries */
- while ((newres = PQgetResult(pset.db)) != NULL)
- PQclear(newres);
+ /* set cancel flag to stop any long-running loops */
+ cancel_pressed = true;
- cancelConn = pset.db;
- if (PQsendQuery(pset.db, query))
- {
- while ((newres = PQgetResult(pset.db)) != NULL)
+ /* and send QueryCancel if we are processing a database query */
+ EnterCriticalSection(&cancelConnLock);
+ if (cancelConn != NULL)
{
- rstatus = PQresultStatus(newres);
- if (ignore_command_ok && rstatus == PGRES_COMMAND_OK)
+ if (PQcancel(cancelConn, errbuf, sizeof(errbuf)))
+ write_stderr("Cancel request sent\n");
+ else
{
- PQclear(newres);
- continue;
+ write_stderr("Could not send cancel request: ");
+ write_stderr(errbuf);
}
- PQclear(res);
- res = newres;
- if (rstatus == PGRES_COPY_IN ||
- rstatus == PGRES_COPY_OUT)
- break;
}
+ LeaveCriticalSection(&cancelConnLock);
+
+ return TRUE;
}
- rstatus = PQresultStatus(res);
- /* keep cancel connection for copy out state */
- if (rstatus != PGRES_COPY_OUT)
- cancelConn = NULL;
- if (rstatus == PGRES_COPY_IN)
- copy_in_state = true;
-
- if (res && (rstatus == PGRES_COMMAND_OK ||
- rstatus == PGRES_TUPLES_OK ||
- rstatus == PGRES_COPY_IN ||
- rstatus == PGRES_COPY_OUT))
- return res;
else
- {
- psql_error("%s", PQerrorMessage(pset.db));
- PQclear(res);
+ /* Return FALSE for any signals not being handled */
+ return FALSE;
+}
- if (PQstatus(pset.db) == CONNECTION_BAD)
- {
- 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);
- if (PQstatus(pset.db) == CONNECTION_BAD)
- {
- fputs(gettext("Failed.\n"), stderr);
- 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
- fputs(gettext("Succeeded.\n"), stderr);
- }
+void
+setup_cancel_handler(void)
+{
+ InitializeCriticalSection(&cancelConnLock);
- return NULL;
- }
+ SetConsoleCtrlHandler(consoleHandler, TRUE);
}
+#endif /* WIN32 */
+/* ConnectionUp
+ *
+ * Returns whether our backend connection is still there.
+ */
+static bool
+ConnectionUp(void)
+{
+ return PQstatus(pset.db) != CONNECTION_BAD;
+}
-/*
- * SendQuery: send the query string to the backend
- * (and print out results)
+
+
+/* CheckConnection
*
- * 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().
+ * Verify that we still have a good connection to the backend, and if not,
+ * see if it can be restored.
*
- * Returns true if the query executed successfully, false otherwise.
+ * 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.
*/
-bool
-SendQuery(const char *query)
+static bool
+CheckConnection(void)
{
- bool success = false;
- PGresult *results;
- PGnotify *notify;
-#ifndef WIN32
- struct timeval before,
- after;
-#else
- struct _timeb before,
- after;
-#endif
+ bool OK;
- if (!pset.db)
+ OK = ConnectionUp();
+ if (!OK)
{
- psql_error("You are currently not connected to a database.\n");
- return false;
+ if (!pset.cur_cmd_interactive)
+ {
+ psql_error("connection to server was lost\n");
+ exit(EXIT_BADCONN);
+ }
+
+ fputs(_("The connection to the server was lost. Attempting reset: "), stderr);
+ PQreset(pset.db);
+ OK = ConnectionUp();
+ if (!OK)
+ {
+ fputs(_("Failed.\n"), stderr);
+ PQfinish(pset.db);
+ pset.db = NULL;
+ ResetCancelConn();
+ UnsyncVariables();
+ }
+ else
+ fputs(_("Succeeded.\n"), stderr);
}
- if (GetVariableBool(pset.vars, "SINGLESTEP"))
- {
- char buf[3];
+ return OK;
+}
- 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')
- return false;
- }
- else
- {
- const char *var = GetVariable(pset.vars, "ECHO");
- if (var && strncmp(var, "queries", strlen(var)) == 0)
- puts(query);
- }
- cancelConn = pset.db;
+/*
+ * SetCancelConn
+ *
+ * Set cancelConn to point to the current database connection.
+ */
+void
+SetCancelConn(void)
+{
+ PGcancel *oldCancelConn;
-#ifndef WIN32
- if (pset.timing)
- gettimeofday(&before, NULL);
- results = PQexec(pset.db, query);
- if (pset.timing)
- gettimeofday(&after, NULL);
-#else
- if (pset.timing)
- _ftime(&before);
- results = PQexec(pset.db, query);
- if (pset.timing)
- _ftime(&after);
+#ifdef WIN32
+ EnterCriticalSection(&cancelConnLock);
#endif
- 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;
+ /* Free the old one if we have one */
+ oldCancelConn = cancelConn;
+ /* be sure handle_sigint doesn't use pointer while freeing */
+ cancelConn = NULL;
- if (results == NULL)
- {
- fputs(PQerrorMessage(pset.db), pset.queryFout);
- success = false;
- }
- else
- {
- switch (PQresultStatus(results))
- {
- case PGRES_TUPLES_OK:
- /* write output to \g argument, if any */
- if (pset.gfname)
- {
- FILE *queryFout_copy = pset.queryFout;
- bool queryFoutPipe_copy = pset.queryFoutPipe;
+ if (oldCancelConn != NULL)
+ PQfreeCancel(oldCancelConn);
- pset.queryFout = stdout; /* so it doesn't get
- * closed */
+ cancelConn = PQgetCancel(pset.db);
- /* open file/pipe */
- if (!setQFout(pset.gfname))
- {
- pset.queryFout = queryFout_copy;
- pset.queryFoutPipe = queryFoutPipe_copy;
- success = false;
- break;
- }
+#ifdef WIN32
+ LeaveCriticalSection(&cancelConnLock);
+#endif
+}
+
+
+/*
+ * ResetCancelConn
+ *
+ * Free the current cancel connection, if any, and set to NULL.
+ */
+void
+ResetCancelConn(void)
+{
+ PGcancel *oldCancelConn;
- printQuery(results, &pset.popt, pset.queryFout);
+#ifdef WIN32
+ EnterCriticalSection(&cancelConnLock);
+#endif
- /* close file/pipe, restore old setting */
- setQFout(NULL);
+ oldCancelConn = cancelConn;
+ /* be sure handle_sigint doesn't use pointer while freeing */
+ cancelConn = NULL;
- pset.queryFout = queryFout_copy;
- pset.queryFoutPipe = queryFoutPipe_copy;
+ if (oldCancelConn != NULL)
+ PQfreeCancel(oldCancelConn);
- free(pset.gfname);
- pset.gfname = NULL;
+#ifdef WIN32
+ LeaveCriticalSection(&cancelConnLock);
+#endif
+}
- success = true;
- }
- else
- {
- printQuery(results, &pset.popt, pset.queryFout);
- success = true;
- }
- 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())
- fprintf(pset.queryFout, "%s\n", PQcmdStatus(results));
- SetVariable(pset.vars, "LASTOID", buf);
- break;
- }
- case PGRES_COPY_OUT:
- success = handleCopyOut(pset.db, pset.queryFout);
- break;
+/*
+ * AcceptResult
+ *
+ * Checks whether a result is valid, giving an error message if necessary;
+ * 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;
+ if (!result)
+ OK = false;
+ else
+ switch (PQresultStatus(result))
+ {
+ case PGRES_COMMAND_OK:
+ case PGRES_TUPLES_OK:
+ case PGRES_EMPTY_QUERY:
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);
+ case PGRES_COPY_OUT:
+ /* Fine, do nothing */
break;
- case PGRES_NONFATAL_ERROR:
- case PGRES_FATAL_ERROR:
- case PGRES_BAD_RESPONSE:
- success = false;
- psql_error("%s", PQerrorMessage(pset.db));
+ default:
+ OK = false;
break;
}
- fflush(pset.queryFout);
+ if (!OK)
+ {
+ const char *error = PQerrorMessage(pset.db);
+
+ if (strlen(error))
+ psql_error("%s", error);
- if (PQstatus(pset.db) == CONNECTION_BAD)
+ CheckConnection();
+ }
+
+ return OK;
+}
+
+
+
+/*
+ * PSQLexec
+ *
+ * This is the way to send "backdoor" queries (those not directly entered
+ * by the user). It is subject to -E but not -e.
+ *
+ * In autocommit-off mode, a new transaction block is started if start_xact
+ * is true; nothing special is done when start_xact is false. Typically,
+ * start_xact = false is used for SELECTs and explicit BEGIN/COMMIT commands.
+ *
+ * Caller is responsible for handling the ensuing processing if a COPY
+ * command is sent.
+ *
+ * Note: we don't bother to check PQclientEncoding; it is assumed that no
+ * caller uses this path to issue "SET CLIENT_ENCODING".
+ */
+PGresult *
+PSQLexec(const char *query, bool start_xact)
+{
+ PGresult *res;
+
+ if (!pset.db)
+ {
+ psql_error("You are currently not connected to a database.\n");
+ return NULL;
+ }
+
+ if (pset.echo_hidden != PSQL_ECHO_HIDDEN_OFF)
+ {
+ printf(_("********* QUERY **********\n"
+ "%s\n"
+ "**************************\n\n"), query);
+ fflush(stdout);
+ if (pset.logfile)
{
- 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);
- if (PQstatus(pset.db) == CONNECTION_BAD)
- {
- fputs(gettext("Failed.\n"), stderr);
- PQfinish(pset.db);
- PQclear(results);
- 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);
- return false;
- }
- else
- fputs(gettext("Succeeded.\n"), stderr);
+ fprintf(pset.logfile,
+ _("********* QUERY **********\n"
+ "%s\n"
+ "**************************\n\n"), query);
+ fflush(pset.logfile);
}
- /* check for asynchronous notification returns */
- while ((notify = PQnotifies(pset.db)) != NULL)
+ if (pset.echo_hidden == PSQL_ECHO_HIDDEN_NOEXEC)
+ return NULL;
+ }
+
+ SetCancelConn();
+
+ if (start_xact &&
+ !pset.autocommit &&
+ PQtransactionStatus(pset.db) == PQTRANS_IDLE)
+ {
+ res = PQexec(pset.db, "BEGIN");
+ if (PQresultStatus(res) != PGRES_COMMAND_OK)
{
- fprintf(pset.queryFout, gettext("Asynchronous NOTIFY '%s' from backend with pid %d received.\n"),
- notify->relname, notify->be_pid);
- free(notify);
- fflush(pset.queryFout);
+ psql_error("%s", PQerrorMessage(pset.db));
+ PQclear(res);
+ ResetCancelConn();
+ return NULL;
}
-
- if (results)
- PQclear(results);
+ PQclear(res);
}
- /* Possible microtiming output */
- if (pset.timing && success)
-#ifndef WIN32
- printf(gettext("Time: %.2f ms\n"),
- ((after.tv_sec - before.tv_sec) * 1000000.0 + after.tv_usec - before.tv_usec) / 1000.0);
-#else
- printf(gettext("Time: %.2f ms\n"),
- ((after.time - before.time) * 1000.0 + after.millitm - before.millitm));
-#endif
+ res = PQexec(pset.db, query);
- return success;
+ ResetCancelConn();
+
+ if (!AcceptResult(res))
+ {
+ PQclear(res);
+ res = NULL;
+ }
+
+ return res;
}
+
/*
- * PageOutput
- *
- * Tests if pager is needed and returns appropriate FILE pointer.
+ * PrintNotifications: check for asynchronous notifications, and print them out
*/
-FILE *
-PageOutput(int lines, bool pager)
+static void
+PrintNotifications(void)
{
- /* check whether we need / can / are supposed to use pager */
- if (pager
-#ifndef WIN32
- &&
- isatty(fileno(stdin)) &&
- isatty(fileno(stdout))
-#endif
- )
+ PGnotify *notify;
+
+ while ((notify = PQnotifies(pset.db)))
{
- const char *pagerprog;
+ /* for backward compatibility, only show payload if nonempty */
+ if (notify->extra[0])
+ fprintf(pset.queryFout, _("Asynchronous notification \"%s\" with payload \"%s\" received from server process with PID %d.\n"),
+ notify->relname, notify->extra, notify->be_pid);
+ else
+ fprintf(pset.queryFout, _("Asynchronous notification \"%s\" received from server process with PID %d.\n"),
+ notify->relname, notify->be_pid);
+ fflush(pset.queryFout);
+ PQfreemem(notify);
+ }
+}
-#ifdef TIOCGWINSZ
- int result;
- struct winsize screen_size;
- result = ioctl(fileno(stdout), TIOCGWINSZ, &screen_size);
- if (result == -1 || lines > screen_size.ws_row || pager > 1)
- {
-#endif
- pagerprog = getenv("PAGER");
- if (!pagerprog)
- pagerprog = DEFAULT_PAGER;
+/*
+ * PrintQueryTuples: assuming query result is OK, print its tuples
+ *
+ * Returns true if successful, false otherwise.
+ */
+static bool
+PrintQueryTuples(const PGresult *results)
+{
+ printQueryOpt my_popt = pset.popt;
+
+ /* write output to \g argument, if any */
+ if (pset.gfname)
+ {
+ /* keep this code in sync with ExecQueryUsingCursor */
+ 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;
+ return false;
+ }
+
+ printQuery(results, &my_popt, pset.queryFout, pset.logfile);
+
+ /* 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, &my_popt, pset.queryFout, pset.logfile);
+
+ return true;
+}
+
+
+/*
+ * ProcessCopyResult: if command was a COPY FROM STDIN/TO STDOUT, handle it
+ *
+ * Note: Utility function for use by SendQuery() only.
+ *
+ * Returns true if the query executed successfully, false otherwise.
+ */
+static bool
+ProcessCopyResult(PGresult *results)
+{
+ bool success = false;
+
+ if (!results)
+ return false;
+
+ switch (PQresultStatus(results))
+ {
+ case PGRES_TUPLES_OK:
+ case PGRES_COMMAND_OK:
+ case PGRES_EMPTY_QUERY:
+ /* nothing to do here */
+ success = true;
+ break;
+
+ case PGRES_COPY_OUT:
+ SetCancelConn();
+ success = handleCopyOut(pset.db, pset.queryFout);
+ ResetCancelConn();
+ break;
+
+ case PGRES_COPY_IN:
+ SetCancelConn();
+ success = handleCopyIn(pset.db, pset.cur_cmd_source,
+ PQbinaryTuples(results));
+ ResetCancelConn();
+ break;
+
+ default:
+ break;
+ }
+
+ /* may need this to recover from conn loss during COPY */
+ if (!CheckConnection())
+ return false;
+
+ return success;
+}
+
+
+/*
+ * PrintQueryStatus: report command status as required
+ *
+ * Note: Utility function for use by PrintQueryResults() only.
+ */
+static void
+PrintQueryStatus(PGresult *results)
+{
+ char buf[16];
+
+ if (!pset.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
+ *
+ * Note: Utility function for use by SendQuery() only.
+ *
+ * Returns true if the query executed successfully, false otherwise.
+ */
+static bool
+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:
+ PrintQueryStatus(results);
+ success = true;
+ break;
+
+ case PGRES_EMPTY_QUERY:
+ success = true;
+ break;
+
+ case PGRES_COPY_OUT:
+ case PGRES_COPY_IN:
+ /* nothing to do here */
+ success = true;
+ break;
+
+ default:
+ break;
+ }
+
+ fflush(pset.queryFout);
+
+ 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;
+ PGTransactionStatusType transaction_status;
+ double elapsed_msec = 0;
+ bool OK,
+ on_error_rollback_savepoint = false;
+ static bool on_error_rollback_warning = false;
+
+ if (!pset.db)
+ {
+ psql_error("You are currently not connected to a database.\n");
+ return false;
+ }
+
+ if (pset.singlestep)
+ {
+ char buf[3];
+
+ printf(_("***(Single step mode: verify command)*******************************************\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')
+ return false;
+ }
+ else if (pset.echo == PSQL_ECHO_QUERIES)
+ {
+ puts(query);
+ fflush(stdout);
+ }
+
+ if (pset.logfile)
+ {
+ fprintf(pset.logfile,
+ _("********* QUERY **********\n"
+ "%s\n"
+ "**************************\n\n"), query);
+ fflush(pset.logfile);
+ }
+
+ SetCancelConn();
+
+ transaction_status = PQtransactionStatus(pset.db);
+
+ if (transaction_status == PQTRANS_IDLE &&
+ !pset.autocommit &&
+ !command_no_begin(query))
+ {
+ results = PQexec(pset.db, "BEGIN");
+ if (PQresultStatus(results) != PGRES_COMMAND_OK)
+ {
+ psql_error("%s", PQerrorMessage(pset.db));
+ PQclear(results);
+ ResetCancelConn();
+ return false;
+ }
+ PQclear(results);
+ transaction_status = PQtransactionStatus(pset.db);
+ }
+
+ if (transaction_status == PQTRANS_INTRANS &&
+ pset.on_error_rollback != PSQL_ERROR_ROLLBACK_OFF &&
+ (pset.cur_cmd_interactive ||
+ pset.on_error_rollback == PSQL_ERROR_ROLLBACK_ON))
+ {
+ if (on_error_rollback_warning == false && pset.sversion < 80000)
+ {
+ fprintf(stderr, _("The server (version %d.%d) does not support savepoints for ON_ERROR_ROLLBACK.\n"),
+ pset.sversion / 10000, (pset.sversion / 100) % 100);
+ on_error_rollback_warning = true;
+ }
+ else
+ {
+ results = PQexec(pset.db, "SAVEPOINT pg_psql_temporary_savepoint");
+ if (PQresultStatus(results) != PGRES_COMMAND_OK)
+ {
+ psql_error("%s", PQerrorMessage(pset.db));
+ PQclear(results);
+ ResetCancelConn();
+ return false;
+ }
+ PQclear(results);
+ on_error_rollback_savepoint = true;
+ }
+ }
+
+ if (pset.fetch_count <= 0 || !is_select_command(query))
+ {
+ /* Default fetch-it-all-and-print mode */
+ instr_time before,
+ after;
+
+ if (pset.timing)
+ INSTR_TIME_SET_CURRENT(before);
+
+ results = PQexec(pset.db, query);
+
+ /* these operations are included in the timing result: */
+ ResetCancelConn();
+ OK = (AcceptResult(results) && ProcessCopyResult(results));
+
+ if (pset.timing)
+ {
+ INSTR_TIME_SET_CURRENT(after);
+ INSTR_TIME_SUBTRACT(after, before);
+ elapsed_msec = INSTR_TIME_GET_MILLISEC(after);
+ }
+
+ /* but printing results isn't: */
+ if (OK)
+ OK = PrintQueryResults(results);
+ }
+ else
+ {
+ /* Fetch-in-segments mode */
+ OK = ExecQueryUsingCursor(query, &elapsed_msec);
+ ResetCancelConn();
+ results = NULL; /* PQclear(NULL) does nothing */
+ }
+
+ /* If we made a temporary savepoint, possibly release/rollback */
+ if (on_error_rollback_savepoint)
+ {
+ const char *svptcmd;
+
+ transaction_status = PQtransactionStatus(pset.db);
+
+ if (transaction_status == PQTRANS_INERROR)
+ {
+ /* We always rollback on an error */
+ svptcmd = "ROLLBACK TO pg_psql_temporary_savepoint";
+ }
+ else if (transaction_status != PQTRANS_INTRANS)
+ {
+ /* If they are no longer in a transaction, then do nothing */
+ svptcmd = NULL;
+ }
+ else
+ {
+ /*
+ * Do nothing if they are messing with savepoints themselves: If
+ * the user did RELEASE or ROLLBACK, our savepoint is gone. If
+ * they issued a SAVEPOINT, releasing ours would remove theirs.
+ */
+ if (results &&
+ (strcmp(PQcmdStatus(results), "SAVEPOINT") == 0 ||
+ strcmp(PQcmdStatus(results), "RELEASE") == 0 ||
+ strcmp(PQcmdStatus(results), "ROLLBACK") == 0))
+ svptcmd = NULL;
+ else
+ svptcmd = "RELEASE pg_psql_temporary_savepoint";
+ }
+
+ if (svptcmd)
+ {
+ PGresult *svptres;
+
+ svptres = PQexec(pset.db, svptcmd);
+ if (PQresultStatus(svptres) != PGRES_COMMAND_OK)
+ {
+ psql_error("%s", PQerrorMessage(pset.db));
+ PQclear(svptres);
+
+ PQclear(results);
+ ResetCancelConn();
+ return false;
+ }
+ PQclear(svptres);
+ }
+ }
+
+ PQclear(results);
+
+ /* Possible microtiming output */
+ if (OK && pset.timing)
+ printf(_("Time: %.3f ms\n"), elapsed_msec);
+
+ /* check for events that may occur during query execution */
+
+ if (pset.encoding != PQclientEncoding(pset.db) &&
+ PQclientEncoding(pset.db) >= 0)
+ {
+ /* track effects of SET CLIENT_ENCODING */
+ pset.encoding = PQclientEncoding(pset.db);
+ pset.popt.topt.encoding = pset.encoding;
+ SetVariable(pset.vars, "ENCODING",
+ pg_encoding_to_char(pset.encoding));
+ }
+
+ PrintNotifications();
+
+ return OK;
+}
+
+
+/*
+ * ExecQueryUsingCursor: run a SELECT-like query using a cursor
+ *
+ * This feature allows result sets larger than RAM to be dealt with.
+ *
+ * Returns true if the query executed successfully, false otherwise.
+ *
+ * If pset.timing is on, total query time (exclusive of result-printing) is
+ * stored into *elapsed_msec.
+ */
+static bool
+ExecQueryUsingCursor(const char *query, double *elapsed_msec)
+{
+ bool OK = true;
+ PGresult *results;
+ PQExpBufferData buf;
+ printQueryOpt my_popt = pset.popt;
+ FILE *queryFout_copy = pset.queryFout;
+ bool queryFoutPipe_copy = pset.queryFoutPipe;
+ bool started_txn = false;
+ bool did_pager = false;
+ int ntuples;
+ char fetch_cmd[64];
+ instr_time before,
+ after;
+ int flush_error;
+
+ *elapsed_msec = 0;
+
+ /* initialize print options for partial table output */
+ my_popt.topt.start_table = true;
+ my_popt.topt.stop_table = false;
+ my_popt.topt.prior_records = 0;
+
+ if (pset.timing)
+ INSTR_TIME_SET_CURRENT(before);
+
+ /* if we're not in a transaction, start one */
+ if (PQtransactionStatus(pset.db) == PQTRANS_IDLE)
+ {
+ results = PQexec(pset.db, "BEGIN");
+ OK = AcceptResult(results) &&
+ (PQresultStatus(results) == PGRES_COMMAND_OK);
+ PQclear(results);
+ if (!OK)
+ return false;
+ started_txn = true;
+ }
+
+ /* Send DECLARE CURSOR */
+ initPQExpBuffer(&buf);
+ appendPQExpBuffer(&buf, "DECLARE _psql_cursor NO SCROLL CURSOR FOR\n%s",
+ query);
+
+ results = PQexec(pset.db, buf.data);
+ OK = AcceptResult(results) &&
+ (PQresultStatus(results) == PGRES_COMMAND_OK);
+ PQclear(results);
+ termPQExpBuffer(&buf);
+ if (!OK)
+ goto cleanup;
+
+ if (pset.timing)
+ {
+ INSTR_TIME_SET_CURRENT(after);
+ INSTR_TIME_SUBTRACT(after, before);
+ *elapsed_msec += INSTR_TIME_GET_MILLISEC(after);
+ }
+
+ snprintf(fetch_cmd, sizeof(fetch_cmd),
+ "FETCH FORWARD %d FROM _psql_cursor",
+ pset.fetch_count);
+
+ /* prepare to write output to \g argument, if any */
+ if (pset.gfname)
+ {
+ /* keep this code in sync with PrintQueryTuples */
+ pset.queryFout = stdout; /* so it doesn't get closed */
+
+ /* open file/pipe */
+ if (!setQFout(pset.gfname))
+ {
+ pset.queryFout = queryFout_copy;
+ pset.queryFoutPipe = queryFoutPipe_copy;
+ OK = false;
+ goto cleanup;
+ }
+ }
+
+ /* clear any pre-existing error indication on the output stream */
+ clearerr(pset.queryFout);
+
+ for (;;)
+ {
+ if (pset.timing)
+ INSTR_TIME_SET_CURRENT(before);
+
+ /* get FETCH_COUNT tuples at a time */
+ results = PQexec(pset.db, fetch_cmd);
+
+ if (pset.timing)
+ {
+ INSTR_TIME_SET_CURRENT(after);
+ INSTR_TIME_SUBTRACT(after, before);
+ *elapsed_msec += INSTR_TIME_GET_MILLISEC(after);
+ }
+
+ if (PQresultStatus(results) != PGRES_TUPLES_OK)
+ {
+ /* shut down pager before printing error message */
+ if (did_pager)
+ {
+ ClosePager(pset.queryFout);
+ pset.queryFout = queryFout_copy;
+ pset.queryFoutPipe = queryFoutPipe_copy;
+ did_pager = false;
+ }
+
+ OK = AcceptResult(results);
+ psql_assert(!OK);
+ PQclear(results);
+ break;
+ }
+
+ ntuples = PQntuples(results);
+
+ if (ntuples < pset.fetch_count)
+ {
+ /* this is the last result set, so allow footer decoration */
+ my_popt.topt.stop_table = true;
+ }
+ else if (pset.queryFout == stdout && !did_pager)
+ {
+ /*
+ * If query requires multiple result sets, hack to ensure that
+ * only one pager instance is used for the whole mess
+ */
+ pset.queryFout = PageOutput(100000, my_popt.topt.pager);
+ did_pager = true;
+ }
+
+ printQuery(results, &my_popt, pset.queryFout, pset.logfile);
+
+ PQclear(results);
+
+ /* after the first result set, disallow header decoration */
+ my_popt.topt.start_table = false;
+ my_popt.topt.prior_records += ntuples;
+
+ /*
+ * Make sure to flush the output stream, so intermediate results are
+ * visible to the client immediately. We check the results because if
+ * the pager dies/exits/etc, there's no sense throwing more data at
+ * it.
+ */
+ flush_error = fflush(pset.queryFout);
+
+ /*
+ * Check if we are at the end, if a cancel was pressed, or if there
+ * were any errors either trying to flush out the results, or more
+ * generally on the output stream at all. If we hit any errors
+ * writing things to the stream, we presume $PAGER has disappeared and
+ * stop bothering to pull down more data.
+ */
+ if (ntuples < pset.fetch_count || cancel_pressed || flush_error ||
+ ferror(pset.queryFout))
+ break;
+ }
+
+ /* close \g argument file/pipe, restore old setting */
+ if (pset.gfname)
+ {
+ /* keep this code in sync with PrintQueryTuples */
+ setQFout(NULL);
+
+ pset.queryFout = queryFout_copy;
+ pset.queryFoutPipe = queryFoutPipe_copy;
+
+ free(pset.gfname);
+ pset.gfname = NULL;
+ }
+ else if (did_pager)
+ {
+ ClosePager(pset.queryFout);
+ pset.queryFout = queryFout_copy;
+ pset.queryFoutPipe = queryFoutPipe_copy;
+ }
+
+cleanup:
+ if (pset.timing)
+ INSTR_TIME_SET_CURRENT(before);
+
+ /*
+ * We try to close the cursor on either success or failure, but on failure
+ * ignore the result (it's probably just a bleat about being in an aborted
+ * transaction)
+ */
+ results = PQexec(pset.db, "CLOSE _psql_cursor");
+ if (OK)
+ {
+ OK = AcceptResult(results) &&
+ (PQresultStatus(results) == PGRES_COMMAND_OK);
+ }
+ PQclear(results);
+
+ if (started_txn)
+ {
+ results = PQexec(pset.db, OK ? "COMMIT" : "ROLLBACK");
+ OK &= AcceptResult(results) &&
+ (PQresultStatus(results) == PGRES_COMMAND_OK);
+ PQclear(results);
+ }
+
+ if (pset.timing)
+ {
+ INSTR_TIME_SET_CURRENT(after);
+ INSTR_TIME_SUBTRACT(after, before);
+ *elapsed_msec += INSTR_TIME_GET_MILLISEC(after);
+ }
+
+ return OK;
+}
+
+
+/*
+ * Advance the given char pointer over white space and SQL comments.
+ */
+static const char *
+skip_white_space(const char *query)
+{
+ int cnestlevel = 0; /* slash-star comment nest level */
+
+ while (*query)
+ {
+ int mblen = PQmblen(query, pset.encoding);
+
+ /*
+ * Note: we assume the encoding is a superset of ASCII, so that for
+ * example "query[0] == '/'" is meaningful. However, we do NOT assume
+ * that the second and subsequent bytes of a multibyte character
+ * couldn't look like ASCII characters; so it is critical to advance
+ * by mblen, not 1, whenever we haven't exactly identified the
+ * character we are skipping over.
+ */
+ if (isspace((unsigned char) *query))
+ query += mblen;
+ else if (query[0] == '/' && query[1] == '*')
+ {
+ cnestlevel++;
+ query += 2;
+ }
+ else if (cnestlevel > 0 && query[0] == '*' && query[1] == '/')
+ {
+ cnestlevel--;
+ query += 2;
+ }
+ else if (cnestlevel == 0 && query[0] == '-' && query[1] == '-')
+ {
+ query += 2;
+
+ /*
+ * We have to skip to end of line since any slash-star inside the
+ * -- comment does NOT start a slash-star comment.
+ */
+ while (*query)
+ {
+ if (*query == '\n')
+ {
+ query++;
+ break;
+ }
+ query += PQmblen(query, pset.encoding);
+ }
+ }
+ else if (cnestlevel > 0)
+ query += mblen;
+ else
+ break; /* found first token */
+ }
+
+ return query;
+}
+
+
+/*
+ * Check whether a command is one of those for which we should NOT start
+ * a new transaction block (ie, send a preceding BEGIN).
+ *
+ * These include the transaction control statements themselves, plus
+ * certain statements that the backend disallows inside transaction blocks.
+ */
+static bool
+command_no_begin(const char *query)
+{
+ int wordlen;
+
+ /*
+ * First we must advance over any whitespace and comments.
+ */
+ query = skip_white_space(query);
+
+ /*
+ * Check word length (since "beginx" is not "begin").
+ */
+ wordlen = 0;
+ while (isalpha((unsigned char) query[wordlen]))
+ wordlen += PQmblen(&query[wordlen], pset.encoding);
+
+ /*
+ * Transaction control commands. These should include every keyword that
+ * gives rise to a TransactionStmt in the backend grammar, except for the
+ * savepoint-related commands.
+ *
+ * (We assume that START must be START TRANSACTION, since there is
+ * presently no other "START foo" command.)
+ */
+ if (wordlen == 5 && pg_strncasecmp(query, "abort", 5) == 0)
+ return true;
+ if (wordlen == 5 && pg_strncasecmp(query, "begin", 5) == 0)
+ return true;
+ if (wordlen == 5 && pg_strncasecmp(query, "start", 5) == 0)
+ return true;
+ if (wordlen == 6 && pg_strncasecmp(query, "commit", 6) == 0)
+ return true;
+ if (wordlen == 3 && pg_strncasecmp(query, "end", 3) == 0)
+ return true;
+ if (wordlen == 8 && pg_strncasecmp(query, "rollback", 8) == 0)
+ return true;
+ if (wordlen == 7 && pg_strncasecmp(query, "prepare", 7) == 0)
+ {
+ /* PREPARE TRANSACTION is a TC command, PREPARE foo is not */
+ query += wordlen;
+
+ query = skip_white_space(query);
+
+ wordlen = 0;
+ while (isalpha((unsigned char) query[wordlen]))
+ wordlen += PQmblen(&query[wordlen], pset.encoding);
+
+ if (wordlen == 11 && pg_strncasecmp(query, "transaction", 11) == 0)
+ return true;
+ return false;
+ }
+
+ /*
+ * Commands not allowed within transactions. The statements checked for
+ * here should be exactly those that call PreventTransactionChain() in the
+ * backend.
+ */
+ if (wordlen == 6 && pg_strncasecmp(query, "vacuum", 6) == 0)
+ return true;
+ if (wordlen == 7 && pg_strncasecmp(query, "cluster", 7) == 0)
+ {
+ /* CLUSTER with any arguments is allowed in transactions */
+ query += wordlen;
+
+ query = skip_white_space(query);
+
+ if (isalpha((unsigned char) query[0]))
+ return false; /* has additional words */
+ return true; /* it's CLUSTER without arguments */
+ }
+
+ if (wordlen == 6 && pg_strncasecmp(query, "create", 6) == 0)
+ {
+ query += wordlen;
+
+ query = skip_white_space(query);
+
+ wordlen = 0;
+ while (isalpha((unsigned char) query[wordlen]))
+ wordlen += PQmblen(&query[wordlen], pset.encoding);
+
+ if (wordlen == 8 && pg_strncasecmp(query, "database", 8) == 0)
+ return true;
+ if (wordlen == 10 && pg_strncasecmp(query, "tablespace", 10) == 0)
+ return true;
+
+ /* CREATE [UNIQUE] INDEX CONCURRENTLY isn't allowed in xacts */
+ if (wordlen == 6 && pg_strncasecmp(query, "unique", 6) == 0)
+ {
+ query += wordlen;
+
+ query = skip_white_space(query);
+
+ wordlen = 0;
+ while (isalpha((unsigned char) query[wordlen]))
+ wordlen += PQmblen(&query[wordlen], pset.encoding);
+ }
+
+ if (wordlen == 5 && pg_strncasecmp(query, "index", 5) == 0)
+ {
+ query += wordlen;
+
+ query = skip_white_space(query);
+
+ wordlen = 0;
+ while (isalpha((unsigned char) query[wordlen]))
+ wordlen += PQmblen(&query[wordlen], pset.encoding);
+
+ if (wordlen == 12 && pg_strncasecmp(query, "concurrently", 12) == 0)
+ return true;
+ }
+
+ return false;
+ }
+
+ /*
+ * Note: these tests will match DROP SYSTEM and REINDEX TABLESPACE, which
+ * aren't really valid commands so we don't care much. The other four
+ * possible matches are correct.
+ */
+ if ((wordlen == 4 && pg_strncasecmp(query, "drop", 4) == 0) ||
+ (wordlen == 7 && pg_strncasecmp(query, "reindex", 7) == 0))
+ {
+ query += wordlen;
+
+ query = skip_white_space(query);
+
+ wordlen = 0;
+ while (isalpha((unsigned char) query[wordlen]))
+ wordlen += PQmblen(&query[wordlen], pset.encoding);
+
+ if (wordlen == 8 && pg_strncasecmp(query, "database", 8) == 0)
+ return true;
+ if (wordlen == 6 && pg_strncasecmp(query, "system", 6) == 0)
+ return true;
+ if (wordlen == 10 && pg_strncasecmp(query, "tablespace", 10) == 0)
+ return true;
+ }
+
+ return false;
+}
+
+
+/*
+ * Check whether the specified command is a SELECT (or VALUES).
+ */
+static bool
+is_select_command(const char *query)
+{
+ int wordlen;
+
+ /*
+ * First advance over any whitespace, comments and left parentheses.
+ */
+ for (;;)
+ {
+ query = skip_white_space(query);
+ if (query[0] == '(')
+ query++;
+ else
+ break;
+ }
+
+ /*
+ * Check word length (since "selectx" is not "select").
+ */
+ wordlen = 0;
+ while (isalpha((unsigned char) query[wordlen]))
+ wordlen += PQmblen(&query[wordlen], pset.encoding);
+
+ if (wordlen == 6 && pg_strncasecmp(query, "select", 6) == 0)
+ return true;
+
+ if (wordlen == 6 && pg_strncasecmp(query, "values", 6) == 0)
+ return true;
+
+ return false;
+}
+
+
+/*
+ * Test if the current user is a database superuser.
+ *
+ * Note: this will correctly detect superuserness only with a protocol-3.0
+ * or newer backend; otherwise it will always say "false".
+ */
+bool
+is_superuser(void)
+{
+ const char *val;
+
+ if (!pset.db)
+ return false;
+
+ val = PQparameterStatus(pset.db, "is_superuser");
+
+ if (val && strcmp(val, "on") == 0)
+ return true;
+
+ return false;
+}
+
+
+/*
+ * 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.
+ *
+ * Note: this will correctly detect the session user only with a
+ * protocol-3.0 or newer backend; otherwise it will return the
+ * connection user.
+ */
+const char *
+session_username(void)
+{
+ const char *val;
+
+ if (!pset.db)
+ return NULL;
+
+ val = PQparameterStatus(pset.db, "session_authorization");
+ if (val)
+ return val;
+ else
+ return PQuser(pset.db);
+}
+
+
+/* expand_tilde
+ *
+ * substitute '~' with HOME or '~username' with username's home dir
+ *
+ */
+char *
+expand_tilde(char **filename)
+{
+ if (!filename || !(*filename))
+ return NULL;
+
+ /*
+ * WIN32 doesn't use tilde expansion for file names. Also, it uses tilde
+ * for short versions of long file names, though the tilde is usually
+ * toward the end, not at the beginning.
+ */
#ifndef WIN32
- pqsignal(SIGPIPE, SIG_IGN);
-#endif
- return popen(pagerprog, "w");
-#ifdef TIOCGWINSZ
+
+ /* try tilde expansion */
+ if (**filename == '~')
+ {
+ char *fn;
+ char oldp,
+ *p;
+ struct passwd *pw;
+ char home[MAXPGPATH];
+
+ fn = *filename;
+ *home = '\0';
+
+ p = fn + 1;
+ while (*p != '/' && *p != '\0')
+ p++;
+
+ oldp = *p;
+ *p = '\0';
+
+ if (*(fn + 1) == '\0')
+ get_home_path(home); /* ~ or ~/ only */
+ else if ((pw = getpwnam(fn + 1)) != NULL)
+ strlcpy(home, pw->pw_dir, sizeof(home)); /* ~user */
+
+ *p = oldp;
+ if (strlen(home) != 0)
+ {
+ char *newfn;
+
+ newfn = pg_malloc(strlen(home) + strlen(p) + 1);
+ strcpy(newfn, home);
+ strcat(newfn, p);
+
+ free(fn);
+ *filename = newfn;
}
-#endif
}
+#endif
- return stdout;
+ return *filename;
}