*
* Copyright 2000 by PostgreSQL Global Development Group
*
- * $Header: /cvsroot/pgsql/src/bin/psql/common.c,v 1.25 2000/11/13 23:37:53 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/bin/psql/common.c,v 1.64 2003/06/12 08:15:28 momjian Exp $
*/
-#include "postgres.h"
+#include "postgres_fe.h"
#include "common.h"
#include <errno.h>
#include <stdarg.h>
-#ifdef HAVE_TERMIOS_H
-#include <termios.h>
-#endif
#ifndef HAVE_STRDUP
#include <strdup.h>
#endif
#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
#include "libpq-fe.h"
-#include "postgres_ext.h"
#include "pqsignal.h"
#include "settings.h"
#include "mainloop.h"
+/* 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
+
+extern bool prompt_state;
+
/*
* "Safe" wrapper around strdup()
*/
if (!string)
{
- fprintf(stderr, "%s: xstrdup: cannot duplicate null pointer (internal error)\n",
+ fprintf(stderr, gettext("%s: xstrdup: cannot duplicate null pointer (internal error)\n"),
pset.progname);
exit(EXIT_FAILURE);
}
/* 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;
if (pset.inputfile)
fprintf(stderr, "%s:%s:%u: ", pset.progname, pset.inputfile, pset.lineno);
va_start(ap, fmt);
- vfprintf(stderr, fmt, ap);
+ vfprintf(stderr, gettext(fmt), ap);
va_end(ap);
}
/*
- * for backend NOTICES
+ * for backend Notice messages (INFO, WARNING, etc)
*/
void
NoticeProcessor(void *arg, const char *message)
-/*
- * simple_prompt
- *
- * Generalized function especially intended for reading in usernames and
- * password interactively. Reads from stdin.
- *
- * prompt: The prompt to print
- * maxlen: How many characters to accept
- * echo: Set to false if you want to hide what is entered (for passwords)
- *
- * Returns a malloc()'ed string with the input (w/o trailing newline).
- */
-static bool prompt_state;
-
-char *
-simple_prompt(const char *prompt, int maxlen, bool echo)
-{
- int length;
- char *destination;
-
-#ifdef HAVE_TERMIOS_H
- struct termios t_orig,
- t;
-
-#endif
-
- destination = (char *) malloc(maxlen + 2);
- if (!destination)
- return NULL;
- if (prompt)
- fputs(prompt, stderr);
-
- prompt_state = true;
-
-#ifdef HAVE_TERMIOS_H
- if (!echo)
- {
- tcgetattr(0, &t);
- t_orig = t;
- t.c_lflag &= ~ECHO;
- tcsetattr(0, TCSADRAIN, &t);
- }
-#endif
-
- fgets(destination, maxlen, stdin);
-
-#ifdef HAVE_TERMIOS_H
- if (!echo)
- {
- tcsetattr(0, TCSADRAIN, &t_orig);
- puts("");
- }
-#endif
-
- prompt_state = false;
-
- length = strlen(destination);
- if (length > 0 && destination[length - 1] != '\n')
- {
- /* eat rest of the line */
- char buf[512];
-
- do
- {
- fgets(buf, 512, stdin);
- } while (buf[strlen(buf) - 1] != '\n');
- }
-
- if (length > 0 && destination[length - 1] == '\n')
- /* remove trailing newline */
- destination[length - 1] = '\0';
-
- return destination;
-}
-
-
-
/*
* Code to support query cancellation
*
* so. We use write() to print to stdout because it's better to use simple
* facilities in a signal handler.
*/
+static PGconn *volatile cancelConn = NULL;
+
+volatile bool cancel_pressed = false;
-PGconn *cancelConn;
-volatile bool cancel_pressed;
#ifndef WIN32
void
handle_sigint(SIGNAL_ARGS)
{
+ int save_errno = errno;
+
/* Don't muck around if copying in or prompting for a password. */
if ((copy_in_state && pset.cur_cmd_interactive) || prompt_state)
return;
write_stderr("Could not send cancel request: ");
write_stderr(PQerrorMessage(cancelConn));
}
+ errno = save_errno; /* just in case the write changed it */
}
+#endif /* not WIN32 */
-#endif /* not WIN32 */
-/*
- * PSQLexec
+/* ConnectionUp
*
- * This is the way to send "backdoor" queries (those not directly entered
- * by the user). It is subject to -E but not -e.
+ * Returns whether our backend connection is still there.
*/
-PGresult *
-PSQLexec(const char *query)
+static bool
+ConnectionUp()
{
- PGresult *res;
- const char *var;
-
- if (!pset.db)
- {
- psql_error("You are currently not connected to a database.\n");
- return NULL;
- }
-
- var = GetVariable(pset.vars, "ECHO_HIDDEN");
- if (var)
- {
- printf("********* QUERY *********\n%s\n*************************\n\n", query);
- fflush(stdout);
- }
+ return PQstatus(pset.db) != CONNECTION_BAD;
+}
- if (var && strcmp(var, "noexec") == 0)
- return NULL;
- cancelConn = pset.db;
- res = PQexec(pset.db, query);
- 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;
- if (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("The connection to the server was lost. Attempting reset: ", stderr);
+
+ fputs(gettext("The connection to the server was lost. Attempting reset: "), stderr);
PQreset(pset.db);
- if (PQstatus(pset.db) == CONNECTION_BAD)
+ OK = ConnectionUp();
+ if (!OK)
{
- fputs("Failed.\n", stderr);
+ fputs(gettext("Failed.\n"), stderr);
PQfinish(pset.db);
- PQclear(res);
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);
- return NULL;
}
else
- fputs("Succeeded.\n", stderr);
+ fputs(gettext("Succeeded.\n"), stderr);
}
- 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
+ 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));
- PQclear(res);
- return NULL;
}
+
+ return OK;
}
/*
- * SendQuery: send the query string to the backend
- * (and print out results)
+ * PSQLexec
*
- * 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().
+ * This is the way to send "backdoor" queries (those not directly entered
+ * by the user). It is subject to -E but not -e.
*
- * Returns true if the query executed successfully, false otherwise.
+ * 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".
*/
-bool
-SendQuery(const char *query)
+PGresult *
+PSQLexec(const char *query, bool ignore_command_ok)
{
- bool success = false;
- PGresult *results;
- PGnotify *notify;
+ PGresult *res = NULL;
+ PGresult *newres;
+ int echo_hidden;
+ ExecStatusType rstatus;
if (!pset.db)
{
psql_error("You are currently not connected to a database.\n");
- return false;
+ return NULL;
}
- if (GetVariableBool(pset.vars, "SINGLESTEP"))
+ echo_hidden = SwitchVariable(pset.vars, "ECHO_HIDDEN", "noexec", NULL);
+ if (echo_hidden != var_notset)
{
- char buf[3];
-
- printf("***(Single step mode: Verify query)*********************************************\n"
+ printf("********* QUERY **********\n"
"%s\n"
- "***(press return to proceed or enter x and return to cancel)********************\n",
- query);
+ "**************************\n\n", query);
fflush(stdout);
- fgets(buf, 3, stdin);
- if (buf[0] == 'x')
- return false;
+
+ if (echo_hidden == 1)
+ return NULL;
}
- else
+
+ /* discard any uneaten results of past queries */
+ while ((newres = PQgetResult(pset.db)) != NULL)
+ PQclear(newres);
+
+ SetCancelConn();
+ if (!PQsendQuery(pset.db, query))
{
- const char *var = GetVariable(pset.vars, "ECHO");
+ psql_error("%s", PQerrorMessage(pset.db));
+ ResetCancelConn();
+ return NULL;
+ }
+
+ rstatus = PGRES_EMPTY_QUERY;
- if (var && strncmp(var, "queries", strlen(var)) == 0)
- puts(query);
+ while (rstatus != PGRES_COPY_IN &&
+ rstatus != PGRES_COPY_OUT &&
+ (newres = PQgetResult(pset.db)))
+ {
+ rstatus = PQresultStatus(newres);
+ if (!ignore_command_ok || rstatus != PGRES_COMMAND_OK)
+ {
+ PGresult *tempRes = res;
+ res = newres;
+ newres = tempRes;
+ }
+ PQclear(newres);
}
- cancelConn = pset.db;
- results = PQexec(pset.db, query);
- 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;
+ if (!AcceptResult(res) && res)
+ {
+ PQclear(res);
+ res = NULL;
+ }
+
+ return res;
+}
+
+
+
+/*
+ * PrintNotifications: check for asynchronous notifications, and print them out
+ *
+ */
+static void
+PrintNotifications(void)
+{
+ PGnotify *notify;
- if (results == NULL)
+ while ((notify = PQnotifies(pset.db)))
{
- fputs(PQerrorMessage(pset.db), pset.queryFout);
- success = false;
+ fprintf(pset.queryFout, gettext("Asynchronous NOTIFY '%s' from backend with pid %d received.\n"),
+ notify->relname, notify->be_pid);
+ PQfreemem(notify);
+ fflush(pset.queryFout);
}
- else
- {
- switch (PQresultStatus(results))
- {
- case PGRES_TUPLES_OK:
+}
+
+
+/*
+ * PrintQueryTuples: assuming query result is OK, print its tuples
+ *
+ * Returns true if successful, false otherwise.
+ */
+static bool
+PrintQueryTuples(const PGresult *results)
+{
/* write output to \g argument, if any */
if (pset.gfname)
{
FILE *queryFout_copy = pset.queryFout;
bool queryFoutPipe_copy = pset.queryFoutPipe;
- pset.queryFout = NULL; /* so it doesn't get
+ pset.queryFout = stdout; /* so it doesn't get
* closed */
/* open file/pipe */
if (!setQFout(pset.gfname))
{
- success = false;
- break;
+ pset.queryFout = queryFout_copy;
+ pset.queryFoutPipe = queryFoutPipe_copy;
+ return false;
}
printQuery(results, &pset.popt, pset.queryFout);
- /* close file/pipe */
+ /* close file/pipe, restore old setting */
setQFout(NULL);
- free(pset.gfname);
- pset.gfname = NULL;
-
pset.queryFout = queryFout_copy;
pset.queryFoutPipe = queryFoutPipe_copy;
- success = true;
- break;
+ free(pset.gfname);
+ pset.gfname = NULL;
}
else
{
- success = true;
printQuery(results, &pset.popt, pset.queryFout);
}
+
+ 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);
break;
case PGRES_EMPTY_QUERY:
success = true;
success = true;
sprintf(buf, "%u", (unsigned int) PQoidValue(results));
if (!QUIET())
- fprintf(pset.queryFout, "%s\n", PQcmdStatus(results));
+ {
+ 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));
+ }
+ }
SetVariable(pset.vars, "LASTOID", buf);
break;
}
case PGRES_COPY_IN:
if (pset.cur_cmd_interactive && !QUIET())
- puts("Enter data to be copied followed by a newline.\n"
- "End with a backslash and a period on a line by itself.");
+ 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;
- case PGRES_NONFATAL_ERROR:
- case PGRES_FATAL_ERROR:
- case PGRES_BAD_RESPONSE:
- success = false;
- psql_error("%s", PQerrorMessage(pset.db));
+ default:
break;
}
fflush(pset.queryFout);
- if (PQstatus(pset.db) == CONNECTION_BAD)
- {
- 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);
- if (PQstatus(pset.db) == CONNECTION_BAD)
- {
- fputs("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("Succeeded.\n", stderr);
- }
+ if (!CheckConnection()) return false;
- /* check for asynchronous notification returns */
- while ((notify = PQnotifies(pset.db)) != NULL)
- {
- fprintf(pset.queryFout, "Asynchronous NOTIFY '%s' from backend with pid '%d' received.\n",
- notify->relname, notify->be_pid);
- free(notify);
- fflush(pset.queryFout);
- }
+ /* Possible microtiming output */
+ if (pset.timing && success)
+ printf(gettext("Time: %.2f ms\n"), DIFF_MSEC(after, before));
+
+ return success;
+}
- if (results)
- PQclear(results);
+
+
+/*
+ * 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)
+ {
+ psql_error("You are currently not connected to a database.\n");
+ return false;
}
- return success;
+ if (GetVariableBool(pset.vars, "SINGLESTEP"))
+ {
+ 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')
+ return false;
+ }
+ else if (VariableEquals(pset.vars, "ECHO", "queries"))
+ puts(query);
+
+ SetCancelConn();
+
+ 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;
}
+
+
+char parse_char(char **buf)
+{
+ long l;
+
+ l = strtol(*buf, buf, 0);
+ --*buf;
+ return (char)l;
+}
+
+
projects / postgresql / blobdiff