Add libpq support for recreating an error message with different verbosity.

Often, upon getting an unexpected error in psql, one's first wish is that
the verbosity setting had been higher; for example, to be able to see the
schema-name field or the server code location info.  Up to now the only way
has been to adjust the VERBOSITY variable and repeat the failing query.
That's a pain, and it doesn't work if the error isn't reproducible.

This commit adds support in libpq for regenerating the error message for
an existing error PGresult at any desired verbosity level.  This is almost
just a matter of refactoring the existing code into a subroutine, but there
is one bit of possibly-needed information that was not getting put into
PGresults: the text of the last query sent to the server.  We must add that
string to the contents of an error PGresult.  But we only need to save it
if it might be used, which with the existing error-formatting code only
happens if there is a PG_DIAG_STATEMENT_POSITION error field, which is
probably pretty rare for errors in production situations.  So really the
overhead when the feature isn't used should be negligible.

Alex Shulgin, reviewed by Daniel Vérité, some improvements by me

Author: tglsfdc

doc/src/sgml/libpq.sgml

@@ -2691,6 +2691,48 @@ char *PQresultErrorMessage(const PGresult *res);
       </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>
@@ -5582,6 +5624,8 @@ PGVerbosity PQsetErrorVerbosity(PGconn *conn, PGVerbosity verbosity);
       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>
@@ -5622,6 +5666,8 @@ PGContextVisibility PQsetErrorContextVisibility(PGconn *conn, PGContextVisibilit
       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>
@@ -6089,8 +6135,9 @@ PQsetNoticeProcessor(PGconn *conn,
    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
+   individual fields using <function>PQresultErrorField</>, or obtain a
+   complete preformatted message 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.)

src/interfaces/libpq/exports.txt

@@ -170,3 +170,4 @@ PQsslStruct               167
 PQsslAttributeNames       168
 PQsslAttribute            169
 PQsetErrorContextVisibility 170
+PQresultVerboseErrorMessage 171

src/interfaces/libpq/fe-exec.c

@@ -159,6 +159,7 @@ PQmakeEmptyPGresult(PGconn *conn, ExecStatusType status)
 	result->nEvents = 0;
 	result->errMsg = NULL;
 	result->errFields = NULL;
+	result->errQuery = NULL;
 	result->null_field[0] = '\0';
 	result->curBlock = NULL;
 	result->curOffset = 0;
@@ -2598,6 +2599,44 @@ PQresultErrorMessage(const PGresult *res)
 	return res->errMsg;
 }
 
+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)
 {