Add a new system view, pg_prepared_statements, that can be used to

access information about the prepared statements that are available
in the current session. Original patch from Joachim Wieland, various
improvements by Neil Conway.

The "statement" column of the view contains the literal query string
sent by the client, without any rewriting or pretty printing. This
means that prepared statements created via SQL will be prefixed with
"PREPARE ... AS ", whereas those prepared via the FE/BE protocol will
not. That is unfortunate, but discussion on -patches did not yield an
efficient way to improve this, and there is some merit in returning
exactly what the client sent to the backend.

Catalog version bumped, regression tests updated.

Author: Neil Conway

doc/src/sgml/catalogs.sgml

@@ -1,6 +1,6 @@
 <!--
  Documentation of the system catalogs, directed toward PostgreSQL developers
- $PostgreSQL: pgsql/doc/src/sgml/catalogs.sgml,v 2.115 2005/11/04 23:13:59 petere Exp $
+ $PostgreSQL: pgsql/doc/src/sgml/catalogs.sgml,v 2.116 2006/01/08 07:00:24 neilc Exp $
  -->
 
 <chapter id="catalogs">
@@ -4372,6 +4372,11 @@
       <entry>currently held locks</entry>
      </row>
 
+     <row>
+      <entry><link linkend="view-pg-prepared-statements"><structname>pg_prepared_statements</structname></link></entry>
+      <entry>current prepared statements</entry>
+     </row>
+
      <row>
       <entry><link linkend="view-pg-prepared-xacts"><structname>pg_prepared_xacts</structname></link></entry>
       <entry>currently prepared transactions</entry>
@@ -4778,6 +4783,101 @@
 
  </sect1>
 
+ <sect1 id="view-pg-prepared-statements">
+  <title><structname>pg_prepared_statements</structname></title>
+
+  <indexterm zone="view-pg-prepared-statements">
+   <primary>pg_prepared_statements</primary>
+  </indexterm>
+
+  <para>
+   The <structname>pg_prepared_statements</structname> view displays
+   all the prepared statements that are available in the current
+   session. See <xref linkend="sql-prepare"
+   endterm="sql-prepare-title"> for more information about prepared
+   statements.
+  </para>
+
+  <para>
+   <structname>pg_prepared_statements</structname> contains one row
+   for each prepared statement. Rows are added to the view when a new
+   prepared statement is created, and removed when a prepared
+   statement is released (for example, via the <xref
+   linkend="sql-deallocate" endterm="sql-deallocate-title">
+   command).
+  </para>
+
+  <table>
+   <title><structname>pg_prepared_statements</> Columns</title>
+
+   <tgroup cols=4>
+    <thead>
+     <row>
+      <entry>Name</entry>
+      <entry>Type</entry>
+      <entry>References</entry>
+      <entry>Description</entry>
+     </row>
+    </thead>
+    <tbody>
+     <row>
+      <entry><structfield>name</structfield></entry>
+      <entry><type>text</type></entry>
+      <entry></entry>
+      <entry>
+       The identifier of the prepared statement.
+      </entry>
+     </row>
+     <row>
+      <entry><structfield>statement</structfield></entry>
+      <entry><type>text</type></entry>
+      <entry></entry>
+      <entry>
+       The query string submitted by the client to create this
+       prepared statement. For prepared statements created via SQL,
+       this is the <command>PREPARE</command> statement submitted by
+       the client. For prepared statements created via the
+       frontend/backend protocol, this is the text of the prepared
+       statement itself.
+      </entry>
+     </row>
+     <row>
+      <entry><structfield>prepare_time</structfield></entry>
+      <entry><type>timestamptz</type></entry>
+      <entry></entry>
+      <entry>
+       The time at which the prepared statement was created.
+      </entry>
+     </row>
+     <row>
+      <entry><structfield>parameter_types</structfield></entry>
+      <entry><type>oid[]</type></entry>
+      <entry></entry>
+      <entry>
+       The expected parameter types for the prepared statement in the form of
+       an array of type OIDs.
+      </entry>
+     </row>
+     <row>
+      <entry><structfield>from_sql</structfield></entry>
+      <entry><type>boolean</type></entry>
+      <entry></entry>
+      <entry>
+       <literal>true</literal> if the prepared statement was created
+       via the <command>PREPARE</command> SQL statement;
+       <literal>false</literal> if the statement was prepared via the
+       frontend/backend protocol.
+      </entry>
+     </row>
+    </tbody>
+   </tgroup>
+  </table>
+
+  <para>
+   The <structname>pg_prepared_statements</structname> view is read only.
+  </para>
+ </sect1>
+
  <sect1 id="view-pg-prepared-xacts">
   <title><structname>pg_prepared_xacts</structname></title>
 

doc/src/sgml/ref/prepare.sgml

@@ -1,5 +1,5 @@
 <!--
-$PostgreSQL: pgsql/doc/src/sgml/ref/prepare.sgml,v 1.16 2005/10/15 01:47:12 neilc Exp $
+$PostgreSQL: pgsql/doc/src/sgml/ref/prepare.sgml,v 1.17 2006/01/08 07:00:25 neilc Exp $
 PostgreSQL documentation
 -->
 
@@ -145,6 +145,11 @@ PREPARE <replaceable class="PARAMETER">plan_name</replaceable> [ (<replaceable c
    the <xref linkend="sql-analyze" endterm="sql-analyze-title">
    documentation.
   </para>
+
+  <para>
+   You can see all available prepared statements of a session by querying the
+   <structname>pg_prepared_statements</> system view.
+  </para>
  </refsect1>
 
  <refsect1 id="sql-prepare-examples">

src/backend/catalog/system_views.sql

@@ -3,7 +3,7 @@
  *
  * Copyright (c) 1996-2005, PostgreSQL Global Development Group
  *
- * $PostgreSQL: pgsql/src/backend/catalog/system_views.sql,v 1.22 2005/10/06 02:29:15 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/catalog/system_views.sql,v 1.23 2006/01/08 07:00:25 neilc Exp $
  */
 
 CREATE VIEW pg_roles AS 
@@ -156,6 +156,12 @@ CREATE VIEW pg_prepared_xacts AS
          LEFT JOIN pg_authid U ON P.ownerid = U.oid
          LEFT JOIN pg_database D ON P.dbid = D.oid;
 
+CREATE VIEW pg_prepared_statements AS
+    SELECT P.name, P.statement, P.prepare_time, P.parameter_types, P.from_sql
+    FROM pg_prepared_statement() AS P
+    (name text, statement text, prepare_time timestamptz,
+     parameter_types oid[], from_sql boolean);
+
 CREATE VIEW pg_settings AS 
     SELECT * 
     FROM pg_show_all_settings() AS A 

src/backend/commands/prepare.c

@@ -10,21 +10,26 @@
  * Copyright (c) 2002-2005, PostgreSQL Global Development Group
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/commands/prepare.c,v 1.44 2005/12/14 17:06:27 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/commands/prepare.c,v 1.45 2006/01/08 07:00:25 neilc Exp $
  *
  *-------------------------------------------------------------------------
  */
 #include "postgres.h"
 
+#include "access/heapam.h"
+#include "catalog/pg_type.h"
 #include "commands/explain.h"
 #include "commands/prepare.h"
 #include "executor/executor.h"
-#include "utils/guc.h"
+#include "funcapi.h"
+#include "parser/parsetree.h"
 #include "optimizer/planner.h"
 #include "rewrite/rewriteHandler.h"
 #include "tcop/pquery.h"
 #include "tcop/tcopprot.h"
 #include "tcop/utility.h"
+#include "utils/builtins.h"
+#include "utils/guc.h"
 #include "utils/hsearch.h"
 #include "utils/memutils.h"
 
@@ -40,6 +45,7 @@ static HTAB *prepared_queries = NULL;
 static void InitQueryHashTable(void);
 static ParamListInfo EvaluateParams(EState *estate,
 			   List *params, List *argtypes);
+static Datum build_oid_array(List *oid_list);
 
 /*
  * Implements the 'PREPARE' utility statement.
@@ -114,7 +120,8 @@ PrepareQuery(PrepareStmt *stmt)
 						   commandTag,
 						   query_list,
 						   plan_list,
-						   stmt->argtype_oids);
+						   stmt->argtype_oids,
+						   true);
 }
 
 /*
@@ -298,7 +305,8 @@ StorePreparedStatement(const char *stmt_name,
 					   const char *commandTag,
 					   List *query_list,
 					   List *plan_list,
-					   List *argtype_list)
+					   List *argtype_list,
+					   bool from_sql)
 {
 	PreparedStatement *entry;
 	MemoryContext oldcxt,
@@ -361,6 +369,8 @@ StorePreparedStatement(const char *stmt_name,
 	entry->plan_list = plan_list;
 	entry->argtype_list = argtype_list;
 	entry->context = entrycxt;
+	entry->prepare_time = GetCurrentTimestamp();
+	entry->from_sql = from_sql;
 
 	MemoryContextSwitchTo(oldcxt);
 }
@@ -383,7 +393,7 @@ FetchPreparedStatement(const char *stmt_name, bool throwError)
 	{
 		/*
 		 * We can't just use the statement name as supplied by the user: the
-		 * hash package is picky enough that it needs to be NULL-padded out to
+		 * hash package is picky enough that it needs to be NUL-padded out to
 		 * the appropriate length to work correctly.
 		 */
 		StrNCpy(key, stmt_name, sizeof(key));
@@ -661,3 +671,125 @@ ExplainExecuteQuery(ExplainStmt *stmt, ParamListInfo params,
 	if (estate)
 		FreeExecutorState(estate);
 }
+
+/*
+ * This set returning function reads all the prepared statements and
+ * returns a set of (name, statement, prepare_time, param_types).
+ */
+Datum
+pg_prepared_statement(PG_FUNCTION_ARGS)
+{
+	FuncCallContext	   *funcctx;
+	HASH_SEQ_STATUS    *hash_seq;
+	PreparedStatement  *prep_stmt;
+
+	/* stuff done only on the first call of the function */
+	if (SRF_IS_FIRSTCALL())
+	{
+		TupleDesc		tupdesc;
+		MemoryContext	oldcontext;
+
+		/* create a function context for cross-call persistence */
+		funcctx = SRF_FIRSTCALL_INIT();
+
+		/*
+		 * switch to memory context appropriate for multiple function
+		 * calls
+		 */
+		oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
+
+		/* allocate memory for user context */
+		if (prepared_queries)
+		{
+			hash_seq = (HASH_SEQ_STATUS *) palloc(sizeof(HASH_SEQ_STATUS));
+			hash_seq_init(hash_seq, prepared_queries);
+			funcctx->user_fctx = (void *) hash_seq;
+		}
+		else
+			funcctx->user_fctx = NULL;
+
+		/*
+		 * build tupdesc for result tuples. This must match the
+		 * definition of the pg_prepared_statements view in
+		 * system_views.sql
+		 */
+		tupdesc = CreateTemplateTupleDesc(5, false);
+		TupleDescInitEntry(tupdesc, (AttrNumber) 1, "name",
+						   TEXTOID, -1, 0);
+		TupleDescInitEntry(tupdesc, (AttrNumber) 2, "statement",
+						   TEXTOID, -1, 0);
+		TupleDescInitEntry(tupdesc, (AttrNumber) 3, "prepare_time",
+						   TIMESTAMPTZOID, -1, 0);
+		TupleDescInitEntry(tupdesc, (AttrNumber) 4, "parameter_types",
+						   OIDARRAYOID, -1, 0);
+		TupleDescInitEntry(tupdesc, (AttrNumber) 5, "from_sql",
+						   BOOLOID, -1, 0);
+
+		funcctx->tuple_desc = BlessTupleDesc(tupdesc);
+		MemoryContextSwitchTo(oldcontext);
+	}
+
+	/* stuff done on every call of the function */
+	funcctx = SRF_PERCALL_SETUP();
+	hash_seq = (HASH_SEQ_STATUS *) funcctx->user_fctx;
+
+	/* if the hash table is uninitialized, we're done */
+	if (hash_seq == NULL)
+		SRF_RETURN_DONE(funcctx);
+
+	prep_stmt = hash_seq_search(hash_seq);
+	if (prep_stmt)
+	{
+		Datum			result;
+		HeapTuple		tuple;
+		Datum			values[5];
+		bool			nulls[5];
+
+		MemSet(nulls, 0, sizeof(nulls));
+
+		values[0] = DirectFunctionCall1(textin,
+										CStringGetDatum(prep_stmt->stmt_name));
+
+		if (prep_stmt->query_string == NULL)
+			nulls[1] = true;
+		else
+			values[1] = DirectFunctionCall1(textin,
+									CStringGetDatum(prep_stmt->query_string));
+
+		values[2] = TimestampTzGetDatum(prep_stmt->prepare_time);
+		values[3] = build_oid_array(prep_stmt->argtype_list);
+		values[4] = BoolGetDatum(prep_stmt->from_sql);
+
+		tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
+		result = HeapTupleGetDatum(tuple);
+		SRF_RETURN_NEXT(funcctx, result);
+	}
+
+	SRF_RETURN_DONE(funcctx);
+}
+
+/*
+ * This utility function takes a List of Oids, and returns a Datum
+ * pointing to a Postgres array containing those OIDs. The empty list
+ * is returned as a zero-element array, not NULL.
+ */
+static Datum
+build_oid_array(List *oid_list)
+{
+	ListCell *lc;
+	int len;
+	int i;
+	Datum *tmp_ary;
+	ArrayType *ary;
+
+	len = list_length(oid_list);
+	tmp_ary = (Datum *) palloc(len * sizeof(Datum));
+
+	i = 0;
+	foreach(lc, oid_list)
+		tmp_ary[i++] = ObjectIdGetDatum(lfirst_oid(lc));
+
+	/* XXX: this hardcodes assumptions about the OID type... */
+	ary = construct_array(tmp_ary, len, OIDOID, sizeof(Oid), true, 'i');
+	return PointerGetDatum(ary);
+}

src/backend/tcop/postgres.c

@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/tcop/postgres.c,v 1.477 2006/01/05 10:07:45 petere Exp $
+ *	  $PostgreSQL: pgsql/src/backend/tcop/postgres.c,v 1.478 2006/01/08 07:00:25 neilc Exp $
  *
  * NOTES
  *	  this is the "main" module of the postgres backend and
@@ -55,6 +55,7 @@
 #include "tcop/pquery.h"
 #include "tcop/tcopprot.h"
 #include "tcop/utility.h"
+#include "utils/builtins.h"
 #include "utils/flatfiles.h"
 #include "utils/guc.h"
 #include "utils/lsyscache.h"
@@ -1308,7 +1309,8 @@ exec_parse_message(const char *query_string,	/* string to execute */
 							   commandTag,
 							   querytree_list,
 							   plantree_list,
-							   param_list);
+							   param_list,
+							   false);
 	}
 	else
 	{
@@ -1322,6 +1324,7 @@ exec_parse_message(const char *query_string,	/* string to execute */
 		pstmt->query_list = querytree_list;
 		pstmt->plan_list = plantree_list;
 		pstmt->argtype_list = param_list;
+		pstmt->from_sql = false;
 		pstmt->context = unnamed_stmt_context;
 		/* Now the unnamed statement is complete and valid */
 		unnamed_stmt_pstmt = pstmt;