contrib/pg_stat_statements 1202

*** a/contrib/pg_stat_statements/pg_stat_statements.c
--- b/contrib/pg_stat_statements/pg_stat_statements.c
***************
*** 216,222 **** error:
  }
  
  /*
!  * pgss_shutdown - Load statistics from file.
   */
  static void
  pgss_startup(void)
--- 216,222 ----
  }
  
  /*
!  * pgss_startup - Load statistics from file.
   */
  static void
  pgss_startup(void)
*** a/doc/src/sgml/pgstatstatements.sgml
--- b/doc/src/sgml/pgstatstatements.sgml
***************
*** 68,74 ****
        <entry><structfield>calls</structfield></entry>
        <entry><type>bigint</type></entry>
        <entry></entry>
!       <entry>Number of being executed</entry>
       </row>
  
       <row>
--- 68,74 ----
        <entry><structfield>calls</structfield></entry>
        <entry><type>bigint</type></entry>
        <entry></entry>
!       <entry>Number of times executed</entry>
       </row>
  
       <row>

diff -cprN HEAD/src/backend/bootstrap/bootstrap.c pg_stat_statements/src/backend/bootstrap/bootstrap.c
*** HEAD/src/backend/bootstrap/bootstrap.c	Fri Nov 14 21:39:34 2008
--- pg_stat_statements/src/backend/bootstrap/bootstrap.c	Fri Dec 12 18:26:03 2008
*************** typedef struct _IndexList
*** 193,198 ****
--- 193,199 ----
  
  static IndexList *ILHead = NULL;
  
+ startup_hook_type	startup_hook = NULL;
  
  /*
   *	 AuxiliaryProcessMain
*************** AuxiliaryProcessMain(int argc, char *arg
*** 419,424 ****
--- 420,427 ----
  			bootstrap_signals();
  			StartupXLOG();
  			BuildFlatFiles(false);
+ 			if (startup_hook)
+ 				startup_hook();
  			proc_exit(0);		/* startup done */
  
  		case BgWriterProcess:
diff -cprN HEAD/src/backend/commands/copy.c pg_stat_statements/src/backend/commands/copy.c
*** HEAD/src/backend/commands/copy.c	Fri Dec  5 00:11:18 2008
--- pg_stat_statements/src/backend/commands/copy.c	Fri Dec 12 18:26:03 2008
*************** DoCopy(const CopyStmt *stmt, const char 
*** 1056,1062 ****
  		/* Create a QueryDesc requesting no output */
  		cstate->queryDesc = CreateQueryDesc(plan, GetActiveSnapshot(),
  											InvalidSnapshot,
! 											dest, NULL, false);
  
  		/*
  		 * Call ExecutorStart to prepare the plan for execution.
--- 1056,1062 ----
  		/* Create a QueryDesc requesting no output */
  		cstate->queryDesc = CreateQueryDesc(plan, GetActiveSnapshot(),
  											InvalidSnapshot,
! 											dest, NULL, false, queryString);
  
  		/*
  		 * Call ExecutorStart to prepare the plan for execution.
diff -cprN HEAD/src/backend/executor/functions.c pg_stat_statements/src/backend/executor/functions.c
*** HEAD/src/backend/executor/functions.c	Fri Dec  5 00:11:18 2008
--- pg_stat_statements/src/backend/executor/functions.c	Fri Dec 12 18:26:03 2008
*************** postquel_start(execution_state *es, SQLF
*** 413,424 ****
  		es->qd = CreateQueryDesc((PlannedStmt *) es->stmt,
  								 snapshot, InvalidSnapshot,
  								 dest,
! 								 fcache->paramLI, false);
  	else
  		es->qd = CreateUtilityQueryDesc(es->stmt,
  										snapshot,
  										dest,
! 										fcache->paramLI);
  
  	/* We assume we don't need to set up ActiveSnapshot for ExecutorStart */
  
--- 413,424 ----
  		es->qd = CreateQueryDesc((PlannedStmt *) es->stmt,
  								 snapshot, InvalidSnapshot,
  								 dest,
! 								 fcache->paramLI, false, fcache->src);
  	else
  		es->qd = CreateUtilityQueryDesc(es->stmt,
  										snapshot,
  										dest,
! 										fcache->paramLI, fcache->src);
  
  	/* We assume we don't need to set up ActiveSnapshot for ExecutorStart */
  
diff -cprN HEAD/src/backend/postmaster/bgwriter.c pg_stat_statements/src/backend/postmaster/bgwriter.c
*** HEAD/src/backend/postmaster/bgwriter.c	Thu Nov 27 23:42:00 2008
--- pg_stat_statements/src/backend/postmaster/bgwriter.c	Fri Dec 12 18:26:03 2008
*************** static BgWriterShmemStruct *BgWriterShme
*** 141,146 ****
--- 141,148 ----
  /* interval for calling AbsorbFsyncRequests in CheckpointWriteDelay */
  #define WRITES_PER_ABSORB		1000
  
+ shutdown_hook_type	shutdown_hook = NULL;
+ 
  /*
   * GUC parameters
   */
*************** BackgroundWriterMain(void)
*** 396,401 ****
--- 398,405 ----
  			 */
  			ExitOnAnyError = true;
  			/* Close down the database */
+ 			if (shutdown_hook)
+ 				shutdown_hook();
  			ShutdownXLOG(0, 0);
  			/* Normal exit from the bgwriter is here */
  			proc_exit(0);		/* done */
diff -cprN HEAD/src/backend/executor/spi.c pg_stat_statements/src/backend/executor/spi.c
*** HEAD/src/backend/executor/spi.c	Fri Dec  5 00:11:18 2008
--- pg_stat_statements/src/backend/executor/spi.c	Fri Dec 12 18:26:03 2008
*************** _SPI_execute_plan(SPIPlanPtr plan, Param
*** 1794,1800 ****
  				qdesc = CreateQueryDesc((PlannedStmt *) stmt,
  										snap, crosscheck_snapshot,
  										dest,
! 										paramLI, false);
  				res = _SPI_pquery(qdesc, fire_triggers,
  								  canSetTag ? tcount : 0);
  				FreeQueryDesc(qdesc);
--- 1794,1801 ----
  				qdesc = CreateQueryDesc((PlannedStmt *) stmt,
  										snap, crosscheck_snapshot,
  										dest,
! 										paramLI, false,
! 										plansource->query_string);
  				res = _SPI_pquery(qdesc, fire_triggers,
  								  canSetTag ? tcount : 0);
  				FreeQueryDesc(qdesc);
diff -cprN HEAD/src/backend/storage/lmgr/proc.c pg_stat_statements/src/backend/storage/lmgr/proc.c
*** HEAD/src/backend/storage/lmgr/proc.c	Wed Dec 10 08:05:02 2008
--- pg_stat_statements/src/backend/storage/lmgr/proc.c	Fri Dec 12 18:26:03 2008
*************** InitAuxiliaryProcess(void)
*** 381,386 ****
--- 381,390 ----
  	if (MyProc != NULL)
  		elog(ERROR, "you already exist");
  
+ #ifdef EXEC_BACKEND
+ 	process_shared_preload_libraries();
+ #endif
+ 
  	/*
  	 * We use the ProcStructLock to protect assignment and releasing of
  	 * AuxiliaryProcs entries.
diff -cprN HEAD/src/backend/tcop/pquery.c pg_stat_statements/src/backend/tcop/pquery.c
*** HEAD/src/backend/tcop/pquery.c	Fri Dec  5 00:11:18 2008
--- pg_stat_statements/src/backend/tcop/pquery.c	Fri Dec 12 18:26:03 2008
*************** Portal		ActivePortal = NULL;
*** 38,44 ****
  static void ProcessQuery(PlannedStmt *plan,
  			 ParamListInfo params,
  			 DestReceiver *dest,
! 			 char *completionTag);
  static void FillPortalStore(Portal portal, bool isTopLevel);
  static uint32 RunFromStore(Portal portal, ScanDirection direction, long count,
  			 DestReceiver *dest);
--- 38,45 ----
  static void ProcessQuery(PlannedStmt *plan,
  			 ParamListInfo params,
  			 DestReceiver *dest,
! 			 char *completionTag,
! 			 const char *sourceText);
  static void FillPortalStore(Portal portal, bool isTopLevel);
  static uint32 RunFromStore(Portal portal, ScanDirection direction, long count,
  			 DestReceiver *dest);
*************** CreateQueryDesc(PlannedStmt *plannedstmt
*** 65,71 ****
  				Snapshot crosscheck_snapshot,
  				DestReceiver *dest,
  				ParamListInfo params,
! 				bool doInstrument)
  {
  	QueryDesc  *qd = (QueryDesc *) palloc(sizeof(QueryDesc));
  
--- 66,73 ----
  				Snapshot crosscheck_snapshot,
  				DestReceiver *dest,
  				ParamListInfo params,
! 				bool doInstrument,
! 				const char *sourceText)
  {
  	QueryDesc  *qd = (QueryDesc *) palloc(sizeof(QueryDesc));
  
*************** CreateQueryDesc(PlannedStmt *plannedstmt
*** 78,83 ****
--- 80,86 ----
  	qd->dest = dest;			/* output dest */
  	qd->params = params;		/* parameter values passed into query */
  	qd->doInstrument = doInstrument;	/* instrumentation wanted? */
+ 	qd->sourceText = sourceText;
  
  	/* null these fields until set by ExecutorStart */
  	qd->tupDesc = NULL;
*************** QueryDesc *
*** 95,101 ****
  CreateUtilityQueryDesc(Node *utilitystmt,
  					   Snapshot snapshot,
  					   DestReceiver *dest,
! 					   ParamListInfo params)
  {
  	QueryDesc  *qd = (QueryDesc *) palloc(sizeof(QueryDesc));
  
--- 98,105 ----
  CreateUtilityQueryDesc(Node *utilitystmt,
  					   Snapshot snapshot,
  					   DestReceiver *dest,
! 					   ParamListInfo params,
! 					   const char *sourceText)
  {
  	QueryDesc  *qd = (QueryDesc *) palloc(sizeof(QueryDesc));
  
*************** CreateUtilityQueryDesc(Node *utilitystmt
*** 107,112 ****
--- 111,117 ----
  	qd->dest = dest;			/* output dest */
  	qd->params = params;		/* parameter values passed into query */
  	qd->doInstrument = false;	/* uninteresting for utilities */
+ 	qd->sourceText = sourceText;
  
  	/* null these fields until set by ExecutorStart */
  	qd->tupDesc = NULL;
*************** static void
*** 155,161 ****
  ProcessQuery(PlannedStmt *plan,
  			 ParamListInfo params,
  			 DestReceiver *dest,
! 			 char *completionTag)
  {
  	QueryDesc  *queryDesc;
  
--- 160,167 ----
  ProcessQuery(PlannedStmt *plan,
  			 ParamListInfo params,
  			 DestReceiver *dest,
! 			 char *completionTag,
! 			 const char *sourceText)
  {
  	QueryDesc  *queryDesc;
  
*************** ProcessQuery(PlannedStmt *plan,
*** 171,177 ****
  	 */
  	queryDesc = CreateQueryDesc(plan,
  								GetActiveSnapshot(), InvalidSnapshot,
! 								dest, params, false);
  
  	/*
  	 * Set up to collect AFTER triggers
--- 177,183 ----
  	 */
  	queryDesc = CreateQueryDesc(plan,
  								GetActiveSnapshot(), InvalidSnapshot,
! 								dest, params, false, sourceText);
  
  	/*
  	 * Set up to collect AFTER triggers
*************** PortalStart(Portal portal, ParamListInfo
*** 507,513 ****
  											InvalidSnapshot,
  											None_Receiver,
  											params,
! 											false);
  
  				/*
  				 * We do *not* call AfterTriggerBeginQuery() here.	We assume
--- 513,520 ----
  											InvalidSnapshot,
  											None_Receiver,
  											params,
! 											false,
! 											portal->sourceText);
  
  				/*
  				 * We do *not* call AfterTriggerBeginQuery() here.	We assume
*************** PortalRunMulti(Portal portal, bool isTop
*** 1259,1272 ****
  				/* statement can set tag string */
  				ProcessQuery(pstmt,
  							 portal->portalParams,
! 							 dest, completionTag);
  			}
  			else
  			{
  				/* stmt added by rewrite cannot set tag */
  				ProcessQuery(pstmt,
  							 portal->portalParams,
! 							 altdest, NULL);
  			}
  
  			if (log_executor_stats)
--- 1266,1279 ----
  				/* statement can set tag string */
  				ProcessQuery(pstmt,
  							 portal->portalParams,
! 							 dest, completionTag, portal->sourceText);
  			}
  			else
  			{
  				/* stmt added by rewrite cannot set tag */
  				ProcessQuery(pstmt,
  							 portal->portalParams,
! 							 altdest, NULL, portal->sourceText);
  			}
  
  			if (log_executor_stats)
diff -cprN HEAD/src/include/storage/ipc.h pg_stat_statements/src/include/storage/ipc.h
*** HEAD/src/include/storage/ipc.h	Sat Nov  1 15:22:28 2008
--- pg_stat_statements/src/include/storage/ipc.h	Fri Dec 12 18:26:03 2008
***************
*** 20,25 ****
--- 20,30 ----
  
  typedef void (*pg_on_exit_callback) (int code, Datum arg);
  
+ typedef void (*startup_hook_type) (void);
+ extern PGDLLIMPORT startup_hook_type startup_hook;
+ typedef void (*shutdown_hook_type) (void);
+ extern PGDLLIMPORT shutdown_hook_type shutdown_hook;
+ 
  /*----------
   * API for handling cleanup that must occur during either ereport(ERROR)
   * or ereport(FATAL) exits from a block of code.  (Typical examples are
diff -cprN HEAD/src/backend/commands/explain.c pg_stat_statements/src/backend/commands/explain.c
*** HEAD/src/backend/commands/explain.c	Sat Nov 22 11:15:56 2008
--- pg_stat_statements/src/backend/commands/explain.c	Fri Dec 12 18:26:03 2008
*************** ExplainOneQuery(Query *query, ExplainStm
*** 172,178 ****
  		plan = pg_plan_query(query, 0, params);
  
  		/* run it (if needed) and produce output */
! 		ExplainOnePlan(plan, params, stmt, tstate);
  	}
  }
  
--- 176,182 ----
  		plan = pg_plan_query(query, 0, params);
  
  		/* run it (if needed) and produce output */
! 		ExplainOnePlan(plan, params, stmt, tstate, queryString);
  	}
  }
  
*************** ExplainOneUtility(Node *utilityStmt, Exp
*** 219,225 ****
   */
  void
  ExplainOnePlan(PlannedStmt *plannedstmt, ParamListInfo params,
! 			   ExplainStmt *stmt, TupOutputState *tstate)
  {
  	QueryDesc  *queryDesc;
  	instr_time	starttime;
--- 223,230 ----
   */
  void
  ExplainOnePlan(PlannedStmt *plannedstmt, ParamListInfo params,
! 			   ExplainStmt *stmt, TupOutputState *tstate,
! 			   const char *queryString)
  {
  	QueryDesc  *queryDesc;
  	instr_time	starttime;
*************** ExplainOnePlan(PlannedStmt *plannedstmt,
*** 237,243 ****
  	queryDesc = CreateQueryDesc(plannedstmt,
  								GetActiveSnapshot(), InvalidSnapshot,
  								None_Receiver, params,
! 								stmt->analyze);
  
  	INSTR_TIME_SET_CURRENT(starttime);
  
--- 242,248 ----
  	queryDesc = CreateQueryDesc(plannedstmt,
  								GetActiveSnapshot(), InvalidSnapshot,
  								None_Receiver, params,
! 								stmt->analyze, queryString);
  
  	INSTR_TIME_SET_CURRENT(starttime);

diff -cprN HEAD/src/backend/commands/prepare.c pg_stat_statements/src/backend/commands/prepare.c
*** HEAD/src/backend/commands/prepare.c	Sat Nov  1 15:22:28 2008
--- pg_stat_statements/src/backend/commands/prepare.c	Fri Dec 12 18:26:03 2008
*************** ExplainExecuteQuery(ExecuteStmt *execstm
*** 697,703 ****
  				pstmt->intoClause = execstmt->into;
  			}
  
! 			ExplainOnePlan(pstmt, paramLI, stmt, tstate);
  		}
  		else
  		{
--- 697,703 ----
  				pstmt->intoClause = execstmt->into;
  			}
  
! 			ExplainOnePlan(pstmt, paramLI, stmt, tstate, queryString);
  		}
  		else
  		{
diff -cprN HEAD/src/include/commands/explain.h pg_stat_statements/src/include/commands/explain.h
*** HEAD/src/include/commands/explain.h	Sat Nov 22 11:15:56 2008
--- pg_stat_statements/src/include/commands/explain.h	Fri Dec 12 18:26:03 2008
*************** extern void ExplainOneUtility(Node *util
*** 39,45 ****
  				  TupOutputState *tstate);
  
  extern void ExplainOnePlan(PlannedStmt *plannedstmt, ParamListInfo params,
! 			   ExplainStmt *stmt, TupOutputState *tstate);
  
  extern void ExplainPrintPlan(StringInfo str, QueryDesc *queryDesc,
  							 bool analyze, bool verbose);
--- 39,46 ----
  				  TupOutputState *tstate);
  
  extern void ExplainOnePlan(PlannedStmt *plannedstmt, ParamListInfo params,
! 			   ExplainStmt *stmt, TupOutputState *tstate,
! 			   const char *queryString);
  
  extern void ExplainPrintPlan(StringInfo str, QueryDesc *queryDesc,
  							 bool analyze, bool verbose);
diff -cprN HEAD/src/include/executor/execdesc.h pg_stat_statements/src/include/executor/execdesc.h
*** HEAD/src/include/executor/execdesc.h	Sat Nov 22 11:15:56 2008
--- pg_stat_statements/src/include/executor/execdesc.h	Fri Dec 12 18:26:03 2008
*************** typedef struct QueryDesc
*** 42,47 ****
--- 42,48 ----
  	DestReceiver *dest;			/* the destination for tuple output */
  	ParamListInfo params;		/* param values being passed in */
  	bool		doInstrument;	/* TRUE requests runtime instrumentation */
+ 	const char *sourceText;		/* Source text for the query */
  
  	/* These fields are set by ExecutorStart */
  	TupleDesc	tupDesc;		/* descriptor for result tuples */
*************** extern QueryDesc *CreateQueryDesc(Planne
*** 58,69 ****
  				Snapshot crosscheck_snapshot,
  				DestReceiver *dest,
  				ParamListInfo params,
! 				bool doInstrument);
  
  extern QueryDesc *CreateUtilityQueryDesc(Node *utilitystmt,
  					   Snapshot snapshot,
  					   DestReceiver *dest,
! 					   ParamListInfo params);
  
  extern void FreeQueryDesc(QueryDesc *qdesc);
  
--- 59,72 ----
  				Snapshot crosscheck_snapshot,
  				DestReceiver *dest,
  				ParamListInfo params,
! 				bool doInstrument,
! 				const char *sourceText);
  
  extern QueryDesc *CreateUtilityQueryDesc(Node *utilitystmt,
  					   Snapshot snapshot,
  					   DestReceiver *dest,
! 					   ParamListInfo params,
! 					   const char *sourceText);
  
  extern void FreeQueryDesc(QueryDesc *qdesc);
  
diff -cprN HEAD/src/include/pgstat.h pg_stat_statements/src/include/pgstat.h
*** HEAD/src/include/pgstat.h	Fri Nov 14 21:39:34 2008
--- pg_stat_statements/src/include/pgstat.h	Fri Dec 12 18:26:03 2008
*************** typedef struct PgStat_FunctionCallUsage
*** 591,597 ****
  extern bool pgstat_track_activities;
  extern bool pgstat_track_counts;
  extern int	pgstat_track_functions;
! extern int	pgstat_track_activity_query_size;
  extern char *pgstat_stat_tmpname;
  extern char *pgstat_stat_filename;
  
--- 591,597 ----
  extern bool pgstat_track_activities;
  extern bool pgstat_track_counts;
  extern int	pgstat_track_functions;
! extern PGDLLIMPORT int	pgstat_track_activity_query_size;
  extern char *pgstat_stat_tmpname;
  extern char *pgstat_stat_filename;
  

diff -cprN HEAD/src/backend/commands/explain.c pg_stat_statements/src/backend/commands/explain.c
*** HEAD/src/backend/commands/explain.c	Sat Nov 22 11:15:56 2008
--- pg_stat_statements/src/backend/commands/explain.c	Fri Dec 12 18:26:03 2008
***************
*** 33,38 ****
--- 33,41 ----
  #include "utils/snapmgr.h"
  
  
+ /* GUC parameter */
+ char *explain_analyze_format;
+ 
  /* Hook for plugins to get control in ExplainOneQuery() */
  ExplainOneQuery_hook_type ExplainOneQuery_hook = NULL;
  
*************** static void show_sort_keys(Plan *sortpla
*** 73,78 ****
--- 76,82 ----
  static void show_sort_info(SortState *sortstate,
  			   StringInfo str, int indent, ExplainState *es);
  static const char *explain_get_index_name(Oid indexId);
+ static void appendInstrument(StringInfo str, const Instrumentation *instr);
  
  
  /*
*************** report_triggers(ResultRelInfo *rInfo, bo
*** 396,403 ****
  			appendStringInfo(buf, " on %s",
  							 RelationGetRelationName(rInfo->ri_RelationDesc));
  
! 		appendStringInfo(buf, ": time=%.3f calls=%.0f\n",
  						 1000.0 * instr->total, instr->ntuples);
  	}
  }
  
--- 401,410 ----
  			appendStringInfo(buf, " on %s",
  							 RelationGetRelationName(rInfo->ri_RelationDesc));
  
! 		appendStringInfo(buf, ": time=%.3f calls=%.0f",
  						 1000.0 * instr->total, instr->ntuples);
+ 		appendInstrument(buf, instr);
+ 		appendStringInfoChar(buf, '\n');
  	}
  }
  
*************** explain_outNode(StringInfo str,
*** 801,811 ****
  	{
  		double		nloops = planstate->instrument->nloops;
  
! 		appendStringInfo(str, " (actual time=%.3f..%.3f rows=%.0f loops=%.0f)",
  						 1000.0 * planstate->instrument->startup / nloops,
  						 1000.0 * planstate->instrument->total / nloops,
  						 planstate->instrument->ntuples / nloops,
  						 planstate->instrument->nloops);
  	}
  	else if (es->printAnalyze)
  		appendStringInfo(str, " (never executed)");
--- 808,820 ----
  	{
  		double		nloops = planstate->instrument->nloops;
  
! 		appendStringInfo(str, " (actual time=%.3f..%.3f rows=%.0f loops=%.0f",
  						 1000.0 * planstate->instrument->startup / nloops,
  						 1000.0 * planstate->instrument->total / nloops,
  						 planstate->instrument->ntuples / nloops,
  						 planstate->instrument->nloops);
+ 		appendInstrument(str, planstate->instrument);
+ 		appendStringInfoChar(str, ')');
  	}
  	else if (es->printAnalyze)
  		appendStringInfo(str, " (never executed)");
*************** explain_get_index_name(Oid indexId)
*** 1335,1338 ****
--- 1344,1423 ----
  		result = quote_identifier(result);
  	}
  	return result;
+ }
+ 
+ /*
+  * append formatted instrumentation to the provided buffer.
+  */
+ static void
+ appendInstrument(StringInfo buf, const Instrumentation *instr)
+ {
+ 	int			format_len;
+ 	int			i;
+ 
+ 	format_len = strlen(explain_analyze_format);
+ 
+ 	for (i = 0; i < format_len; i++)
+ 	{
+ 		if (explain_analyze_format[i] != '%')
+ 		{
+ 			/* literal char, just copy */
+ 			appendStringInfoChar(buf, explain_analyze_format[i]);
+ 			continue;
+ 		}
+ 		/* go to char after '%' */
+ 		i++;
+ 		if (i >= format_len)
+ 			break;				/* format error - ignore it */
+ 
+ 		/* process the option */
+ 		switch (explain_analyze_format[i])
+ 		{
+ 			case 'g':
+ 				appendStringInfo(buf, "%ld", instr->buffer.shared_gets);
+ 				break;
+ 			case 'h':
+ 				appendStringInfo(buf, "%ld", instr->buffer.shared_hits);
+ 				break;
+ 			case 'r':
+ 				appendStringInfo(buf, "%ld", instr->buffer.shared_gets - instr->buffer.shared_hits);
+ 				break;
+ 			case 'w':
+ 				appendStringInfo(buf, "%ld", instr->buffer.shared_writes);
+ 				break;
+ 			case 'G':
+ 				appendStringInfo(buf, "%ld", instr->buffer.local_gets);
+ 				break;
+ 			case 'H':
+ 				appendStringInfo(buf, "%ld", instr->buffer.local_hits);
+ 				break;
+ 			case 'R':
+ 				appendStringInfo(buf, "%ld", instr->buffer.local_gets - instr->buffer.local_hits);
+ 				break;
+ 			case 'W':
+ 				appendStringInfo(buf, "%ld", instr->buffer.local_writes);
+ 				break;
+ 			case 't':
+ 				appendStringInfo(buf, "%ld", instr->buffer.buffile_reads);
+ 				break;
+ 			case 'T':
+ 				appendStringInfo(buf, "%ld", instr->buffer.buffile_writes);
+ 				break;
+ 			case 'p':
+ 				appendStringInfo(buf, "%.2f", 1000.0 * (instr->utime + instr->stime));
+ 				break;
+ 			case 'u':
+ 				appendStringInfo(buf, "%.2f", 1000.0 * instr->utime);
+ 				break;
+ 			case 's':
+ 				appendStringInfo(buf, "%.2f", 1000.0 * instr->stime);
+ 				break;
+ 			case '%':
+ 				appendStringInfoChar(buf, '%');
+ 				break;
+ 			default:
+ 				/* format error - ignore it */
+ 				break;
+ 		}
+ 	}
  }
diff -cprN HEAD/src/backend/executor/instrument.c pg_stat_statements/src/backend/executor/instrument.c
*** HEAD/src/backend/executor/instrument.c	Sat Nov  1 15:22:28 2008
--- pg_stat_statements/src/backend/executor/instrument.c	Fri Dec 12 18:26:03 2008
***************
*** 14,22 ****
--- 14,31 ----
  #include "postgres.h"
  
  #include <unistd.h>
+ #ifdef HAVE_SYS_RESOURCE_H
+ #include <sys/time.h>
+ #include <sys/resource.h>
+ #endif
+ 
+ #ifndef HAVE_GETRUSAGE
+ #include "rusagestub.h"
+ #endif
  
  #include "executor/instrument.h"
  
+ #define timeval_to_sec(t) 	((double) (t).tv_sec + (t).tv_usec / 1000000.0)
  
  /* Allocate new instrumentation structure(s) */
  Instrumentation *
*************** void
*** 34,40 ****
--- 43,59 ----
  InstrStartNode(Instrumentation *instr)
  {
  	if (INSTR_TIME_IS_ZERO(instr->starttime))
+ 	{
+ 		struct rusage	ru;
+ 
  		INSTR_TIME_SET_CURRENT(instr->starttime);
+ 
+ 		BufferCounterSub(&instr->buffer, &BufferStats);
+ 
+ 		getrusage(RUSAGE_SELF, &ru);
+ 		instr->utime -= timeval_to_sec(ru.ru_utime);
+ 		instr->stime -= timeval_to_sec(ru.ru_stime);
+ 	}
  	else
  		elog(DEBUG2, "InstrStartNode called twice in a row");
  }
*************** void
*** 44,49 ****
--- 63,69 ----
  InstrStopNode(Instrumentation *instr, double nTuples)
  {
  	instr_time	endtime;
+ 	struct rusage	ru;
  
  	/* count the returned tuples */
  	instr->tuplecount += nTuples;
*************** InstrStopNode(Instrumentation *instr, do
*** 56,61 ****
--- 76,87 ----
  
  	INSTR_TIME_SET_CURRENT(endtime);
  	INSTR_TIME_ACCUM_DIFF(instr->counter, endtime, instr->starttime);
+ 
+ 	BufferCounterAdd(&instr->buffer, &BufferStats);
+ 
+ 	getrusage(RUSAGE_SELF, &ru);
+ 	instr->utime += timeval_to_sec(ru.ru_utime);
+ 	instr->stime += timeval_to_sec(ru.ru_stime);
  
  	INSTR_TIME_SET_ZERO(instr->starttime);
  
diff -cprN HEAD/src/backend/storage/buffer/buf_init.c pg_stat_statements/src/backend/storage/buffer/buf_init.c
*** HEAD/src/backend/storage/buffer/buf_init.c	Sat Nov  1 15:22:28 2008
--- pg_stat_statements/src/backend/storage/buffer/buf_init.c	Fri Dec 12 18:26:03 2008
*************** char	   *BufferBlocks;
*** 23,37 ****
  int32	   *PrivateRefCount;
  
  /* statistics counters */
! long int	ReadBufferCount;
! long int	ReadLocalBufferCount;
! long int	BufferHitCount;
! long int	LocalBufferHitCount;
! long int	BufferFlushCount;
! long int	LocalBufferFlushCount;
! long int	BufFileReadCount;
! long int	BufFileWriteCount;
  
  
  /*
   * Data Structures:
--- 23,55 ----
  int32	   *PrivateRefCount;
  
  /* statistics counters */
! BufferCounter	BufferStats;
  
+ void
+ BufferCounterAdd(BufferCounter *into, const BufferCounter *arg)
+ {
+ 	into->shared_gets += arg->shared_gets;
+ 	into->shared_hits += arg->shared_hits;
+ 	into->shared_writes += arg->shared_writes;
+ 	into->local_gets += arg->local_gets;
+ 	into->local_hits += arg->local_hits;
+ 	into->local_writes += arg->local_writes;
+ 	into->buffile_reads += arg->buffile_reads;
+ 	into->buffile_writes += arg->buffile_writes;
+ }
+ 
+ void
+ BufferCounterSub(BufferCounter *into, const BufferCounter *arg)
+ {
+ 	into->shared_gets -= arg->shared_gets;
+ 	into->shared_hits -= arg->shared_hits;
+ 	into->shared_writes -= arg->shared_writes;
+ 	into->local_gets -= arg->local_gets;
+ 	into->local_hits -= arg->local_hits;
+ 	into->local_writes -= arg->local_writes;
+ 	into->buffile_reads -= arg->buffile_reads;
+ 	into->buffile_writes -= arg->buffile_writes;
+ }
  
  /*
   * Data Structures:
diff -cprN HEAD/src/backend/storage/buffer/bufmgr.c pg_stat_statements/src/backend/storage/buffer/bufmgr.c
*** HEAD/src/backend/storage/buffer/bufmgr.c	Sat Nov 22 11:15:56 2008
--- pg_stat_statements/src/backend/storage/buffer/bufmgr.c	Fri Dec 12 18:26:03 2008
*************** double		bgwriter_lru_multiplier = 2.0;
*** 69,74 ****
--- 69,77 ----
  static volatile BufferDesc *InProgressBuf = NULL;
  static bool IsForInput;
  
+ /* baseline of buffer counters */
+ static BufferCounter	BufferStats_base;
+ 
  /* local state for LockBufferForCleanup */
  static volatile BufferDesc *PinCountWaitBuf = NULL;
  
*************** ReadBuffer_common(SMgrRelation smgr, boo
*** 208,218 ****
  
  	if (isLocalBuf)
  	{
! 		ReadLocalBufferCount++;
  		bufHdr = LocalBufferAlloc(smgr, forkNum, blockNum, &found);
  		if (found)
  		{
! 			LocalBufferHitCount++;
  			TRACE_POSTGRESQL_BUFFER_HIT(true); /* true == local buffer */
  		}
  		else
--- 211,221 ----
  
  	if (isLocalBuf)
  	{
! 		BufferStats.local_gets++;
  		bufHdr = LocalBufferAlloc(smgr, forkNum, blockNum, &found);
  		if (found)
  		{
! 			BufferStats.local_hits++;
  			TRACE_POSTGRESQL_BUFFER_HIT(true); /* true == local buffer */
  		}
  		else
*************** ReadBuffer_common(SMgrRelation smgr, boo
*** 222,228 ****
  	}
  	else
  	{
! 		ReadBufferCount++;
  
  		/*
  		 * lookup the buffer.  IO_IN_PROGRESS is set if the requested block is
--- 225,231 ----
  	}
  	else
  	{
! 		BufferStats.shared_gets++;
  
  		/*
  		 * lookup the buffer.  IO_IN_PROGRESS is set if the requested block is
*************** ReadBuffer_common(SMgrRelation smgr, boo
*** 231,237 ****
  		bufHdr = BufferAlloc(smgr, forkNum, blockNum, strategy, &found);
  		if (found)
  		{
! 			BufferHitCount++;
  			TRACE_POSTGRESQL_BUFFER_HIT(false); /* false != local buffer */
  		}
  		else
--- 234,240 ----
  		bufHdr = BufferAlloc(smgr, forkNum, blockNum, strategy, &found);
  		if (found)
  		{
! 			BufferStats.shared_hits++;
  			TRACE_POSTGRESQL_BUFFER_HIT(false); /* false != local buffer */
  		}
  		else
*************** ShowBufferUsage(void)
*** 1524,1551 ****
  	StringInfoData str;
  	float		hitrate;
  	float		localhitrate;
  
  	initStringInfo(&str);
  
! 	if (ReadBufferCount == 0)
  		hitrate = 0.0;
  	else
! 		hitrate = (float) BufferHitCount *100.0 / ReadBufferCount;
  
! 	if (ReadLocalBufferCount == 0)
  		localhitrate = 0.0;
  	else
! 		localhitrate = (float) LocalBufferHitCount *100.0 / ReadLocalBufferCount;
  
  	appendStringInfo(&str,
  	"!\tShared blocks: %10ld read, %10ld written, buffer hit rate = %.2f%%\n",
! 				ReadBufferCount - BufferHitCount, BufferFlushCount, hitrate);
  	appendStringInfo(&str,
  	"!\tLocal  blocks: %10ld read, %10ld written, buffer hit rate = %.2f%%\n",
! 					 ReadLocalBufferCount - LocalBufferHitCount, LocalBufferFlushCount, localhitrate);
  	appendStringInfo(&str,
  					 "!\tDirect blocks: %10ld read, %10ld written\n",
! 					 BufFileReadCount, BufFileWriteCount);
  
  	return str.data;
  }
--- 1527,1557 ----
  	StringInfoData str;
  	float		hitrate;
  	float		localhitrate;
+ 	BufferCounter	c = BufferStats;
+ 
+ 	BufferCounterSub(&c, &BufferStats_base);
  
  	initStringInfo(&str);
  
! 	if (c.shared_gets == 0)
  		hitrate = 0.0;
  	else
! 		hitrate = c.shared_hits * 100.0f / c.shared_gets;
  
! 	if (c.local_gets == 0)
  		localhitrate = 0.0;
  	else
! 		localhitrate = c.local_hits * 100.0f / c.local_gets;
  
  	appendStringInfo(&str,
  	"!\tShared blocks: %10ld read, %10ld written, buffer hit rate = %.2f%%\n",
! 				c.shared_gets - c.shared_hits, c.shared_writes, hitrate);
  	appendStringInfo(&str,
  	"!\tLocal  blocks: %10ld read, %10ld written, buffer hit rate = %.2f%%\n",
! 				c.local_gets - c.local_hits, c.local_writes, localhitrate);
  	appendStringInfo(&str,
  					 "!\tDirect blocks: %10ld read, %10ld written\n",
! 					 c.buffile_reads, c.buffile_writes);
  
  	return str.data;
  }
*************** ShowBufferUsage(void)
*** 1553,1566 ****
  void
  ResetBufferUsage(void)
  {
! 	BufferHitCount = 0;
! 	ReadBufferCount = 0;
! 	BufferFlushCount = 0;
! 	LocalBufferHitCount = 0;
! 	ReadLocalBufferCount = 0;
! 	LocalBufferFlushCount = 0;
! 	BufFileReadCount = 0;
! 	BufFileWriteCount = 0;
  }
  
  /*
--- 1559,1565 ----
  void
  ResetBufferUsage(void)
  {
! 	BufferStats_base = BufferStats;
  }
  
  /*
*************** FlushBuffer(volatile BufferDesc *buf, SM
*** 1818,1824 ****
  			  (char *) BufHdrGetBlock(buf),
  			  false);
  
! 	BufferFlushCount++;
  
  	TRACE_POSTGRESQL_BUFFER_FLUSH_DONE(reln->smgr_rnode.spcNode,
  		 reln->smgr_rnode.dbNode, reln->smgr_rnode.relNode);
--- 1817,1823 ----
  			  (char *) BufHdrGetBlock(buf),
  			  false);
  
! 	BufferStats.shared_writes++;
  
  	TRACE_POSTGRESQL_BUFFER_FLUSH_DONE(reln->smgr_rnode.spcNode,
  		 reln->smgr_rnode.dbNode, reln->smgr_rnode.relNode);
diff -cprN HEAD/src/backend/storage/buffer/localbuf.c pg_stat_statements/src/backend/storage/buffer/localbuf.c
*** HEAD/src/backend/storage/buffer/localbuf.c	Fri Dec  5 00:11:18 2008
--- pg_stat_statements/src/backend/storage/buffer/localbuf.c	Fri Dec 12 18:26:03 2008
*************** LocalBufferAlloc(SMgrRelation smgr, Fork
*** 172,178 ****
  		/* Mark not-dirty now in case we error out below */
  		bufHdr->flags &= ~BM_DIRTY;
  
! 		LocalBufferFlushCount++;
  	}
  
  	/*
--- 172,178 ----
  		/* Mark not-dirty now in case we error out below */
  		bufHdr->flags &= ~BM_DIRTY;
  
! 		BufferStats.local_writes++;
  	}
  
  	/*
diff -cprN HEAD/src/backend/storage/file/buffile.c pg_stat_statements/src/backend/storage/file/buffile.c
*** HEAD/src/backend/storage/file/buffile.c	Sat Nov  1 15:22:28 2008
--- pg_stat_statements/src/backend/storage/file/buffile.c	Fri Dec 12 18:26:03 2008
*************** BufFileLoadBuffer(BufFile *file)
*** 240,246 ****
  	file->offsets[file->curFile] += file->nbytes;
  	/* we choose not to advance curOffset here */
  
! 	BufFileReadCount++;
  }
  
  /*
--- 240,246 ----
  	file->offsets[file->curFile] += file->nbytes;
  	/* we choose not to advance curOffset here */
  
! 	BufferStats.buffile_reads++;
  }
  
  /*
*************** BufFileDumpBuffer(BufFile *file)
*** 304,310 ****
  		file->curOffset += bytestowrite;
  		wpos += bytestowrite;
  
! 		BufFileWriteCount++;
  	}
  	file->dirty = false;
  
--- 304,310 ----
  		file->curOffset += bytestowrite;
  		wpos += bytestowrite;
  
! 		BufferStats.buffile_writes++;
  	}
  	file->dirty = false;
  
diff -cprN HEAD/src/backend/utils/misc/guc.c pg_stat_statements/src/backend/utils/misc/guc.c
*** HEAD/src/backend/utils/misc/guc.c	Fri Dec  5 00:11:18 2008
--- pg_stat_statements/src/backend/utils/misc/guc.c	Fri Dec 12 18:26:03 2008
*************** extern char *default_tablespace;
*** 113,118 ****
--- 113,119 ----
  extern char *temp_tablespaces;
  extern bool synchronize_seqscans;
  extern bool fullPageWrites;
+ extern char *explain_analyze_format;
  
  #ifdef TRACE_SORT
  extern bool trace_sort;
*************** static struct config_string ConfigureNam
*** 2493,2498 ****
--- 2494,2508 ----
  	},
  #endif   /* USE_SSL */
  
+ 	{
+ 		{"explain_analyze_format", PGC_USERSET, CLIENT_CONN_STATEMENT,
+ 			gettext_noop("Controls information returned in explain analyze."),
+ 			gettext_noop("If blank, basic statistics are returned.")
+ 		},
+ 		&explain_analyze_format,
+ 		"", NULL, NULL
+ 	},
+ 
  	/* End-of-list marker */
  	{
  		{NULL, 0, 0, NULL, NULL}, NULL, NULL, NULL, NULL
*************** define_custom_variable(struct config_gen
*** 5707,5713 ****
  		case PGC_S_ENV_VAR:
  		case PGC_S_FILE:
  		case PGC_S_ARGV:
! 			phcontext = PGC_SIGHUP;
  			break;
  		case PGC_S_DATABASE:
  		case PGC_S_USER:
--- 5717,5726 ----
  		case PGC_S_ENV_VAR:
  		case PGC_S_FILE:
  		case PGC_S_ARGV:
! 			if (variable->context == PGC_POSTMASTER)
! 				phcontext = PGC_POSTMASTER;
! 			else
! 				phcontext = PGC_SIGHUP;
  			break;
  		case PGC_S_DATABASE:
  		case PGC_S_USER:
diff -cprN HEAD/src/backend/utils/misc/postgresql.conf.sample pg_stat_statements/src/backend/utils/misc/postgresql.conf.sample
*** HEAD/src/backend/utils/misc/postgresql.conf.sample	Fri Nov 14 21:39:34 2008
--- pg_stat_statements/src/backend/utils/misc/postgresql.conf.sample	Fri Dec 12 18:26:03 2008
***************
*** 443,448 ****
--- 443,450 ----
  # default configuration for text search
  #default_text_search_config = 'pg_catalog.simple'
  
+ #explain_analyze_format = ''	# special values %[ghrwGHRWtTpus%]
+ 
  # - Other Defaults -
  
  #dynamic_library_path = '$libdir'
diff -cprN HEAD/src/include/executor/instrument.h pg_stat_statements/src/include/executor/instrument.h
*** HEAD/src/include/executor/instrument.h	Sat Nov  1 15:22:28 2008
--- pg_stat_statements/src/include/executor/instrument.h	Fri Dec 12 18:26:03 2008
***************
*** 14,19 ****
--- 14,20 ----
  #define INSTRUMENT_H
  
  #include "portability/instr_time.h"
+ #include "storage/buf_internals.h"
  
  
  typedef struct Instrumentation
*************** typedef struct Instrumentation
*** 29,34 ****
--- 30,39 ----
  	double		total;			/* Total total time (in seconds) */
  	double		ntuples;		/* Total tuples produced */
  	double		nloops;			/* # of run cycles for this node */
+ 
+ 	BufferCounter	buffer;		/* buffer stats */
+ 	double		utime;			/* user time in sec */
+ 	double		stime;			/* sys time in sec */
  } Instrumentation;
  
  extern Instrumentation *InstrAlloc(int n);
diff -cprN HEAD/src/include/pgstat.h pg_stat_statements/src/include/pgstat.h
*** HEAD/src/include/pgstat.h	Fri Nov 14 21:39:34 2008
--- pg_stat_statements/src/include/pgstat.h	Fri Dec 12 18:26:03 2008
*************** typedef struct PgStat_FunctionCallUsage
*** 591,597 ****
  extern bool pgstat_track_activities;
  extern bool pgstat_track_counts;
  extern int	pgstat_track_functions;
! extern int	pgstat_track_activity_query_size;
  extern char *pgstat_stat_tmpname;
  extern char *pgstat_stat_filename;
  
--- 591,597 ----
  extern bool pgstat_track_activities;
  extern bool pgstat_track_counts;
  extern int	pgstat_track_functions;
! extern PGDLLIMPORT int	pgstat_track_activity_query_size;
  extern char *pgstat_stat_tmpname;
  extern char *pgstat_stat_filename;
  
diff -cprN HEAD/src/include/storage/buf_internals.h pg_stat_statements/src/include/storage/buf_internals.h
*** HEAD/src/include/storage/buf_internals.h	Sat Nov  1 15:22:28 2008
--- pg_stat_statements/src/include/storage/buf_internals.h	Fri Dec 12 18:26:03 2008
*************** extern PGDLLIMPORT BufferDesc *BufferDes
*** 174,188 ****
  extern BufferDesc *LocalBufferDescriptors;
  
  /* event counters in buf_init.c */
! extern long int ReadBufferCount;
! extern long int ReadLocalBufferCount;
! extern long int BufferHitCount;
! extern long int LocalBufferHitCount;
! extern long int BufferFlushCount;
! extern long int LocalBufferFlushCount;
! extern long int BufFileReadCount;
! extern long int BufFileWriteCount;
  
  
  /*
   * Internal routines: only called by bufmgr
--- 174,195 ----
  extern BufferDesc *LocalBufferDescriptors;
  
  /* event counters in buf_init.c */
! typedef struct BufferCounter
! {
! 	long	shared_gets;
! 	long	shared_hits;
! 	long	shared_writes;
! 	long	local_gets;
! 	long	local_hits;
! 	long	local_writes;
! 	long	buffile_reads;
! 	long	buffile_writes;
! } BufferCounter;
  
+ extern PGDLLIMPORT BufferCounter	BufferStats;
+ 
+ extern void	BufferCounterAdd(BufferCounter *into, const BufferCounter *arg);
+ extern void	BufferCounterSub(BufferCounter *into, const BufferCounter *arg);
  
  /*
   * Internal routines: only called by bufmgr

diff -cprN HEAD/contrib/Makefile pg_stat_statements/contrib/Makefile
*** HEAD/contrib/Makefile	Sat Nov 22 11:15:56 2008
--- pg_stat_statements/contrib/Makefile	Fri Dec 12 18:26:03 2008
*************** WANTED_DIRS = \
*** 31,36 ****
--- 31,37 ----
  		pgbench		\
  		pgcrypto	\
  		pgrowlocks	\
+ 		pg_stat_statements	\
  		pgstattuple	\
  		seg		\
  		spi		\
diff -cprN HEAD/contrib/pg_stat_statements/Makefile pg_stat_statements/contrib/pg_stat_statements/Makefile
*** HEAD/contrib/pg_stat_statements/Makefile	Thu Jan  1 09:00:00 1970
--- pg_stat_statements/contrib/pg_stat_statements/Makefile	Mon Jun 23 11:05:19 2008
***************
*** 0 ****
--- 1,15 ----
+ MODULE_big = pg_stat_statements
+ DATA_built = pg_stat_statements.sql
+ DATA = uninstall_pg_stat_statements.sql
+ OBJS = pg_stat_statements.o
+ 
+ ifdef USE_PGXS
+ PG_CONFIG = pg_config
+ PGXS := $(shell $(PG_CONFIG) --pgxs)
+ include $(PGXS)
+ else
+ subdir = contrib/pg_stat_statements
+ top_builddir = ../..
+ include $(top_builddir)/src/Makefile.global
+ include $(top_srcdir)/contrib/contrib-global.mk
+ endif
diff -cprN HEAD/contrib/pg_stat_statements/pg_stat_statements.c pg_stat_statements/contrib/pg_stat_statements/pg_stat_statements.c
*** HEAD/contrib/pg_stat_statements/pg_stat_statements.c	Thu Jan  1 09:00:00 1970
--- pg_stat_statements/contrib/pg_stat_statements/pg_stat_statements.c	Fri Dec 12 10:52:02 2008
***************
*** 0 ****
--- 1,810 ----
+ /*-------------------------------------------------------------------------
+  *
+  * pg_stat_statements.c
+  *
+  *-------------------------------------------------------------------------
+  */
+ #include "postgres.h"
+ 
+ #include <unistd.h>
+ 
+ #ifdef HAVE_SYS_RESOURCE_H
+ #include <sys/time.h>
+ #include <sys/resource.h>
+ #endif
+ #ifndef HAVE_GETRUSAGE
+ #include "rusagestub.h"
+ #endif
+ 
+ #include "access/hash.h"
+ #include "executor/instrument.h"
+ #include "funcapi.h"
+ #include "mb/pg_wchar.h"
+ #include "miscadmin.h"
+ #include "pgstat.h"
+ #include "storage/ipc.h"
+ #include "storage/spin.h"
+ #include "utils/builtins.h"
+ #include "utils/guc.h"
+ 
+ PG_MODULE_MAGIC;
+ 
+ #define GUCNAME(name)		("statistics." name)
+ 
+ #define MAX_STATEMENTS_DEFAULT	1000
+ #define CHUNK_SIZE				MAXALIGN(pgstat_track_activity_query_size)
+ 
+ const uint32 PGSS_FILE_HEADER = 0x20081202;
+ 
+ /* XXX: Should USAGE_EXEC reflect execution time and/or buffer usage? */
+ #define USAGE_EXEC(duration)	(1.0)
+ #define USAGE_INIT				(1.0)	/* including initial planning */
+ #define USAGE_DECREASE_FACTOR	(0.99)	/* decreased every entry_dealloc */
+ #define USAGE_DEALLOC_PERCENT	5		/* free this % of entries at once */
+ 
+ #define timeval_diff_in_usec(end, beg) \
+ 	( (int64) ((end).tv_sec - (beg).tv_sec) * 1000000 \
+ 	+ ((end).tv_usec - (beg).tv_usec))
+ 
+ #define track_statements_enabled() \
+ 	(track_statements == PGSS_TRACK_ALL || \
+ 	(track_statements == PGSS_TRACK_TOP && nested_level == 0))
+ 
+ /*
+  * Chunk buffer for query text.
+  */
+ typedef union Chunk Chunk;
+ union Chunk
+ {
+ 	char	query[1];	/* query text. true size is [CHUNK_SIZE] */
+ 	Chunk  *next;		/* next free chunk */
+ };
+ 
+ typedef struct Counters
+ {
+ 	int64		calls;		/* # of executed */
+ 	double		total_time;	/* total execution time in sec */
+ 	double		cpu_user;	/* user cpu time in sec */
+ 	double		cpu_sys;	/* sys cpu time in sec */
+ 	int64		gets;		/* # of buffer gets during execution */
+ 	int64		reads;		/* # of buffer reads during execution */
+ 	int64		lreads;		/* # of buffile reads during execution */
+ 	int64		rows;		/* # of retrieved or affected rows */
+ } Counters;
+ 
+ /*
+  * Statistics per statement
+  */
+ typedef struct Entry
+ {
+ 	uint32		tag;		/* hash value of query */
+ 	Oid			userid;		/* user oid */
+ 	Oid			dbid;		/* database oid */
+ 	Counters	counters;	/* counters */
+ 	double		usage;		/* usage factor */
+ 	Chunk	   *chunk;		/* query text */
+ 	slock_t		mutex;		/* protect above fields */
+ } Entry;
+ 
+ /*
+  * Global shared state
+  */
+ typedef struct pgStatStmt
+ {
+ 	LWLockId	lock;				/* protect fields and hash */
+ 	int			num_statements;		/* # of entries in hash */
+ 	int			chunk_size;			/* max query length in bytes */
+ 	Chunk	   *free_chunks;		/* single linked list of free chunks */
+ 	Chunk		chunks[1];			/* chunk buffers */
+ } pgStatStmt;
+ 
+ /*---- Local variables ----*/
+ 
+ static int						nested_level = 0;
+ static startup_hook_type		prev_startup_hook = NULL;
+ static shutdown_hook_type		prev_shutdown_hook = NULL;
+ static ExecutorStart_hook_type	prev_ExecutorStart = NULL;
+ static ExecutorRun_hook_type	prev_ExecutorRun = NULL;
+ static ExecutorEnd_hook_type	prev_ExecutorEnd = NULL;
+ static pgStatStmt			   *pgss;
+ static HTAB					   *pgss_hash;
+ static bool						reset_requested = false;
+ 
+ /*---- Function declarations ----*/
+ 
+ void	_PG_init(void);
+ void	_PG_fini(void);
+ Datum	pg_stat_statements_reset(PG_FUNCTION_ARGS);
+ Datum	pg_stat_statements(PG_FUNCTION_ARGS);
+ 
+ PG_FUNCTION_INFO_V1(pg_stat_statements_reset);
+ PG_FUNCTION_INFO_V1(pg_stat_statements);
+ 
+ static uint32 pgss_tag(Oid userid, Oid dbid, const char *query);
+ static void pgss_ExecutorStart(QueryDesc *queryDesc, int eflags);
+ static void pgss_ExecutorRun(QueryDesc *queryDesc,
+ 							 ScanDirection direction,
+ 							 long count);
+ static void pgss_ExecutorEnd(QueryDesc *queryDesc);
+ static void pgss_executed(const char *query,
+ 						  const Instrumentation *instr, uint32 rows);
+ 
+ static Size	pgss_memsize(void);
+ static void pgss_init(void);
+ static volatile Entry *entry_alloc(uint32 tag, Oid userid, Oid dbid,
+ 							const char *query);
+ static void entry_dealloc(void);
+ static void entry_reset(void);
+ static Chunk *chunk_alloc(void);
+ static void chunk_free(Chunk *chunk);
+ static void chunk_reset(void);
+ 
+ static const char *assign_saved_file(const char *newval, bool doit, GucSource source);
+ 
+ /*---- GUC variables ----*/
+ 
+ typedef enum
+ {
+ 	PGSS_TRACK_NONE,	/* log no statements */
+ 	PGSS_TRACK_TOP,		/* only top level statements */
+ 	PGSS_TRACK_ALL,		/* all statements, including nested ones */
+ } PGSSTrackLevel;
+ 
+ static const struct config_enum_entry track_options[] = {
+ 	{"none", PGSS_TRACK_NONE, false},
+ 	{"top", PGSS_TRACK_TOP, false},
+ 	{"all", PGSS_TRACK_ALL, false},
+ 	{NULL, 0, false}
+ };
+ 
+ static int		max_statements;
+ static int		track_statements;
+ static char	   *saved_file;
+ 
+ /*
+  * pgss_shutdown - Dump statistics into file.
+  */
+ static void
+ pgss_shutdown(void)
+ {
+ 	FILE			   *file;
+ 	HASH_SEQ_STATUS		hash_seq;
+ 	Entry			   *entry;
+ 	int					save_errno;
+ 
+ 	if (prev_shutdown_hook)
+ 		prev_shutdown_hook();
+ 
+ 	if (saved_file == NULL || saved_file[0] == '\0')
+ 		return;
+ 
+ 	if (!pgss)
+ 		pgss_init();
+ 
+ 	file = fopen(saved_file, PG_BINARY_W);
+ 	if (file == NULL ||
+ 		fwrite(&PGSS_FILE_HEADER, sizeof(uint32), 1, file) != 1 ||
+ 		fwrite(&pgss->num_statements, sizeof(int32), 1, file) != 1)
+ 		goto error;
+ 
+ 	hash_seq_init(&hash_seq, pgss_hash);
+ 	while ((entry = hash_seq_search(&hash_seq)) != NULL)
+ 	{
+ 		int32	len = (int32) strlen(entry->chunk->query);
+ 
+ 		if (fwrite(entry, offsetof(Entry, chunk), 1, file) != 1 ||
+ 			fwrite(&len, sizeof(int32), 1, file) != 1 ||
+ 			fwrite(entry->chunk->query, 1, len, file) != len)
+ 			goto error;
+ 	}
+ 
+ 	fclose(file);
+ 	return;
+ 
+ error:
+ 	save_errno = errno;
+ 
+ 	if (file)
+ 		fclose(file);
+ 	unlink(saved_file);
+ 
+ 	errno = save_errno;
+ 	ereport(LOG,
+ 		(errcode_for_file_access(),
+ 		 errmsg("could not write pg_stat_statement file \"%s\": %m",
+ 				saved_file)));
+ }
+ 
+ /*
+  * pgss_startup - Load statistics from file.
+  */
+ static void
+ pgss_startup(void)
+ {
+ 	FILE	   *file;
+ 	uint32		header;
+ 	int32		num;
+ 	int32		i;
+ 	char	   *buffer = NULL;
+ 	int			save_errno;
+ 
+ 	if (prev_startup_hook)
+ 		prev_startup_hook();
+ 
+ 	if (saved_file == NULL || saved_file[0] == '\0')
+ 		return;
+ 
+ 	file = fopen(saved_file, PG_BINARY_R);
+ 	if (file == NULL)
+ 	{
+ 		if (errno == ENOENT)
+ 			return;	/* ignore not found error */
+ 		goto error;
+ 	}
+ 
+ 	if (!pgss)
+ 		pgss_init();
+ 
+ 	buffer = palloc(CHUNK_SIZE);
+ 
+ 	if (fread(&header, sizeof(uint32), 1, file) != 1 ||
+ 		header != PGSS_FILE_HEADER ||
+ 		fread(&num, sizeof(int32), 1, file) != 1)
+ 		goto error;
+ 
+ 	for (i = 0; i < num; i++)
+ 	{
+ 		Entry		temp;
+ 		Entry	   *entry;
+ 		int32		templen;
+ 		int32		len;
+ 
+ 		if (fread(&temp, offsetof(Entry, chunk), 1, file) != 1 ||
+ 			fread(&templen, sizeof(int32), 1, file) != 1)
+ 			goto error;
+ 
+ 		/*
+ 		 * We might not have enough buffer to read query text
+ 		 * when pgstat_track_activity_query_size is set smaller.
+ 		 */
+ 		if (templen < CHUNK_SIZE)
+ 			len = templen;
+ 		else
+ 			len = CHUNK_SIZE - 1;
+ 
+ 		if (fread(buffer, 1, len, file) != len)
+ 			goto error;
+ 		buffer[len] = '\0';
+ 		entry = (Entry *) entry_alloc(
+ 			temp.tag, temp.userid, temp.dbid, buffer);
+ 		memcpy(entry, &temp, offsetof(Entry, chunk));
+ 
+ 		/* Discard the tail of query text. */
+ 		if (templen > len)
+ 			fseek(file, templen - len, SEEK_CUR);
+ 	}
+ 
+ 	pfree(buffer);
+ 	fclose(file);
+ 	return;
+ 
+ error:
+ 	save_errno = errno;
+ 
+ 	if (file)
+ 		fclose(file);
+ 	unlink(saved_file);
+ 	if (buffer)
+ 		pfree(buffer);
+ 
+ 	errno = save_errno;
+ 	ereport(LOG,
+ 		(errcode_for_file_access(),
+ 		 errmsg("could not read pg_stat_statement file \"%s\": %m",
+ 				saved_file)));
+ }
+ 
+ void
+ _PG_init(void)
+ {
+ 	/* Define custom guc variables. */
+ 	DefineCustomIntVariable(
+ 		GUCNAME("max_statements"),
+ 		"Sets the maximum number of statements tracked by pg_stat_statements.",
+ 		NULL,
+ 		&max_statements,
+ 		MAX_STATEMENTS_DEFAULT,
+ 		100,
+ 		INT_MAX,
+ 		PGC_POSTMASTER,
+ 		0,
+ 		NULL,
+ 		NULL);
+ 
+ 	DefineCustomEnumVariable(
+ 		GUCNAME("track_statements"),
+ 		"Collects information about executed statements.",
+ 		NULL,
+ 		&track_statements,
+ 		PGSS_TRACK_NONE,
+ 		track_options,
+ 		PGC_SUSET,
+ 		0,
+ 		NULL,
+ 		NULL);
+ 
+ 	DefineCustomStringVariable(
+ 		GUCNAME("saved_file"),
+ 		"Writes statistic files to the specified path on shutdown.",
+ 		NULL,
+ 		&saved_file,
+ 		"global/pg_stat_statements.dump",
+ 		PGC_USERSET,
+ 		GUC_SUPERUSER_ONLY,
+ 		assign_saved_file,
+ 		NULL);
+ 
+ 	/* Request additonal shared resources. */
+ 	RequestAddinShmemSpace(pgss_memsize());
+ 	RequestAddinLWLocks(1);
+ 
+ 	/* Install hooks. */
+ 	prev_startup_hook = startup_hook;
+ 	startup_hook = pgss_startup;
+ 	prev_shutdown_hook = shutdown_hook;
+ 	shutdown_hook = pgss_shutdown;
+ 	prev_ExecutorStart = ExecutorStart_hook;
+ 	ExecutorStart_hook = pgss_ExecutorStart;
+ 	prev_ExecutorRun = ExecutorRun_hook;
+ 	ExecutorRun_hook = pgss_ExecutorRun;
+ 	prev_ExecutorEnd = ExecutorEnd_hook;
+ 	ExecutorEnd_hook = pgss_ExecutorEnd;
+ }
+ 
+ void
+ _PG_fini(void)
+ {
+ 	/* Uninstall hooks. */
+ 	ExecutorStart_hook = prev_ExecutorStart;
+ 	ExecutorRun_hook = prev_ExecutorRun;
+ 	ExecutorEnd_hook = prev_ExecutorEnd;
+ 	shutdown_hook = prev_shutdown_hook;
+ 	startup_hook = prev_startup_hook;
+ }
+ 
+ static uint32
+ pgss_tag(Oid userid, Oid dbid, const char *query)
+ {
+ 	return oid_hash(&userid, sizeof(Oid)) ^
+ 		   oid_hash(&dbid, sizeof(Oid)) ^
+ 		   DatumGetUInt32(hash_any((const unsigned char *) query,
+ 								   (int) strlen(query)));
+ }
+ 
+ static void
+ pgss_executed(const char *query, const Instrumentation *instr, uint32 rows)
+ {
+ 	volatile Entry *entry;
+ 	Oid				userid;
+ 	Oid				dbid;
+ 	uint32			tag;
+ 	long			gets;
+ 	long			reads;
+ 	double			usage;
+ 
+ 	Assert(query != NULL);
+ 
+ 	if (!track_statements)
+ 		return;
+ 	if (!pgss)
+ 		pgss_init();
+ 
+ 	userid = GetUserId();
+ 	dbid = MyDatabaseId;
+ 	tag = pgss_tag(userid, dbid, query);
+ 	gets = instr->buffer.shared_gets + instr->buffer.local_gets;
+ 	reads = gets - instr->buffer.shared_hits - instr->buffer.local_hits;
+ 	usage = USAGE_EXEC(duration);
+ 
+ 	LWLockAcquire(pgss->lock, LW_SHARED);
+ 
+ 	entry = hash_search(pgss_hash, &tag, HASH_FIND, NULL);
+ 	if (!entry)
+ 	{
+ 		/* Re-acquire exclusive lock to add a new entry. */
+ 		LWLockRelease(pgss->lock);
+ 		LWLockAcquire(pgss->lock, LW_EXCLUSIVE);
+ 		entry = entry_alloc(tag, userid, dbid, query);
+ 	}
+ 
+ 	SpinLockAcquire(&entry->mutex);
+ 	entry->counters.calls += 1;
+ 	entry->counters.total_time += instr->total;
+ 	entry->counters.cpu_user += instr->utime;
+ 	entry->counters.cpu_sys += instr->stime;
+ 	entry->counters.gets += gets;
+ 	entry->counters.reads += reads;
+ 	entry->counters.lreads += instr->buffer.buffile_reads;
+ 	entry->counters.rows += rows;
+ 	entry->usage += usage;
+ 	SpinLockRelease(&entry->mutex);
+ 
+ 	LWLockRelease(pgss->lock);
+ }
+ 
+ void
+ pgss_ExecutorStart(QueryDesc *queryDesc, int eflags)
+ {
+ 	if (track_statements_enabled() && queryDesc->totaltime == NULL)
+ 		queryDesc->totaltime = InstrAlloc(1);
+ 
+ 	if (prev_ExecutorStart)
+ 		prev_ExecutorStart(queryDesc, eflags);
+ 	else
+ 		standard_ExecutorStart(queryDesc, eflags);
+ }
+ 
+ void
+ pgss_ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, long count)
+ {
+ 	nested_level++;
+ 	PG_TRY();
+ 	{
+ 		if (prev_ExecutorRun)
+ 			prev_ExecutorRun(queryDesc, direction, count);
+ 		else
+ 			standard_ExecutorRun(queryDesc, direction, count);
+ 		nested_level--;
+ 	}
+ 	PG_CATCH();
+ 	{
+ 		nested_level--;
+ 		PG_RE_THROW();
+ 	}
+ 	PG_END_TRY();
+ }
+ 
+ 
+ void
+ pgss_ExecutorEnd(QueryDesc *queryDesc)
+ {
+ 	if (queryDesc->totaltime && track_statements_enabled())
+ 	{
+ 		/*
+ 		 * Make sure stats accumulation is done.  (Note: it's okay if
+ 		 * several levels of hook all do this.)
+ 		 */
+ 		InstrEndLoop(queryDesc->totaltime);
+ 
+ 		pgss_executed(queryDesc->sourceText,
+ 			queryDesc->totaltime,
+ 			queryDesc->estate->es_processed);
+ 	}
+ 
+ 	if (prev_ExecutorEnd)
+ 		prev_ExecutorEnd(queryDesc);
+ 	else
+ 		standard_ExecutorEnd(queryDesc);
+ 
+ 	/* Reset statistics if requested. */
+ 	if (reset_requested && nested_level == 0)
+ 	{
+ 		entry_reset();
+ 		reset_requested = false;
+ 	}
+ }
+ 
+ Datum
+ pg_stat_statements_reset(PG_FUNCTION_ARGS)
+ {
+ 	if (!pgss)
+ 		pgss_init();
+ 	reset_requested = true;
+ 	PG_RETURN_BOOL(true);
+ }
+ 
+ #define pg_stat_statements_cols		11
+ 
+ Datum
+ pg_stat_statements(PG_FUNCTION_ARGS)
+ {
+ 	ReturnSetInfo	   *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
+ 	TupleDesc			tupdesc;
+ 	Tuplestorestate    *tupstore;
+ 	MemoryContext		per_query_ctx;
+ 	MemoryContext		oldcontext;
+ 	Oid					userid = GetUserId();
+ 	bool				is_superuser = superuser();
+ 	HASH_SEQ_STATUS		hash_seq;
+ 	Entry			   *entry;
+ 
+ 	if (!pgss)
+ 		pgss_init();
+ 
+ 	/* check to see if caller supports us returning a tuplestore */
+ 	if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ 				 errmsg("set-valued function called in context that cannot accept a set")));
+ 	if (!(rsinfo->allowedModes & SFRM_Materialize))
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ 				 errmsg("materialize mode required, but it is not " \
+ 						"allowed in this context")));
+ 
+ 	per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
+ 	oldcontext = MemoryContextSwitchTo(per_query_ctx);
+ 
+ 	tupdesc = CreateTupleDescCopy(rsinfo->expectedDesc);
+ 	tupstore = tuplestore_begin_heap(true, false, work_mem);
+ 	rsinfo->returnMode = SFRM_Materialize;
+ 	rsinfo->setResult = tupstore;
+ 	rsinfo->setDesc = tupdesc;
+ 
+ 	LWLockAcquire(pgss->lock, LW_SHARED);
+ 
+ 	hash_seq_init(&hash_seq, pgss_hash);
+ 	while ((entry = hash_seq_search(&hash_seq)) != NULL)
+ 	{
+ 		Datum	values[pg_stat_statements_cols];
+ 		bool	nulls[pg_stat_statements_cols] = { 0 };
+ 		int		i = 0;
+ 
+ 		/* generate junk in short-term context */
+ 		MemoryContextSwitchTo(oldcontext);
+ 
+ 		values[i++] = ObjectIdGetDatum(entry->userid);
+ 		values[i++] = ObjectIdGetDatum(entry->dbid);
+ 
+ 		if (is_superuser || entry->userid == userid)
+ 			values[i++] = CStringGetTextDatum(entry->chunk->query);
+ 		else
+ 			values[i++] = CStringGetTextDatum("<insufficient privilege>");
+ 
+ 		SpinLockAcquire(&entry->mutex);
+ 		values[i++] = Int64GetDatumFast(entry->counters.calls);
+ 		values[i++] = Float8GetDatumFast(entry->counters.total_time);
+ 		values[i++] = Float8GetDatumFast(entry->counters.cpu_user);
+ 		values[i++] = Float8GetDatumFast(entry->counters.cpu_sys);
+ 		values[i++] = Int64GetDatumFast(entry->counters.gets);
+ 		values[i++] = Int64GetDatumFast(entry->counters.reads);
+ 		values[i++] = Int64GetDatumFast(entry->counters.lreads);
+ 		values[i++] = Int64GetDatumFast(entry->counters.rows);
+ 		SpinLockRelease(&entry->mutex);
+ 		Assert(i == pg_stat_statements_cols);
+ 
+ 		/* switch to appropriate context while storing the tuple */
+ 		MemoryContextSwitchTo(per_query_ctx);
+ 		tuplestore_putvalues(tupstore, tupdesc, values, nulls);
+ 	}
+ 
+ 	LWLockRelease(pgss->lock);
+ 
+ 	/* clean up and return the tuplestore */
+ 	tuplestore_donestoring(tupstore);
+ 
+ 	MemoryContextSwitchTo(oldcontext);
+ 
+ 	return (Datum) 0;
+ }
+ 
+ static Size
+ pgss_memsize(void)
+ {
+ 	Size	size;
+ 
+ 	size = offsetof(pgStatStmt, chunks);
+ 	size = add_size(size, mul_size(max_statements, CHUNK_SIZE));
+ 	size = add_size(size, hash_estimate_size(max_statements, sizeof(Entry)));
+ 
+ 	return size;
+ }
+ 
+ static void
+ pgss_init(void)
+ {
+     bool		found;
+ 	Size		size;
+ 	HASHCTL		info = { 0 };
+ 
+ 	Assert(pgss == NULL);
+ 
+ 	size = pgss_memsize();
+ 
+ 	LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE);
+ 
+ 	pgss = ShmemInitStruct("pg_stat_statements", size, &found);
+ 	if (!pgss)
+ 		elog(ERROR, "out of shared memory");
+ 
+ 	if (!found)
+     {
+ 		pgss->lock = LWLockAssign();
+ 		pgss->num_statements = 0;
+ 		pgss->chunk_size = CHUNK_SIZE;
+ 		chunk_reset();
+ 	}
+ 
+ 	info.keysize = sizeof(uint32);
+ 	info.entrysize = sizeof(Entry);
+ 	info.hash = oid_hash;
+ 	pgss_hash = ShmemInitHash("pg_stat_statements hash",
+ 							  max_statements, max_statements,
+ 							  &info,
+ 							  HASH_ELEM | HASH_FUNCTION);
+ 	if (!pgss_hash)
+ 		elog(ERROR, "out of shared memory");
+ 
+ 	LWLockRelease(AddinShmemInitLock);
+ }
+ 
+ /*
+  * caller must be hold an exclusive lock on pgStateStmt->lock
+  */
+ static volatile Entry *
+ entry_alloc(uint32 tag, Oid userid, Oid dbid, const char *query)
+ {
+ 	bool	found;
+ 	Entry  *entry;
+ 
+ 	Assert(query != NULL);
+ 
+ 	while (pgss->num_statements >= max_statements)
+ 		entry_dealloc();
+ 
+ 	entry = hash_search(pgss_hash, &tag, HASH_ENTER, &found);
+ 
+ 	if (!found)
+ 	{
+ 		Size	len;
+ 
+ 		pgss->num_statements++;
+ 
+ 		entry->userid = userid;
+ 		entry->dbid = dbid;
+ 		memset(&entry->counters, 0, sizeof(Counters));
+ 		entry->usage = USAGE_INIT;
+ 
+ 		entry->chunk = chunk_alloc();
+ 		len = strlen(query);
+ 		len = pg_mbcliplen(query, len, pgss->chunk_size - 1);
+ 		memcpy(entry->chunk->query, query, len);
+ 		entry->chunk->query[len] = '\0';
+ 
+ 		SpinLockInit(&entry->mutex);
+ 	}
+ 
+ 	return entry;
+ }
+ 
+ /*
+  * Free least recently used entries.
+  * Caller must be hold an exclusive lock on pgStateStmt->lock.
+  */
+ static int
+ entry_cmp(const void *lhs, const void *rhs)
+ {
+ 	double	l_usage = (*(const Entry **)lhs)->usage;
+ 	double	r_usage = (*(const Entry **)rhs)->usage;
+ 
+ 	if (l_usage < r_usage)
+ 		return -1;
+ 	else if (l_usage > r_usage)
+ 		return +1;
+ 	else
+ 		return 0;
+ }
+ 
+ /*
+  * Deallocate least used entries.
+  */
+ static void
+ entry_dealloc(void)
+ {
+ 	HASH_SEQ_STATUS		hash_seq;
+ 	Entry			  **entries;
+ 	Entry			   *entry;
+ 	int					nvictims;
+ 	int					i;
+ 
+ 	/* Sort entries by usage and deallocate USAGE_DEALLOC_PERCENT of them. */
+ 
+ 	entries = palloc(pgss->num_statements * sizeof(Entry *));
+ 
+ 	i = 0;
+ 	hash_seq_init(&hash_seq, pgss_hash);
+ 	while ((entry = hash_seq_search(&hash_seq)) != NULL)
+ 	{
+ 		entries[i++] = entry;
+ 		entry->usage *= USAGE_DECREASE_FACTOR;
+ 	}
+ 
+ 	qsort(entries, i, sizeof(Entry *), entry_cmp);
+ 	nvictims = Max(10, i * USAGE_DEALLOC_PERCENT / 100);
+ 
+ 	for (i = 0; i < nvictims; i++)
+ 	{
+ 		chunk_free(entries[i]->chunk);
+ 		(void) SpinLockFree(&entries[i]->mutex);
+ 		hash_search(pgss_hash, &entries[i]->tag, HASH_REMOVE, NULL);
+ 		pgss->num_statements--;
+ 	}
+ 
+ 	pfree(entries);
+ }
+ 
+ static void
+ entry_reset(void)
+ {
+ 	HASH_SEQ_STATUS		hash_seq;
+ 	Entry			   *entry;
+ 
+ 	LWLockAcquire(pgss->lock, LW_EXCLUSIVE);
+ 
+ 	hash_seq_init(&hash_seq, pgss_hash);
+ 	while ((entry = hash_seq_search(&hash_seq)) != NULL)
+ 	{
+ 		(void) SpinLockFree(&entry->mutex);
+ 		hash_search(pgss_hash, &entry->tag, HASH_REMOVE, NULL);
+ 	}
+ 
+ 	pgss->num_statements = 0;
+ 	chunk_reset();
+ 
+ 	LWLockRelease(pgss->lock);
+ }
+ 
+ static Chunk *
+ chunk_alloc(void)
+ {
+ 	Chunk *chunk;
+ 
+ 	Assert(pgss->free_chunks != NULL);
+ 
+ 	chunk = pgss->free_chunks;
+ 	pgss->free_chunks = pgss->free_chunks->next;
+ 	return chunk;
+ }
+ 
+ static void
+ chunk_free(Chunk *chunk)
+ {
+ 	Assert(chunk != NULL);
+ 
+ 	chunk->next = pgss->free_chunks;
+ 	pgss->free_chunks = chunk;
+ }
+ 
+ static void
+ chunk_reset(void)
+ {
+ 	Chunk  *chunk;
+ 	Chunk  *next;
+ 	int				i;
+ 
+ 	chunk = pgss->free_chunks = pgss->chunks;
+ 	for (i = 0; i < max_statements - 1; i++)
+ 	{
+ 		next = (Chunk *) ((char *)chunk + pgss->chunk_size);
+ 		chunk->next = next;
+ 		chunk = next;
+ 	}
+ 	chunk->next = NULL;
+ }
+ 
+ const char *
+ assign_saved_file(const char *newval, bool doit, GucSource source)
+ {
+ 	if (doit)
+ 	{
+ 		char *canon_val = strdup(newval);
+ 		if (canon_val == NULL)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_OUT_OF_MEMORY),
+ 					 errmsg("out of memory")));
+ 		canonicalize_path(canon_val);
+ 		return canon_val;
+ 	}
+ 	else
+ 		return newval;
+ }
diff -cprN HEAD/contrib/pg_stat_statements/pg_stat_statements.sql.in pg_stat_statements/contrib/pg_stat_statements/pg_stat_statements.sql.in
*** HEAD/contrib/pg_stat_statements/pg_stat_statements.sql.in	Thu Jan  1 09:00:00 1970
--- pg_stat_statements/contrib/pg_stat_statements/pg_stat_statements.sql.in	Tue Dec  2 16:07:20 2008
***************
*** 0 ****
--- 1,36 ----
+ -- Adjust this setting to control where the objects get created.
+ SET search_path = public;
+ 
+ -- Register functions.
+ CREATE FUNCTION pg_stat_statements_reset()
+ RETURNS bool
+ AS 'MODULE_PATHNAME'
+ LANGUAGE C;
+ 
+ CREATE FUNCTION pg_stat_statements(
+     OUT userid oid,
+     OUT dbid oid,
+     OUT query text,
+     OUT calls int8,
+     OUT total_time float8,
+     OUT cpu_user float8,
+     OUT cpu_sys float8,
+     OUT gets int8,
+     OUT reads int8,
+     OUT local_reads int8,
+     OUT rows int8
+ )
+ RETURNS SETOF record
+ AS 'MODULE_PATHNAME'
+ LANGUAGE C;
+ 
+ -- Register a view.
+ CREATE VIEW pg_stat_statements AS
+     SELECT userid, dbid, query, calls,
+            (total_time * 1000)::int8 AS total_time,
+            ((cpu_user + cpu_sys) * 1000)::int8 AS cpu_time,
+            gets, reads, local_reads, rows
+       FROM pg_stat_statements();
+ 
+ -- Don't want these to be available at public.
+ REVOKE ALL ON FUNCTION pg_stat_statements_reset() FROM PUBLIC;
diff -cprN HEAD/contrib/pg_stat_statements/uninstall_pg_stat_statements.sql pg_stat_statements/contrib/pg_stat_statements/uninstall_pg_stat_statements.sql
*** HEAD/contrib/pg_stat_statements/uninstall_pg_stat_statements.sql	Thu Jan  1 09:00:00 1970
--- pg_stat_statements/contrib/pg_stat_statements/uninstall_pg_stat_statements.sql	Mon Jul 14 18:03:04 2008
***************
*** 0 ****
--- 1,6 ----
+ -- Adjust this setting to control where the objects get dropped.
+ SET search_path = public;
+ 
+ DROP VIEW pg_stat_statements;
+ DROP FUNCTION pg_stat_statements();
+ DROP FUNCTION pg_stat_statements_reset();
diff -cprN HEAD/doc/src/sgml/contrib.sgml pg_stat_statements/doc/src/sgml/contrib.sgml
*** HEAD/doc/src/sgml/contrib.sgml	Sat Nov 22 11:15:56 2008
--- pg_stat_statements/doc/src/sgml/contrib.sgml	Fri Dec 12 18:26:03 2008
*************** psql -d dbname -f <replaceable>SHAREDIR<
*** 103,108 ****
--- 103,109 ----
   &pgfreespacemap;
   &pgrowlocks;
   &pgstandby;
+  &pgstatstatements;
   &pgstattuple;
   &pgtrgm;
   &seg;
diff -cprN HEAD/doc/src/sgml/filelist.sgml pg_stat_statements/doc/src/sgml/filelist.sgml
*** HEAD/doc/src/sgml/filelist.sgml	Sat Nov 22 11:15:56 2008
--- pg_stat_statements/doc/src/sgml/filelist.sgml	Fri Dec 12 18:26:03 2008
***************
*** 116,121 ****
--- 116,122 ----
  <!entity pgfreespacemap  SYSTEM "pgfreespacemap.sgml">
  <!entity pgrowlocks      SYSTEM "pgrowlocks.sgml">
  <!entity pgstandby       SYSTEM "pgstandby.sgml">
+ <!entity pgstatstatements SYSTEM "pgstatstatements.sgml">
  <!entity pgstattuple     SYSTEM "pgstattuple.sgml">
  <!entity pgtrgm          SYSTEM "pgtrgm.sgml">
  <!entity seg             SYSTEM "seg.sgml">
diff -cprN HEAD/doc/src/sgml/pgstatstatements.sgml pg_stat_statements/doc/src/sgml/pgstatstatements.sgml
*** HEAD/doc/src/sgml/pgstatstatements.sgml	Thu Jan  1 09:00:00 1970
--- pg_stat_statements/doc/src/sgml/pgstatstatements.sgml	Mon Dec  8 11:48:40 2008
***************
*** 0 ****
--- 1,281 ----
+ <sect1 id="pgstatstatements">
+  <title>pg_stat_statements</title>
+ 
+  <indexterm zone="pgstatstatements">
+   <primary>pg_stat_statements</primary>
+  </indexterm>
+ 
+  <para>
+   The <filename>pg_stat_statements</filename> module provides a means for
+   tracing and analyzing SQL statements executed in a server.
+  </para>
+ 
+  <para>
+   The module should be loaded through <varname>shared_preload_libraries</>
+   because it requires additional shared memory. You might need to restart
+   servers to enable the module.
+  </para>
+ 
+  <para>
+   NOTE: It'd be better to to execute statements using prepared statements
+   or extended protocol if you want to get a better report from the module.
+   If simple protocol is used, statements that have differences only in the
+   query parameters are not grouped in the report.
+  </para>
+ 
+  <sect2>
+   <title>The <structname>pg_stat_statements</structname> view</title>
+ 
+   <para>
+    The definitions of the columns exposed by the view are:
+   </para>
+ 
+   <table>
+    <title><structname>pg_stat_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>userid</structfield></entry>
+       <entry><type>oid</type></entry>
+       <entry>pg_authid.oid</entry>
+       <entry>User who executed the statement</entry>
+      </row>
+ 
+      <row>
+       <entry><structfield>dbid</structfield></entry>
+       <entry><type>oid</type></entry>
+       <entry><literal>pg_class.oid</literal></entry>
+       <entry>Database in which the statement is executed</entry>
+      </row>
+ 
+     <row>
+       <entry><structfield>query</structfield></entry>
+       <entry><type>text</type></entry>
+       <entry></entry>
+       <entry>Query text of the statement</entry>
+      </row>
+ 
+      <row>
+       <entry><structfield>calls</structfield></entry>
+       <entry><type>bigint</type></entry>
+       <entry></entry>
+       <entry>Number of times executed</entry>
+      </row>
+ 
+      <row>
+       <entry><structfield>total_time</structfield></entry>
+       <entry><type>bigint</type></entry>
+       <entry></entry>
+       <entry>Total time spent for the statement in milliseconds</entry>
+      </row>
+ 
+      <row>
+       <entry><structfield>cpu_time</structfield></entry>
+       <entry><type>bigint</type></entry>
+       <entry></entry>
+       <entry>CPU time spent for the statement in milliseconds</entry>
+      </row>
+ 
+      <row>
+       <entry><structfield>gets</structfield></entry>
+       <entry><type>bigint</type></entry>
+       <entry></entry>
+       <entry>Total buffer gets during execution</entry>
+      </row>
+ 
+      <row>
+       <entry><structfield>reads</structfield></entry>
+       <entry><type>bigint</type></entry>
+       <entry></entry>
+       <entry>Total buffer reads during execution</entry>
+      </row>
+ 
+      <row>
+       <entry><structfield>local_reads</structfield></entry>
+       <entry><type>bigint</type></entry>
+       <entry></entry>
+       <entry>Total direct reads during execution, for example disk sorting and materializing</entry>
+      </row>
+ 
+      <row>
+       <entry><structfield>rows</structfield></entry>
+       <entry><type>bigint</type></entry>
+       <entry></entry>
+       <entry>Number of rows retrieved or affected by the statement</entry>
+      </row>
+ 
+     </tbody>
+    </tgroup>
+   </table>
+ 
+   <para>
+    There is one row for each statement. Statements are grouped when they have
+    same SQL text, are in the same database, and are executed by the same user.
+   </para>
+ 
+   <para>
+    Because of security restriction, non-super users cannot see query strings
+    executed by other users.
+   </para>
+  </sect2>
+ 
+  <sect2>
+   <title>Functions</title>
+ 
+   <variablelist>
+    <varlistentry>
+     <term>
+      <function>pg_stat_statements_reset() returns bool</function>
+     </term>
+ 
+     <listitem>
+      <para>
+       <function>pg_stat_statements_reset</function> resets all of statement
+       statistics. <structname>pg_stat_statements</> view will be empty.
+      </para>
+     </listitem>
+    </varlistentry>
+ 
+   </variablelist>
+  </sect2>
+ 
+  <sect2>
+   <title>Configuration parameters</title>
+ 
+   <variablelist>
+    <varlistentry>
+     <term>
+      <varname>statistics.max_statements (<type>integer</type>)</varname>
+     </term>
+ 
+     <listitem>
+      <para>
+       <varname>statistics.max_statements</varname> is the maximum number of
+       statements tracked by the module. If variations of statements are larger
+       than the value, statistics of the least used statement is discarded.
+       The default value is 1000. The module requires addional shared memory
+       about <varname>statistics.max_statements</varname> * <varname>track_activity_query_size</varname>.
+       This parameter can only be set at server start.
+      </para>
+     </listitem>
+    </varlistentry>
+ 
+    <varlistentry>
+     <term>
+      <varname>statistics.track_statements (<type>string</type>)</varname>
+     </term>
+ 
+     <listitem>
+      <para>
+       <varname>statistics.track_statements</varname> enables collection of
+       statement statistics by the module. Specify top to count only top-level
+       statements, all to also track nested statements, and none to disable.
+       The default value is none.
+       Only superusers can change this setting.
+      </para>
+      <para>
+       NOTE: Shared memory allocated by the module is not released even if
+       statistics collection is disabled.
+      </para>
+     </listitem>
+    </varlistentry>
+ 
+    <varlistentry>
+     <term>
+      <varname>statistics.saved_file (<type>string</type>)</varname>
+     </term>
+ 
+     <listitem>
+      <para>
+       <varname>statistics.saved_file</varname> specifies the name of saved file
+       where the statement statistics are loaded or dumped. The default value is
+       'global/pg_stat_statements.dump'. If the value is an empty string,
+       statistics are neither loaded nor dumped. This parameter can only be set
+       in the postgresql.conf file or on the server command line.
+      </para>
+     </listitem>
+    </varlistentry>
+   </variablelist>
+ 
+   <para>
+    If you set the above configuration parameters, you also need to
+    add 'statistics' entry to <varname>custom_variable_classes</varname>.
+   </para>
+ 
+   <programlisting>
+   # postgresql.conf
+   shared_preload_libraries = 'pg_stat_statements'
+   
+   custom_variable_classes = 'statistics'
+   #statistics.max_statements = 1000
+   #statistics.track_statements = top
+   #statistics.saved_file = 'global/pg_stat_statements.dump'
+   </programlisting>
+  </sect2>
+ 
+  <sect2>
+   <title>Sample output</title>
+ 
+   <programlisting>
+   $ pgbench -i
+ 
+   postgres=# SELECT pg_stat_statements_reset();
+ 
+   $ pgbench -c10 -t300 -M prepared
+   
+   postgres=# \x
+   postgres=# SELECT * FROM pg_stat_statements ORDER BY total_time DESC LIMIT 3;
+   -[ RECORD 1 ]+-------------------------------------------------------------
+   userid       | 10
+   dbid         | 16384
+   query        | UPDATE branches SET bbalance = bbalance + $1 WHERE bid = $2;
+   calls        | 3000
+   total_time   | 34683
+   cpu_time     | 1843
+   gets         | 48166
+   reads        | 12
+   local_reads  | 0
+   rows         | 3000
+   -[ RECORD 2 ]+-------------------------------------------------------------
+   userid       | 10
+   dbid         | 16384
+   query        | UPDATE tellers SET tbalance = tbalance + $1 WHERE tid = $2;
+   calls        | 3000
+   total_time   | 34611
+   cpu_time     | 593
+   gets         | 26447
+   reads        | 7
+   local_reads  | 0
+   rows         | 3000
+   -[ RECORD 3 ]+-------------------------------------------------------------
+   userid       | 10
+   dbid         | 16384
+   query        | UPDATE accounts SET abalance = abalance + $1 WHERE aid = $2;
+   calls        | 3000
+   total_time   | 546
+   cpu_time     | 359
+   gets         | 18025
+   reads        | 274
+   local_reads  | 0
+   rows         | 3000
+   </programlisting>
+  </sect2>
+ 
+  <sect2>
+   <title>Authors</title>
+ 
+   <para>
+    Takahiro Itagaki <email>itagaki.takahiro@oss.ntt.co.jp</email>
+   </para>
+  </sect2>
+ 
+ </sect1>