Add schema-qualified relnames in constraint error messages.

From 402866a6899791e7f410ed747e3b0018eed717e0 Mon Sep 17 00:00:00 2001
From: Oleksandr Shulgin <oleksandr.shulgin@zalando.de>
Date: Wed, 6 Jan 2016 14:58:17 +0100
Subject: [PATCH] POC: \errverbose in psql

---
 src/bin/psql/command.c              |  20 ++++++
 src/bin/psql/common.c               |   6 +-
 src/bin/psql/settings.h             |   1 +
 src/bin/psql/startup.c              |   1 +
 src/interfaces/libpq/exports.txt    |   1 +
 src/interfaces/libpq/fe-exec.c      |  21 ++++++
 src/interfaces/libpq/fe-protocol3.c | 131 +++++++++++++++++++-----------------
 src/interfaces/libpq/libpq-fe.h     |   1 +
 src/interfaces/libpq/libpq-int.h    |   2 +
 9 files changed, 122 insertions(+), 62 deletions(-)

diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 9750a5b..9ae5ae5 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -822,6 +822,24 @@ exec_command(const char *cmd,
 		}
 	}
 
+	/* \errverbose -- display verbose error message from last result */
+	else if (strcmp(cmd, "errverbose") == 0)
+	{
+		char	   *errmsg;
+
+		if (pset.last_result && PQresultStatus(pset.last_result) == PGRES_FATAL_ERROR)
+		{
+			/* increase error verbosity for a moment */
+			PQsetErrorVerbosity(pset.db, PQERRORS_VERBOSE);
+			errmsg = PQresultBuildErrorMessage(pset.db, pset.last_result);
+			PQsetErrorVerbosity(pset.db, pset.verbosity);
+
+			psql_error("%s", errmsg);
+
+			PQfreemem(errmsg);
+		}
+	}
+
 	/* \f -- change field separator */
 	else if (strcmp(cmd, "f") == 0)
 	{
@@ -1865,6 +1883,8 @@ do_connect(char *dbname, char *user, char *host, char *port)
 			{
 				PQfinish(o_conn);
 				pset.db = NULL;
+				PQclear(pset.last_result);
+				pset.last_result = NULL;
 			}
 		}
 
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
index 2cb2e9b..85658e6 100644
--- a/src/bin/psql/common.c
+++ b/src/bin/psql/common.c
@@ -315,6 +315,8 @@ CheckConnection(void)
 			psql_error("Failed.\n");
 			PQfinish(pset.db);
 			pset.db = NULL;
+			PQclear(pset.last_result);
+			pset.last_result = NULL;
 			ResetCancelConn();
 			UnsyncVariables();
 		}
@@ -1154,7 +1156,9 @@ SendQuery(const char *query)
 		}
 	}
 
-	PQclear(results);
+	/* XXX: can we have PQclear that would free everything except errfields? */
+	PQclear(pset.last_result);
+	pset.last_result = results;
 
 	/* Possible microtiming output */
 	if (pset.timing)
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index 20a6470..8b88fbb 100644
--- a/src/bin/psql/settings.h
+++ b/src/bin/psql/settings.h
@@ -80,6 +80,7 @@ enum trivalue
 typedef struct _psqlSettings
 {
 	PGconn	   *db;				/* connection to backend */
+	PGresult   *last_result;	/* last result from running a query, if any */
 	int			encoding;		/* client_encoding */
 	FILE	   *queryFout;		/* where to send the query results */
 	bool		queryFoutPipe;	/* queryFout is from a popen() */
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
index 6916f6f..7586ee81 100644
--- a/src/bin/psql/startup.c
+++ b/src/bin/psql/startup.c
@@ -130,6 +130,7 @@ main(int argc, char *argv[])
 	pset.progname = get_progname(argv[0]);
 
 	pset.db = NULL;
+	pset.last_result = NULL;
 	setDecimalLocale();
 	pset.encoding = PQenv2encoding();
 	pset.queryFout = stdout;
diff --git a/src/interfaces/libpq/exports.txt b/src/interfaces/libpq/exports.txt
index c69a4d5..042bdd1 100644
--- a/src/interfaces/libpq/exports.txt
+++ b/src/interfaces/libpq/exports.txt
@@ -170,3 +170,4 @@ PQsslStruct               167
 PQsslAttributeNames       168
 PQsslAttribute            169
 PQsetErrorContextVisibility 170
+PQresultBuildErrorMessage 171
diff --git a/src/interfaces/libpq/fe-exec.c b/src/interfaces/libpq/fe-exec.c
index 41937c0..ca2fb50 100644
--- a/src/interfaces/libpq/fe-exec.c
+++ b/src/interfaces/libpq/fe-exec.c
@@ -2591,6 +2591,27 @@ PQresStatus(ExecStatusType status)
 }
 
 char *
+PQresultBuildErrorMessage(const PGconn *conn, const PGresult *res)
+{
+	char			   *errmsg;
+	PQExpBufferData		errbuf;
+
+	if (PG_PROTOCOL_MAJOR(conn->pversion) >= 3)
+	{
+		initPQExpBuffer(&errbuf);
+		pqBuildErrorNoticeMessage3(conn, res, &errbuf);
+
+		errmsg = strdup(errbuf.data);
+
+		termPQExpBuffer(&errbuf);
+	}
+	else
+		errmsg = strdup("requires libpq protocol version 3");
+
+	return errmsg;
+}
+
+char *
 PQresultErrorMessage(const PGresult *res)
 {
 	if (!res || !res->errMsg)
diff --git a/src/interfaces/libpq/fe-protocol3.c b/src/interfaces/libpq/fe-protocol3.c
index 43898a4..7e674c7 100644
--- a/src/interfaces/libpq/fe-protocol3.c
+++ b/src/interfaces/libpq/fe-protocol3.c
@@ -865,9 +865,6 @@ pqGetErrorNotice3(PGconn *conn, bool isError)
 	PGresult   *res = NULL;
 	PQExpBufferData workBuf;
 	char		id;
-	const char *val;
-	const char *querytext = NULL;
-	int			querypos = 0;
 
 	/*
 	 * Since the fields might be pretty long, we create a temporary
@@ -910,20 +907,67 @@ pqGetErrorNotice3(PGconn *conn, bool isError)
 	 * Also, save the SQLSTATE in conn->last_sqlstate.
 	 */
 	resetPQExpBuffer(&workBuf);
+	pqBuildErrorNoticeMessage3(conn, res, &workBuf);
+
+	/*
+	 * Either save error as current async result, or just emit the notice.
+	 */
+	if (isError)
+	{
+		if (res)
+			res->errMsg = pqResultStrdup(res, workBuf.data);
+		pqClearAsyncResult(conn);
+		conn->result = res;
+		if (PQExpBufferDataBroken(workBuf))
+			printfPQExpBuffer(&conn->errorMessage,
+							  libpq_gettext("out of memory"));
+		else
+			appendPQExpBufferStr(&conn->errorMessage, workBuf.data);
+	}
+	else
+	{
+		/* if we couldn't allocate the result set, just discard the NOTICE */
+		if (res)
+		{
+			/* We can cheat a little here and not copy the message. */
+			res->errMsg = workBuf.data;
+			if (res->noticeHooks.noticeRec != NULL)
+				(*res->noticeHooks.noticeRec) (res->noticeHooks.noticeRecArg, res);
+			PQclear(res);
+		}
+	}
+
+	termPQExpBuffer(&workBuf);
+	return 0;
+
+fail:
+	PQclear(res);
+	termPQExpBuffer(&workBuf);
+	return EOF;
+}
+
+void
+pqBuildErrorNoticeMessage3(const PGconn *conn, const PGresult *res, PQExpBuffer workBuf)
+{
+	const char *val;
+	const char *querytext = NULL;
+	int			querypos = 0;
+
 	val = PQresultErrorField(res, PG_DIAG_SEVERITY);
 	if (val)
-		appendPQExpBuffer(&workBuf, "%s:  ", val);
+		appendPQExpBuffer(workBuf, "%s:  ", val);
 	val = PQresultErrorField(res, PG_DIAG_SQLSTATE);
 	if (val)
 	{
+		/* XXX: multiple calls seems OK, but we violate the constness of conn */
 		if (strlen(val) < sizeof(conn->last_sqlstate))
-			strcpy(conn->last_sqlstate, val);
+			strcpy(((PGconn *) conn)->last_sqlstate, val);
 		if (conn->verbosity == PQERRORS_VERBOSE)
-			appendPQExpBuffer(&workBuf, "%s: ", val);
+			appendPQExpBuffer(workBuf, "%s: ", val);
 	}
 	val = PQresultErrorField(res, PG_DIAG_MESSAGE_PRIMARY);
 	if (val)
-		appendPQExpBufferStr(&workBuf, val);
+		appendPQExpBufferStr(workBuf, val);
 	val = PQresultErrorField(res, PG_DIAG_STATEMENT_POSITION);
 	if (val)
 	{
@@ -937,7 +981,7 @@ pqGetErrorNotice3(PGconn *conn, bool isError)
 		{
 			/* emit position as text addition to primary message */
 			/* translator: %s represents a digit string */
-			appendPQExpBuffer(&workBuf, libpq_gettext(" at character %s"),
+			appendPQExpBuffer(workBuf, libpq_gettext(" at character %s"),
 							  val);
 		}
 	}
@@ -956,32 +1000,33 @@ pqGetErrorNotice3(PGconn *conn, bool isError)
 			{
 				/* emit position as text addition to primary message */
 				/* translator: %s represents a digit string */
-				appendPQExpBuffer(&workBuf, libpq_gettext(" at character %s"),
+				appendPQExpBuffer(workBuf, libpq_gettext(" at character %s"),
 								  val);
 			}
 		}
 	}
-	appendPQExpBufferChar(&workBuf, '\n');
+	appendPQExpBufferChar(workBuf, '\n');
 	if (conn->verbosity != PQERRORS_TERSE)
 	{
 		if (querytext && querypos > 0)
-			reportErrorPosition(&workBuf, querytext, querypos,
+			reportErrorPosition(workBuf, querytext, querypos,
 								conn->client_encoding);
 		val = PQresultErrorField(res, PG_DIAG_MESSAGE_DETAIL);
 		if (val)
-			appendPQExpBuffer(&workBuf, libpq_gettext("DETAIL:  %s\n"), val);
+			appendPQExpBuffer(workBuf, libpq_gettext("DETAIL:  %s\n"), val);
 		val = PQresultErrorField(res, PG_DIAG_MESSAGE_HINT);
 		if (val)
-			appendPQExpBuffer(&workBuf, libpq_gettext("HINT:  %s\n"), val);
+			appendPQExpBuffer(workBuf, libpq_gettext("HINT:  %s\n"), val);
 		val = PQresultErrorField(res, PG_DIAG_INTERNAL_QUERY);
 		if (val)
-			appendPQExpBuffer(&workBuf, libpq_gettext("QUERY:  %s\n"), val);
+			appendPQExpBuffer(workBuf, libpq_gettext("QUERY:  %s\n"), val);
 		if (conn->show_context == PQSHOW_CONTEXT_ALWAYS ||
-			(conn->show_context == PQSHOW_CONTEXT_ERRORS && isError))
+			(conn->show_context == PQSHOW_CONTEXT_ERRORS &&
+			 res->resultStatus == PGRES_FATAL_ERROR))
 		{
 			val = PQresultErrorField(res, PG_DIAG_CONTEXT);
 			if (val)
-				appendPQExpBuffer(&workBuf, libpq_gettext("CONTEXT:  %s\n"),
+				appendPQExpBuffer(workBuf, libpq_gettext("CONTEXT:  %s\n"),
 								  val);
 		}
 	}
@@ -989,23 +1034,23 @@ pqGetErrorNotice3(PGconn *conn, bool isError)
 	{
 		val = PQresultErrorField(res, PG_DIAG_SCHEMA_NAME);
 		if (val)
-			appendPQExpBuffer(&workBuf,
+			appendPQExpBuffer(workBuf,
 							  libpq_gettext("SCHEMA NAME:  %s\n"), val);
 		val = PQresultErrorField(res, PG_DIAG_TABLE_NAME);
 		if (val)
-			appendPQExpBuffer(&workBuf,
+			appendPQExpBuffer(workBuf,
 							  libpq_gettext("TABLE NAME:  %s\n"), val);
 		val = PQresultErrorField(res, PG_DIAG_COLUMN_NAME);
 		if (val)
-			appendPQExpBuffer(&workBuf,
+			appendPQExpBuffer(workBuf,
 							  libpq_gettext("COLUMN NAME:  %s\n"), val);
 		val = PQresultErrorField(res, PG_DIAG_DATATYPE_NAME);
 		if (val)
-			appendPQExpBuffer(&workBuf,
+			appendPQExpBuffer(workBuf,
 							  libpq_gettext("DATATYPE NAME:  %s\n"), val);
 		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_NAME);
 		if (val)
-			appendPQExpBuffer(&workBuf,
+			appendPQExpBuffer(workBuf,
 							  libpq_gettext("CONSTRAINT NAME:  %s\n"), val);
 	}
 	if (conn->verbosity == PQERRORS_VERBOSE)
@@ -1018,51 +1063,15 @@ pqGetErrorNotice3(PGconn *conn, bool isError)
 		val = PQresultErrorField(res, PG_DIAG_SOURCE_FUNCTION);
 		if (val || valf || vall)
 		{
-			appendPQExpBufferStr(&workBuf, libpq_gettext("LOCATION:  "));
+			appendPQExpBufferStr(workBuf, libpq_gettext("LOCATION:  "));
 			if (val)
-				appendPQExpBuffer(&workBuf, libpq_gettext("%s, "), val);
+				appendPQExpBuffer(workBuf, libpq_gettext("%s, "), val);
 			if (valf && vall)	/* unlikely we'd have just one */
-				appendPQExpBuffer(&workBuf, libpq_gettext("%s:%s"),
+				appendPQExpBuffer(workBuf, libpq_gettext("%s:%s"),
 								  valf, vall);
-			appendPQExpBufferChar(&workBuf, '\n');
+			appendPQExpBufferChar(workBuf, '\n');
 		}
 	}
-
-	/*
-	 * Either save error as current async result, or just emit the notice.
-	 */
-	if (isError)
-	{
-		if (res)
-			res->errMsg = pqResultStrdup(res, workBuf.data);
-		pqClearAsyncResult(conn);
-		conn->result = res;
-		if (PQExpBufferDataBroken(workBuf))
-			printfPQExpBuffer(&conn->errorMessage,
-							  libpq_gettext("out of memory"));
-		else
-			appendPQExpBufferStr(&conn->errorMessage, workBuf.data);
-	}
-	else
-	{
-		/* if we couldn't allocate the result set, just discard the NOTICE */
-		if (res)
-		{
-			/* We can cheat a little here and not copy the message. */
-			res->errMsg = workBuf.data;
-			if (res->noticeHooks.noticeRec != NULL)
-				(*res->noticeHooks.noticeRec) (res->noticeHooks.noticeRecArg, res);
-			PQclear(res);
-		}
-	}
-
-	termPQExpBuffer(&workBuf);
-	return 0;
-
-fail:
-	PQclear(res);
-	termPQExpBuffer(&workBuf);
-	return EOF;
 }
 
 /*
diff --git a/src/interfaces/libpq/libpq-fe.h b/src/interfaces/libpq/libpq-fe.h
index 6bf34b3..5d89767 100644
--- a/src/interfaces/libpq/libpq-fe.h
+++ b/src/interfaces/libpq/libpq-fe.h
@@ -462,6 +462,7 @@ extern PGresult *PQfn(PGconn *conn,
 /* Accessor functions for PGresult objects */
 extern ExecStatusType PQresultStatus(const PGresult *res);
 extern char *PQresStatus(ExecStatusType status);
+extern char *PQresultBuildErrorMessage(const PGconn *conn, const PGresult *res);
 extern char *PQresultErrorMessage(const PGresult *res);
 extern char *PQresultErrorField(const PGresult *res, int fieldcode);
 extern int	PQntuples(const PGresult *res);
diff --git a/src/interfaces/libpq/libpq-int.h b/src/interfaces/libpq/libpq-int.h
index 6c9bbf7..c7a9e96 100644
--- a/src/interfaces/libpq/libpq-int.h
+++ b/src/interfaces/libpq/libpq-int.h
@@ -575,6 +575,8 @@ extern char *pqBuildStartupPacket3(PGconn *conn, int *packetlen,
 					  const PQEnvironmentOption *options);
 extern void pqParseInput3(PGconn *conn);
 extern int	pqGetErrorNotice3(PGconn *conn, bool isError);
+extern void pqBuildErrorNoticeMessage3(const PGconn *conn, const PGresult *res,
+				PQExpBuffer workBuf);
 extern int	pqGetCopyData3(PGconn *conn, char **buffer, int async);
 extern int	pqGetline3(PGconn *conn, char *s, int maxlen);
 extern int	pqGetlineAsync3(PGconn *conn, char *buffer, int bufsize);
-- 
2.5.0

From d8d6a65da57d8e14eac4f614d31b19d52f8176d9 Mon Sep 17 00:00:00 2001
From: Oleksandr Shulgin <oleksandr.shulgin@zalando.de>
Date: Wed, 6 Jan 2016 14:58:17 +0100
Subject: [PATCH] Add \errverbose psql command and support in libpq

For every error we build both the default and verbose error message,
then store both in PGresult.  The client can then retrieve the verbose
message using the new exported function PGresultVerboseErrorMessage().

In psql we store the verbose error message in pset (if any) for display
when requested by the user with \errverbose.
---
 doc/src/sgml/libpq.sgml             |  40 ++++++++-
 src/bin/psql/command.c              |   9 ++
 src/bin/psql/common.c               |   5 ++
 src/bin/psql/help.c                 |   1 +
 src/bin/psql/settings.h             |   2 +
 src/bin/psql/startup.c              |   1 +
 src/bin/psql/tab-complete.c         |   2 +-
 src/interfaces/libpq/exports.txt    |   1 +
 src/interfaces/libpq/fe-exec.c      |  29 ++++++-
 src/interfaces/libpq/fe-protocol3.c | 166 +++++++++++++++++++++---------------
 src/interfaces/libpq/libpq-fe.h     |   1 +
 src/interfaces/libpq/libpq-int.h    |   3 +-
 12 files changed, 181 insertions(+), 79 deletions(-)

diff --git a/doc/src/sgml/libpq.sgml b/doc/src/sgml/libpq.sgml
index 2328d8f..8b9544f 100644
--- a/doc/src/sgml/libpq.sgml
+++ b/doc/src/sgml/libpq.sgml
@@ -2691,6 +2691,38 @@ char *PQresultErrorMessage(const PGresult *res);
       </listitem>
      </varlistentry>
 
+     <varlistentry id="libpq-pqresultverboseerrormessage">
+      <term>
+       <function>PQresultVerboseErrorMessage</function>
+       <indexterm>
+        <primary>PQresultVerboseErrorMessage</primary>
+       </indexterm>
+      </term>
+
+      <listitem>
+       <para>
+        Returns the most verbose error message associated with the
+        command, or an empty string if there was no error.
+<synopsis>
+char *PQresultVerboseErrorMessage(const PGresult *res);
+</synopsis>
+        If there was an error, the returned string will include a trailing
+        newline.  The caller should not free the result directly. It will
+        be freed when the associated <structname>PGresult</> handle is
+        passed to <function>PQclear</function>.
+       </para>
+
+       <para>
+         If error verbosity is already set to the maximum available level,
+         this will return exactly the same error message
+         as <function>PQresultErrorMessage</function>. Otherwise it can be
+         useful to retrieve a more detailed error message without running
+         the failed query again (while increasing the error verbosity
+         level).
+       </para>
+      </listitem>
+     </varlistentry>
+
      <varlistentry id="libpq-pqresulterrorfield">
       <term><function>PQresultErrorField</function><indexterm><primary>PQresultErrorField</></></term>
       <listitem>
@@ -5579,9 +5611,11 @@ PGVerbosity PQsetErrorVerbosity(PGconn *conn, PGVerbosity verbosity);
       this will normally fit on a single line.  The default mode produces
       messages that include the above plus any detail, hint, or context
       fields (these might span multiple lines).  The <firstterm>VERBOSE</>
-      mode includes all available fields.  Changing the verbosity does not
-      affect the messages available from already-existing
-      <structname>PGresult</> objects, only subsequently-created ones.
+      mode includes all available fields.  It is still possible to
+      retrieve the most verbose error message from an
+      existing <structname>PGresult</> object (without changing the
+      current verbosity level)
+      using <function>PQresultVerboseErrorMessage</>.
      </para>
     </listitem>
    </varlistentry>
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 9750a5b..8ec2bbd 100644
--- a/src/bin/psql/command.c
+++ b/src/bin/psql/command.c
@@ -822,6 +822,13 @@ exec_command(const char *cmd,
 		}
 	}
 
+	/* \errverbose -- display verbose error message from last result */
+	else if (strcmp(cmd, "errverbose") == 0)
+	{
+		if (pset.verbose_error && *pset.verbose_error)
+			psql_error("%s", pset.verbose_error);
+	}
+
 	/* \f -- change field separator */
 	else if (strcmp(cmd, "f") == 0)
 	{
@@ -1865,6 +1872,8 @@ do_connect(char *dbname, char *user, char *host, char *port)
 			{
 				PQfinish(o_conn);
 				pset.db = NULL;
+				free(pset.verbose_error);
+				pset.verbose_error = NULL;
 			}
 		}
 
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
index 2cb2e9b..331addb 100644
--- a/src/bin/psql/common.c
+++ b/src/bin/psql/common.c
@@ -315,6 +315,8 @@ CheckConnection(void)
 			psql_error("Failed.\n");
 			PQfinish(pset.db);
 			pset.db = NULL;
+			free(pset.verbose_error);
+			pset.verbose_error = NULL;
 			ResetCancelConn();
 			UnsyncVariables();
 		}
@@ -1154,6 +1156,9 @@ SendQuery(const char *query)
 		}
 	}
 
+	/* Save the verbose error message (if any) and clear the results. */
+	free(pset.verbose_error);
+	pset.verbose_error = pg_strdup(PQresultVerboseErrorMessage(results));
 	PQclear(results);
 
 	/* Possible microtiming output */
diff --git a/src/bin/psql/help.c b/src/bin/psql/help.c
index 59f6f25..abfa40d 100644
--- a/src/bin/psql/help.c
+++ b/src/bin/psql/help.c
@@ -172,6 +172,7 @@ slashUsage(unsigned short int pager)
 
 	fprintf(output, _("General\n"));
 	fprintf(output, _("  \\copyright             show PostgreSQL usage and distribution terms\n"));
+	fprintf(output, _("  \\errverbose            show verbose error message from the last query\n"));
 	fprintf(output, _("  \\g [FILE] or ;         execute query (and send results to file or |pipe)\n"));
 	fprintf(output, _("  \\gset [PREFIX]         execute query and store results in psql variables\n"));
 	fprintf(output, _("  \\q                     quit psql\n"));
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index 20a6470..bcb16ce 100644
--- a/src/bin/psql/settings.h
+++ b/src/bin/psql/settings.h
@@ -130,6 +130,8 @@ typedef struct _psqlSettings
 	const char *prompt3;
 	PGVerbosity verbosity;		/* current error verbosity level */
 	PGContextVisibility show_context;	/* current context display level */
+	char	   *verbose_error;	/* set if last query resulted in an error
+								   and a verbose message was available */
 } PsqlSettings;
 
 extern PsqlSettings pset;
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
index 6916f6f..695a84a 100644
--- a/src/bin/psql/startup.c
+++ b/src/bin/psql/startup.c
@@ -130,6 +130,7 @@ main(int argc, char *argv[])
 	pset.progname = get_progname(argv[0]);
 
 	pset.db = NULL;
+	pset.verbose_error = NULL;
 	setDecimalLocale();
 	pset.encoding = PQenv2encoding();
 	pset.queryFout = stdout;
diff --git a/src/bin/psql/tab-complete.c b/src/bin/psql/tab-complete.c
index 6a81416..061da8d 100644
--- a/src/bin/psql/tab-complete.c
+++ b/src/bin/psql/tab-complete.c
@@ -1279,7 +1279,7 @@ psql_completion(const char *text, int start, int end)
 		"\\dF", "\\dFd", "\\dFp", "\\dFt", "\\dg", "\\di", "\\dl", "\\dL",
 		"\\dm", "\\dn", "\\do", "\\dO", "\\dp", "\\drds", "\\ds", "\\dS",
 		"\\dt", "\\dT", "\\dv", "\\du", "\\dx", "\\dy",
-		"\\e", "\\echo", "\\ef", "\\encoding", "\\ev",
+		"\\e", "\\echo", "\\ef", "\\encoding", "\\errverbose", "\\ev",
 		"\\f", "\\g", "\\gset", "\\h", "\\help", "\\H", "\\i", "\\ir", "\\l",
 		"\\lo_import", "\\lo_export", "\\lo_list", "\\lo_unlink",
 		"\\o", "\\p", "\\password", "\\prompt", "\\pset", "\\q", "\\qecho", "\\r",
diff --git a/src/interfaces/libpq/exports.txt b/src/interfaces/libpq/exports.txt
index c69a4d5..21dd772 100644
--- a/src/interfaces/libpq/exports.txt
+++ b/src/interfaces/libpq/exports.txt
@@ -170,3 +170,4 @@ PQsslStruct               167
 PQsslAttributeNames       168
 PQsslAttribute            169
 PQsetErrorContextVisibility 170
+PQresultVerboseErrorMessage 171
diff --git a/src/interfaces/libpq/fe-exec.c b/src/interfaces/libpq/fe-exec.c
index 41937c0..72f31a0 100644
--- a/src/interfaces/libpq/fe-exec.c
+++ b/src/interfaces/libpq/fe-exec.c
@@ -158,6 +158,7 @@ PQmakeEmptyPGresult(PGconn *conn, ExecStatusType status)
 	result->events = NULL;
 	result->nEvents = 0;
 	result->errMsg = NULL;
+	result->errMsgVerbose = NULL;
 	result->errFields = NULL;
 	result->null_field[0] = '\0';
 	result->curBlock = NULL;
@@ -627,17 +628,29 @@ pqSetResultError(PGresult *res, const char *msg)
  *		concatenate a new error message to the one already in a PGresult
  */
 void
-pqCatenateResultError(PGresult *res, const char *msg)
+pqCatenateResultError(PGresult *res, const char *msg, const char *msgVerbose)
 {
 	PQExpBufferData errorBuf;
 
 	if (!res || !msg)
 		return;
+
 	initPQExpBuffer(&errorBuf);
 	if (res->errMsg)
 		appendPQExpBufferStr(&errorBuf, res->errMsg);
 	appendPQExpBufferStr(&errorBuf, msg);
 	pqSetResultError(res, errorBuf.data);
+
+	if (msgVerbose)
+	{
+		resetPQExpBuffer(&errorBuf);
+		if (res->errMsgVerbose)
+			appendPQExpBufferStr(&errorBuf, res->errMsgVerbose);
+		appendPQExpBufferStr(&errorBuf, msgVerbose);
+
+		res->errMsgVerbose = pqResultStrdup(res, errorBuf.data);
+	}
+
 	termPQExpBuffer(&errorBuf);
 }
 
@@ -740,7 +753,9 @@ pqSaveErrorResult(PGconn *conn)
 	else
 	{
 		/* Else, concatenate error message to existing async result. */
-		pqCatenateResultError(conn->result, conn->errorMessage.data);
+
+		/* XXX do we need to store verbose error message in conn? */
+		pqCatenateResultError(conn->result, conn->errorMessage.data, NULL);
 	}
 }
 
@@ -2004,7 +2019,7 @@ PQexecFinish(PGconn *conn)
 			if (lastResult->resultStatus == PGRES_FATAL_ERROR &&
 				result->resultStatus == PGRES_FATAL_ERROR)
 			{
-				pqCatenateResultError(lastResult, result->errMsg);
+				pqCatenateResultError(lastResult, result->errMsg, result->errMsgVerbose);
 				PQclear(result);
 				result = lastResult;
 
@@ -2599,6 +2614,14 @@ PQresultErrorMessage(const PGresult *res)
 }
 
 char *
+PQresultVerboseErrorMessage(const PGresult *res)
+{
+	if (!res || !res->errMsgVerbose)
+		return "";
+	return res->errMsgVerbose;
+}
+
+char *
 PQresultErrorField(const PGresult *res, int fieldcode)
 {
 	PGMessageField *pfield;
diff --git a/src/interfaces/libpq/fe-protocol3.c b/src/interfaces/libpq/fe-protocol3.c
index 43898a4..a3365ac 100644
--- a/src/interfaces/libpq/fe-protocol3.c
+++ b/src/interfaces/libpq/fe-protocol3.c
@@ -51,6 +51,8 @@ static int	getParameterStatus(PGconn *conn);
 static int	getNotify(PGconn *conn);
 static int	getCopyStart(PGconn *conn, ExecStatusType copytype);
 static int	getReadyForQuery(PGconn *conn);
+static void buildErrorMessage(const PGconn *conn, const PGresult *res, bool isError,
+					PGVerbosity verbosity, PQExpBuffer workBuf);
 static void reportErrorPosition(PQExpBuffer msg, const char *query,
 					int loc, int encoding);
 static int build_startup_packet(const PGconn *conn, char *packet,
@@ -865,9 +867,7 @@ pqGetErrorNotice3(PGconn *conn, bool isError)
 	PGresult   *res = NULL;
 	PQExpBufferData workBuf;
 	char		id;
-	const char *val;
-	const char *querytext = NULL;
-	int			querypos = 0;
+	const char *sqlstate;
 
 	/*
 	 * Since the fields might be pretty long, we create a temporary
@@ -904,30 +904,90 @@ pqGetErrorNotice3(PGconn *conn, bool isError)
 		pqSaveMessageField(res, id, workBuf.data);
 	}
 
+	/* Save the last SQLSTATE in connection. */
+	sqlstate = PQresultErrorField(res, PG_DIAG_SQLSTATE);
+	if (sqlstate && strlen(sqlstate) < sizeof(conn->last_sqlstate))
+		strcpy(conn->last_sqlstate, sqlstate);
+
+	/* Now build the "overall" error message for PQresultErrorMessage. */
+	resetPQExpBuffer(&workBuf);
+	buildErrorMessage(conn, res, isError, conn->verbosity, &workBuf);
+
 	/*
-	 * Now build the "overall" error message for PQresultErrorMessage.
-	 *
-	 * Also, save the SQLSTATE in conn->last_sqlstate.
+	 * Either save error as current async result, or just emit the notice.
 	 */
-	resetPQExpBuffer(&workBuf);
+	if (isError)
+	{
+		if (res)
+			res->errMsg = pqResultStrdup(res, workBuf.data);
+		pqClearAsyncResult(conn);
+		conn->result = res;
+		if (PQExpBufferDataBroken(workBuf))
+			printfPQExpBuffer(&conn->errorMessage,
+							  libpq_gettext("out of memory"));
+		else
+		{
+			appendPQExpBufferStr(&conn->errorMessage, workBuf.data);
+
+			if (res)
+			{
+				/* Also build the verbose error message. */
+				resetPQExpBuffer(&workBuf);
+				buildErrorMessage(conn, res, isError, PQERRORS_VERBOSE, &workBuf);
+				if (PQExpBufferDataBroken(workBuf))
+					res->errMsgVerbose = pqResultStrdup(res,
+														libpq_gettext("out of memory"));
+				else
+					res->errMsgVerbose = pqResultStrdup(res, workBuf.data);
+			}
+		}
+	}
+	else
+	{
+		/* if we couldn't allocate the result set, just discard the NOTICE */
+		if (res)
+		{
+			/* We can cheat a little here and not copy the message. */
+			res->errMsg = workBuf.data;
+			if (res->noticeHooks.noticeRec != NULL)
+				(*res->noticeHooks.noticeRec) (res->noticeHooks.noticeRecArg, res);
+			PQclear(res);
+		}
+	}
+
+	termPQExpBuffer(&workBuf);
+	return 0;
+
+fail:
+	PQclear(res);
+	termPQExpBuffer(&workBuf);
+	return EOF;
+}
+
+static void
+buildErrorMessage(const PGconn *conn, const PGresult *res, bool isError,
+				  PGVerbosity verbosity, PQExpBuffer workBuf)
+{
+	const char *val;
+	const char *querytext = NULL;
+	int			querypos = 0;
+
 	val = PQresultErrorField(res, PG_DIAG_SEVERITY);
 	if (val)
-		appendPQExpBuffer(&workBuf, "%s:  ", val);
+		appendPQExpBuffer(workBuf, "%s:  ", val);
 	val = PQresultErrorField(res, PG_DIAG_SQLSTATE);
 	if (val)
 	{
-		if (strlen(val) < sizeof(conn->last_sqlstate))
-			strcpy(conn->last_sqlstate, val);
-		if (conn->verbosity == PQERRORS_VERBOSE)
-			appendPQExpBuffer(&workBuf, "%s: ", val);
+		if (verbosity == PQERRORS_VERBOSE)
+			appendPQExpBuffer(workBuf, "%s: ", val);
 	}
 	val = PQresultErrorField(res, PG_DIAG_MESSAGE_PRIMARY);
 	if (val)
-		appendPQExpBufferStr(&workBuf, val);
+		appendPQExpBufferStr(workBuf, val);
 	val = PQresultErrorField(res, PG_DIAG_STATEMENT_POSITION);
 	if (val)
 	{
-		if (conn->verbosity != PQERRORS_TERSE && conn->last_query != NULL)
+		if (verbosity != PQERRORS_TERSE && conn->last_query != NULL)
 		{
 			/* emit position as a syntax cursor display */
 			querytext = conn->last_query;
@@ -937,7 +997,7 @@ pqGetErrorNotice3(PGconn *conn, bool isError)
 		{
 			/* emit position as text addition to primary message */
 			/* translator: %s represents a digit string */
-			appendPQExpBuffer(&workBuf, libpq_gettext(" at character %s"),
+			appendPQExpBuffer(workBuf, libpq_gettext(" at character %s"),
 							  val);
 		}
 	}
@@ -947,7 +1007,7 @@ pqGetErrorNotice3(PGconn *conn, bool isError)
 		if (val)
 		{
 			querytext = PQresultErrorField(res, PG_DIAG_INTERNAL_QUERY);
-			if (conn->verbosity != PQERRORS_TERSE && querytext != NULL)
+			if (verbosity != PQERRORS_TERSE && querytext != NULL)
 			{
 				/* emit position as a syntax cursor display */
 				querypos = atoi(val);
@@ -956,59 +1016,59 @@ pqGetErrorNotice3(PGconn *conn, bool isError)
 			{
 				/* emit position as text addition to primary message */
 				/* translator: %s represents a digit string */
-				appendPQExpBuffer(&workBuf, libpq_gettext(" at character %s"),
+				appendPQExpBuffer(workBuf, libpq_gettext(" at character %s"),
 								  val);
 			}
 		}
 	}
-	appendPQExpBufferChar(&workBuf, '\n');
-	if (conn->verbosity != PQERRORS_TERSE)
+	appendPQExpBufferChar(workBuf, '\n');
+	if (verbosity != PQERRORS_TERSE)
 	{
 		if (querytext && querypos > 0)
-			reportErrorPosition(&workBuf, querytext, querypos,
+			reportErrorPosition(workBuf, querytext, querypos,
 								conn->client_encoding);
 		val = PQresultErrorField(res, PG_DIAG_MESSAGE_DETAIL);
 		if (val)
-			appendPQExpBuffer(&workBuf, libpq_gettext("DETAIL:  %s\n"), val);
+			appendPQExpBuffer(workBuf, libpq_gettext("DETAIL:  %s\n"), val);
 		val = PQresultErrorField(res, PG_DIAG_MESSAGE_HINT);
 		if (val)
-			appendPQExpBuffer(&workBuf, libpq_gettext("HINT:  %s\n"), val);
+			appendPQExpBuffer(workBuf, libpq_gettext("HINT:  %s\n"), val);
 		val = PQresultErrorField(res, PG_DIAG_INTERNAL_QUERY);
 		if (val)
-			appendPQExpBuffer(&workBuf, libpq_gettext("QUERY:  %s\n"), val);
+			appendPQExpBuffer(workBuf, libpq_gettext("QUERY:  %s\n"), val);
 		if (conn->show_context == PQSHOW_CONTEXT_ALWAYS ||
 			(conn->show_context == PQSHOW_CONTEXT_ERRORS && isError))
 		{
 			val = PQresultErrorField(res, PG_DIAG_CONTEXT);
 			if (val)
-				appendPQExpBuffer(&workBuf, libpq_gettext("CONTEXT:  %s\n"),
+				appendPQExpBuffer(workBuf, libpq_gettext("CONTEXT:  %s\n"),
 								  val);
 		}
 	}
-	if (conn->verbosity == PQERRORS_VERBOSE)
+	if (verbosity == PQERRORS_VERBOSE)
 	{
 		val = PQresultErrorField(res, PG_DIAG_SCHEMA_NAME);
 		if (val)
-			appendPQExpBuffer(&workBuf,
+			appendPQExpBuffer(workBuf,
 							  libpq_gettext("SCHEMA NAME:  %s\n"), val);
 		val = PQresultErrorField(res, PG_DIAG_TABLE_NAME);
 		if (val)
-			appendPQExpBuffer(&workBuf,
+			appendPQExpBuffer(workBuf,
 							  libpq_gettext("TABLE NAME:  %s\n"), val);
 		val = PQresultErrorField(res, PG_DIAG_COLUMN_NAME);
 		if (val)
-			appendPQExpBuffer(&workBuf,
+			appendPQExpBuffer(workBuf,
 							  libpq_gettext("COLUMN NAME:  %s\n"), val);
 		val = PQresultErrorField(res, PG_DIAG_DATATYPE_NAME);
 		if (val)
-			appendPQExpBuffer(&workBuf,
+			appendPQExpBuffer(workBuf,
 							  libpq_gettext("DATATYPE NAME:  %s\n"), val);
 		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_NAME);
 		if (val)
-			appendPQExpBuffer(&workBuf,
+			appendPQExpBuffer(workBuf,
 							  libpq_gettext("CONSTRAINT NAME:  %s\n"), val);
 	}
-	if (conn->verbosity == PQERRORS_VERBOSE)
+	if (verbosity == PQERRORS_VERBOSE)
 	{
 		const char *valf;
 		const char *vall;
@@ -1018,51 +1078,15 @@ pqGetErrorNotice3(PGconn *conn, bool isError)
 		val = PQresultErrorField(res, PG_DIAG_SOURCE_FUNCTION);
 		if (val || valf || vall)
 		{
-			appendPQExpBufferStr(&workBuf, libpq_gettext("LOCATION:  "));
+			appendPQExpBufferStr(workBuf, libpq_gettext("LOCATION:  "));
 			if (val)
-				appendPQExpBuffer(&workBuf, libpq_gettext("%s, "), val);
+				appendPQExpBuffer(workBuf, libpq_gettext("%s, "), val);
 			if (valf && vall)	/* unlikely we'd have just one */
-				appendPQExpBuffer(&workBuf, libpq_gettext("%s:%s"),
+				appendPQExpBuffer(workBuf, libpq_gettext("%s:%s"),
 								  valf, vall);
-			appendPQExpBufferChar(&workBuf, '\n');
+			appendPQExpBufferChar(workBuf, '\n');
 		}
 	}
-
-	/*
-	 * Either save error as current async result, or just emit the notice.
-	 */
-	if (isError)
-	{
-		if (res)
-			res->errMsg = pqResultStrdup(res, workBuf.data);
-		pqClearAsyncResult(conn);
-		conn->result = res;
-		if (PQExpBufferDataBroken(workBuf))
-			printfPQExpBuffer(&conn->errorMessage,
-							  libpq_gettext("out of memory"));
-		else
-			appendPQExpBufferStr(&conn->errorMessage, workBuf.data);
-	}
-	else
-	{
-		/* if we couldn't allocate the result set, just discard the NOTICE */
-		if (res)
-		{
-			/* We can cheat a little here and not copy the message. */
-			res->errMsg = workBuf.data;
-			if (res->noticeHooks.noticeRec != NULL)
-				(*res->noticeHooks.noticeRec) (res->noticeHooks.noticeRecArg, res);
-			PQclear(res);
-		}
-	}
-
-	termPQExpBuffer(&workBuf);
-	return 0;
-
-fail:
-	PQclear(res);
-	termPQExpBuffer(&workBuf);
-	return EOF;
 }
 
 /*
diff --git a/src/interfaces/libpq/libpq-fe.h b/src/interfaces/libpq/libpq-fe.h
index 6bf34b3..ad177cc 100644
--- a/src/interfaces/libpq/libpq-fe.h
+++ b/src/interfaces/libpq/libpq-fe.h
@@ -463,6 +463,7 @@ extern PGresult *PQfn(PGconn *conn,
 extern ExecStatusType PQresultStatus(const PGresult *res);
 extern char *PQresStatus(ExecStatusType status);
 extern char *PQresultErrorMessage(const PGresult *res);
+extern char *PQresultVerboseErrorMessage(const PGresult *res);
 extern char *PQresultErrorField(const PGresult *res, int fieldcode);
 extern int	PQntuples(const PGresult *res);
 extern int	PQnfields(const PGresult *res);
diff --git a/src/interfaces/libpq/libpq-int.h b/src/interfaces/libpq/libpq-int.h
index 6c9bbf7..1574b7b 100644
--- a/src/interfaces/libpq/libpq-int.h
+++ b/src/interfaces/libpq/libpq-int.h
@@ -196,6 +196,7 @@ struct pg_result
 	 * per-field info then it is stored in a linked list.
 	 */
 	char	   *errMsg;			/* error message, or NULL if no error */
+	char	   *errMsgVerbose;	/* verbose error message, or NULL if no error */
 	PGMessageField *errFields;	/* message broken into fields */
 
 	/* All NULL attributes in the query result point to this null string */
@@ -539,7 +540,7 @@ extern pgthreadlock_t pg_g_threadlock;
 /* === in fe-exec.c === */
 
 extern void pqSetResultError(PGresult *res, const char *msg);
-extern void pqCatenateResultError(PGresult *res, const char *msg);
+extern void pqCatenateResultError(PGresult *res, const char *msg, const char *msgVerbose);
 extern void *pqResultAlloc(PGresult *res, size_t nBytes, bool isBinary);
 extern char *pqResultStrdup(PGresult *res, const char *str);
 extern void pqClearAsyncResult(PGconn *conn);
-- 
2.5.0

diff --git a/doc/src/sgml/libpq.sgml b/doc/src/sgml/libpq.sgml
index 2328d8f..80f7014 100644
*** a/doc/src/sgml/libpq.sgml
--- b/doc/src/sgml/libpq.sgml
*************** char *PQresultErrorMessage(const PGresul
*** 2691,2696 ****
--- 2691,2738 ----
        </listitem>
       </varlistentry>
  
+      <varlistentry id="libpq-pqresultverboseerrormessage">
+       <term>
+        <function>PQresultVerboseErrorMessage</function>
+        <indexterm>
+         <primary>PQresultVerboseErrorMessage</primary>
+        </indexterm>
+       </term>
+ 
+       <listitem>
+        <para>
+         Returns a reformatted version of the error message associated with
+         a <structname>PGresult</> object.
+ <synopsis>
+ char *PQresultVerboseErrorMessage(const PGresult *res,
+                                   PGVerbosity verbosity,
+                                   PGContextVisibility show_context);
+ </synopsis>
+         In some situations a client might wish to obtain a more detailed
+         version of a previously-reported error.
+         <function>PQresultVerboseErrorMessage</function> addresses this need
+         by computing the message that would have been produced
+         by <function>PQresultErrorMessage</function> if the specified
+         verbosity settings had been in effect for the connection when the
+         given <structname>PGresult</> was generated.  If
+         the <structname>PGresult</> is not an error result,
+         <quote>PGresult is not an error result</> is reported instead.
+         The returned string includes a trailing newline.
+        </para>
+ 
+        <para>
+         Unlike most other functions for extracting data from
+         a <structname>PGresult</>, the result of this function is a freshly
+         allocated string.  The caller must free it
+         using <function>PQfreemem()</> when the string is no longer needed.
+        </para>
+ 
+        <para>
+         A NULL return is possible if there is insufficient memory.
+        </para>
+       </listitem>
+      </varlistentry>
+ 
       <varlistentry id="libpq-pqresulterrorfield">
        <term><function>PQresultErrorField</function><indexterm><primary>PQresultErrorField</></></term>
        <listitem>
*************** PGVerbosity PQsetErrorVerbosity(PGconn *
*** 5582,5587 ****
--- 5624,5631 ----
        mode includes all available fields.  Changing the verbosity does not
        affect the messages available from already-existing
        <structname>PGresult</> objects, only subsequently-created ones.
+       (But see <function>PQresultVerboseErrorMessage</function> if you
+       want to print a previous error with a different verbosity.)
       </para>
      </listitem>
     </varlistentry>
*************** PGContextVisibility PQsetErrorContextVis
*** 5622,5627 ****
--- 5666,5673 ----
        affect the messages available from
        already-existing <structname>PGresult</> objects, only
        subsequently-created ones.
+       (But see <function>PQresultVerboseErrorMessage</function> if you
+       want to print a previous error with a different display mode.)
       </para>
      </listitem>
     </varlistentry>
*************** PQsetNoticeProcessor(PGconn *conn,
*** 6089,6096 ****
     receiver function is called.  It is passed the message in the form of
     a <symbol>PGRES_NONFATAL_ERROR</symbol>
     <structname>PGresult</structname>.  (This allows the receiver to extract
!    individual fields using <function>PQresultErrorField</>, or the complete
!    preformatted message using <function>PQresultErrorMessage</>.) The same
     void pointer passed to <function>PQsetNoticeReceiver</function> is also
     passed.  (This pointer can be used to access application-specific state
     if needed.)
--- 6135,6143 ----
     receiver function is called.  It is passed the message in the form of
     a <symbol>PGRES_NONFATAL_ERROR</symbol>
     <structname>PGresult</structname>.  (This allows the receiver to extract
!    individual fields using <function>PQresultErrorField</>, or complete
!    preformatted messages using <function>PQresultErrorMessage</> or
!    <function>PQresultVerboseErrorMessage</>.) The same
     void pointer passed to <function>PQsetNoticeReceiver</function> is also
     passed.  (This pointer can be used to access application-specific state
     if needed.)
diff --git a/src/interfaces/libpq/exports.txt b/src/interfaces/libpq/exports.txt
index c69a4d5..21dd772 100644
*** a/src/interfaces/libpq/exports.txt
--- b/src/interfaces/libpq/exports.txt
*************** PQsslStruct               167
*** 170,172 ****
--- 170,173 ----
  PQsslAttributeNames       168
  PQsslAttribute            169
  PQsetErrorContextVisibility 170
+ PQresultVerboseErrorMessage 171
diff --git a/src/interfaces/libpq/fe-exec.c b/src/interfaces/libpq/fe-exec.c
index 41937c0..2621767 100644
*** a/src/interfaces/libpq/fe-exec.c
--- b/src/interfaces/libpq/fe-exec.c
*************** PQmakeEmptyPGresult(PGconn *conn, ExecSt
*** 159,164 ****
--- 159,165 ----
  	result->nEvents = 0;
  	result->errMsg = NULL;
  	result->errFields = NULL;
+ 	result->errQuery = NULL;
  	result->null_field[0] = '\0';
  	result->curBlock = NULL;
  	result->curOffset = 0;
*************** PQresultErrorMessage(const PGresult *res
*** 2599,2604 ****
--- 2600,2643 ----
  }
  
  char *
+ PQresultVerboseErrorMessage(const PGresult *res,
+ 							PGVerbosity verbosity,
+ 							PGContextVisibility show_context)
+ {
+ 	PQExpBufferData workBuf;
+ 
+ 	/*
+ 	 * Because the caller is expected to free the result string, we must
+ 	 * strdup any constant result.  We use plain strdup and document that
+ 	 * callers should expect NULL if out-of-memory.
+ 	 */
+ 	if (!res ||
+ 		(res->resultStatus != PGRES_FATAL_ERROR &&
+ 		 res->resultStatus != PGRES_NONFATAL_ERROR))
+ 		return strdup(libpq_gettext("PGresult is not an error result\n"));
+ 
+ 	initPQExpBuffer(&workBuf);
+ 
+ 	/*
+ 	 * Currently, we pass this off to fe-protocol3.c in all cases; it will
+ 	 * behave reasonably sanely with an error reported by fe-protocol2.c as
+ 	 * well.  If necessary, we could record the protocol version in PGresults
+ 	 * so as to be able to invoke a version-specific message formatter, but
+ 	 * for now there's no need.
+ 	 */
+ 	pqBuildErrorMessage3(&workBuf, res, verbosity, show_context);
+ 
+ 	/* If insufficient memory to format the message, fail cleanly */
+ 	if (PQExpBufferDataBroken(workBuf))
+ 	{
+ 		termPQExpBuffer(&workBuf);
+ 		return strdup(libpq_gettext("out of memory\n"));
+ 	}
+ 
+ 	return workBuf.data;
+ }
+ 
+ char *
  PQresultErrorField(const PGresult *res, int fieldcode)
  {
  	PGMessageField *pfield;
diff --git a/src/interfaces/libpq/fe-protocol3.c b/src/interfaces/libpq/fe-protocol3.c
index 3034773..481ee9b 100644
*** a/src/interfaces/libpq/fe-protocol3.c
--- b/src/interfaces/libpq/fe-protocol3.c
*************** pqGetErrorNotice3(PGconn *conn, bool isE
*** 878,886 ****
  	PGresult   *res = NULL;
  	PQExpBufferData workBuf;
  	char		id;
- 	const char *val;
- 	const char *querytext = NULL;
- 	int			querypos = 0;
  
  	/*
  	 * Since the fields might be pretty long, we create a temporary
--- 878,883 ----
*************** pqGetErrorNotice3(PGconn *conn, bool isE
*** 905,910 ****
--- 902,909 ----
  
  	/*
  	 * Read the fields and save into res.
+ 	 *
+ 	 * Also, save the SQLSTATE in conn->last_sqlstate.
  	 */
  	for (;;)
  	{
*************** pqGetErrorNotice3(PGconn *conn, bool isE
*** 915,956 ****
  		if (pqGets(&workBuf, conn))
  			goto fail;
  		pqSaveMessageField(res, id, workBuf.data);
  	}
  
  	/*
  	 * Now build the "overall" error message for PQresultErrorMessage.
- 	 *
- 	 * Also, save the SQLSTATE in conn->last_sqlstate.
  	 */
  	resetPQExpBuffer(&workBuf);
  	val = PQresultErrorField(res, PG_DIAG_SEVERITY);
  	if (val)
! 		appendPQExpBuffer(&workBuf, "%s:  ", val);
! 	val = PQresultErrorField(res, PG_DIAG_SQLSTATE);
! 	if (val)
  	{
! 		if (strlen(val) < sizeof(conn->last_sqlstate))
! 			strcpy(conn->last_sqlstate, val);
! 		if (conn->verbosity == PQERRORS_VERBOSE)
! 			appendPQExpBuffer(&workBuf, "%s: ", val);
  	}
  	val = PQresultErrorField(res, PG_DIAG_MESSAGE_PRIMARY);
  	if (val)
! 		appendPQExpBufferStr(&workBuf, val);
  	val = PQresultErrorField(res, PG_DIAG_STATEMENT_POSITION);
  	if (val)
  	{
! 		if (conn->verbosity != PQERRORS_TERSE && conn->last_query != NULL)
  		{
  			/* emit position as a syntax cursor display */
! 			querytext = conn->last_query;
  			querypos = atoi(val);
  		}
  		else
  		{
  			/* emit position as text addition to primary message */
  			/* translator: %s represents a digit string */
! 			appendPQExpBuffer(&workBuf, libpq_gettext(" at character %s"),
  							  val);
  		}
  	}
--- 914,1032 ----
  		if (pqGets(&workBuf, conn))
  			goto fail;
  		pqSaveMessageField(res, id, workBuf.data);
+ 		if (id == PG_DIAG_SQLSTATE)
+ 			strlcpy(conn->last_sqlstate, workBuf.data,
+ 					sizeof(conn->last_sqlstate));
  	}
  
  	/*
+ 	 * Save the active query text, if any, into res as well.
+ 	 */
+ 	if (res && conn->last_query)
+ 		res->errQuery = pqResultStrdup(res, conn->last_query);
+ 
+ 	/*
  	 * Now build the "overall" error message for PQresultErrorMessage.
  	 */
  	resetPQExpBuffer(&workBuf);
+ 	pqBuildErrorMessage3(&workBuf, res, conn->verbosity, conn->show_context);
+ 
+ 	/*
+ 	 * Either save error as current async result, or just emit the notice.
+ 	 */
+ 	if (isError)
+ 	{
+ 		if (res)
+ 			res->errMsg = pqResultStrdup(res, workBuf.data);
+ 		pqClearAsyncResult(conn);
+ 		conn->result = res;
+ 		if (PQExpBufferDataBroken(workBuf))
+ 			printfPQExpBuffer(&conn->errorMessage,
+ 							  libpq_gettext("out of memory"));
+ 		else
+ 			appendPQExpBufferStr(&conn->errorMessage, workBuf.data);
+ 	}
+ 	else
+ 	{
+ 		/* if we couldn't allocate the result set, just discard the NOTICE */
+ 		if (res)
+ 		{
+ 			/* We can cheat a little here and not copy the message. */
+ 			res->errMsg = workBuf.data;
+ 			if (res->noticeHooks.noticeRec != NULL)
+ 				(*res->noticeHooks.noticeRec) (res->noticeHooks.noticeRecArg, res);
+ 			PQclear(res);
+ 		}
+ 	}
+ 
+ 	termPQExpBuffer(&workBuf);
+ 	return 0;
+ 
+ fail:
+ 	PQclear(res);
+ 	termPQExpBuffer(&workBuf);
+ 	return EOF;
+ }
+ 
+ /*
+  * Construct an error message from the fields in the given PGresult,
+  * appending it to the contents of "msg".
+  */
+ void
+ pqBuildErrorMessage3(PQExpBuffer msg, const PGresult *res,
+ 					 PGVerbosity verbosity, PGContextVisibility show_context)
+ {
+ 	const char *val;
+ 	const char *querytext = NULL;
+ 	int			querypos = 0;
+ 
+ 	/* If we couldn't allocate a PGresult, just say "out of memory" */
+ 	if (res == NULL)
+ 	{
+ 		appendPQExpBuffer(msg, libpq_gettext("out of memory\n"));
+ 		return;
+ 	}
+ 
+ 	/*
+ 	 * If we don't have any broken-down fields, just return the base message.
+ 	 * This mainly applies if we're given a libpq-generated error result.
+ 	 */
+ 	if (res->errFields == NULL)
+ 	{
+ 		if (res->errMsg && res->errMsg[0])
+ 			appendPQExpBufferStr(msg, res->errMsg);
+ 		else
+ 			appendPQExpBuffer(msg, libpq_gettext("no error message available\n"));
+ 		return;
+ 	}
+ 
+ 	/* Else build error message from relevant fields */
  	val = PQresultErrorField(res, PG_DIAG_SEVERITY);
  	if (val)
! 		appendPQExpBuffer(msg, "%s:  ", val);
! 	if (verbosity == PQERRORS_VERBOSE)
  	{
! 		val = PQresultErrorField(res, PG_DIAG_SQLSTATE);
! 		if (val)
! 			appendPQExpBuffer(msg, "%s: ", val);
  	}
  	val = PQresultErrorField(res, PG_DIAG_MESSAGE_PRIMARY);
  	if (val)
! 		appendPQExpBufferStr(msg, val);
  	val = PQresultErrorField(res, PG_DIAG_STATEMENT_POSITION);
  	if (val)
  	{
! 		if (verbosity != PQERRORS_TERSE && res->errQuery != NULL)
  		{
  			/* emit position as a syntax cursor display */
! 			querytext = res->errQuery;
  			querypos = atoi(val);
  		}
  		else
  		{
  			/* emit position as text addition to primary message */
  			/* translator: %s represents a digit string */
! 			appendPQExpBuffer(msg, libpq_gettext(" at character %s"),
  							  val);
  		}
  	}
*************** pqGetErrorNotice3(PGconn *conn, bool isE
*** 960,966 ****
  		if (val)
  		{
  			querytext = PQresultErrorField(res, PG_DIAG_INTERNAL_QUERY);
! 			if (conn->verbosity != PQERRORS_TERSE && querytext != NULL)
  			{
  				/* emit position as a syntax cursor display */
  				querypos = atoi(val);
--- 1036,1042 ----
  		if (val)
  		{
  			querytext = PQresultErrorField(res, PG_DIAG_INTERNAL_QUERY);
! 			if (verbosity != PQERRORS_TERSE && querytext != NULL)
  			{
  				/* emit position as a syntax cursor display */
  				querypos = atoi(val);
*************** pqGetErrorNotice3(PGconn *conn, bool isE
*** 969,1027 ****
  			{
  				/* emit position as text addition to primary message */
  				/* translator: %s represents a digit string */
! 				appendPQExpBuffer(&workBuf, libpq_gettext(" at character %s"),
  								  val);
  			}
  		}
  	}
! 	appendPQExpBufferChar(&workBuf, '\n');
! 	if (conn->verbosity != PQERRORS_TERSE)
  	{
  		if (querytext && querypos > 0)
! 			reportErrorPosition(&workBuf, querytext, querypos,
! 								conn->client_encoding);
  		val = PQresultErrorField(res, PG_DIAG_MESSAGE_DETAIL);
  		if (val)
! 			appendPQExpBuffer(&workBuf, libpq_gettext("DETAIL:  %s\n"), val);
  		val = PQresultErrorField(res, PG_DIAG_MESSAGE_HINT);
  		if (val)
! 			appendPQExpBuffer(&workBuf, libpq_gettext("HINT:  %s\n"), val);
  		val = PQresultErrorField(res, PG_DIAG_INTERNAL_QUERY);
  		if (val)
! 			appendPQExpBuffer(&workBuf, libpq_gettext("QUERY:  %s\n"), val);
! 		if (conn->show_context == PQSHOW_CONTEXT_ALWAYS ||
! 			(conn->show_context == PQSHOW_CONTEXT_ERRORS && isError))
  		{
  			val = PQresultErrorField(res, PG_DIAG_CONTEXT);
  			if (val)
! 				appendPQExpBuffer(&workBuf, libpq_gettext("CONTEXT:  %s\n"),
  								  val);
  		}
  	}
! 	if (conn->verbosity == PQERRORS_VERBOSE)
  	{
  		val = PQresultErrorField(res, PG_DIAG_SCHEMA_NAME);
  		if (val)
! 			appendPQExpBuffer(&workBuf,
  							  libpq_gettext("SCHEMA NAME:  %s\n"), val);
  		val = PQresultErrorField(res, PG_DIAG_TABLE_NAME);
  		if (val)
! 			appendPQExpBuffer(&workBuf,
  							  libpq_gettext("TABLE NAME:  %s\n"), val);
  		val = PQresultErrorField(res, PG_DIAG_COLUMN_NAME);
  		if (val)
! 			appendPQExpBuffer(&workBuf,
  							  libpq_gettext("COLUMN NAME:  %s\n"), val);
  		val = PQresultErrorField(res, PG_DIAG_DATATYPE_NAME);
  		if (val)
! 			appendPQExpBuffer(&workBuf,
  							  libpq_gettext("DATATYPE NAME:  %s\n"), val);
  		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_NAME);
  		if (val)
! 			appendPQExpBuffer(&workBuf,
  							  libpq_gettext("CONSTRAINT NAME:  %s\n"), val);
  	}
! 	if (conn->verbosity == PQERRORS_VERBOSE)
  	{
  		const char *valf;
  		const char *vall;
--- 1045,1104 ----
  			{
  				/* emit position as text addition to primary message */
  				/* translator: %s represents a digit string */
! 				appendPQExpBuffer(msg, libpq_gettext(" at character %s"),
  								  val);
  			}
  		}
  	}
! 	appendPQExpBufferChar(msg, '\n');
! 	if (verbosity != PQERRORS_TERSE)
  	{
  		if (querytext && querypos > 0)
! 			reportErrorPosition(msg, querytext, querypos,
! 								res->client_encoding);
  		val = PQresultErrorField(res, PG_DIAG_MESSAGE_DETAIL);
  		if (val)
! 			appendPQExpBuffer(msg, libpq_gettext("DETAIL:  %s\n"), val);
  		val = PQresultErrorField(res, PG_DIAG_MESSAGE_HINT);
  		if (val)
! 			appendPQExpBuffer(msg, libpq_gettext("HINT:  %s\n"), val);
  		val = PQresultErrorField(res, PG_DIAG_INTERNAL_QUERY);
  		if (val)
! 			appendPQExpBuffer(msg, libpq_gettext("QUERY:  %s\n"), val);
! 		if (show_context == PQSHOW_CONTEXT_ALWAYS ||
! 			(show_context == PQSHOW_CONTEXT_ERRORS &&
! 			 res->resultStatus == PGRES_FATAL_ERROR))
  		{
  			val = PQresultErrorField(res, PG_DIAG_CONTEXT);
  			if (val)
! 				appendPQExpBuffer(msg, libpq_gettext("CONTEXT:  %s\n"),
  								  val);
  		}
  	}
! 	if (verbosity == PQERRORS_VERBOSE)
  	{
  		val = PQresultErrorField(res, PG_DIAG_SCHEMA_NAME);
  		if (val)
! 			appendPQExpBuffer(msg,
  							  libpq_gettext("SCHEMA NAME:  %s\n"), val);
  		val = PQresultErrorField(res, PG_DIAG_TABLE_NAME);
  		if (val)
! 			appendPQExpBuffer(msg,
  							  libpq_gettext("TABLE NAME:  %s\n"), val);
  		val = PQresultErrorField(res, PG_DIAG_COLUMN_NAME);
  		if (val)
! 			appendPQExpBuffer(msg,
  							  libpq_gettext("COLUMN NAME:  %s\n"), val);
  		val = PQresultErrorField(res, PG_DIAG_DATATYPE_NAME);
  		if (val)
! 			appendPQExpBuffer(msg,
  							  libpq_gettext("DATATYPE NAME:  %s\n"), val);
  		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_NAME);
  		if (val)
! 			appendPQExpBuffer(msg,
  							  libpq_gettext("CONSTRAINT NAME:  %s\n"), val);
  	}
! 	if (verbosity == PQERRORS_VERBOSE)
  	{
  		const char *valf;
  		const char *vall;
*************** pqGetErrorNotice3(PGconn *conn, bool isE
*** 1031,1081 ****
  		val = PQresultErrorField(res, PG_DIAG_SOURCE_FUNCTION);
  		if (val || valf || vall)
  		{
! 			appendPQExpBufferStr(&workBuf, libpq_gettext("LOCATION:  "));
  			if (val)
! 				appendPQExpBuffer(&workBuf, libpq_gettext("%s, "), val);
  			if (valf && vall)	/* unlikely we'd have just one */
! 				appendPQExpBuffer(&workBuf, libpq_gettext("%s:%s"),
  								  valf, vall);
! 			appendPQExpBufferChar(&workBuf, '\n');
! 		}
! 	}
! 
! 	/*
! 	 * Either save error as current async result, or just emit the notice.
! 	 */
! 	if (isError)
! 	{
! 		if (res)
! 			res->errMsg = pqResultStrdup(res, workBuf.data);
! 		pqClearAsyncResult(conn);
! 		conn->result = res;
! 		if (PQExpBufferDataBroken(workBuf))
! 			printfPQExpBuffer(&conn->errorMessage,
! 							  libpq_gettext("out of memory"));
! 		else
! 			appendPQExpBufferStr(&conn->errorMessage, workBuf.data);
! 	}
! 	else
! 	{
! 		/* if we couldn't allocate the result set, just discard the NOTICE */
! 		if (res)
! 		{
! 			/* We can cheat a little here and not copy the message. */
! 			res->errMsg = workBuf.data;
! 			if (res->noticeHooks.noticeRec != NULL)
! 				(*res->noticeHooks.noticeRec) (res->noticeHooks.noticeRecArg, res);
! 			PQclear(res);
  		}
  	}
- 
- 	termPQExpBuffer(&workBuf);
- 	return 0;
- 
- fail:
- 	PQclear(res);
- 	termPQExpBuffer(&workBuf);
- 	return EOF;
  }
  
  /*
--- 1108,1122 ----
  		val = PQresultErrorField(res, PG_DIAG_SOURCE_FUNCTION);
  		if (val || valf || vall)
  		{
! 			appendPQExpBufferStr(msg, libpq_gettext("LOCATION:  "));
  			if (val)
! 				appendPQExpBuffer(msg, libpq_gettext("%s, "), val);
  			if (valf && vall)	/* unlikely we'd have just one */
! 				appendPQExpBuffer(msg, libpq_gettext("%s:%s"),
  								  valf, vall);
! 			appendPQExpBufferChar(msg, '\n');
  		}
  	}
  }
  
  /*
diff --git a/src/interfaces/libpq/libpq-fe.h b/src/interfaces/libpq/libpq-fe.h
index 6bf34b3..9ca0756 100644
*** a/src/interfaces/libpq/libpq-fe.h
--- b/src/interfaces/libpq/libpq-fe.h
*************** extern PGresult *PQfn(PGconn *conn,
*** 463,468 ****
--- 463,471 ----
  extern ExecStatusType PQresultStatus(const PGresult *res);
  extern char *PQresStatus(ExecStatusType status);
  extern char *PQresultErrorMessage(const PGresult *res);
+ extern char *PQresultVerboseErrorMessage(const PGresult *res,
+ 							PGVerbosity verbosity,
+ 							PGContextVisibility show_context);
  extern char *PQresultErrorField(const PGresult *res, int fieldcode);
  extern int	PQntuples(const PGresult *res);
  extern int	PQnfields(const PGresult *res);
diff --git a/src/interfaces/libpq/libpq-int.h b/src/interfaces/libpq/libpq-int.h
index 6c9bbf7..1183323 100644
*** a/src/interfaces/libpq/libpq-int.h
--- b/src/interfaces/libpq/libpq-int.h
*************** struct pg_result
*** 197,202 ****
--- 197,203 ----
  	 */
  	char	   *errMsg;			/* error message, or NULL if no error */
  	PGMessageField *errFields;	/* message broken into fields */
+ 	char	   *errQuery;		/* text of triggering query, if available */
  
  	/* All NULL attributes in the query result point to this null string */
  	char		null_field[1];
*************** extern char *pqBuildStartupPacket3(PGcon
*** 575,580 ****
--- 576,583 ----
  					  const PQEnvironmentOption *options);
  extern void pqParseInput3(PGconn *conn);
  extern int	pqGetErrorNotice3(PGconn *conn, bool isError);
+ extern void pqBuildErrorMessage3(PQExpBuffer msg, const PGresult *res,
+ 					 PGVerbosity verbosity, PGContextVisibility show_context);
  extern int	pqGetCopyData3(PGconn *conn, char **buffer, int async);
  extern int	pqGetline3(PGconn *conn, char *s, int maxlen);
  extern int	pqGetlineAsync3(PGconn *conn, char *buffer, int bufsize);

diff --git a/doc/src/sgml/ref/psql-ref.sgml b/doc/src/sgml/ref/psql-ref.sgml
index 385cb59..330127a 100644
*** a/doc/src/sgml/ref/psql-ref.sgml
--- b/doc/src/sgml/ref/psql-ref.sgml
*************** Tue Oct 26 21:40:57 CEST 1999
*** 1718,1723 ****
--- 1718,1737 ----
  
  
        <varlistentry>
+         <term><literal>\errverbose</literal></term>
+ 
+         <listitem>
+         <para>
+         Repeats the most recent server error or notice message at maximum
+         verbosity, as though <varname>VERBOSITY</varname> were set
+         to <literal>verbose</> and <varname>SHOW_CONTEXT</varname> were
+         set to <literal>always</>.
+         </para>
+         </listitem>
+       </varlistentry>
+ 
+ 
+       <varlistentry>
          <term><literal>\f [ <replaceable class="parameter">string</replaceable> ]</literal></term>
  
          <listitem>
diff --git a/src/bin/psql/command.c b/src/bin/psql/command.c
index 50dc43b..3401b51 100644
*** a/src/bin/psql/command.c
--- b/src/bin/psql/command.c
*************** exec_command(const char *cmd,
*** 822,827 ****
--- 822,849 ----
  		}
  	}
  
+ 	/* \errverbose -- display verbose message from last failed query */
+ 	else if (strcmp(cmd, "errverbose") == 0)
+ 	{
+ 		if (pset.last_error_result)
+ 		{
+ 			char	   *msg;
+ 
+ 			msg = PQresultVerboseErrorMessage(pset.last_error_result,
+ 											  PQERRORS_VERBOSE,
+ 											  PQSHOW_CONTEXT_ALWAYS);
+ 			if (msg)
+ 			{
+ 				psql_error("%s", msg);
+ 				PQfreemem(msg);
+ 			}
+ 			else
+ 				puts(_("out of memory"));
+ 		}
+ 		else
+ 			puts(_("There was no previous error."));
+ 	}
+ 
  	/* \f -- change field separator */
  	else if (strcmp(cmd, "f") == 0)
  	{
diff --git a/src/bin/psql/common.c b/src/bin/psql/common.c
index 892058e..a2a07fb 100644
*** a/src/bin/psql/common.c
--- b/src/bin/psql/common.c
*************** AcceptResult(const PGresult *result)
*** 497,502 ****
--- 497,529 ----
  }
  
  
+ /*
+  * ClearOrSaveResult
+  *
+  * If the result represents an error, remember it for possible display by
+  * \errverbose.  Otherwise, just PQclear() it.
+  */
+ static void
+ ClearOrSaveResult(PGresult *result)
+ {
+ 	if (result)
+ 	{
+ 		switch (PQresultStatus(result))
+ 		{
+ 			case PGRES_NONFATAL_ERROR:
+ 			case PGRES_FATAL_ERROR:
+ 				if (pset.last_error_result)
+ 					PQclear(pset.last_error_result);
+ 				pset.last_error_result = result;
+ 				break;
+ 
+ 			default:
+ 				PQclear(result);
+ 				break;
+ 		}
+ 	}
+ }
+ 
  
  /*
   * PSQLexec
*************** PSQLexec(const char *query)
*** 548,554 ****
  
  	if (!AcceptResult(res))
  	{
! 		PQclear(res);
  		res = NULL;
  	}
  
--- 575,581 ----
  
  	if (!AcceptResult(res))
  	{
! 		ClearOrSaveResult(res);
  		res = NULL;
  	}
  
*************** PSQLexecWatch(const char *query, const p
*** 590,596 ****
  
  	if (!AcceptResult(res))
  	{
! 		PQclear(res);
  		return 0;
  	}
  
--- 617,623 ----
  
  	if (!AcceptResult(res))
  	{
! 		ClearOrSaveResult(res);
  		return 0;
  	}
  
*************** SendQuery(const char *query)
*** 1077,1087 ****
  		if (PQresultStatus(results) != PGRES_COMMAND_OK)
  		{
  			psql_error("%s", PQerrorMessage(pset.db));
! 			PQclear(results);
  			ResetCancelConn();
  			goto sendquery_cleanup;
  		}
! 		PQclear(results);
  		transaction_status = PQtransactionStatus(pset.db);
  	}
  
--- 1104,1114 ----
  		if (PQresultStatus(results) != PGRES_COMMAND_OK)
  		{
  			psql_error("%s", PQerrorMessage(pset.db));
! 			ClearOrSaveResult(results);
  			ResetCancelConn();
  			goto sendquery_cleanup;
  		}
! 		ClearOrSaveResult(results);
  		transaction_status = PQtransactionStatus(pset.db);
  	}
  
*************** SendQuery(const char *query)
*** 1102,1112 ****
  			if (PQresultStatus(results) != PGRES_COMMAND_OK)
  			{
  				psql_error("%s", PQerrorMessage(pset.db));
! 				PQclear(results);
  				ResetCancelConn();
  				goto sendquery_cleanup;
  			}
! 			PQclear(results);
  			on_error_rollback_savepoint = true;
  		}
  	}
--- 1129,1139 ----
  			if (PQresultStatus(results) != PGRES_COMMAND_OK)
  			{
  				psql_error("%s", PQerrorMessage(pset.db));
! 				ClearOrSaveResult(results);
  				ResetCancelConn();
  				goto sendquery_cleanup;
  			}
! 			ClearOrSaveResult(results);
  			on_error_rollback_savepoint = true;
  		}
  	}
*************** SendQuery(const char *query)
*** 1202,1208 ****
  			if (PQresultStatus(svptres) != PGRES_COMMAND_OK)
  			{
  				psql_error("%s", PQerrorMessage(pset.db));
! 				PQclear(svptres);
  				OK = false;
  
  				PQclear(results);
--- 1229,1235 ----
  			if (PQresultStatus(svptres) != PGRES_COMMAND_OK)
  			{
  				psql_error("%s", PQerrorMessage(pset.db));
! 				ClearOrSaveResult(svptres);
  				OK = false;
  
  				PQclear(results);
*************** SendQuery(const char *query)
*** 1213,1219 ****
  		}
  	}
  
! 	PQclear(results);
  
  	/* Possible microtiming output */
  	if (pset.timing)
--- 1240,1246 ----
  		}
  	}
  
! 	ClearOrSaveResult(results);
  
  	/* Possible microtiming output */
  	if (pset.timing)
*************** ExecQueryUsingCursor(const char *query, 
*** 1299,1305 ****
  		results = PQexec(pset.db, "BEGIN");
  		OK = AcceptResult(results) &&
  			(PQresultStatus(results) == PGRES_COMMAND_OK);
! 		PQclear(results);
  		if (!OK)
  			return false;
  		started_txn = true;
--- 1326,1332 ----
  		results = PQexec(pset.db, "BEGIN");
  		OK = AcceptResult(results) &&
  			(PQresultStatus(results) == PGRES_COMMAND_OK);
! 		ClearOrSaveResult(results);
  		if (!OK)
  			return false;
  		started_txn = true;
*************** ExecQueryUsingCursor(const char *query, 
*** 1313,1319 ****
  	results = PQexec(pset.db, buf.data);
  	OK = AcceptResult(results) &&
  		(PQresultStatus(results) == PGRES_COMMAND_OK);
! 	PQclear(results);
  	termPQExpBuffer(&buf);
  	if (!OK)
  		goto cleanup;
--- 1340,1346 ----
  	results = PQexec(pset.db, buf.data);
  	OK = AcceptResult(results) &&
  		(PQresultStatus(results) == PGRES_COMMAND_OK);
! 	ClearOrSaveResult(results);
  	termPQExpBuffer(&buf);
  	if (!OK)
  		goto cleanup;
*************** ExecQueryUsingCursor(const char *query, 
*** 1384,1390 ****
  
  			OK = AcceptResult(results);
  			Assert(!OK);
! 			PQclear(results);
  			break;
  		}
  
--- 1411,1417 ----
  
  			OK = AcceptResult(results);
  			Assert(!OK);
! 			ClearOrSaveResult(results);
  			break;
  		}
  
*************** ExecQueryUsingCursor(const char *query, 
*** 1392,1398 ****
  		{
  			/* StoreQueryTuple will complain if not exactly one row */
  			OK = StoreQueryTuple(results);
! 			PQclear(results);
  			break;
  		}
  
--- 1419,1425 ----
  		{
  			/* StoreQueryTuple will complain if not exactly one row */
  			OK = StoreQueryTuple(results);
! 			ClearOrSaveResult(results);
  			break;
  		}
  
*************** ExecQueryUsingCursor(const char *query, 
*** 1415,1421 ****
  
  		printQuery(results, &my_popt, fout, is_pager, pset.logfile);
  
! 		PQclear(results);
  
  		/* after the first result set, disallow header decoration */
  		my_popt.topt.start_table = false;
--- 1442,1448 ----
  
  		printQuery(results, &my_popt, fout, is_pager, pset.logfile);
  
! 		ClearOrSaveResult(results);
  
  		/* after the first result set, disallow header decoration */
  		my_popt.topt.start_table = false;
*************** cleanup:
*** 1473,1486 ****
  		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)
--- 1500,1513 ----
  		OK = AcceptResult(results) &&
  			(PQresultStatus(results) == PGRES_COMMAND_OK);
  	}
! 	ClearOrSaveResult(results);
  
  	if (started_txn)
  	{
  		results = PQexec(pset.db, OK ? "COMMIT" : "ROLLBACK");
  		OK &= AcceptResult(results) &&
  			(PQresultStatus(results) == PGRES_COMMAND_OK);
! 		ClearOrSaveResult(results);
  	}
  
  	if (pset.timing)
diff --git a/src/bin/psql/help.c b/src/bin/psql/help.c
index 59f6f25..c6f0993 100644
*** a/src/bin/psql/help.c
--- b/src/bin/psql/help.c
*************** slashUsage(unsigned short int pager)
*** 168,177 ****
  	 * Use "psql --help=commands | wc" to count correctly.  It's okay to count
  	 * the USE_READLINE line even in builds without that.
  	 */
! 	output = PageOutput(109, pager ? &(pset.popt.topt) : NULL);
  
  	fprintf(output, _("General\n"));
  	fprintf(output, _("  \\copyright             show PostgreSQL usage and distribution terms\n"));
  	fprintf(output, _("  \\g [FILE] or ;         execute query (and send results to file or |pipe)\n"));
  	fprintf(output, _("  \\gset [PREFIX]         execute query and store results in psql variables\n"));
  	fprintf(output, _("  \\q                     quit psql\n"));
--- 168,178 ----
  	 * Use "psql --help=commands | wc" to count correctly.  It's okay to count
  	 * the USE_READLINE line even in builds without that.
  	 */
! 	output = PageOutput(110, pager ? &(pset.popt.topt) : NULL);
  
  	fprintf(output, _("General\n"));
  	fprintf(output, _("  \\copyright             show PostgreSQL usage and distribution terms\n"));
+ 	fprintf(output, _("  \\errverbose            show most recent error message at maximum verbosity\n"));
  	fprintf(output, _("  \\g [FILE] or ;         execute query (and send results to file or |pipe)\n"));
  	fprintf(output, _("  \\gset [PREFIX]         execute query and store results in psql variables\n"));
  	fprintf(output, _("  \\q                     quit psql\n"));
diff --git a/src/bin/psql/settings.h b/src/bin/psql/settings.h
index 159a7a5..ae30b2e 100644
*** a/src/bin/psql/settings.h
--- b/src/bin/psql/settings.h
*************** typedef struct _psqlSettings
*** 86,91 ****
--- 86,93 ----
  
  	FILE	   *copyStream;		/* Stream to read/write for \copy command */
  
+ 	PGresult   *last_error_result;		/* most recent error result, if any */
+ 
  	printQueryOpt popt;
  
  	char	   *gfname;			/* one-shot file output argument for \g */
diff --git a/src/bin/psql/startup.c b/src/bin/psql/startup.c
index 07e94d0..b96cdc4 100644
*** a/src/bin/psql/startup.c
--- b/src/bin/psql/startup.c
*************** main(int argc, char *argv[])
*** 135,140 ****
--- 135,141 ----
  	pset.queryFout = stdout;
  	pset.queryFoutPipe = false;
  	pset.copyStream = NULL;
+ 	pset.last_error_result = NULL;
  	pset.cur_cmd_source = stdin;
  	pset.cur_cmd_interactive = false;
  
diff --git a/src/bin/psql/tab-complete.c b/src/bin/psql/tab-complete.c
index eb592bb..688d92a 100644
*** a/src/bin/psql/tab-complete.c
--- b/src/bin/psql/tab-complete.c
*************** psql_completion(const char *text, int st
*** 1280,1286 ****
  		"\\dF", "\\dFd", "\\dFp", "\\dFt", "\\dg", "\\di", "\\dl", "\\dL",
  		"\\dm", "\\dn", "\\do", "\\dO", "\\dp", "\\drds", "\\ds", "\\dS",
  		"\\dt", "\\dT", "\\dv", "\\du", "\\dx", "\\dy",
! 		"\\e", "\\echo", "\\ef", "\\encoding", "\\ev",
  		"\\f", "\\g", "\\gset", "\\h", "\\help", "\\H", "\\i", "\\ir", "\\l",
  		"\\lo_import", "\\lo_export", "\\lo_list", "\\lo_unlink",
  		"\\o", "\\p", "\\password", "\\prompt", "\\pset", "\\q", "\\qecho", "\\r",
--- 1280,1286 ----
  		"\\dF", "\\dFd", "\\dFp", "\\dFt", "\\dg", "\\di", "\\dl", "\\dL",
  		"\\dm", "\\dn", "\\do", "\\dO", "\\dp", "\\drds", "\\ds", "\\dS",
  		"\\dt", "\\dT", "\\dv", "\\du", "\\dx", "\\dy",
! 		"\\e", "\\echo", "\\ef", "\\encoding", "\\errverbose", "\\ev",
  		"\\f", "\\g", "\\gset", "\\h", "\\help", "\\H", "\\i", "\\ir", "\\l",
  		"\\lo_import", "\\lo_export", "\\lo_list", "\\lo_unlink",
  		"\\o", "\\p", "\\password", "\\prompt", "\\pset", "\\q", "\\qecho", "\\r",