* postgres.c
* POSTGRES C Backend Interface
*
- * Portions Copyright (c) 1996-2006, 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.500 2006/08/29 02:11:29 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/xact.h"
#include "catalog/pg_type.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"
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. This is not static
* 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
*
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 */
+ List *new_list = (List *) copyObject(raw_parsetree_list);
- 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;
-
- /*
- * For the first EXECUTE we find, record the client statement used by
- * the PREPARE. PREPARE doesn't save the parse tree so we have no
- * way to conditionally output based on the type of query prepared.
- * Parse does save the command tag, so perhaps we can use that.
- */
- if (IsA(parsetree, ExecuteStmt))
- {
- ExecuteStmt *stmt = (ExecuteStmt *) parsetree;
- PreparedStatement *entry;
-
- if (*prepare_string == NULL &&
- (entry = FetchPreparedStatement(stmt->name, false)) != NULL &&
- entry->query_string)
- *prepare_string = pstrdup(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", query_string),
- *prepare_string ? errdetail("prepare: %s",
- *prepare_string) : 0));
- 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.
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, query_string,
- 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;
}
List *parsetree_list;
ListCell *parsetree_item;
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.
* 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);
/* Log immediately if dictated by log_statement */
- was_logged = log_after_parse(parsetree_list, query_string, &prepare_string);
+ 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.
*/
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();
PortalDefineQuery(portal,
NULL,
query_string,
- NULL,
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;
-
/*
* Emit duration logging if appropriate.
*/
- if (log_duration || log_min_duration_statement >= 0)
+ switch (check_log_duration(msec_str, was_logged))
{
- long secs;
- int usecs;
- int msecs;
-
- TimestampDifference(GetCurrentStatementStartTimestamp(),
- GetCurrentTimestamp(),
- &secs, &usecs);
- msecs = usecs / 1000;
-
- /*
- * The 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 (log_duration ||
- log_min_duration_statement == 0 ||
- (log_min_duration_statement > 0 &&
- (secs > log_min_duration_statement / 1000 ||
- secs * 1000 + msecs >= log_min_duration_statement)))
- {
- if (was_logged)
- ereport(LOG,
- (errmsg("duration: %ld.%03d ms",
- secs * 1000 + msecs, usecs % 1000)));
- else
- ereport(LOG,
- (errmsg("duration: %ld.%03d ms statement: %s",
- secs * 1000 + msecs, usecs % 1000,
- query_string),
- prepare_string ? errdetail("prepare: %s",
- prepare_string) : 0));
- }
+ case 1:
+ ereport(LOG,
+ (errmsg("duration: %s ms", msec_str),
+ errhidestmt(true)));
+ break;
+ case 2:
+ ereport(LOG,
+ (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.
if (save_log_statement_stats)
ResetUsage();
- if (log_statement == LOGSTMT_ALL)
- ereport(LOG,
- (errmsg("statement: prepare %s, %s",
- *stmt_name ? 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
* state, but not many...)
*/
if (IsAbortedTransactionBlockState() &&
- !IsTransactionExitStmt(parsetree))
+ !IsTransactionExitStmt(raw_parse_tree))
ereport(ERROR,
(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
errmsg("current transaction is aborted, "
* 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,
- query_string,
- ¶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->from_sql = false;
- 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
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;
- PreparedStatement *pstmt;
+ CachedPlanSource *psrc;
+ CachedPlan *cplan;
Portal portal;
ParamListInfo params;
- StringInfoData bind_values_str;
+ List *plan_list;
+ bool save_log_statement_stats = log_statement_stats;
+ char msec_str[32];
- pgstat_report_activity("<BIND>");
+ /* 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(debug_query_string);
set_ps_display("BIND", false);
+ if (save_log_statement_stats)
+ ResetUsage();
+
/*
* Start up a transaction command so we can call functions etc. (Note that
* this will normally change current memory context.) Nothing happens if
/* Switch back to message context */
MemoryContextSwitchTo(MessageContext);
- initStringInfo(&bind_values_str);
-
- /* 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;
-
+ 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
* functions.
*/
if (IsAbortedTransactionBlockState() &&
- (!IsTransactionExitStmtList(pstmt->query_list) ||
+ (!IsTransactionExitStmt(psrc->raw_parse_tree) ||
numParams != 0))
ereport(ERROR,
(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
*/
if (numParams > 0)
{
- ListCell *l;
MemoryContext oldContext;
int paramno;
/* sizeof(ParamListInfoData) includes the first array element */
params = (ParamListInfo) palloc(sizeof(ParamListInfoData) +
- (numParams - 1) * sizeof(ParamExternData));
+ (numParams - 1) *sizeof(ParamExternData));
params->numParams = numParams;
- paramno = 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;
{
Oid typinput;
Oid typioparam;
- char *pstring, *p;
+ char *pstring;
getTypeInputInfo(ptype, &typinput, &typioparam);
else
pstring = pg_client_to_server(pbuf.data, plength);
- params->params[paramno].value =
- OidInputFunctionCall(typinput,
- pstring,
- typioparam,
- -1);
-
- /* Save the parameter values */
- appendStringInfo(&bind_values_str, "%s$%d = '",
- bind_values_str.len ? ", " : "",
- paramno + 1);
- for (p = pstring; *p; p++)
- {
- if (*p == '\'') /* double single quotes */
- appendStringInfoChar(&bind_values_str, *p);
- appendStringInfoChar(&bind_values_str, *p);
- }
- appendStringInfoChar(&bind_values_str, '\'');
+ pval = OidInputFunctionCall(typinput, pstring, typioparam, -1);
/* Free result of encoding conversion, if any */
if (pstring && pstring != pbuf.data)
pfree(pstring);
}
- else if (pformat == 1) /* binary mode */
+ else if (pformat == 1) /* binary mode */
{
Oid typreceive;
Oid typioparam;
else
bufptr = &pbuf;
- params->params[paramno].value = OidReceiveFunctionCall(typreceive,
- bufptr,
- typioparam,
- -1);
+ pval = OidReceiveFunctionCall(typreceive, bufptr, typioparam, -1);
/* Trouble if it didn't eat the whole buffer */
if (!isNull && pbuf.cursor != pbuf.len)
(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
errmsg("incorrect binary data format in bind parameter %d",
paramno + 1)));
-
- /* XXX TODO: convert value to text and log it */
}
else
{
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("unsupported format code: %d",
pformat)));
+ pval = 0; /* keep compiler quiet */
}
/* Restore message buffer contents */
if (!isNull)
pbuf.data[plength] = csave;
+ params->params[paramno].value = pval;
params->params[paramno].isnull = isNull;
- params->params[paramno].ptype = ptype;
- paramno++;
+ /*
+ * 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);
else
params = NULL;
- if (log_statement == LOGSTMT_ALL)
- {
- ereport(LOG,
- (errmsg("statement: bind %s%s%s%s%s",
- *stmt_name ? stmt_name : "<unnamed>",
- *portal->name ? "/" : "",
- *portal->name ? portal->name : "",
- /* print bind parameters if we have them */
- bind_values_str.len ? ", " : "",
- bind_values_str.len ? bind_values_str.data : ""),
- errdetail("prepare: %s", pstmt->query_string)));
- }
-
/* Get the result format codes */
numRFormats = pq_getmsgint(input_message, 2);
if (numRFormats > 0)
{
- int i;
+ int i;
rformats = (int16 *) palloc(numRFormats * sizeof(int16));
for (i = 0; i < numRFormats; i++)
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)
+ if (psrc->fully_planned)
{
- MemoryContext oldContext = MemoryContextSwitchTo(pstmt->context);
+ /*
+ * 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;
+ 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,
- *stmt_name ? pstrdup(stmt_name) : NULL,
- pstmt->query_string,
- bind_values_str.len ? pstrdup(bind_values_str.data) : NULL,
- 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);
*/
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;
}
/*
Portal portal;
bool completed;
char completionTag[COMPLETION_TAG_BUFSIZE];
- const char *sourceText = NULL;
- const char *bindText = NULL;
+ const char *sourceText;
const char *prepStmtName;
+ ParamListInfo portalParams;
bool save_log_statement_stats = log_statement_stats;
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 (portal->commandTag == NULL)
{
- Assert(portal->parseTrees == NIL);
+ Assert(portal->stmts == NIL);
NullCommand(dest);
return;
}
/* Does the portal contain a transaction command? */
- is_xact_command = IsTransactionStmtList(portal->parseTrees);
+ is_xact_command = IsTransactionStmtList(portal->stmts);
/*
- * 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.
+ * 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.
*/
- execute_is_fetch = !portal->atStart;
-
- /* Should we display the portal names here? */
- if (execute_is_fetch)
+ if (is_xact_command)
{
- debug_query_string = "fetch message";
- pgstat_report_activity("<FETCH>");
+ 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>");
- }
-
- set_ps_display(portal->commandTag, false);
-
- /* copy prepStmtName now too, in case portal is destroyed */
- if (portal->prepStmtName)
- prepStmtName = pstrdup(portal->prepStmtName);
- else
- prepStmtName = "<unnamed>";
-
- /*
- * We must copy the sourceText and bindText 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)
- sourceText = pstrdup(portal->sourceText);
- else
sourceText = portal->sourceText;
-
- if (portal->bindText)
- {
- if (is_xact_command)
- bindText = pstrdup(portal->bindText);
+ if (portal->prepStmtName)
+ prepStmtName = portal->prepStmtName;
else
- bindText = portal->bindText;
+ prepStmtName = "<unnamed>";
+ portalParams = portal->portalParams;
}
-
+
/*
- * We use save_log_statement_stats so ShowUsage doesn't report incorrect
- * results because ResetUsage wasn't called.
+ * Report query to various monitoring facilities.
*/
+ 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)
- ereport(LOG,
- (errmsg("statement: execute %s%s%s%s",
- execute_is_fetch ? "fetch from " : "",
- prepStmtName,
- *portal_name ? "/" : "",
- *portal_name ? portal_name : ""),
- errdetail("prepare: %s%s%s", sourceText,
- /* optionally print bind parameters */
- bindText ? " bind: " : "",
- bindText ? bindText : "")));
-
BeginCommand(portal->commandTag, dest);
/*
*/
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() &&
- !IsTransactionExitStmtList(portal->parseTrees))
+ !IsTransactionExitStmtList(portal->stmts))
ereport(ERROR,
(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
errmsg("current transaction is aborted, "
completed = PortalRun(portal,
max_rows,
+ true, /* always top level */
receiver,
receiver,
completionTag);
/*
* Emit duration logging if appropriate.
*/
+ switch (check_log_duration(msec_str, was_logged))
+ {
+ 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;
+ }
+
+ if (save_log_statement_stats)
+ ShowUsage("EXECUTE MESSAGE STATISTICS");
+
+ 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(),
msecs = usecs / 1000;
/*
- * The 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.
+ * 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 (log_duration ||
- log_min_duration_statement == 0 ||
- (log_min_duration_statement > 0 &&
- (secs > log_min_duration_statement / 1000 ||
- secs * 1000 + msecs >= log_min_duration_statement)))
+ 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)
{
- if (log_statement == LOGSTMT_ALL) /* already logged? */
- ereport(LOG,
- (errmsg("duration: %ld.%03d ms",
- secs * 1000 + msecs, usecs % 1000)));
+ snprintf(msec_str, 32, "%ld.%03d",
+ secs * 1000 + msecs, usecs % 1000);
+ if (exceeded && !was_logged)
+ return 2;
else
- ereport(LOG,
- (errmsg("duration: %ld.%03d ms execute %s%s%s%s",
- secs * 1000 + msecs, usecs % 1000,
- execute_is_fetch ? "fetch from " : "",
- prepStmtName,
- *portal_name ? "/" : "",
- *portal_name ? portal_name : ""),
- errdetail("prepare: %s%s%s", sourceText,
- /* optionally print bind parameters */
- bindText ? " bind: " : "",
- bindText ? bindText : "")));
+ 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
/* 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")));
}
+ /* Prepared statements shouldn't have changeable result descs */
+ Assert(psrc->fixed_result);
+
/*
- * If we are in aborted transaction state, we can't safely create a result
- * tupledesc, because that needs catalog accesses. 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 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() &&
- PreparedStatementReturnsTuples(pstmt))
+ psrc->resultDesc)
ereport(ERROR,
(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
errmsg("current transaction is aborted, "
* 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 */
/*
* 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
+ * 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.)
#ifdef SHOW_MEMORY_STATS
/* Print mem stats after each commit for leak tracking */
- if (ShowStats)
- MemoryContextStats(TopMemoryContext);
+ MemoryContextStats(TopMemoryContext);
#endif
xact_started = false;
* ones that we allow in transaction-aborted state.
*/
+/* Test a bare parsetree */
static bool
IsTransactionExitStmt(Node *parsetree)
{
return false;
}
+/* Test a list that might contain Query nodes or bare parsetrees */
static bool
IsTransactionExitStmtList(List *parseTrees)
{
if (list_length(parseTrees) == 1)
{
- Query *query = (Query *) linitial(parseTrees);
+ Node *stmt = (Node *) linitial(parseTrees);
+
+ if (IsA(stmt, Query))
+ {
+ Query *query = (Query *) stmt;
- if (query->commandType == CMD_UTILITY &&
- IsTransactionExitStmt(query->utilityStmt))
+ 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)
{
- Query *query = (Query *) linitial(parseTrees);
+ Node *stmt = (Node *) linitial(parseTrees);
- if (query->commandType == CMD_UTILITY &&
- query->utilityStmt && IsA(query->utilityStmt, TransactionStmt))
+ 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
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;
}
bool
set_plan_disabling_options(const char *arg, GucContext context, GucSource source)
{
- char *tmp = NULL;
+ char *tmp = NULL;
switch (arg[0])
{
- case 's': /* seqscan */
+ case 's': /* seqscan */
tmp = "enable_seqscan";
break;
- case 'i': /* indexscan */
+ case 'i': /* indexscan */
tmp = "enable_indexscan";
break;
- case 'b': /* bitmapscan */
+ case 'b': /* bitmapscan */
tmp = "enable_bitmapscan";
break;
- case 't': /* tidscan */
+ case 't': /* tidscan */
tmp = "enable_tidscan";
break;
- case 'n': /* nestloop */
+ case 'n': /* nestloop */
tmp = "enable_nestloop";
break;
- case 'm': /* mergejoin */
+ case 'm': /* mergejoin */
tmp = "enable_mergejoin";
break;
- case 'h': /* hashjoin */
+ case 'h': /* hashjoin */
tmp = "enable_hashjoin";
break;
}
switch (arg[0])
{
case 'p':
- if (optarg[1] == 'a') /* "parser" */
+ if (optarg[1] == 'a') /* "parser" */
return "log_parser_stats";
- else if (optarg[1] == 'l') /* "planner" */
+ else if (optarg[1] == 'l') /* "planner" */
return "log_planner_stats";
break;
- case 'e': /* "executor" */
+ case 'e': /* "executor" */
return "log_executor_stats";
break;
}
*/
MyProcPid = getpid();
+ MyStartTime = time(NULL);
+
/*
* Fire up essential subsystems: error and memory management
*
ctx = PGC_POSTMASTER;
gucsource = PGC_S_ARGV; /* initial switches came from command line */
+ /*
+ * 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 'r':
/* send output (stdout and stderr) to the given file */
if (secure)
- StrNCpy(OutputFileName, optarg, MAXPGPATH);
+ strlcpy(OutputFileName, optarg, MAXPGPATH);
break;
case 'S':
break;
case 's':
+
/*
* Since log options are SUSET, we need to postpone unless
* still in secure context
break;
case 't':
- {
- const char *tmp = get_stats_option_name(optarg);
- if (tmp)
{
- if (ctx == PGC_BACKEND)
- PendingConfigOption(tmp, "true");
+ const char *tmp = get_stats_option_name(optarg);
+
+ if (tmp)
+ {
+ if (ctx == PGC_BACKEND)
+ PendingConfigOption(tmp, "true");
+ else
+ SetConfigOption(tmp, "true", ctx, gucsource);
+ }
else
- SetConfigOption(tmp, "true", ctx, gucsource);
+ errs++;
+ break;
}
- else
- errs++;
- break;
- }
case 'v':
if (secure)
case 'y':
+
/*
* y - special flag passed if backend was forked by a
* postmaster.
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.
*
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 */
}
/*
- * 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).
+ * 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)
*/
ereport(DEBUG3,
(errmsg_internal("InitPostgres")));
- am_superuser = InitPostgres(dbname, username);
+ am_superuser = InitPostgres(dbname, InvalidOid, username, NULL);
SetProcessingMode(NormalProcessing);
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 any libraries that should be preloaded at backend start (this
+ * likewise can't be done until GUC settings are complete)
*/
process_local_preload_libraries();
*/
MemoryContextSwitchTo(TopMemoryContext);
FlushErrorState();
- QueryContext = NULL;
/*
* If we were handling an extended-query-protocol message, initiate
PG_SETMASK(&UnBlockSig);
if (!ignore_till_sync)
- send_ready_for_query = true; /* initially, or after error */
+ send_ready_for_query = true; /* initially, or after error */
/*
* Non-error queries loop here.
}
else
{
- pgstat_report_tabstat();
+ pgstat_report_tabstat(false);
set_ps_display("idle", false);
pgstat_report_activity("<IDLE>");
/*
* 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
+ * 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.
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':
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;
"user=%s database=%s host=%s%s%s",
hours, minutes, seconds, msecs,
port->user_name, port->database_name, port->remote_host,
- port->remote_port[0] ? " port=" : "", port->remote_port)));
+ port->remote_port[0] ? " port=" : "", port->remote_port)));
}
projects / postgresql / blobdiff