* postgres.c
* POSTGRES C Backend Interface
*
- * Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/tcop/postgres.c,v 1.466 2005/10/15 02:49:27 momjian Exp $
+ * $PostgreSQL: pgsql/src/backend/tcop/postgres.c,v 1.538 2007/11/15 21:14:38 momjian Exp $
*
* NOTES
* this is the "main" module of the postgres backend and
#include <signal.h>
#include <fcntl.h>
#include <sys/socket.h>
-#if HAVE_SYS_SELECT_H
+#ifdef HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif
+#ifdef HAVE_SYS_RESOURCE_H
+#include <sys/time.h>
+#include <sys/resource.h>
+#endif
#ifdef HAVE_GETOPT_H
#include <getopt.h>
#endif
+#ifndef HAVE_GETRUSAGE
+#include "rusagestub.h"
+#endif
+
#include "access/printtup.h"
-#include "access/xlog.h"
+#include "access/xact.h"
#include "catalog/pg_type.h"
#include "commands/async.h"
#include "commands/prepare.h"
-#include "commands/trigger.h"
#include "libpq/libpq.h"
#include "libpq/pqformat.h"
#include "libpq/pqsignal.h"
#include "miscadmin.h"
#include "nodes/print.h"
-#include "optimizer/cost.h"
#include "optimizer/planner.h"
#include "parser/analyze.h"
#include "parser/parser.h"
+#include "postmaster/autovacuum.h"
#include "rewrite/rewriteHandler.h"
#include "storage/freespace.h"
#include "storage/ipc.h"
-#include "storage/pg_shmem.h"
#include "storage/proc.h"
#include "storage/sinval.h"
#include "tcop/fastpath.h"
#include "tcop/tcopprot.h"
#include "tcop/utility.h"
#include "utils/flatfiles.h"
-#include "utils/guc.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/ps_status.h"
const char *debug_query_string; /* for pgmonitor and log_min_error_statement */
/* Note: whereToSendOutput is initialized for the bootstrap/standalone case */
-CommandDest whereToSendOutput = Debug;
+CommandDest whereToSendOutput = DestDebug;
/* flag for logging end of session */
bool Log_disconnections = false;
LogStmtLevel log_statement = LOGSTMT_NONE;
/* GUC variable for maximum stack depth (measured in kilobytes) */
-int max_stack_depth = 2048;
+int max_stack_depth = 100;
+
+/* wait N seconds to allow attach from a debugger */
+int PostAuthDelay = 0;
+
/* ----------------
*/
/* max_stack_depth converted to bytes for speed of checking */
-static int max_stack_depth_bytes = 2048 * 1024;
+static long max_stack_depth_bytes = 100 * 1024L;
-/* stack base pointer (initialized by PostgresMain) */
-/* Do not make static so PL/Java can modifiy it */
+/*
+ * Stack base pointer -- initialized by PostgresMain. This is not static
+ * so that PL/Java can modify it.
+ */
char *stack_base_ptr = NULL;
* We keep it separate from the hashtable kept by commands/prepare.c
* in order to reduce overhead for short-lived queries.
*/
+static CachedPlanSource *unnamed_stmt_psrc = NULL;
+
+/* workspace for building a new unnamed statement in */
static MemoryContext unnamed_stmt_context = NULL;
-static PreparedStatement *unnamed_stmt_pstmt = NULL;
static bool EchoQuery = false; /* default don't echo */
* ----------------------------------------------------------------
*/
static int InteractiveBackend(StringInfo inBuf);
+static int interactive_getc(void);
static int SocketBackend(StringInfo inBuf);
static int ReadCommand(StringInfo inBuf);
-static bool log_after_parse(List *raw_parsetree_list,
- const char *query_string, char **prepare_string);
-static List *pg_rewrite_queries(List *querytree_list);
+static List *pg_rewrite_query(Query *query);
+static bool check_log_statement(List *stmt_list);
+static int errdetail_execute(List *raw_parsetree_list);
+static int errdetail_params(ParamListInfo params);
static void start_xact_command(void);
static void finish_xact_command(void);
+static bool IsTransactionExitStmt(Node *parsetree);
+static bool IsTransactionExitStmtList(List *parseTrees);
+static bool IsTransactionStmtList(List *parseTrees);
+static void drop_unnamed_stmt(void);
static void SigHupHandler(SIGNAL_ARGS);
static void log_disconnections(int code, Datum arg);
printf("backend> ");
fflush(stdout);
- /* Reset inBuf to empty */
- inBuf->len = 0;
- inBuf->data[0] = '\0';
- inBuf->cursor = 0;
+ resetStringInfo(inBuf);
- for (;;)
+ if (UseNewLine)
{
- if (UseNewLine)
+ /*
+ * if we are using \n as a delimiter, then read characters until the
+ * \n.
+ */
+ while ((c = interactive_getc()) != EOF)
{
- /*
- * if we are using \n as a delimiter, then read characters until
- * the \n.
- */
- while ((c = getc(stdin)) != EOF)
+ if (c == '\n')
{
- if (c == '\n')
+ if (backslashSeen)
{
- if (backslashSeen)
- {
- /* discard backslash from inBuf */
- inBuf->data[--inBuf->len] = '\0';
- backslashSeen = false;
- continue;
- }
- else
- {
- /* keep the newline character */
- appendStringInfoChar(inBuf, '\n');
- break;
- }
+ /* discard backslash from inBuf */
+ inBuf->data[--inBuf->len] = '\0';
+ backslashSeen = false;
+ continue;
}
- else if (c == '\\')
- backslashSeen = true;
else
- backslashSeen = false;
-
- appendStringInfoChar(inBuf, (char) c);
+ {
+ /* keep the newline character */
+ appendStringInfoChar(inBuf, '\n');
+ break;
+ }
}
+ else if (c == '\\')
+ backslashSeen = true;
+ else
+ backslashSeen = false;
- if (c == EOF)
- end = true;
- }
- else
- {
- /*
- * otherwise read characters until EOF.
- */
- while ((c = getc(stdin)) != EOF)
- appendStringInfoChar(inBuf, (char) c);
-
- if (inBuf->len == 0)
- end = true;
+ appendStringInfoChar(inBuf, (char) c);
}
- if (end)
- return EOF;
-
+ if (c == EOF)
+ end = true;
+ }
+ else
+ {
/*
- * otherwise we have a user query so process it.
+ * otherwise read characters until EOF.
*/
- break;
+ while ((c = interactive_getc()) != EOF)
+ appendStringInfoChar(inBuf, (char) c);
+
+ /* No input before EOF signal means time to quit. */
+ if (inBuf->len == 0)
+ end = true;
}
+ if (end)
+ return EOF;
+
+ /*
+ * otherwise we have a user query so process it.
+ */
+
/* Add '\0' to make it look the same as message case. */
appendStringInfoChar(inBuf, (char) '\0');
return 'Q';
}
+/*
+ * interactive_getc -- collect one character from stdin
+ *
+ * Even though we are not reading from a "client" process, we still want to
+ * respond to signals, particularly SIGTERM/SIGQUIT. Hence we must use
+ * prepare_for_client_read and client_read_ended.
+ */
+static int
+interactive_getc(void)
+{
+ int c;
+
+ prepare_for_client_read();
+ c = getc(stdin);
+ client_read_ended();
+ return c;
+}
+
/* ----------------
* SocketBackend() Is called for frontend-backend connections
*
* sync, better to say "command unknown" than to run out of memory because
* we used garbage as a length word.
*
- * This also gives us a place to set the doing_extended_query_message flag as
- * soon as possible.
+ * This also gives us a place to set the doing_extended_query_message flag
+ * as soon as possible.
*/
switch (qtype)
{
{
int result;
- if (whereToSendOutput == Remote)
+ if (whereToSendOutput == DestRemote)
result = SocketBackend(inBuf);
else
result = InteractiveBackend(inBuf);
querytree_list = list_concat(querytree_list,
pg_analyze_and_rewrite(parsetree,
+ query_string,
paramTypes,
numParams));
}
if (log_parser_stats)
ShowUsage("PARSER STATISTICS");
- return raw_parsetree_list;
-}
-
-static bool
-log_after_parse(List *raw_parsetree_list, const char *query_string,
- char **prepare_string)
-{
- ListCell *parsetree_item;
- bool log_this_statement = (log_statement == LOGSTMT_ALL);
-
- *prepare_string = NULL;
-
- /* Check if we need to log the statement, and get prepare_string. */
- foreach(parsetree_item, raw_parsetree_list)
+#ifdef COPY_PARSE_PLAN_TREES
+ /* Optional debugging check: pass raw parsetrees through copyObject() */
{
- Node *parsetree = (Node *) lfirst(parsetree_item);
- const char *commandTag;
-
- if (IsA(parsetree, ExplainStmt) &&
- ((ExplainStmt *) parsetree)->analyze)
- parsetree = (Node *) (((ExplainStmt *) parsetree)->query);
-
- if (IsA(parsetree, PrepareStmt))
- parsetree = (Node *) (((PrepareStmt *) parsetree)->query);
-
- if (IsA(parsetree, SelectStmt) &&
- ((SelectStmt *) parsetree)->into == NULL)
- continue; /* optimization for frequent command */
-
- if (log_statement == LOGSTMT_MOD &&
- (IsA(parsetree, InsertStmt) ||
- IsA(parsetree, UpdateStmt) ||
- IsA(parsetree, DeleteStmt) ||
- IsA(parsetree, TruncateStmt) ||
- (IsA(parsetree, CopyStmt) &&
- ((CopyStmt *) parsetree)->is_from))) /* COPY FROM */
- log_this_statement = true;
-
- commandTag = CreateCommandTag(parsetree);
- if ((log_statement == LOGSTMT_MOD ||
- log_statement == LOGSTMT_DDL) &&
- (strncmp(commandTag, "CREATE ", strlen("CREATE ")) == 0 ||
- IsA(parsetree, SelectStmt) || /* SELECT INTO, CREATE AS */
- strncmp(commandTag, "ALTER ", strlen("ALTER ")) == 0 ||
- strncmp(commandTag, "DROP ", strlen("DROP ")) == 0 ||
- IsA(parsetree, GrantStmt) || /* GRANT or REVOKE */
- IsA(parsetree, CommentStmt)))
- log_this_statement = true;
+ List *new_list = (List *) copyObject(raw_parsetree_list);
- /*
- * For the first EXECUTE we find, record the client statement used by
- * the PREPARE.
- */
- if (IsA(parsetree, ExecuteStmt))
- {
- ExecuteStmt *stmt = (ExecuteStmt *) parsetree;
- PreparedStatement *entry;
-
- if ((entry = FetchPreparedStatement(stmt->name, false)) != NULL &&
- entry->query_string)
- {
- *prepare_string = palloc(strlen(entry->query_string) +
- strlen(" [client PREPARE: %s]") - 1);
- sprintf(*prepare_string, " [client PREPARE: %s]",
- entry->query_string);
- }
- }
+ /* This checks both copyObject() and the equal() routines... */
+ if (!equal(new_list, raw_parsetree_list))
+ elog(WARNING, "copyObject() failed to produce an equal raw parse tree");
+ else
+ raw_parsetree_list = new_list;
}
+#endif
- if (log_this_statement)
- {
- ereport(LOG,
- (errmsg("statement: %s%s", query_string,
- *prepare_string ? *prepare_string : "")));
- return true;
- }
- else
- return false;
+ return raw_parsetree_list;
}
-
/*
* Given a raw parsetree (gram.y output), and optionally information about
* types of parameter symbols ($n), perform parse analysis and rule rewriting.
* NOTE: for reasons mentioned above, this must be separate from raw parsing.
*/
List *
-pg_analyze_and_rewrite(Node *parsetree, Oid *paramTypes, int numParams)
+pg_analyze_and_rewrite(Node *parsetree, const char *query_string,
+ Oid *paramTypes, int numParams)
{
+ Query *query;
List *querytree_list;
/*
if (log_parser_stats)
ResetUsage();
- querytree_list = parse_analyze(parsetree, paramTypes, numParams);
+ query = parse_analyze(parsetree, query_string, paramTypes, numParams);
if (log_parser_stats)
ShowUsage("PARSE ANALYSIS STATISTICS");
/*
* (2) Rewrite the queries, as necessary
*/
- querytree_list = pg_rewrite_queries(querytree_list);
+ querytree_list = pg_rewrite_query(query);
return querytree_list;
}
/*
- * Perform rewriting of a list of queries produced by parse analysis.
+ * Perform rewriting of a query produced by parse analysis.
*
- * Note: queries must just have come from the parser, because we do not do
- * AcquireRewriteLocks() on them.
+ * Note: query must just have come from the parser, because we do not do
+ * AcquireRewriteLocks() on it.
*/
static List *
-pg_rewrite_queries(List *querytree_list)
+pg_rewrite_query(Query *query)
{
- List *new_list = NIL;
- ListCell *list_item;
+ List *querytree_list;
if (log_parser_stats)
ResetUsage();
- /*
- * rewritten queries are collected in new_list. Note there may be more or
- * fewer than in the original list.
- */
- foreach(list_item, querytree_list)
- {
- Query *querytree = (Query *) lfirst(list_item);
-
- if (Debug_print_parse)
- elog_node_display(DEBUG1, "parse tree", querytree,
- Debug_pretty_print);
-
- if (querytree->commandType == CMD_UTILITY)
- {
- /* don't rewrite utilities, just dump 'em into new_list */
- new_list = lappend(new_list, querytree);
- }
- else
- {
- /* rewrite regular queries */
- List *rewritten = QueryRewrite(querytree);
+ if (Debug_print_parse)
+ elog_node_display(DEBUG1, "parse tree", query,
+ Debug_pretty_print);
- new_list = list_concat(new_list, rewritten);
- }
+ if (query->commandType == CMD_UTILITY)
+ {
+ /* don't rewrite utilities, just dump 'em into result list */
+ querytree_list = list_make1(query);
+ }
+ else
+ {
+ /* rewrite regular queries */
+ querytree_list = QueryRewrite(query);
}
-
- querytree_list = new_list;
if (log_parser_stats)
ShowUsage("REWRITER STATISTICS");
#ifdef COPY_PARSE_PLAN_TREES
+ /* Optional debugging check: pass querytree output through copyObject() */
+ {
+ List *new_list;
- /*
- * Optional debugging check: pass querytree output through copyObject()
- */
- new_list = (List *) copyObject(querytree_list);
- /* This checks both copyObject() and the equal() routines... */
- if (!equal(new_list, querytree_list))
- elog(WARNING, "copyObject() failed to produce an equal parse tree");
- else
- querytree_list = new_list;
+ new_list = (List *) copyObject(querytree_list);
+ /* This checks both copyObject() and the equal() routines... */
+ if (!equal(new_list, querytree_list))
+ elog(WARNING, "copyObject() failed to produce equal parse tree");
+ else
+ querytree_list = new_list;
+ }
#endif
if (Debug_print_rewritten)
}
-/* Generate a plan for a single already-rewritten query. */
-Plan *
-pg_plan_query(Query *querytree, ParamListInfo boundParams)
+/*
+ * Generate a plan for a single already-rewritten query.
+ * This is a thin wrapper around planner() and takes the same parameters.
+ */
+PlannedStmt *
+pg_plan_query(Query *querytree, int cursorOptions, ParamListInfo boundParams)
{
- Plan *plan;
+ PlannedStmt *plan;
/* Utility commands have no plans. */
if (querytree->commandType == CMD_UTILITY)
ResetUsage();
/* call the optimizer */
- plan = planner(querytree, false, 0, boundParams);
+ plan = planner(querytree, cursorOptions, boundParams);
if (log_planner_stats)
ShowUsage("PLANNER STATISTICS");
#ifdef COPY_PARSE_PLAN_TREES
/* Optional debugging check: pass plan output through copyObject() */
{
- Plan *new_plan = (Plan *) copyObject(plan);
+ PlannedStmt *new_plan = (PlannedStmt *) copyObject(plan);
/*
* equal() currently does not have routines to compare Plan nodes, so
* utility statements depend on not having frozen the snapshot yet.
* (We assume that such statements cannot appear together with plannable
* statements in the rewriter's output.)
+ *
+ * Normal optimizable statements generate PlannedStmt entries in the result
+ * list. Utility statements are simply represented by their statement nodes.
*/
List *
-pg_plan_queries(List *querytrees, ParamListInfo boundParams,
+pg_plan_queries(List *querytrees, int cursorOptions, ParamListInfo boundParams,
bool needSnapshot)
{
- List *plan_list = NIL;
+ List *stmt_list = NIL;
ListCell *query_list;
foreach(query_list, querytrees)
{
Query *query = (Query *) lfirst(query_list);
- Plan *plan;
+ Node *stmt;
if (query->commandType == CMD_UTILITY)
{
/* Utility commands have no plans. */
- plan = NULL;
+ stmt = query->utilityStmt;
}
else
{
ActiveSnapshot = CopySnapshot(GetTransactionSnapshot());
needSnapshot = false;
}
- plan = pg_plan_query(query, boundParams);
+ stmt = (Node *) pg_plan_query(query, cursorOptions, boundParams);
}
- plan_list = lappend(plan_list, plan);
+ stmt_list = lappend(stmt_list, stmt);
}
- return plan_list;
+ return stmt_list;
}
MemoryContext oldcontext;
List *parsetree_list;
ListCell *parsetree_item;
- struct timeval start_t,
- stop_t;
- bool save_log_duration = log_duration;
- int save_log_min_duration_statement = log_min_duration_statement;
bool save_log_statement_stats = log_statement_stats;
- char *prepare_string = NULL;
bool was_logged = false;
+ bool isTopLevel;
+ char msec_str[32];
/*
* Report query to various monitoring facilities.
pgstat_report_activity(query_string);
/*
- * We use save_log_* so "SET log_duration = true" and "SET
- * log_min_duration_statement = true" don't report incorrect time because
- * gettimeofday() wasn't called. Similarly, log_statement_stats has to be
- * captured once.
+ * We use save_log_statement_stats so ShowUsage doesn't report incorrect
+ * results because ResetUsage wasn't called.
*/
- if (save_log_duration || save_log_min_duration_statement != -1)
- gettimeofday(&start_t, NULL);
-
if (save_log_statement_stats)
ResetUsage();
* statement and portal; this ensures we recover any storage used by prior
* unnamed operations.)
*/
- unnamed_stmt_pstmt = NULL;
- if (unnamed_stmt_context)
- {
- DropDependentPortals(unnamed_stmt_context);
- MemoryContextDelete(unnamed_stmt_context);
- }
- unnamed_stmt_context = NULL;
+ drop_unnamed_stmt();
/*
* Switch to appropriate context for constructing parsetrees.
*/
oldcontext = MemoryContextSwitchTo(MessageContext);
- QueryContext = CurrentMemoryContext;
-
/*
* Do basic parsing of the query or queries (this should be safe even if
* we are in aborted transaction state!)
*/
parsetree_list = pg_parse_query(query_string);
- if (log_statement != LOGSTMT_NONE || save_log_min_duration_statement != -1)
- was_logged = log_after_parse(parsetree_list, query_string,
- &prepare_string);
+ /* Log immediately if dictated by log_statement */
+ if (check_log_statement(parsetree_list))
+ {
+ ereport(LOG,
+ (errmsg("statement: %s", query_string),
+ errhidestmt(true),
+ errdetail_execute(parsetree_list)));
+ was_logged = true;
+ }
/*
* Switch back to transaction context to enter the loop.
*/
MemoryContextSwitchTo(oldcontext);
+ /*
+ * We'll tell PortalRun it's a top-level command iff there's exactly one
+ * raw parsetree. If more than one, it's effectively a transaction block
+ * and we want PreventTransactionChain to reject unsafe commands. (Note:
+ * we're assuming that query rewrite cannot add commands that are
+ * significant to PreventTransactionChain.)
+ */
+ isTopLevel = (list_length(parsetree_list) == 1);
+
/*
* Run through the raw parsetree(s) and process each one.
*/
*/
commandTag = CreateCommandTag(parsetree);
- set_ps_display(commandTag);
+ set_ps_display(commandTag, false);
BeginCommand(commandTag, dest);
* might be safe to allow some additional utility commands in this
* state, but not many...)
*/
- if (IsAbortedTransactionBlockState())
- {
- bool allowit = false;
-
- if (IsA(parsetree, TransactionStmt))
- {
- TransactionStmt *stmt = (TransactionStmt *) parsetree;
-
- if (stmt->kind == TRANS_STMT_COMMIT ||
- stmt->kind == TRANS_STMT_PREPARE ||
- stmt->kind == TRANS_STMT_ROLLBACK ||
- stmt->kind == TRANS_STMT_ROLLBACK_TO)
- allowit = true;
- }
-
- if (!allowit)
- ereport(ERROR,
- (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
- errmsg("current transaction is aborted, "
+ if (IsAbortedTransactionBlockState() &&
+ !IsTransactionExitStmt(parsetree))
+ ereport(ERROR,
+ (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
+ errmsg("current transaction is aborted, "
"commands ignored until end of transaction block")));
- }
/* Make sure we are in a transaction command */
start_xact_command();
*/
oldcontext = MemoryContextSwitchTo(MessageContext);
- querytree_list = pg_analyze_and_rewrite(parsetree, NULL, 0);
+ querytree_list = pg_analyze_and_rewrite(parsetree, query_string,
+ NULL, 0);
- plantree_list = pg_plan_queries(querytree_list, NULL, true);
+ plantree_list = pg_plan_queries(querytree_list, 0, NULL, true);
/* If we got a cancel signal in analysis or planning, quit */
CHECK_FOR_INTERRUPTS();
* already is one, silently drop it.
*/
portal = CreatePortal("", true, true);
+ /* Don't display the portal in pg_cursors */
+ portal->visible = false;
PortalDefineQuery(portal,
+ NULL,
query_string,
commandTag,
- querytree_list,
plantree_list,
- MessageContext);
+ NULL);
/*
* Start the portal. No parameters here.
*/
(void) PortalRun(portal,
FETCH_ALL,
+ isTopLevel,
receiver,
receiver,
completionTag);
if (!parsetree_list)
NullCommand(dest);
- QueryContext = NULL;
-
/*
- * Combine processing here as we need to calculate the query duration in
- * both instances.
+ * Emit duration logging if appropriate.
*/
- if (save_log_duration || save_log_min_duration_statement != -1)
+ switch (check_log_duration(msec_str, was_logged))
{
- long usecs;
-
- gettimeofday(&stop_t, NULL);
- if (stop_t.tv_usec < start_t.tv_usec)
- {
- stop_t.tv_sec--;
- stop_t.tv_usec += 1000000;
- }
- usecs = (long) (stop_t.tv_sec - start_t.tv_sec) * 1000000 +
- (long) (stop_t.tv_usec - start_t.tv_usec);
-
- /* Only print duration if we previously printed the statement. */
- if (was_logged && save_log_duration)
+ case 1:
ereport(LOG,
- (errmsg("duration: %ld.%03ld ms",
- (long) ((stop_t.tv_sec - start_t.tv_sec) * 1000 +
- (stop_t.tv_usec - start_t.tv_usec) / 1000),
- (long) (stop_t.tv_usec - start_t.tv_usec) % 1000)));
-
- /*
- * Output a duration_statement to the log if the query has exceeded
- * the min duration, or if we are to print all durations.
- */
- if (save_log_min_duration_statement == 0 ||
- (save_log_min_duration_statement > 0 &&
- usecs >= save_log_min_duration_statement * 1000))
+ (errmsg("duration: %s ms", msec_str),
+ errhidestmt(true)));
+ break;
+ case 2:
ereport(LOG,
- (errmsg("duration: %ld.%03ld ms statement: %s%s",
- (long) ((stop_t.tv_sec - start_t.tv_sec) * 1000 +
- (stop_t.tv_usec - start_t.tv_usec) / 1000),
- (long) (stop_t.tv_usec - start_t.tv_usec) % 1000,
- query_string,
- prepare_string ? prepare_string : "")));
+ (errmsg("duration: %s ms statement: %s",
+ msec_str, query_string),
+ errhidestmt(true),
+ errdetail_execute(parsetree_list)));
+ break;
}
if (save_log_statement_stats)
ShowUsage("QUERY STATISTICS");
- if (prepare_string != NULL)
- pfree(prepare_string);
-
debug_query_string = NULL;
}
{
MemoryContext oldcontext;
List *parsetree_list;
+ Node *raw_parse_tree;
const char *commandTag;
List *querytree_list,
- *plantree_list,
- *param_list;
+ *stmt_list;
bool is_named;
+ bool fully_planned;
bool save_log_statement_stats = log_statement_stats;
+ char msec_str[32];
/*
* Report query to various monitoring facilities.
pgstat_report_activity(query_string);
- set_ps_display("PARSE");
+ set_ps_display("PARSE", false);
if (save_log_statement_stats)
ResetUsage();
- if (log_statement == LOGSTMT_ALL)
- ereport(LOG,
- (errmsg("statement: PREPARE %s AS %s",
- (*stmt_name != '\0') ? stmt_name : "<unnamed>",
- query_string)));
+ ereport(DEBUG2,
+ (errmsg("parse %s: %s",
+ *stmt_name ? stmt_name : "<unnamed>",
+ query_string)));
/*
* Start up a transaction command so we can run parse analysis etc. (Note
* We have two strategies depending on whether the prepared statement is
* named or not. For a named prepared statement, we do parsing in
* MessageContext and copy the finished trees into the prepared
- * statement's private context; then the reset of MessageContext releases
+ * statement's plancache entry; then the reset of MessageContext releases
* temporary space used by parsing and planning. For an unnamed prepared
* statement, we assume the statement isn't going to hang around long, so
* getting rid of temp space quickly is probably not worth the costs of
- * copying parse/plan trees. So in this case, we set up a special context
- * for the unnamed statement, and do all the parsing/planning therein.
+ * copying parse/plan trees. So in this case, we create the plancache
+ * entry's context here, and do all the parsing work therein.
*/
is_named = (stmt_name[0] != '\0');
if (is_named)
else
{
/* Unnamed prepared statement --- release any prior unnamed stmt */
- unnamed_stmt_pstmt = NULL;
- if (unnamed_stmt_context)
- {
- DropDependentPortals(unnamed_stmt_context);
- MemoryContextDelete(unnamed_stmt_context);
- }
- unnamed_stmt_context = NULL;
- /* create context for parsing/planning */
+ drop_unnamed_stmt();
+ /* Create context for parsing/planning */
unnamed_stmt_context =
- AllocSetContextCreate(TopMemoryContext,
+ AllocSetContextCreate(CacheMemoryContext,
"unnamed prepared statement",
ALLOCSET_DEFAULT_MINSIZE,
ALLOCSET_DEFAULT_INITSIZE,
oldcontext = MemoryContextSwitchTo(unnamed_stmt_context);
}
- QueryContext = CurrentMemoryContext;
-
/*
* Do basic parsing of the query or queries (this should be safe even if
* we are in aborted transaction state!)
if (parsetree_list != NIL)
{
- Node *parsetree = (Node *) linitial(parsetree_list);
+ Query *query;
int i;
+ raw_parse_tree = (Node *) linitial(parsetree_list);
+
/*
* Get the command name for possible use in status display.
*/
- commandTag = CreateCommandTag(parsetree);
+ commandTag = CreateCommandTag(raw_parse_tree);
/*
* If we are in an aborted transaction, reject all commands except
* (It might be safe to allow some additional utility commands in this
* state, but not many...)
*/
- if (IsAbortedTransactionBlockState())
- {
- bool allowit = false;
-
- if (IsA(parsetree, TransactionStmt))
- {
- TransactionStmt *stmt = (TransactionStmt *) parsetree;
-
- if (stmt->kind == TRANS_STMT_COMMIT ||
- stmt->kind == TRANS_STMT_PREPARE ||
- stmt->kind == TRANS_STMT_ROLLBACK ||
- stmt->kind == TRANS_STMT_ROLLBACK_TO)
- allowit = true;
- }
-
- if (!allowit)
- ereport(ERROR,
- (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
- errmsg("current transaction is aborted, "
+ if (IsAbortedTransactionBlockState() &&
+ !IsTransactionExitStmt(raw_parse_tree))
+ ereport(ERROR,
+ (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
+ errmsg("current transaction is aborted, "
"commands ignored until end of transaction block")));
- }
/*
* OK to analyze, rewrite, and plan this query. Note that the
* originally specified parameter set is not required to be complete,
* so we have to use parse_analyze_varparams().
+ *
+ * XXX must use copyObject here since parse analysis scribbles on its
+ * input, and we need the unmodified raw parse tree for possible
+ * replanning later.
*/
if (log_parser_stats)
ResetUsage();
- querytree_list = parse_analyze_varparams(parsetree,
- ¶mTypes,
- &numParams);
+ query = parse_analyze_varparams(copyObject(raw_parse_tree),
+ query_string,
+ ¶mTypes,
+ &numParams);
/*
- * Check all parameter types got determined, and convert array
- * representation to a list for storage.
+ * Check all parameter types got determined.
*/
- param_list = NIL;
for (i = 0; i < numParams; i++)
{
Oid ptype = paramTypes[i];
(errcode(ERRCODE_INDETERMINATE_DATATYPE),
errmsg("could not determine data type of parameter $%d",
i + 1)));
- param_list = lappend_oid(param_list, ptype);
}
if (log_parser_stats)
ShowUsage("PARSE ANALYSIS STATISTICS");
- querytree_list = pg_rewrite_queries(querytree_list);
+ querytree_list = pg_rewrite_query(query);
/*
* If this is the unnamed statement and it has parameters, defer query
* planning until Bind. Otherwise do it now.
*/
if (!is_named && numParams > 0)
- plantree_list = NIL;
+ {
+ stmt_list = querytree_list;
+ fully_planned = false;
+ }
else
- plantree_list = pg_plan_queries(querytree_list, NULL, true);
+ {
+ stmt_list = pg_plan_queries(querytree_list, 0, NULL, true);
+ fully_planned = true;
+ }
}
else
{
/* Empty input string. This is legal. */
+ raw_parse_tree = NULL;
commandTag = NULL;
- querytree_list = NIL;
- plantree_list = NIL;
- param_list = NIL;
+ stmt_list = NIL;
+ fully_planned = true;
}
/* If we got a cancel signal in analysis or planning, quit */
if (is_named)
{
StorePreparedStatement(stmt_name,
+ raw_parse_tree,
query_string,
commandTag,
- querytree_list,
- plantree_list,
- param_list);
+ paramTypes,
+ numParams,
+ 0, /* default cursor options */
+ stmt_list,
+ false);
}
else
{
- PreparedStatement *pstmt;
+ /*
+ * paramTypes and query_string need to be copied into
+ * unnamed_stmt_context. The rest is there already
+ */
+ Oid *newParamTypes;
- pstmt = (PreparedStatement *) palloc0(sizeof(PreparedStatement));
- /* query_string needs to be copied into unnamed_stmt_context */
- pstmt->query_string = pstrdup(query_string);
- /* the rest is there already */
- pstmt->commandTag = commandTag;
- pstmt->query_list = querytree_list;
- pstmt->plan_list = plantree_list;
- pstmt->argtype_list = param_list;
- pstmt->context = unnamed_stmt_context;
- /* Now the unnamed statement is complete and valid */
- unnamed_stmt_pstmt = pstmt;
+ if (numParams > 0)
+ {
+ newParamTypes = (Oid *) palloc(numParams * sizeof(Oid));
+ memcpy(newParamTypes, paramTypes, numParams * sizeof(Oid));
+ }
+ else
+ newParamTypes = NULL;
+
+ unnamed_stmt_psrc = FastCreateCachedPlan(raw_parse_tree,
+ pstrdup(query_string),
+ commandTag,
+ newParamTypes,
+ numParams,
+ 0, /* cursor options */
+ stmt_list,
+ fully_planned,
+ true,
+ unnamed_stmt_context);
+ /* context now belongs to the plancache entry */
+ unnamed_stmt_context = NULL;
}
MemoryContextSwitchTo(oldcontext);
- QueryContext = NULL;
-
/*
* We do NOT close the open transaction command here; that only happens
* when the client sends Sync. Instead, do CommandCounterIncrement just
/*
* Send ParseComplete.
*/
- if (whereToSendOutput == Remote)
+ if (whereToSendOutput == DestRemote)
pq_putemptymessage('1');
+ /*
+ * Emit duration logging if appropriate.
+ */
+ switch (check_log_duration(msec_str, false))
+ {
+ case 1:
+ ereport(LOG,
+ (errmsg("duration: %s ms", msec_str),
+ errhidestmt(true)));
+ break;
+ case 2:
+ ereport(LOG,
+ (errmsg("duration: %s ms parse %s: %s",
+ msec_str,
+ *stmt_name ? stmt_name : "<unnamed>",
+ query_string),
+ errhidestmt(true)));
+ break;
+ }
+
if (save_log_statement_stats)
ShowUsage("PARSE MESSAGE STATISTICS");
int numParams;
int numRFormats;
int16 *rformats = NULL;
- int i;
- PreparedStatement *pstmt;
+ CachedPlanSource *psrc;
+ CachedPlan *cplan;
Portal portal;
ParamListInfo params;
- bool isaborted = IsAbortedTransactionBlockState();
+ List *plan_list;
+ bool save_log_statement_stats = log_statement_stats;
+ char msec_str[32];
+
+ /* Get the fixed part of the message */
+ portal_name = pq_getmsgstring(input_message);
+ stmt_name = pq_getmsgstring(input_message);
+
+ ereport(DEBUG2,
+ (errmsg("bind %s to %s",
+ *portal_name ? portal_name : "<unnamed>",
+ *stmt_name ? stmt_name : "<unnamed>")));
+
+ /* Find prepared statement */
+ if (stmt_name[0] != '\0')
+ {
+ PreparedStatement *pstmt;
+
+ pstmt = FetchPreparedStatement(stmt_name, true);
+ psrc = pstmt->plansource;
+ }
+ else
+ {
+ /* special-case the unnamed statement */
+ psrc = unnamed_stmt_psrc;
+ if (!psrc)
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_PSTATEMENT),
+ errmsg("unnamed prepared statement does not exist")));
+ }
+
+ /*
+ * Report query to various monitoring facilities.
+ */
+ debug_query_string = psrc->query_string ? psrc->query_string : "<BIND>";
- pgstat_report_activity("<BIND>");
+ pgstat_report_activity(debug_query_string);
- set_ps_display("BIND");
+ set_ps_display("BIND", false);
+
+ if (save_log_statement_stats)
+ ResetUsage();
/*
* Start up a transaction command so we can call functions etc. (Note that
/* Switch back to message context */
MemoryContextSwitchTo(MessageContext);
- /* Get the fixed part of the message */
- portal_name = pq_getmsgstring(input_message);
- stmt_name = pq_getmsgstring(input_message);
-
/* Get the parameter format codes */
numPFormats = pq_getmsgint(input_message, 2);
if (numPFormats > 0)
{
+ int i;
+
pformats = (int16 *) palloc(numPFormats * sizeof(int16));
for (i = 0; i < numPFormats; i++)
pformats[i] = pq_getmsgint(input_message, 2);
errmsg("bind message has %d parameter formats but %d parameters",
numPFormats, numParams)));
- /* Find prepared statement */
- if (stmt_name[0] != '\0')
- pstmt = FetchPreparedStatement(stmt_name, true);
- else
- {
- /* special-case the unnamed statement */
- pstmt = unnamed_stmt_pstmt;
- if (!pstmt)
- ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_PSTATEMENT),
- errmsg("unnamed prepared statement does not exist")));
- }
-
- if (numParams != list_length(pstmt->argtype_list))
+ if (numParams != psrc->num_params)
ereport(ERROR,
(errcode(ERRCODE_PROTOCOL_VIOLATION),
errmsg("bind message supplies %d parameters, but prepared statement \"%s\" requires %d",
- numParams, stmt_name, list_length(pstmt->argtype_list))));
+ numParams, stmt_name, psrc->num_params)));
+
+ /*
+ * If we are in aborted transaction state, the only portals we can
+ * actually run are those containing COMMIT or ROLLBACK commands. We
+ * disallow binding anything else to avoid problems with infrastructure
+ * that expects to run inside a valid transaction. We also disallow
+ * binding any parameters, since we can't risk calling user-defined I/O
+ * functions.
+ */
+ if (IsAbortedTransactionBlockState() &&
+ (!IsTransactionExitStmt(psrc->raw_parse_tree) ||
+ numParams != 0))
+ ereport(ERROR,
+ (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
+ errmsg("current transaction is aborted, "
+ "commands ignored until end of transaction block")));
/*
* Create the portal. Allow silent replacement of an existing portal only
else
portal = CreatePortal(portal_name, false, false);
- /* We need to output the parameter values someday */
- if (log_statement == LOGSTMT_ALL)
- ereport(LOG,
- (errmsg("statement: <BIND> %s", portal_name)));
-
/*
* Fetch parameters, if any, and store in the portal's memory context.
- *
- * In an aborted transaction, we can't risk calling user-defined functions,
- * but we can't fail to Bind either, so bind all parameters to null
- * values.
*/
if (numParams > 0)
{
- ListCell *l;
MemoryContext oldContext;
+ int paramno;
oldContext = MemoryContextSwitchTo(PortalGetHeapMemory(portal));
- params = (ParamListInfo)
- palloc0((numParams + 1) * sizeof(ParamListInfoData));
+ /* sizeof(ParamListInfoData) includes the first array element */
+ params = (ParamListInfo) palloc(sizeof(ParamListInfoData) +
+ (numParams - 1) *sizeof(ParamExternData));
+ params->numParams = numParams;
- i = 0;
- foreach(l, pstmt->argtype_list)
+ for (paramno = 0; paramno < numParams; paramno++)
{
- Oid ptype = lfirst_oid(l);
+ Oid ptype = psrc->param_types[paramno];
int32 plength;
+ Datum pval;
bool isNull;
+ StringInfoData pbuf;
+ char csave;
+ int16 pformat;
plength = pq_getmsgint(input_message, 4);
isNull = (plength == -1);
{
const char *pvalue = pq_getmsgbytes(input_message, plength);
- if (isaborted)
- {
- /* We don't bother to check the format in this case */
- isNull = true;
- }
+ /*
+ * Rather than copying data around, we just set up a phony
+ * StringInfo pointing to the correct portion of the message
+ * buffer. We assume we can scribble on the message buffer so
+ * as to maintain the convention that StringInfos have a
+ * trailing null. This is grotty but is a big win when
+ * dealing with very large parameter strings.
+ */
+ pbuf.data = (char *) pvalue;
+ pbuf.maxlen = plength + 1;
+ pbuf.len = plength;
+ pbuf.cursor = 0;
+
+ csave = pbuf.data[plength];
+ pbuf.data[plength] = '\0';
+ }
+ else
+ {
+ pbuf.data = NULL; /* keep compiler quiet */
+ csave = 0;
+ }
+
+ if (numPFormats > 1)
+ pformat = pformats[paramno];
+ else if (numPFormats > 0)
+ pformat = pformats[0];
+ else
+ pformat = 0; /* default = text */
+
+ if (pformat == 0) /* text mode */
+ {
+ Oid typinput;
+ Oid typioparam;
+ char *pstring;
+
+ getTypeInputInfo(ptype, &typinput, &typioparam);
+
+ /*
+ * We have to do encoding conversion before calling the
+ * typinput routine.
+ */
+ if (isNull)
+ pstring = NULL;
else
- {
- int16 pformat;
- StringInfoData pbuf;
- char csave;
-
- if (numPFormats > 1)
- pformat = pformats[i];
- else if (numPFormats > 0)
- pformat = pformats[0];
- else
- pformat = 0; /* default = text */
+ pstring = pg_client_to_server(pbuf.data, plength);
- /*
- * Rather than copying data around, we just set up a phony
- * StringInfo pointing to the correct portion of the
- * message buffer. We assume we can scribble on the
- * message buffer so as to maintain the convention that
- * StringInfos have a trailing null. This is grotty but
- * is a big win when dealing with very large parameter
- * strings.
- */
- pbuf.data = (char *) pvalue;
- pbuf.maxlen = plength + 1;
- pbuf.len = plength;
- pbuf.cursor = 0;
+ pval = OidInputFunctionCall(typinput, pstring, typioparam, -1);
- csave = pbuf.data[plength];
- pbuf.data[plength] = '\0';
+ /* Free result of encoding conversion, if any */
+ if (pstring && pstring != pbuf.data)
+ pfree(pstring);
+ }
+ else if (pformat == 1) /* binary mode */
+ {
+ Oid typreceive;
+ Oid typioparam;
+ StringInfo bufptr;
- if (pformat == 0)
- {
- Oid typinput;
- Oid typioparam;
- char *pstring;
-
- getTypeInputInfo(ptype, &typinput, &typioparam);
-
- /*
- * We have to do encoding conversion before calling
- * the typinput routine.
- */
- pstring = pg_client_to_server(pbuf.data, plength);
- params[i].value =
- OidFunctionCall3(typinput,
- CStringGetDatum(pstring),
- ObjectIdGetDatum(typioparam),
- Int32GetDatum(-1));
- /* Free result of encoding conversion, if any */
- if (pstring != pbuf.data)
- pfree(pstring);
- }
- else if (pformat == 1)
- {
- Oid typreceive;
- Oid typioparam;
-
- /*
- * Call the parameter type's binary input converter
- */
- getTypeBinaryInputInfo(ptype, &typreceive, &typioparam);
-
- params[i].value =
- OidFunctionCall3(typreceive,
- PointerGetDatum(&pbuf),
- ObjectIdGetDatum(typioparam),
- Int32GetDatum(-1));
-
- /* Trouble if it didn't eat the whole buffer */
- if (pbuf.cursor != pbuf.len)
- ereport(ERROR,
- (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
- errmsg("incorrect binary data format in bind parameter %d",
- i + 1)));
- }
- else
- {
- ereport(ERROR,
- (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- errmsg("unsupported format code: %d",
- pformat)));
- }
+ /*
+ * Call the parameter type's binary input converter
+ */
+ getTypeBinaryInputInfo(ptype, &typreceive, &typioparam);
- /* Restore message buffer contents */
- pbuf.data[plength] = csave;
- }
+ if (isNull)
+ bufptr = NULL;
+ else
+ bufptr = &pbuf;
+
+ pval = OidReceiveFunctionCall(typreceive, bufptr, typioparam, -1);
+
+ /* Trouble if it didn't eat the whole buffer */
+ if (!isNull && pbuf.cursor != pbuf.len)
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
+ errmsg("incorrect binary data format in bind parameter %d",
+ paramno + 1)));
+ }
+ else
+ {
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ errmsg("unsupported format code: %d",
+ pformat)));
+ pval = 0; /* keep compiler quiet */
}
- params[i].kind = PARAM_NUM;
- params[i].id = i + 1;
- params[i].ptype = ptype;
- params[i].isnull = isNull;
+ /* Restore message buffer contents */
+ if (!isNull)
+ pbuf.data[plength] = csave;
- i++;
- }
+ params->params[paramno].value = pval;
+ params->params[paramno].isnull = isNull;
- params[i].kind = PARAM_INVALID;
+ /*
+ * We mark the params as CONST. This has no effect if we already
+ * did planning, but if we didn't, it licenses the planner to
+ * substitute the parameters directly into the one-shot plan we
+ * will generate below.
+ */
+ params->params[paramno].pflags = PARAM_FLAG_CONST;
+ params->params[paramno].ptype = ptype;
+ }
MemoryContextSwitchTo(oldContext);
}
numRFormats = pq_getmsgint(input_message, 2);
if (numRFormats > 0)
{
+ int i;
+
rformats = (int16 *) palloc(numRFormats * sizeof(int16));
for (i = 0; i < numRFormats; i++)
rformats[i] = pq_getmsgint(input_message, 2);
pq_getmsgend(input_message);
- /*
- * If we didn't plan the query before, do it now. This allows the planner
- * to make use of the concrete parameter values we now have.
- *
- * This happens only for unnamed statements, and so switching into the
- * statement context for planning is correct (see notes in
- * exec_parse_message).
- */
- if (pstmt->plan_list == NIL && pstmt->query_list != NIL &&
- !isaborted)
+ if (psrc->fully_planned)
+ {
+ /*
+ * Revalidate the cached plan; this may result in replanning. Any
+ * cruft will be generated in MessageContext. The plan refcount will
+ * be assigned to the Portal, so it will be released at portal
+ * destruction.
+ */
+ cplan = RevalidateCachedPlan(psrc, false);
+ plan_list = cplan->stmt_list;
+ }
+ else
{
- MemoryContext oldContext = MemoryContextSwitchTo(pstmt->context);
+ MemoryContext oldContext;
+ List *query_list;
+
+ /*
+ * Revalidate the cached plan; this may result in redoing parse
+ * analysis and rewriting (but not planning). Any cruft will be
+ * generated in MessageContext. The plan refcount is assigned to
+ * CurrentResourceOwner.
+ */
+ cplan = RevalidateCachedPlan(psrc, true);
- pstmt->plan_list = pg_plan_queries(pstmt->query_list, params, true);
+ /*
+ * We didn't plan the query before, so do it now. This allows the
+ * planner to make use of the concrete parameter values we now have.
+ * Because we use PARAM_FLAG_CONST, the plan is good only for this set
+ * of param values, and so we generate the plan in the portal's own
+ * memory context where it will be thrown away after use. As in
+ * exec_parse_message, we make no attempt to recover planner temporary
+ * memory until the end of the operation.
+ *
+ * XXX because the planner has a bad habit of scribbling on its input,
+ * we have to make a copy of the parse trees. FIXME someday.
+ */
+ oldContext = MemoryContextSwitchTo(PortalGetHeapMemory(portal));
+ query_list = copyObject(cplan->stmt_list);
+ plan_list = pg_plan_queries(query_list, 0, params, true);
MemoryContextSwitchTo(oldContext);
+
+ /* We no longer need the cached plan refcount ... */
+ ReleaseCachedPlan(cplan, true);
+ /* ... and we don't want the portal to depend on it, either */
+ cplan = NULL;
}
/*
* Define portal and start execution.
*/
PortalDefineQuery(portal,
- pstmt->query_string,
- pstmt->commandTag,
- pstmt->query_list,
- pstmt->plan_list,
- pstmt->context);
+ stmt_name[0] ? stmt_name : NULL,
+ psrc->query_string,
+ psrc->commandTag,
+ plan_list,
+ cplan);
PortalStart(portal, params, InvalidSnapshot);
/*
* Send BindComplete.
*/
- if (whereToSendOutput == Remote)
+ if (whereToSendOutput == DestRemote)
pq_putemptymessage('2');
+
+ /*
+ * Emit duration logging if appropriate.
+ */
+ switch (check_log_duration(msec_str, false))
+ {
+ case 1:
+ ereport(LOG,
+ (errmsg("duration: %s ms", msec_str),
+ errhidestmt(true)));
+ break;
+ case 2:
+ ereport(LOG,
+ (errmsg("duration: %s ms bind %s%s%s: %s",
+ msec_str,
+ *stmt_name ? stmt_name : "<unnamed>",
+ *portal_name ? "/" : "",
+ *portal_name ? portal_name : "",
+ psrc->query_string ? psrc->query_string : "<source not stored>"),
+ errhidestmt(true),
+ errdetail_params(params)));
+ break;
+ }
+
+ if (save_log_statement_stats)
+ ShowUsage("BIND MESSAGE STATISTICS");
+
+ debug_query_string = NULL;
}
/*
CommandDest dest;
DestReceiver *receiver;
Portal portal;
- bool is_trans_stmt = false;
- bool is_trans_exit = false;
bool completed;
char completionTag[COMPLETION_TAG_BUFSIZE];
- struct timeval start_t,
- stop_t;
- bool save_log_duration = log_duration;
- int save_log_min_duration_statement = log_min_duration_statement;
+ const char *sourceText;
+ const char *prepStmtName;
+ ParamListInfo portalParams;
bool save_log_statement_stats = log_statement_stats;
- bool execute_is_fetch = false;
+ bool is_xact_command;
+ bool execute_is_fetch;
+ bool was_logged = false;
+ char msec_str[32];
/* Adjust destination to tell printtup.c what to do */
dest = whereToSendOutput;
- if (dest == Remote)
- dest = RemoteExecute;
+ if (dest == DestRemote)
+ dest = DestRemoteExecute;
portal = GetPortalByName(portal_name);
if (!PortalIsValid(portal))
(errcode(ERRCODE_UNDEFINED_CURSOR),
errmsg("portal \"%s\" does not exist", portal_name)));
- /*
- * If we re-issue an Execute protocol request against an existing portal,
- * then we are only fetching more rows rather than completely re-executing
- * the query from the start. atStart is never reset for a v3 portal, so we
- * are safe to use this check.
- */
- if (!portal->atStart)
- execute_is_fetch = true;
-
/*
* If the original query was a null string, just return
* EmptyQueryResponse.
*/
if (portal->commandTag == NULL)
{
- Assert(portal->parseTrees == NIL);
+ Assert(portal->stmts == NIL);
NullCommand(dest);
return;
}
- /* Should we display the portal names here? */
- if (execute_is_fetch)
- {
- debug_query_string = "fetch message";
- pgstat_report_activity("<FETCH>");
- }
- else if (portal->sourceText)
+ /* Does the portal contain a transaction command? */
+ is_xact_command = IsTransactionStmtList(portal->stmts);
+
+ /*
+ * We must copy the sourceText and prepStmtName into MessageContext in
+ * case the portal is destroyed during finish_xact_command. Can avoid the
+ * copy if it's not an xact command, though.
+ */
+ if (is_xact_command)
{
- debug_query_string = portal->sourceText;
- pgstat_report_activity(portal->sourceText);
+ sourceText = portal->sourceText ? pstrdup(portal->sourceText) : NULL;
+ if (portal->prepStmtName)
+ prepStmtName = pstrdup(portal->prepStmtName);
+ else
+ prepStmtName = "<unnamed>";
+
+ /*
+ * An xact command shouldn't have any parameters, which is a good
+ * thing because they wouldn't be around after finish_xact_command.
+ */
+ portalParams = NULL;
}
else
{
- debug_query_string = "execute message";
- pgstat_report_activity("<EXECUTE>");
+ sourceText = portal->sourceText;
+ if (portal->prepStmtName)
+ prepStmtName = portal->prepStmtName;
+ else
+ prepStmtName = "<unnamed>";
+ portalParams = portal->portalParams;
}
- set_ps_display(portal->commandTag);
-
/*
- * We use save_log_* so "SET log_duration = true" and "SET
- * log_min_duration_statement = true" don't report incorrect time because
- * gettimeofday() wasn't called. Similarly, log_statement_stats has to be
- * captured once.
+ * Report query to various monitoring facilities.
*/
- if (save_log_duration || save_log_min_duration_statement != -1)
- gettimeofday(&start_t, NULL);
+ debug_query_string = sourceText ? sourceText : "<EXECUTE>";
+
+ pgstat_report_activity(debug_query_string);
+
+ set_ps_display(portal->commandTag, false);
if (save_log_statement_stats)
ResetUsage();
- if (log_statement == LOGSTMT_ALL)
- /* We have the portal, so output the source query. */
- ereport(LOG,
- (errmsg("statement: %sEXECUTE %s [PREPARE: %s]",
- (execute_is_fetch) ? "FETCH from " : "",
- (*portal_name != '\0') ? portal_name : "<unnamed>",
- portal->sourceText ? portal->sourceText : "")));
-
BeginCommand(portal->commandTag, dest);
- /* Check for transaction-control commands */
- if (list_length(portal->parseTrees) == 1)
- {
- Query *query = (Query *) linitial(portal->parseTrees);
-
- if (query->commandType == CMD_UTILITY &&
- query->utilityStmt != NULL &&
- IsA(query->utilityStmt, TransactionStmt))
- {
- TransactionStmt *stmt = (TransactionStmt *) query->utilityStmt;
-
- is_trans_stmt = true;
- if (stmt->kind == TRANS_STMT_COMMIT ||
- stmt->kind == TRANS_STMT_PREPARE ||
- stmt->kind == TRANS_STMT_ROLLBACK ||
- stmt->kind == TRANS_STMT_ROLLBACK_TO)
- is_trans_exit = true;
- }
- }
-
/*
* Create dest receiver in MessageContext (we don't want it in transaction
* context, because that may get deleted if portal contains VACUUM).
*/
start_xact_command();
+ /*
+ * If we re-issue an Execute protocol request against an existing portal,
+ * then we are only fetching more rows rather than completely re-executing
+ * the query from the start. atStart is never reset for a v3 portal, so we
+ * are safe to use this check.
+ */
+ execute_is_fetch = !portal->atStart;
+
+ /* Log immediately if dictated by log_statement */
+ if (check_log_statement(portal->stmts))
+ {
+ ereport(LOG,
+ (errmsg("%s %s%s%s%s%s",
+ execute_is_fetch ?
+ _("execute fetch from") :
+ _("execute"),
+ prepStmtName,
+ *portal_name ? "/" : "",
+ *portal_name ? portal_name : "",
+ sourceText ? ": " : "",
+ sourceText ? sourceText : ""),
+ errhidestmt(true),
+ errdetail_params(portalParams)));
+ was_logged = true;
+ }
+
/*
* If we are in aborted transaction state, the only portals we can
* actually run are those containing COMMIT or ROLLBACK commands.
*/
- if (IsAbortedTransactionBlockState())
- {
- if (!is_trans_exit)
- ereport(ERROR,
- (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
- errmsg("current transaction is aborted, "
+ if (IsAbortedTransactionBlockState() &&
+ !IsTransactionExitStmtList(portal->stmts))
+ ereport(ERROR,
+ (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
+ errmsg("current transaction is aborted, "
"commands ignored until end of transaction block")));
- }
/* Check for cancel signal before we start execution */
CHECK_FOR_INTERRUPTS();
completed = PortalRun(portal,
max_rows,
+ true, /* always top level */
receiver,
receiver,
completionTag);
if (completed)
{
- if (is_trans_stmt)
+ if (is_xact_command)
{
/*
* If this was a transaction control statement, commit it. We
else
{
/* Portal run not complete, so send PortalSuspended */
- if (whereToSendOutput == Remote)
+ if (whereToSendOutput == DestRemote)
pq_putemptymessage('s');
}
/*
- * Combine processing here as we need to calculate the query duration in
- * both instances.
+ * Emit duration logging if appropriate.
*/
- if (save_log_duration || save_log_min_duration_statement != -1)
+ switch (check_log_duration(msec_str, was_logged))
{
- long usecs;
+ case 1:
+ ereport(LOG,
+ (errmsg("duration: %s ms", msec_str),
+ errhidestmt(true)));
+ break;
+ case 2:
+ ereport(LOG,
+ (errmsg("duration: %s ms %s %s%s%s%s%s",
+ msec_str,
+ execute_is_fetch ?
+ _("execute fetch from") :
+ _("execute"),
+ prepStmtName,
+ *portal_name ? "/" : "",
+ *portal_name ? portal_name : "",
+ sourceText ? ": " : "",
+ sourceText ? sourceText : ""),
+ errhidestmt(true),
+ errdetail_params(portalParams)));
+ break;
+ }
- gettimeofday(&stop_t, NULL);
- if (stop_t.tv_usec < start_t.tv_usec)
- {
- stop_t.tv_sec--;
- stop_t.tv_usec += 1000000;
- }
- usecs = (long) (stop_t.tv_sec - start_t.tv_sec) * 1000000 +
- (long) (stop_t.tv_usec - start_t.tv_usec);
+ if (save_log_statement_stats)
+ ShowUsage("EXECUTE MESSAGE STATISTICS");
- /* Only print duration if we previously printed the statement. */
- if (log_statement == LOGSTMT_ALL && save_log_duration)
- ereport(LOG,
- (errmsg("duration: %ld.%03ld ms",
- (long) ((stop_t.tv_sec - start_t.tv_sec) * 1000 +
- (stop_t.tv_usec - start_t.tv_usec) / 1000),
- (long) (stop_t.tv_usec - start_t.tv_usec) % 1000)));
+ debug_query_string = NULL;
+}
+
+/*
+ * check_log_statement
+ * Determine whether command should be logged because of log_statement
+ *
+ * parsetree_list can be either raw grammar output or a list of planned
+ * statements
+ */
+static bool
+check_log_statement(List *stmt_list)
+{
+ ListCell *stmt_item;
+
+ if (log_statement == LOGSTMT_NONE)
+ return false;
+ if (log_statement == LOGSTMT_ALL)
+ return true;
+
+ /* Else we have to inspect the statement(s) to see whether to log */
+ foreach(stmt_item, stmt_list)
+ {
+ Node *stmt = (Node *) lfirst(stmt_item);
+
+ if (GetCommandLogLevel(stmt) <= log_statement)
+ return true;
+ }
+
+ return false;
+}
+
+/*
+ * check_log_duration
+ * Determine whether current command's duration should be logged
+ *
+ * Returns:
+ * 0 if no logging is needed
+ * 1 if just the duration should be logged
+ * 2 if duration and query details should be logged
+ *
+ * If logging is needed, the duration in msec is formatted into msec_str[],
+ * which must be a 32-byte buffer.
+ *
+ * was_logged should be TRUE if caller already logged query details (this
+ * essentially prevents 2 from being returned).
+ */
+int
+check_log_duration(char *msec_str, bool was_logged)
+{
+ if (log_duration || log_min_duration_statement >= 0)
+ {
+ long secs;
+ int usecs;
+ int msecs;
+ bool exceeded;
+
+ TimestampDifference(GetCurrentStatementStartTimestamp(),
+ GetCurrentTimestamp(),
+ &secs, &usecs);
+ msecs = usecs / 1000;
/*
- * Output a duration_statement to the log if the query has exceeded
- * the min duration, or if we are to print all durations.
+ * This odd-looking test for log_min_duration_statement being exceeded
+ * is designed to avoid integer overflow with very long durations:
+ * don't compute secs * 1000 until we've verified it will fit in int.
*/
- if (save_log_min_duration_statement == 0 ||
- (save_log_min_duration_statement > 0 &&
- usecs >= save_log_min_duration_statement * 1000))
- ereport(LOG,
- (errmsg("duration: %ld.%03ld ms statement: %sEXECUTE %s [PREPARE: %s]",
- (long) ((stop_t.tv_sec - start_t.tv_sec) * 1000 +
- (stop_t.tv_usec - start_t.tv_usec) / 1000),
- (long) (stop_t.tv_usec - start_t.tv_usec) % 1000,
- (execute_is_fetch) ? "FETCH from " : "",
- (*portal_name != '\0') ? portal_name : "<unnamed>",
- portal->sourceText ? portal->sourceText : "")));
+ exceeded = (log_min_duration_statement == 0 ||
+ (log_min_duration_statement > 0 &&
+ (secs > log_min_duration_statement / 1000 ||
+ secs * 1000 + msecs >= log_min_duration_statement)));
+
+ if (exceeded || log_duration)
+ {
+ snprintf(msec_str, 32, "%ld.%03d",
+ secs * 1000 + msecs, usecs % 1000);
+ if (exceeded && !was_logged)
+ return 2;
+ else
+ return 1;
+ }
}
- if (save_log_statement_stats)
- ShowUsage("QUERY STATISTICS");
+ return 0;
+}
- debug_query_string = NULL;
+/*
+ * errdetail_execute
+ *
+ * Add an errdetail() line showing the query referenced by an EXECUTE, if any.
+ * The argument is the raw parsetree list.
+ */
+static int
+errdetail_execute(List *raw_parsetree_list)
+{
+ ListCell *parsetree_item;
+
+ foreach(parsetree_item, raw_parsetree_list)
+ {
+ Node *parsetree = (Node *) lfirst(parsetree_item);
+
+ if (IsA(parsetree, ExecuteStmt))
+ {
+ ExecuteStmt *stmt = (ExecuteStmt *) parsetree;
+ PreparedStatement *pstmt;
+
+ pstmt = FetchPreparedStatement(stmt->name, false);
+ if (pstmt && pstmt->plansource->query_string)
+ {
+ errdetail("prepare: %s", pstmt->plansource->query_string);
+ return 0;
+ }
+ }
+ }
+
+ return 0;
+}
+
+/*
+ * errdetail_params
+ *
+ * Add an errdetail() line showing bind-parameter data, if available.
+ */
+static int
+errdetail_params(ParamListInfo params)
+{
+ /* We mustn't call user-defined I/O functions when in an aborted xact */
+ if (params && params->numParams > 0 && !IsAbortedTransactionBlockState())
+ {
+ StringInfoData param_str;
+ MemoryContext oldcontext;
+ int paramno;
+
+ /* Make sure any trash is generated in MessageContext */
+ oldcontext = MemoryContextSwitchTo(MessageContext);
+
+ initStringInfo(¶m_str);
+
+ for (paramno = 0; paramno < params->numParams; paramno++)
+ {
+ ParamExternData *prm = ¶ms->params[paramno];
+ Oid typoutput;
+ bool typisvarlena;
+ char *pstring;
+ char *p;
+
+ appendStringInfo(¶m_str, "%s$%d = ",
+ paramno > 0 ? ", " : "",
+ paramno + 1);
+
+ if (prm->isnull || !OidIsValid(prm->ptype))
+ {
+ appendStringInfoString(¶m_str, "NULL");
+ continue;
+ }
+
+ getTypeOutputInfo(prm->ptype, &typoutput, &typisvarlena);
+
+ pstring = OidOutputFunctionCall(typoutput, prm->value);
+
+ appendStringInfoCharMacro(¶m_str, '\'');
+ for (p = pstring; *p; p++)
+ {
+ if (*p == '\'') /* double single quotes */
+ appendStringInfoCharMacro(¶m_str, *p);
+ appendStringInfoCharMacro(¶m_str, *p);
+ }
+ appendStringInfoCharMacro(¶m_str, '\'');
+
+ pfree(pstring);
+ }
+
+ errdetail("parameters: %s", param_str.data);
+
+ pfree(param_str.data);
+
+ MemoryContextSwitchTo(oldcontext);
+ }
+
+ return 0;
}
/*
static void
exec_describe_statement_message(const char *stmt_name)
{
- PreparedStatement *pstmt;
- TupleDesc tupdesc;
- ListCell *l;
+ CachedPlanSource *psrc;
StringInfoData buf;
+ int i;
+
+ /*
+ * Start up a transaction command. (Note that this will normally change
+ * current memory context.) Nothing happens if we are already in one.
+ */
+ start_xact_command();
+
+ /* Switch back to message context */
+ MemoryContextSwitchTo(MessageContext);
/* Find prepared statement */
if (stmt_name[0] != '\0')
+ {
+ PreparedStatement *pstmt;
+
pstmt = FetchPreparedStatement(stmt_name, true);
+ psrc = pstmt->plansource;
+ }
else
{
/* special-case the unnamed statement */
- pstmt = unnamed_stmt_pstmt;
- if (!pstmt)
+ psrc = unnamed_stmt_psrc;
+ if (!psrc)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_PSTATEMENT),
errmsg("unnamed prepared statement does not exist")));
}
- if (whereToSendOutput != Remote)
+ /* Prepared statements shouldn't have changeable result descs */
+ Assert(psrc->fixed_result);
+
+ /*
+ * If we are in aborted transaction state, we can't run
+ * SendRowDescriptionMessage(), because that needs catalog accesses. (We
+ * can't do RevalidateCachedPlan, either, but that's a lesser problem.)
+ * Hence, refuse to Describe statements that return data. (We shouldn't
+ * just refuse all Describes, since that might break the ability of some
+ * clients to issue COMMIT or ROLLBACK commands, if they use code that
+ * blindly Describes whatever it does.) We can Describe parameters
+ * without doing anything dangerous, so we don't restrict that.
+ */
+ if (IsAbortedTransactionBlockState() &&
+ psrc->resultDesc)
+ ereport(ERROR,
+ (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
+ errmsg("current transaction is aborted, "
+ "commands ignored until end of transaction block")));
+
+ if (whereToSendOutput != DestRemote)
return; /* can't actually do anything... */
/*
* First describe the parameters...
*/
pq_beginmessage(&buf, 't'); /* parameter description message type */
- pq_sendint(&buf, list_length(pstmt->argtype_list), 2);
+ pq_sendint(&buf, psrc->num_params, 2);
- foreach(l, pstmt->argtype_list)
+ for (i = 0; i < psrc->num_params; i++)
{
- Oid ptype = lfirst_oid(l);
+ Oid ptype = psrc->param_types[i];
pq_sendint(&buf, (int) ptype, 4);
}
/*
* Next send RowDescription or NoData to describe the result...
*/
- tupdesc = FetchPreparedStatementResultDesc(pstmt);
- if (tupdesc)
- SendRowDescriptionMessage(tupdesc,
- FetchPreparedStatementTargetList(pstmt),
- NULL);
+ if (psrc->resultDesc)
+ {
+ CachedPlan *cplan;
+ List *tlist;
+
+ /* Make sure the plan is up to date */
+ cplan = RevalidateCachedPlan(psrc, true);
+
+ /* Get the primary statement and find out what it returns */
+ tlist = FetchStatementTargetList(PortalListGetPrimaryStmt(cplan->stmt_list));
+
+ SendRowDescriptionMessage(psrc->resultDesc, tlist, NULL);
+
+ ReleaseCachedPlan(cplan, true);
+ }
else
pq_putemptymessage('n'); /* NoData */
{
Portal portal;
+ /*
+ * Start up a transaction command. (Note that this will normally change
+ * current memory context.) Nothing happens if we are already in one.
+ */
+ start_xact_command();
+
+ /* Switch back to message context */
+ MemoryContextSwitchTo(MessageContext);
+
portal = GetPortalByName(portal_name);
if (!PortalIsValid(portal))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_CURSOR),
errmsg("portal \"%s\" does not exist", portal_name)));
- if (whereToSendOutput != Remote)
+ /*
+ * If we are in aborted transaction state, we can't run
+ * SendRowDescriptionMessage(), because that needs catalog accesses.
+ * Hence, refuse to Describe portals that return data. (We shouldn't just
+ * refuse all Describes, since that might break the ability of some
+ * clients to issue COMMIT or ROLLBACK commands, if they use code that
+ * blindly Describes whatever it does.)
+ */
+ if (IsAbortedTransactionBlockState() &&
+ portal->tupDesc)
+ ereport(ERROR,
+ (errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
+ errmsg("current transaction is aborted, "
+ "commands ignored until end of transaction block")));
+
+ if (whereToSendOutput != DestRemote)
return; /* can't actually do anything... */
if (portal->tupDesc)
StartTransactionCommand();
/* Set statement timeout running, if any */
+ /* NB: this mustn't be enabled until we are within an xact */
if (StatementTimeout > 0)
enable_sig_alarm(StatementTimeout, true);
else
#ifdef SHOW_MEMORY_STATS
/* Print mem stats after each commit for leak tracking */
- if (ShowStats)
- MemoryContextStats(TopMemoryContext);
+ MemoryContextStats(TopMemoryContext);
#endif
xact_started = false;
}
+/*
+ * Convenience routines for checking whether a statement is one of the
+ * ones that we allow in transaction-aborted state.
+ */
+
+/* Test a bare parsetree */
+static bool
+IsTransactionExitStmt(Node *parsetree)
+{
+ if (parsetree && IsA(parsetree, TransactionStmt))
+ {
+ TransactionStmt *stmt = (TransactionStmt *) parsetree;
+
+ if (stmt->kind == TRANS_STMT_COMMIT ||
+ stmt->kind == TRANS_STMT_PREPARE ||
+ stmt->kind == TRANS_STMT_ROLLBACK ||
+ stmt->kind == TRANS_STMT_ROLLBACK_TO)
+ return true;
+ }
+ return false;
+}
+
+/* Test a list that might contain Query nodes or bare parsetrees */
+static bool
+IsTransactionExitStmtList(List *parseTrees)
+{
+ if (list_length(parseTrees) == 1)
+ {
+ Node *stmt = (Node *) linitial(parseTrees);
+
+ if (IsA(stmt, Query))
+ {
+ Query *query = (Query *) stmt;
+
+ if (query->commandType == CMD_UTILITY &&
+ IsTransactionExitStmt(query->utilityStmt))
+ return true;
+ }
+ else if (IsTransactionExitStmt(stmt))
+ return true;
+ }
+ return false;
+}
+
+/* Test a list that might contain Query nodes or bare parsetrees */
+static bool
+IsTransactionStmtList(List *parseTrees)
+{
+ if (list_length(parseTrees) == 1)
+ {
+ Node *stmt = (Node *) linitial(parseTrees);
+
+ if (IsA(stmt, Query))
+ {
+ Query *query = (Query *) stmt;
+
+ if (query->commandType == CMD_UTILITY &&
+ IsA(query->utilityStmt, TransactionStmt))
+ return true;
+ }
+ else if (IsA(stmt, TransactionStmt))
+ return true;
+ }
+ return false;
+}
+
+/* Release any existing unnamed prepared statement */
+static void
+drop_unnamed_stmt(void)
+{
+ /* Release any completed unnamed statement */
+ if (unnamed_stmt_psrc)
+ DropCachedPlan(unnamed_stmt_psrc);
+ unnamed_stmt_psrc = NULL;
+
+ /*
+ * If we failed while trying to build a prior unnamed statement, we may
+ * have a memory context that wasn't assigned to a completed plancache
+ * entry. If so, drop it to avoid a permanent memory leak.
+ */
+ if (unnamed_stmt_context)
+ MemoryContextDelete(unnamed_stmt_context);
+ unnamed_stmt_context = NULL;
+}
+
+
/* --------------------------------
* signal handler routines used in PostgresMain()
* --------------------------------
* corrupted, so we don't want to try to clean up our transaction. Just
* nail the windows shut and get out of town.
*
- * Note we do exit(1) not exit(0). This is to force the postmaster into a
+ * Note we do exit(2) not exit(0). This is to force the postmaster into a
* system reset cycle if some idiot DBA sends a manual SIGQUIT to a random
* backend. This is necessary precisely because we don't clean up our
* shared memory state.
*/
- exit(1);
+ exit(2);
}
/*
/*
* Timeout or shutdown signal from postmaster during client authentication.
- * Simply exit(0).
+ * Simply exit(1).
*
* XXX: possible future improvement: try to send a message indicating
* why we are disconnecting. Problem is to be sure we don't block while
void
authdie(SIGNAL_ARGS)
{
- exit(0);
+ exit(1);
}
/*
ImmediateInterruptOK = false; /* not idle anymore */
DisableNotifyInterrupt();
DisableCatchupInterrupt();
- ereport(FATAL,
- (errcode(ERRCODE_ADMIN_SHUTDOWN),
+ if (IsAutoVacuumWorkerProcess())
+ ereport(FATAL,
+ (errcode(ERRCODE_ADMIN_SHUTDOWN),
+ errmsg("terminating autovacuum process due to administrator command")));
+ else
+ ereport(FATAL,
+ (errcode(ERRCODE_ADMIN_SHUTDOWN),
errmsg("terminating connection due to administrator command")));
}
if (QueryCancelPending)
* This should be called someplace in any recursive routine that might possibly
* recurse deep enough to overflow the stack. Most Unixen treat stack
* overflow as an unrecoverable SIGSEGV, so we want to error out ourselves
- * before hitting the hardware limit. Unfortunately we have no direct way
- * to detect the hardware limit, so we have to rely on the admin to set a
- * GUC variable for it ...
+ * before hitting the hardware limit.
*/
void
check_stack_depth(void)
{
char stack_top_loc;
- int stack_depth;
+ long stack_depth;
/*
* Compute distance from PostgresMain's local variables to my own
- *
- * Note: in theory stack_depth should be ptrdiff_t or some such, but since
- * the whole point of this code is to bound the value to something much
- * less than integer-sized, int should work fine.
*/
- stack_depth = (int) (stack_base_ptr - &stack_top_loc);
+ stack_depth = (long) (stack_base_ptr - &stack_top_loc);
/*
* Take abs value, since stacks grow up on some machines, down on others
/*
* Trouble?
*
- * The test on stack_base_ptr prevents us from erroring out if called during
- * process setup or in a non-backend process. Logically it should be done
- * first, but putting it here avoids wasting cycles during normal cases.
+ * The test on stack_base_ptr prevents us from erroring out if called
+ * during process setup or in a non-backend process. Logically it should
+ * be done first, but putting it here avoids wasting cycles during normal
+ * cases.
*/
if (stack_depth > max_stack_depth_bytes &&
stack_base_ptr != NULL)
ereport(ERROR,
(errcode(ERRCODE_STATEMENT_TOO_COMPLEX),
errmsg("stack depth limit exceeded"),
- errhint("Increase the configuration parameter \"max_stack_depth\".")));
+ errhint("Increase the configuration parameter \"max_stack_depth\", "
+ "after ensuring the platform's stack depth limit is adequate.")));
}
}
-/* GUC assign hook to update max_stack_depth_bytes from max_stack_depth */
+/* GUC assign hook for max_stack_depth */
bool
assign_max_stack_depth(int newval, bool doit, GucSource source)
{
- /* Range check was already handled by guc.c */
+ long newval_bytes = newval * 1024L;
+ long stack_rlimit = get_stack_depth_rlimit();
+
+ if (stack_rlimit > 0 && newval_bytes > stack_rlimit - STACK_DEPTH_SLOP)
+ {
+ ereport((source >= PGC_S_INTERACTIVE) ? ERROR : LOG,
+ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ errmsg("\"max_stack_depth\" must not exceed %ldkB",
+ (stack_rlimit - STACK_DEPTH_SLOP) / 1024L),
+ errhint("Increase the platform's stack depth limit via \"ulimit -s\" or local equivalent.")));
+ return false;
+ }
if (doit)
- max_stack_depth_bytes = newval * 1024;
+ max_stack_depth_bytes = newval_bytes;
return true;
}
-static void
-usage(const char *progname)
-{
- printf(_("%s is the PostgreSQL stand-alone backend. It is not\nintended to be used by normal users.\n\n"), progname);
-
- printf(_("Usage:\n %s [OPTION]... [DBNAME]\n\n"), progname);
- printf(_("Options:\n"));
-#ifdef USE_ASSERT_CHECKING
- printf(_(" -A 1|0 enable/disable run-time assert checking\n"));
-#endif
- printf(_(" -B NBUFFERS number of shared buffers\n"));
- printf(_(" -c NAME=VALUE set run-time parameter\n"));
- printf(_(" -d 0-5 debugging level (0 is off)\n"));
- printf(_(" -D DATADIR database directory\n"));
- printf(_(" -e use European date input format (DMY)\n"));
- printf(_(" -E echo query before execution\n"));
- printf(_(" -F turn fsync off\n"));
- printf(_(" -N do not use newline as interactive query delimiter\n"));
- printf(_(" -o FILENAME send stdout and stderr to given file\n"));
- printf(_(" -P disable system indexes\n"));
- printf(_(" -s show statistics after each query\n"));
- printf(_(" -S WORK-MEM set amount of memory for sorts (in kB)\n"));
- printf(_(" --describe-config describe configuration parameters, then exit\n"));
- printf(_(" --help show this help, then exit\n"));
- printf(_(" --version output version information, then exit\n"));
- printf(_("\nDeveloper options:\n"));
- printf(_(" -f s|i|n|m|h forbid use of some plan types\n"));
- printf(_(" -i do not execute queries\n"));
- printf(_(" -O allow system table structure changes\n"));
- printf(_(" -t pa|pl|ex show timings after each query\n"));
- printf(_(" -W NUM wait NUM seconds to allow attach from a debugger\n"));
- printf(_("\nReport bugs to <pgsql-bugs@postgresql.org>.\n"));
-}
-
-
/*
* set_debug_options --- apply "-d N" command line option
*
}
+bool
+set_plan_disabling_options(const char *arg, GucContext context, GucSource source)
+{
+ char *tmp = NULL;
+
+ switch (arg[0])
+ {
+ case 's': /* seqscan */
+ tmp = "enable_seqscan";
+ break;
+ case 'i': /* indexscan */
+ tmp = "enable_indexscan";
+ break;
+ case 'b': /* bitmapscan */
+ tmp = "enable_bitmapscan";
+ break;
+ case 't': /* tidscan */
+ tmp = "enable_tidscan";
+ break;
+ case 'n': /* nestloop */
+ tmp = "enable_nestloop";
+ break;
+ case 'm': /* mergejoin */
+ tmp = "enable_mergejoin";
+ break;
+ case 'h': /* hashjoin */
+ tmp = "enable_hashjoin";
+ break;
+ }
+ if (tmp)
+ {
+ SetConfigOption(tmp, "false", context, source);
+ return true;
+ }
+ else
+ return false;
+}
+
+
+const char *
+get_stats_option_name(const char *arg)
+{
+ switch (arg[0])
+ {
+ case 'p':
+ if (optarg[1] == 'a') /* "parser" */
+ return "log_parser_stats";
+ else if (optarg[1] == 'l') /* "planner" */
+ return "log_planner_stats";
+ break;
+
+ case 'e': /* "executor" */
+ return "log_executor_stats";
+ break;
+ }
+
+ return NULL;
+}
+
+
/* ----------------------------------------------------------------
* PostgresMain
* postgres main loop -- all backends, interactive or otherwise start here
GucContext ctx;
GucSource gucsource;
bool am_superuser;
- char *tmp;
int firstchar;
char stack_base;
StringInfoData input_message;
sigjmp_buf local_sigjmp_buf;
- volatile bool send_rfq = true;
+ volatile bool send_ready_for_query = true;
#define PendingConfigOption(name,val) \
(guc_names = lappend(guc_names, pstrdup(name)), \
guc_values = lappend(guc_values, pstrdup(val)))
- /*
- * Catch standard options before doing much else. This even works on
- * systems without getopt_long.
- */
- if (!IsUnderPostmaster && argc > 1)
- {
- if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
- {
- usage(argv[0]);
- exit(0);
- }
- if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
- {
- puts(PG_VERSIONSTR);
- exit(0);
- }
- }
-
/*
* initialize globals (already done if under postmaster, but not if
* standalone; cheap enough to do over)
*/
MyProcPid = getpid();
+ MyStartTime = time(NULL);
+
/*
* Fire up essential subsystems: error and memory management
*
if (!IsUnderPostmaster)
MemoryContextInit();
- set_ps_display("startup");
+ set_ps_display("startup", false);
SetProcessingMode(InitProcessing);
* ----------------
*/
+ /* Ignore the initial --single argument, if present */
+ if (argc > 1 && strcmp(argv[1], "--single") == 0)
+ {
+ argv++;
+ argc--;
+ }
+
/* all options are allowed until '-p' */
secure = true;
ctx = PGC_POSTMASTER;
gucsource = PGC_S_ARGV; /* initial switches came from command line */
- while ((flag = getopt(argc, argv, "A:B:c:D:d:Eef:FiNOPo:p:S:st:v:W:-:")) != -1)
+ /*
+ * Parse command-line options. CAUTION: keep this in sync with
+ * postmaster/postmaster.c (the option sets should not conflict) and with
+ * the common help() function in main/main.c.
+ */
+ while ((flag = getopt(argc, argv, "A:B:c:D:d:EeFf:h:ijk:lN:nOo:Pp:r:S:sTt:v:W:y:-:")) != -1)
{
switch (flag)
{
case 'A':
-#ifdef USE_ASSERT_CHECKING
SetConfigOption("debug_assertions", optarg, ctx, gucsource);
-#else
- ereport(WARNING,
- (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("assert checking is not compiled in")));
-#endif
break;
case 'B':
-
- /*
- * specify the size of buffer pool
- */
SetConfigOption("shared_buffers", optarg, ctx, gucsource);
break;
- case 'D': /* PGDATA or config directory */
+ case 'D':
if (secure)
userDoption = optarg;
break;
- case 'd': /* debug level */
+ case 'd':
debug_flag = atoi(optarg);
break;
case 'E':
-
- /*
- * E - echo the query the user entered
- */
EchoQuery = true;
break;
case 'e':
-
- /*
- * Use European date input format (DMY)
- */
SetConfigOption("datestyle", "euro", ctx, gucsource);
break;
case 'F':
-
- /*
- * turn off fsync
- */
SetConfigOption("fsync", "false", ctx, gucsource);
break;
case 'f':
+ if (!set_plan_disabling_options(optarg, ctx, gucsource))
+ errs++;
+ break;
- /*
- * f - forbid generation of certain plans
- */
- tmp = NULL;
- switch (optarg[0])
- {
- case 's': /* seqscan */
- tmp = "enable_seqscan";
- break;
- case 'i': /* indexscan */
- tmp = "enable_indexscan";
- break;
- case 'b': /* bitmapscan */
- tmp = "enable_bitmapscan";
- break;
- case 't': /* tidscan */
- tmp = "enable_tidscan";
- break;
- case 'n': /* nestloop */
- tmp = "enable_nestloop";
- break;
- case 'm': /* mergejoin */
- tmp = "enable_mergejoin";
- break;
- case 'h': /* hashjoin */
- tmp = "enable_hashjoin";
- break;
- default:
- errs++;
- }
- if (tmp)
- SetConfigOption(tmp, "false", ctx, gucsource);
+ case 'h':
+ SetConfigOption("listen_addresses", optarg, ctx, gucsource);
break;
- case 'N':
+ case 'i':
+ SetConfigOption("listen_addresses", "*", ctx, gucsource);
+ break;
- /*
- * N - Don't use newline as a query delimiter
- */
+ case 'j':
UseNewLine = 0;
break;
- case 'O':
+ case 'k':
+ SetConfigOption("unix_socket_directory", optarg, ctx, gucsource);
+ break;
- /*
- * allow system table structure modifications
- */
- if (secure) /* XXX safe to allow from client??? */
- allowSystemTableMods = true;
+ case 'l':
+ SetConfigOption("ssl", "true", ctx, gucsource);
break;
- case 'P':
+ case 'N':
+ SetConfigOption("max_connections", optarg, ctx, gucsource);
+ break;
- /*
- * ignore system indexes
- *
- * As of PG 7.4 this is safe to allow from the client, since it
- * only disables reading the system indexes, not writing them.
- * Worst case consequence is slowness.
- */
- IgnoreSystemIndexes(true);
+ case 'n':
+ /* ignored for consistency with postmaster */
+ break;
+
+ case 'O':
+ SetConfigOption("allow_system_table_mods", "true", ctx, gucsource);
break;
case 'o':
+ errs++;
+ break;
- /*
- * o - send output (stdout and stderr) to the given file
- */
- if (secure)
- StrNCpy(OutputFileName, optarg, MAXPGPATH);
+ case 'P':
+ SetConfigOption("ignore_system_indexes", "true", ctx, gucsource);
break;
case 'p':
+ SetConfigOption("port", optarg, ctx, gucsource);
+ break;
- /*
- * p - special flag passed if backend was forked by a
- * postmaster.
- */
+ case 'r':
+ /* send output (stdout and stderr) to the given file */
if (secure)
- {
- dbname = strdup(optarg);
-
- secure = false; /* subsequent switches are NOT secure */
- ctx = PGC_BACKEND;
- gucsource = PGC_S_CLIENT;
- }
+ strlcpy(OutputFileName, optarg, MAXPGPATH);
break;
case 'S':
-
- /*
- * S - amount of sort memory to use in 1k bytes
- */
SetConfigOption("work_mem", optarg, ctx, gucsource);
break;
case 's':
/*
- * s - report usage statistics (timings) after each query
- *
- * Since log options are SUSET, we need to postpone unless still
- * in secure context
+ * Since log options are SUSET, we need to postpone unless
+ * still in secure context
*/
if (ctx == PGC_BACKEND)
PendingConfigOption("log_statement_stats", "true");
ctx, gucsource);
break;
+ case 'T':
+ /* ignored for consistency with postmaster */
+ break;
+
case 't':
- /* ---------------
- * tell postgres to report usage statistics (timings) for
- * each query
- *
- * -tpa[rser] = print stats for parser time of each query
- * -tpl[anner] = print stats for planner time of each query
- * -te[xecutor] = print stats for executor time of each query
- * caution: -s can not be used together with -t.
- * ----------------
- */
- tmp = NULL;
- switch (optarg[0])
{
- case 'p':
- if (optarg[1] == 'a')
- tmp = "log_parser_stats";
- else if (optarg[1] == 'l')
- tmp = "log_planner_stats";
+ const char *tmp = get_stats_option_name(optarg);
+
+ if (tmp)
+ {
+ if (ctx == PGC_BACKEND)
+ PendingConfigOption(tmp, "true");
else
- errs++;
- break;
- case 'e':
- tmp = "log_executor_stats";
- break;
- default:
- errs++;
- break;
- }
- if (tmp)
- {
- if (ctx == PGC_BACKEND)
- PendingConfigOption(tmp, "true");
+ SetConfigOption(tmp, "true", ctx, gucsource);
+ }
else
- SetConfigOption(tmp, "true", ctx, gucsource);
+ errs++;
+ break;
}
- break;
case 'v':
if (secure)
break;
case 'W':
+ SetConfigOption("post_auth_delay", optarg, ctx, gucsource);
+ break;
+
+
+ case 'y':
/*
- * wait N seconds to allow attach from a debugger
+ * y - special flag passed if backend was forked by a
+ * postmaster.
*/
- pg_usleep(atoi(optarg) * 1000000L);
+ if (secure)
+ {
+ dbname = strdup(optarg);
+
+ secure = false; /* subsequent switches are NOT secure */
+ ctx = PGC_BACKEND;
+ gucsource = PGC_S_CLIENT;
+ }
break;
case 'c':
{
if (!SelectConfigFiles(userDoption, argv[0]))
proc_exit(1);
+ /* If timezone is not set, determine what the OS uses */
+ pg_timezone_initialize();
+ /* If timezone_abbreviations is not set, select default */
+ pg_timezone_abbrev_initialize();
}
+ if (PostAuthDelay)
+ pg_usleep(PostAuthDelay * 1000000L);
+
+ /*
+ * You might expect to see a setsid() call here, but it's not needed,
+ * because if we are under a postmaster then BackendInitialize() did it.
+ */
+
/*
* Set up signal handlers and masks.
*
- * Note that postmaster blocked all signals before forking child process, so
- * there is no race condition whereby we might receive a signal before we
- * have set up the handler.
+ * Note that postmaster blocked all signals before forking child process,
+ * so there is no race condition whereby we might receive a signal before
+ * we have set up the handler.
*
* Also note: it's best not to use any signals that are SIG_IGNored in the
* postmaster. If such a signal arrives before we are able to change the
pqsignal(SIGHUP, SigHupHandler); /* set flag to read config file */
pqsignal(SIGINT, StatementCancelHandler); /* cancel current query */
pqsignal(SIGTERM, die); /* cancel current query and exit */
- pqsignal(SIGQUIT, quickdie); /* hard crash time */
+
+ /*
+ * In a standalone backend, SIGQUIT can be generated from the keyboard
+ * easily, while SIGTERM cannot, so we make both signals do die() rather
+ * than quickdie().
+ */
+ if (IsUnderPostmaster)
+ pqsignal(SIGQUIT, quickdie); /* hard crash time */
+ else
+ pqsignal(SIGQUIT, die); /* cancel current query and exit */
pqsignal(SIGALRM, handle_sig_alarm); /* timeout conditions */
/*
pqinitmask();
- /* We allow SIGQUIT (quickdie) at all times */
+ if (IsUnderPostmaster)
+ {
+ /* We allow SIGQUIT (quickdie) at all times */
#ifdef HAVE_SIGPROCMASK
- sigdelset(&BlockSig, SIGQUIT);
+ sigdelset(&BlockSig, SIGQUIT);
#else
- BlockSig &= ~(sigmask(SIGQUIT));
+ BlockSig &= ~(sigmask(SIGQUIT));
#endif
+ }
PG_SETMASK(&BlockSig); /* block everything except SIGQUIT */
-
if (IsUnderPostmaster)
{
/* noninteractive case: nothing should be left after switches */
BuildFlatFiles(true);
}
+ /*
+ * Create a per-backend PGPROC struct in shared memory, except in the
+ * EXEC_BACKEND case where this was done in SubPostmasterMain. We must do
+ * this before we can use LWLocks (and in the EXEC_BACKEND case we already
+ * had to do some stuff with LWLocks).
+ */
+#ifdef EXEC_BACKEND
+ if (!IsUnderPostmaster)
+ InitProcess();
+#else
+ InitProcess();
+#endif
+
/*
* General initialization.
*
- * NOTE: if you are tempted to add code in this vicinity, consider putting it
- * inside InitPostgres() instead. In particular, anything that involves
- * database access should be there, not here.
+ * NOTE: if you are tempted to add code in this vicinity, consider putting
+ * it inside InitPostgres() instead. In particular, anything that
+ * involves database access should be there, not here.
*/
ereport(DEBUG3,
(errmsg_internal("InitPostgres")));
- am_superuser = InitPostgres(dbname, username);
+ am_superuser = InitPostgres(dbname, InvalidOid, username, NULL);
SetProcessingMode(NormalProcessing);
if (IsUnderPostmaster && Log_disconnections)
on_proc_exit(log_disconnections, 0);
+ /*
+ * process any libraries that should be preloaded at backend start (this
+ * likewise can't be done until GUC settings are complete)
+ */
+ process_local_preload_libraries();
+
/*
* Send this backend's cancellation info to the frontend.
*/
- if (whereToSendOutput == Remote &&
+ if (whereToSendOutput == DestRemote &&
PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
{
StringInfoData buf;
}
/* Welcome banner for standalone case */
- if (whereToSendOutput == Debug)
+ if (whereToSendOutput == DestDebug)
printf("\nPostgreSQL stand-alone backend %s\n", PG_VERSION);
/*
* If an exception is encountered, processing resumes here so we abort the
* current transaction and start a new one.
*
- * You might wonder why this isn't coded as an infinite loop around a PG_TRY
- * construct. The reason is that this is the bottom of the exception
- * stack, and so with PG_TRY there would be no exception handler in force
- * at all during the CATCH part. By leaving the outermost setjmp always
- * active, we have at least some chance of recovering from an error during
- * error recovery. (If we get into an infinite loop thereby, it will soon
- * be stopped by overflow of elog.c's internal state stack.)
+ * You might wonder why this isn't coded as an infinite loop around a
+ * PG_TRY construct. The reason is that this is the bottom of the
+ * exception stack, and so with PG_TRY there would be no exception handler
+ * in force at all during the CATCH part. By leaving the outermost setjmp
+ * always active, we have at least some chance of recovering from an error
+ * during error recovery. (If we get into an infinite loop thereby, it
+ * will soon be stopped by overflow of elog.c's internal state stack.)
*/
if (sigsetjmp(local_sigjmp_buf, 1) != 0)
*/
MemoryContextSwitchTo(TopMemoryContext);
FlushErrorState();
- QueryContext = NULL;
/*
* If we were handling an extended-query-protocol message, initiate
PG_SETMASK(&UnBlockSig);
if (!ignore_till_sync)
- send_rfq = true; /* initially, or after error */
+ send_ready_for_query = true; /* initially, or after error */
/*
* Non-error queries loop here.
* processing of batched messages, and because we don't want to report
* uncommitted updates (that confuses autovacuum).
*/
- if (send_rfq)
+ if (send_ready_for_query)
{
if (IsTransactionOrTransactionBlock())
{
- set_ps_display("idle in transaction");
+ set_ps_display("idle in transaction", false);
pgstat_report_activity("<IDLE> in transaction");
}
else
{
- pgstat_report_tabstat();
+ pgstat_report_tabstat(false);
- set_ps_display("idle");
+ set_ps_display("idle", false);
pgstat_report_activity("<IDLE>");
}
ReadyForQuery(whereToSendOutput);
- send_rfq = false;
+ send_ready_for_query = false;
}
/*
{
const char *query_string;
+ /* Set statement_timestamp() */
+ SetCurrentStatementStartTimestamp();
+
query_string = pq_getmsgstring(&input_message);
pq_getmsgend(&input_message);
exec_simple_query(query_string);
- send_rfq = true;
+ send_ready_for_query = true;
}
break;
int numParams;
Oid *paramTypes = NULL;
+ /* Set statement_timestamp() */
+ SetCurrentStatementStartTimestamp();
+
stmt_name = pq_getmsgstring(&input_message);
query_string = pq_getmsgstring(&input_message);
numParams = pq_getmsgint(&input_message, 2);
break;
case 'B': /* bind */
+ /* Set statement_timestamp() */
+ SetCurrentStatementStartTimestamp();
/*
* this message is complex enough that it seems best to put
const char *portal_name;
int max_rows;
+ /* Set statement_timestamp() */
+ SetCurrentStatementStartTimestamp();
+
portal_name = pq_getmsgstring(&input_message);
max_rows = pq_getmsgint(&input_message, 4);
pq_getmsgend(&input_message);
break;
case 'F': /* fastpath function call */
+ /* Set statement_timestamp() */
+ SetCurrentStatementStartTimestamp();
+
/* Tell the collector what we're doing */
pgstat_report_activity("<FASTPATH> function call");
/* start an xact for this function invocation */
start_xact_command();
+ /*
+ * Note: we may at this point be inside an aborted
+ * transaction. We can't throw error for that until we've
+ * finished reading the function-call message, so
+ * HandleFunctionRequest() must check for it after doing so.
+ * Be careful not to do anything that assumes we're inside a
+ * valid transaction here.
+ */
+
/* switch back to message context */
MemoryContextSwitchTo(MessageContext);
- /* set snapshot in case function needs one */
- ActiveSnapshot = CopySnapshot(GetTransactionSnapshot());
-
if (HandleFunctionRequest(&input_message) == EOF)
{
/* lost frontend connection during F message input */
* Reset whereToSendOutput to prevent ereport from
* attempting to send any more messages to client.
*/
- if (whereToSendOutput == Remote)
- whereToSendOutput = None;
+ if (whereToSendOutput == DestRemote)
+ whereToSendOutput = DestNone;
proc_exit(0);
}
/* commit the function-invocation transaction */
finish_xact_command();
- send_rfq = true;
+ send_ready_for_query = true;
break;
case 'C': /* close */
else
{
/* special-case the unnamed statement */
- unnamed_stmt_pstmt = NULL;
- if (unnamed_stmt_context)
- {
- DropDependentPortals(unnamed_stmt_context);
- MemoryContextDelete(unnamed_stmt_context);
- }
- unnamed_stmt_context = NULL;
+ drop_unnamed_stmt();
}
break;
case 'P':
break;
}
- if (whereToSendOutput == Remote)
+ if (whereToSendOutput == DestRemote)
pq_putemptymessage('3'); /* CloseComplete */
}
break;
int describe_type;
const char *describe_target;
+ /* Set statement_timestamp() (needed for xact) */
+ SetCurrentStatementStartTimestamp();
+
describe_type = pq_getmsgbyte(&input_message);
describe_target = pq_getmsgstring(&input_message);
pq_getmsgend(&input_message);
case 'H': /* flush */
pq_getmsgend(&input_message);
- if (whereToSendOutput == Remote)
+ if (whereToSendOutput == DestRemote)
pq_flush();
break;
case 'S': /* sync */
pq_getmsgend(&input_message);
finish_xact_command();
- send_rfq = true;
+ send_ready_for_query = true;
break;
/*
* Reset whereToSendOutput to prevent ereport from attempting
* to send any more messages to client.
*/
- if (whereToSendOutput == Remote)
- whereToSendOutput = None;
+ if (whereToSendOutput == DestRemote)
+ whereToSendOutput = DestNone;
/*
* NOTE: if you are tempted to add more code here, DON'T!
return 1; /* keep compiler quiet */
}
-#ifndef HAVE_GETRUSAGE
-#include "rusagestub.h"
-#else
-#include <sys/resource.h>
-#endif /* HAVE_GETRUSAGE */
+
+/*
+ * Obtain platform stack depth limit (in bytes)
+ *
+ * Return -1 if unlimited or not known
+ */
+long
+get_stack_depth_rlimit(void)
+{
+#if defined(HAVE_GETRLIMIT) && defined(RLIMIT_STACK)
+ static long val = 0;
+
+ /* This won't change after process launch, so check just once */
+ if (val == 0)
+ {
+ struct rlimit rlim;
+
+ if (getrlimit(RLIMIT_STACK, &rlim) < 0)
+ val = -1;
+ else if (rlim.rlim_cur == RLIM_INFINITY)
+ val = -1;
+ else
+ val = rlim.rlim_cur;
+ }
+ return val;
+#else /* no getrlimit */
+#if defined(WIN32) || defined(__CYGWIN__)
+ /* On Windows we set the backend stack size in src/backend/Makefile */
+ return WIN32_STACK_RLIMIT;
+#else /* not windows ... give up */
+ return -1;
+#endif
+#endif
+}
+
static struct rusage Save_r;
static struct timeval Save_t;
(long) user.tv_usec,
(long) sys.tv_sec,
(long) sys.tv_usec);
-/* BeOS has rusage but only has some fields, and not these... */
#if defined(HAVE_GETRUSAGE)
appendStringInfo(&str,
"!\t%ld/%ld [%ld/%ld] filesystem blocks in/out\n",
log_disconnections(int code, Datum arg)
{
Port *port = MyProcPort;
- struct timeval end;
+ long secs;
+ int usecs;
+ int msecs;
int hours,
minutes,
seconds;
- gettimeofday(&end, NULL);
- if (end.tv_usec < port->session_start.tv_usec)
- {
- end.tv_sec--;
- end.tv_usec += 1000000;
- }
- end.tv_sec -= port->session_start.tv_sec;
- end.tv_usec -= port->session_start.tv_usec;
+ TimestampDifference(port->SessionStartTime,
+ GetCurrentTimestamp(),
+ &secs, &usecs);
+ msecs = usecs / 1000;
- /* for stricter accuracy here we could round - this is close enough */
- hours = end.tv_sec / SECS_PER_HOUR;
- end.tv_sec %= SECS_PER_HOUR;
- minutes = end.tv_sec / SECS_PER_MINUTE;
- seconds = end.tv_sec % SECS_PER_MINUTE;
+ hours = secs / SECS_PER_HOUR;
+ secs %= SECS_PER_HOUR;
+ minutes = secs / SECS_PER_MINUTE;
+ seconds = secs % SECS_PER_MINUTE;
ereport(LOG,
- (errmsg("disconnection: session time: %d:%02d:%02d.%02d "
+ (errmsg("disconnection: session time: %d:%02d:%02d.%03d "
"user=%s database=%s host=%s%s%s",
- hours, minutes, seconds, (int) (end.tv_usec / 10000),
+ hours, minutes, seconds, msecs,
port->user_name, port->database_name, port->remote_host,
port->remote_port[0] ? " port=" : "", port->remote_port)));
}
projects / postgresql / blobdiff