postgres.c 84.4 KB
Newer Older
1 2
/*-------------------------------------------------------------------------
 *
3
 * postgres.c
4
 *	  POSTGRES C Backend Interface
5
 *
Bruce Momjian's avatar
Bruce Momjian committed
6
 * Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
Bruce Momjian's avatar
Add:  
Bruce Momjian committed
7
 * Portions Copyright (c) 1994, Regents of the University of California
8 9 10
 *
 *
 * IDENTIFICATION
11
 *	  $PostgreSQL: pgsql/src/backend/tcop/postgres.c,v 1.404 2004/05/12 13:38:40 momjian Exp $
12 13
 *
 * NOTES
14 15
 *	  this is the "main" module of the postgres backend and
 *	  hence the main module of the "traffic cop".
16 17 18
 *
 *-------------------------------------------------------------------------
 */
Bruce Momjian's avatar
Bruce Momjian committed
19

20 21
#include "postgres.h"

Bruce Momjian's avatar
Bruce Momjian committed
22
#include <unistd.h>
23
#include <signal.h>
24 25
#include <time.h>
#include <sys/time.h>
Bruce Momjian's avatar
Bruce Momjian committed
26
#include <fcntl.h>
27
#include <sys/socket.h>
28
#include <errno.h>
29
#if HAVE_SYS_SELECT_H
30
#include <sys/select.h>
31
#endif
32
#ifdef HAVE_GETOPT_H
Bruce Momjian's avatar
Bruce Momjian committed
33
#include <getopt.h>
34
#endif
35

36
#include "access/printtup.h"
37
#include "access/xlog.h"
38
#include "catalog/pg_type.h"
39
#include "commands/async.h"
40
#include "commands/prepare.h"
41
#include "commands/trigger.h"
42
#include "libpq/libpq.h"
43
#include "libpq/pqformat.h"
44
#include "libpq/pqsignal.h"
Bruce Momjian's avatar
Bruce Momjian committed
45
#include "miscadmin.h"
46 47
#include "nodes/print.h"
#include "optimizer/cost.h"
48
#include "optimizer/planner.h"
49
#include "parser/analyze.h"
50
#include "parser/parser.h"
Bruce Momjian's avatar
Bruce Momjian committed
51
#include "rewrite/rewriteHandler.h"
52
#include "storage/freespace.h"
53
#include "storage/ipc.h"
54
#include "storage/pg_shmem.h"
55
#include "storage/proc.h"
56 57
#include "tcop/fastpath.h"
#include "tcop/pquery.h"
Bruce Momjian's avatar
Bruce Momjian committed
58
#include "tcop/tcopprot.h"
59
#include "tcop/utility.h"
60
#include "utils/guc.h"
61
#include "utils/lsyscache.h"
62
#include "utils/memutils.h"
63
#include "utils/ps_status.h"
Bruce Momjian's avatar
Bruce Momjian committed
64
#include "mb/pg_wchar.h"
65

66
#include "pgstat.h"
67

68 69 70
extern int	optind;
extern char *optarg;

71
/* ----------------
72
 *		global variables
73 74
 * ----------------
 */
75
const char *debug_query_string; /* for pgmonitor and
Bruce Momjian's avatar
Bruce Momjian committed
76
								 * log_min_error_statement */
77

78
/* Note: whereToSendOutput is initialized for the bootstrap/standalone case */
79
CommandDest whereToSendOutput = Debug;
80

81
/* note: these declarations had better match tcopprot.h */
82
sigjmp_buf	Warn_restart;
83

84
bool		Warn_restart_ready = false;
85
bool		InError = false;
86

87 88 89
/* flag for logging end of session */
bool        Log_disconnections = false;

90 91
LogStmtLevel log_statement = LOGSTMT_NONE;

92 93 94 95
/* GUC variable for maximum stack depth (measured in kilobytes) */
int			max_stack_depth = 2048;


96 97 98 99
/* ----------------
 *		private variables
 * ----------------
 */
100

101 102 103 104 105 106 107
/* max_stack_depth converted to bytes for speed of checking */
static int	max_stack_depth_bytes = 2048*1024;

/* stack base pointer (initialized by PostgresMain) */
static char *stack_base_ptr = NULL;


108 109 110 111 112 113 114
/*
 * Flag to mark SIGHUP. Whenever the main loop comes around it
 * will reread the configuration file. (Better than doing the
 * reading in the signal handler, ey?)
 */
static volatile bool got_SIGHUP = false;

115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
/*
 * Flag to keep track of whether we have started a transaction.
 * For extended query protocol this has to be remembered across messages.
 */
static bool xact_started = false;

/*
 * Flags to implement skip-till-Sync-after-error behavior for messages of
 * the extended query protocol.
 */
static bool doing_extended_query_message = false;
static bool ignore_till_sync = false;

/*
 * If an unnamed prepared statement exists, it's stored here.
 * We keep it separate from the hashtable kept by commands/prepare.c
 * in order to reduce overhead for short-lived queries.
 */
static MemoryContext unnamed_stmt_context = NULL;
static PreparedStatement *unnamed_stmt_pstmt = NULL;


static bool EchoQuery = false;	/* default don't echo */

/*
 * people who want to use EOF should #define DONTUSENEWLINE in
 * tcop/tcopdebug.h
142 143
 */
#ifndef TCOP_DONTUSENEWLINE
144
static int	UseNewLine = 1;		/* Use newlines query delimiters (the
145
								 * default) */
Bruce Momjian's avatar
Bruce Momjian committed
146

147
#else
148
static int	UseNewLine = 0;		/* Use EOF as query delimiters */
149
#endif   /* TCOP_DONTUSENEWLINE */
150 151 152


/* ----------------------------------------------------------------
153
 *		decls for routines only used in this file
154 155
 * ----------------------------------------------------------------
 */
156 157 158
static int	InteractiveBackend(StringInfo inBuf);
static int	SocketBackend(StringInfo inBuf);
static int	ReadCommand(StringInfo inBuf);
159
static void start_xact_command(void);
160
static void finish_xact_command(void);
161 162
static void SigHupHandler(SIGNAL_ARGS);
static void FloatExceptionHandler(SIGNAL_ARGS);
163
static void log_disconnections(int code, Datum arg);
164 165 166


/* ----------------------------------------------------------------
167
 *		routines to obtain user input
168 169 170 171
 * ----------------------------------------------------------------
 */

/* ----------------
172
 *	InteractiveBackend() is called for user interactive connections
173 174 175
 *
 *	the string entered by the user is placed in its parameter inBuf,
 *	and we act like a Q message was received.
176
 *
177
 *	EOF is returned if end-of-file input is seen; time to shut down.
178 179 180
 * ----------------
 */

181
static int
182
InteractiveBackend(StringInfo inBuf)
183
{
184 185 186
	int			c;				/* character read from getc() */
	bool		end = false;	/* end-of-input flag */
	bool		backslashSeen = false;	/* have we seen a \ ? */
187

188 189
	/*
	 * display a prompt and obtain input from the user
190
	 */
191
	printf("backend> ");
192
	fflush(stdout);
193

194 195 196
	/* Reset inBuf to empty */
	inBuf->len = 0;
	inBuf->data[0] = '\0';
197
	inBuf->cursor = 0;
198

199 200 201 202
	for (;;)
	{
		if (UseNewLine)
		{
203 204 205
			/*
			 * if we are using \n as a delimiter, then read characters
			 * until the \n.
206 207 208 209 210 211 212
			 */
			while ((c = getc(stdin)) != EOF)
			{
				if (c == '\n')
				{
					if (backslashSeen)
					{
213 214 215
						/* discard backslash from inBuf */
						inBuf->data[--inBuf->len] = '\0';
						backslashSeen = false;
216 217 218 219 220
						continue;
					}
					else
					{
						/* keep the newline character */
221
						appendStringInfoChar(inBuf, '\n');
222 223 224 225 226 227 228 229
						break;
					}
				}
				else if (c == '\\')
					backslashSeen = true;
				else
					backslashSeen = false;

230
				appendStringInfoChar(inBuf, (char) c);
231 232 233 234 235 236 237
			}

			if (c == EOF)
				end = true;
		}
		else
		{
238 239
			/*
			 * otherwise read characters until EOF.
240 241
			 */
			while ((c = getc(stdin)) != EOF)
242
				appendStringInfoChar(inBuf, (char) c);
243

244
			if (inBuf->len == 0)
245 246 247 248
				end = true;
		}

		if (end)
249
			return EOF;
250

251 252
		/*
		 * otherwise we have a user query so process it.
253 254 255 256
		 */
		break;
	}

257 258 259
	/* Add '\0' to make it look the same as message case. */
	appendStringInfoChar(inBuf, (char) '\0');

260 261
	/*
	 * if the query echo flag was given, print the query..
262 263
	 */
	if (EchoQuery)
264
		printf("statement: %s\n", inBuf->data);
265
	fflush(stdout);
266

267
	return 'Q';
268 269 270
}

/* ----------------
271
 *	SocketBackend()		Is called for frontend-backend connections
272
 *
273
 *	Returns the message type code, and loads message body data into inBuf.
274
 *
275
 *	EOF is returned if the connection is lost.
276 277
 * ----------------
 */
278
static int
279
SocketBackend(StringInfo inBuf)
280
{
281
	int			qtype;
282

283
	/*
284
	 * Get message type code from the frontend.
285
	 */
286
	qtype = pq_getbyte();
287

288 289
	if (qtype == EOF)			/* frontend disconnected */
	{
290 291 292
		ereport(COMMERROR,
				(errcode(ERRCODE_PROTOCOL_VIOLATION),
				 errmsg("unexpected EOF on client connection")));
293 294 295 296 297
		return qtype;
	}

	/*
	 * Validate message type code before trying to read body; if we have
Bruce Momjian's avatar
Bruce Momjian committed
298 299
	 * lost sync, better to say "command unknown" than to run out of
	 * memory because we used garbage as a length word.
300 301 302
	 *
	 * This also gives us a place to set the doing_extended_query_message
	 * flag as soon as possible.
303
	 */
304
	switch (qtype)
305
	{
306
		case 'Q':				/* simple query */
307
			doing_extended_query_message = false;
308 309 310 311 312
			if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
			{
				/* old style without length word; convert */
				if (pq_getstring(inBuf))
				{
313 314
					ereport(COMMERROR,
							(errcode(ERRCODE_PROTOCOL_VIOLATION),
Bruce Momjian's avatar
Bruce Momjian committed
315
						 errmsg("unexpected EOF on client connection")));
316 317 318
					return EOF;
				}
			}
319 320
			break;

321
		case 'F':				/* fastpath function call */
322 323
			/* we let fastpath.c cope with old-style input of this */
			doing_extended_query_message = false;
324
			break;
325

326
		case 'X':				/* terminate */
327
			doing_extended_query_message = false;
328
			ignore_till_sync = false;
329 330 331 332 333 334 335 336 337 338 339
			break;

		case 'B':				/* bind */
		case 'C':				/* close */
		case 'D':				/* describe */
		case 'E':				/* execute */
		case 'H':				/* flush */
		case 'P':				/* parse */
			doing_extended_query_message = true;
			/* these are only legal in protocol 3 */
			if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
340 341
				ereport(FATAL,
						(errcode(ERRCODE_PROTOCOL_VIOLATION),
Bruce Momjian's avatar
Bruce Momjian committed
342
					 errmsg("invalid frontend message type %d", qtype)));
343 344 345 346 347 348 349 350 351
			break;

		case 'S':				/* sync */
			/* stop any active skip-till-Sync */
			ignore_till_sync = false;
			/* mark not-extended, so that a new error doesn't begin skip */
			doing_extended_query_message = false;
			/* only legal in protocol 3 */
			if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
352 353
				ereport(FATAL,
						(errcode(ERRCODE_PROTOCOL_VIOLATION),
Bruce Momjian's avatar
Bruce Momjian committed
354
					 errmsg("invalid frontend message type %d", qtype)));
355
			break;
356

357 358 359
		case 'd':				/* copy data */
		case 'c':				/* copy done */
		case 'f':				/* copy fail */
360 361 362
			doing_extended_query_message = false;
			/* these are only legal in protocol 3 */
			if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
363 364
				ereport(FATAL,
						(errcode(ERRCODE_PROTOCOL_VIOLATION),
Bruce Momjian's avatar
Bruce Momjian committed
365
					 errmsg("invalid frontend message type %d", qtype)));
366
			break;
367

368
		default:
Bruce Momjian's avatar
Bruce Momjian committed
369

370
			/*
Bruce Momjian's avatar
Bruce Momjian committed
371 372 373
			 * Otherwise we got garbage from the frontend.	We treat this
			 * as fatal because we have probably lost message boundary
			 * sync, and there's no good way to recover.
374
			 */
375 376 377
			ereport(FATAL,
					(errcode(ERRCODE_PROTOCOL_VIOLATION),
					 errmsg("invalid frontend message type %d", qtype)));
378
			break;
379
	}
380

381 382 383 384 385 386 387 388 389 390 391
	/*
	 * In protocol version 3, all frontend messages have a length word
	 * next after the type code; we can read the message contents
	 * independently of the type.
	 */
	if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 3)
	{
		if (pq_getmessage(inBuf, 0))
			return EOF;			/* suitable message already logged */
	}

392
	return qtype;
393 394 395
}

/* ----------------
396
 *		ReadCommand reads a command from either the frontend or
397 398 399
 *		standard input, places it in inBuf, and returns the
 *		message type code (first byte of the message).
 *		EOF is returned if end of file.
400 401
 * ----------------
 */
402
static int
403
ReadCommand(StringInfo inBuf)
404
{
405
	int			result;
406

407
	if (whereToSendOutput == Remote)
408
		result = SocketBackend(inBuf);
409
	else
410 411
		result = InteractiveBackend(inBuf);
	return result;
412 413
}

414 415 416 417 418 419

/*
 * Parse a query string and pass it through the rewriter.
 *
 * A list of Query nodes is returned, since the string might contain
 * multiple queries and/or the rewriter might expand one query to several.
420 421 422
 *
 * NOTE: this routine is no longer used for processing interactive queries,
 * but it is still needed for parsing of SQL function bodies.
423
 */
424
List *
Bruce Momjian's avatar
Bruce Momjian committed
425
pg_parse_and_rewrite(const char *query_string,	/* string to execute */
426
					 Oid *paramTypes,	/* parameter types */
Bruce Momjian's avatar
Bruce Momjian committed
427
					 int numParams)		/* number of parameters */
428
{
429
	List	   *raw_parsetree_list;
430
	List	   *querytree_list;
431 432
	List	   *list_item;

433 434
	/*
	 * (1) parse the request string into a list of raw parse trees.
435
	 */
436
	raw_parsetree_list = pg_parse_query(query_string);
437

438 439
	/*
	 * (2) Do parse analysis and rule rewrite.
440 441 442 443
	 */
	querytree_list = NIL;
	foreach(list_item, raw_parsetree_list)
	{
444
		Node	   *parsetree = (Node *) lfirst(list_item);
445 446

		querytree_list = nconc(querytree_list,
447 448 449
							   pg_analyze_and_rewrite(parsetree,
													  paramTypes,
													  numParams));
450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
	}

	return querytree_list;
}

/*
 * Do raw parsing (only).
 *
 * A list of parsetrees is returned, since there might be multiple
 * commands in the given string.
 *
 * NOTE: for interactive queries, it is important to keep this routine
 * separate from the analysis & rewrite stages.  Analysis and rewriting
 * cannot be done in an aborted transaction, since they require access to
 * database tables.  So, we rely on the raw parser to determine whether
 * we've seen a COMMIT or ABORT command; when we are in abort state, other
 * commands are not processed any further than the raw parse stage.
 */
468
List *
469
pg_parse_query(const char *query_string)
470
{
471 472
	List	   *raw_parsetree_list,
			   *parsetree_item;
473

474
	if (log_statement == LOGSTMT_ALL)
475
		ereport(LOG,
476
				(errmsg("statement: %s", query_string)));
477

Bruce Momjian's avatar
Bruce Momjian committed
478
	if (log_parser_stats)
479 480
		ResetUsage();

481
	raw_parsetree_list = raw_parser(query_string);
482

483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527
	/* do log_statement tests for mod and ddl */
	if (log_statement == LOGSTMT_MOD ||
		log_statement == LOGSTMT_DDL)
	{
		foreach(parsetree_item, raw_parsetree_list)
		{
			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))
				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 */
			{
				ereport(LOG,
						(errmsg("statement: %s", query_string)));
				break;
			}
			commandTag = CreateCommandTag(parsetree);
			if (strncmp(commandTag, "CREATE ", strlen("CREATE ")) == 0 ||
				strncmp(commandTag, "ALTER ", strlen("ALTER ")) == 0 ||
				strncmp(commandTag, "DROP ", strlen("DROP ")) == 0 ||
				IsA(parsetree, GrantStmt) ||	/* GRANT or REVOKE */
				IsA(parsetree, CommentStmt))
			{
				ereport(LOG,
						(errmsg("statement: %s", query_string)));
				break;
			}
		}
	}

Bruce Momjian's avatar
Bruce Momjian committed
528
	if (log_parser_stats)
529
		ShowUsage("PARSER STATISTICS");
530 531 532 533 534

	return raw_parsetree_list;
}

/*
535 536
 * Given a raw parsetree (gram.y output), and optionally information about
 * types of parameter symbols ($n), perform parse analysis and rule rewriting.
537 538 539 540 541 542
 *
 * A list of Query nodes is returned, since either the analyzer or the
 * rewriter might expand one query to several.
 *
 * NOTE: for reasons mentioned above, this must be separate from raw parsing.
 */
543
List *
544
pg_analyze_and_rewrite(Node *parsetree, Oid *paramTypes, int numParams)
545 546 547
{
	List	   *querytree_list;

548 549
	/*
	 * (1) Perform parse analysis.
550
	 */
Bruce Momjian's avatar
Bruce Momjian committed
551
	if (log_parser_stats)
552 553
		ResetUsage();

554
	querytree_list = parse_analyze(parsetree, paramTypes, numParams);
555

Bruce Momjian's avatar
Bruce Momjian committed
556
	if (log_parser_stats)
557
		ShowUsage("PARSE ANALYSIS STATISTICS");
558

559 560
	/*
	 * (2) Rewrite the queries, as necessary
561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579
	 */
	querytree_list = pg_rewrite_queries(querytree_list);

	return querytree_list;
}

/*
 * Perform rewriting of a list of queries produced by parse analysis.
 */
List *
pg_rewrite_queries(List *querytree_list)
{
	List	   *new_list = NIL;
	List	   *list_item;

	if (log_parser_stats)
		ResetUsage();

	/*
Bruce Momjian's avatar
Bruce Momjian committed
580 581
	 * rewritten queries are collected in new_list.  Note there may be
	 * more or fewer than in the original list.
582
	 */
583
	foreach(list_item, querytree_list)
584
	{
585
		Query	   *querytree = (Query *) lfirst(list_item);
586

587
		if (Debug_print_parse)
588
			elog_node_display(DEBUG1, "parse tree", querytree,
589
							  Debug_pretty_print);
590 591 592

		if (querytree->commandType == CMD_UTILITY)
		{
593 594
			/* don't rewrite utilities, just dump 'em into new_list */
			new_list = lappend(new_list, querytree);
595
		}
596
		else
597
		{
598
			/* rewrite regular queries */
599 600
			List	   *rewritten = QueryRewrite(querytree);

601
			new_list = nconc(new_list, rewritten);
602 603 604 605 606
		}
	}

	querytree_list = new_list;

Bruce Momjian's avatar
Bruce Momjian committed
607
	if (log_parser_stats)
608
		ShowUsage("REWRITER STATISTICS");
609

610
#ifdef COPY_PARSE_PLAN_TREES
611 612 613 614 615

	/*
	 * Optional debugging check: pass querytree output through
	 * copyObject()
	 */
616 617
	new_list = (List *) copyObject(querytree_list);
	/* This checks both copyObject() and the equal() routines... */
618
	if (!equal(new_list, querytree_list))
619
		elog(WARNING, "copyObject() failed to produce an equal parse tree");
620 621
	else
		querytree_list = new_list;
622 623
#endif

624
	if (Debug_print_rewritten)
625
		elog_node_display(DEBUG1, "rewritten parse tree", querytree_list,
626
						  Debug_pretty_print);
627

628 629
	return querytree_list;
}
630 631


632
/* Generate a plan for a single already-rewritten query. */
633 634 635 636
Plan *
pg_plan_query(Query *querytree)
{
	Plan	   *plan;
637

638 639 640
	/* Utility commands have no plans. */
	if (querytree->commandType == CMD_UTILITY)
		return NULL;
641

Bruce Momjian's avatar
Bruce Momjian committed
642
	if (log_planner_stats)
643
		ResetUsage();
644

645
	/* call the optimizer */
646
	plan = planner(querytree, false, 0);
647

Bruce Momjian's avatar
Bruce Momjian committed
648
	if (log_planner_stats)
649
		ShowUsage("PLANNER STATISTICS");
650

651 652 653
#ifdef COPY_PARSE_PLAN_TREES
	/* Optional debugging check: pass plan output through copyObject() */
	{
654
		Plan	   *new_plan = (Plan *) copyObject(plan);
655

656 657
		/*
		 * equal() currently does not have routines to compare Plan nodes,
658 659 660 661
		 * so don't try to test equality here.  Perhaps fix someday?
		 */
#ifdef NOT_USED
		/* This checks both copyObject() and the equal() routines... */
662
		if (!equal(new_plan, plan))
663
			elog(WARNING, "copyObject() failed to produce an equal plan tree");
664 665 666 667 668 669
		else
#endif
			plan = new_plan;
	}
#endif

670 671
	/*
	 * Print plan if debugging.
672
	 */
673
	if (Debug_print_plan)
674
		elog_node_display(DEBUG1, "plan", plan, Debug_pretty_print);
675

676
	return plan;
677 678
}

679 680
/*
 * Generate plans for a list of already-rewritten queries.
681
 *
682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723
 * If needSnapshot is TRUE, we haven't yet set a snapshot for the current
 * query.  A snapshot must be set before invoking the planner, since it
 * might try to evaluate user-defined functions.  But we must not set a
 * snapshot if the list contains only utility statements, because some
 * 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.)
 */
List *
pg_plan_queries(List *querytrees, bool needSnapshot)
{
	List	   *plan_list = NIL;
	List	   *query_list;

	foreach(query_list, querytrees)
	{
		Query	   *query = (Query *) lfirst(query_list);
		Plan	   *plan;

		if (query->commandType == CMD_UTILITY)
		{
			/* Utility commands have no plans. */
			plan = NULL;
		}
		else
		{
			if (needSnapshot)
			{
				SetQuerySnapshot();
				needSnapshot = false;
			}
			plan = pg_plan_query(query);
		}

		plan_list = lappend(plan_list, plan);
	}

	return plan_list;
}


/*
724
 * exec_simple_query
725
 *
726
 * Execute a "simple Query" protocol message.
727
 */
728
static void
729
exec_simple_query(const char *query_string)
730
{
Bruce Momjian's avatar
Bruce Momjian committed
731
	CommandDest dest = whereToSendOutput;
732
	MemoryContext oldcontext;
733 734
	List	   *parsetree_list,
			   *parsetree_item;
Bruce Momjian's avatar
Bruce Momjian committed
735 736
	struct timeval start_t,
				stop_t;
Bruce Momjian's avatar
Bruce Momjian committed
737
	bool		save_log_duration = log_duration;
738
	int			save_log_min_duration_statement = log_min_duration_statement;
739
	bool		save_log_statement_stats = log_statement_stats;
740

741 742 743
	/*
	 * Report query to various monitoring facilities.
	 */
744
	debug_query_string = query_string;
745

746 747
	pgstat_report_activity(query_string);

748
	/*
Bruce Momjian's avatar
Bruce Momjian committed
749 750 751 752
	 * 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.
753
	 */
754
	if (save_log_duration || save_log_min_duration_statement != -1)
755
		gettimeofday(&start_t, NULL);
756

757 758 759
	if (save_log_statement_stats)
		ResetUsage();

760
	/*
761 762 763 764
	 * Start up a transaction command.	All queries generated by the
	 * query_string will be in this same command block, *unless* we find a
	 * BEGIN/COMMIT/ABORT statement; we have to force a new xact command
	 * after one of those, else bad things will happen in xact.c. (Note
765
	 * that this will normally change current memory context.)
766 767
	 */
	start_xact_command();
768 769

	/*
Bruce Momjian's avatar
Bruce Momjian committed
770 771 772 773
	 * Zap any pre-existing unnamed statement.	(While not strictly
	 * necessary, it seems best to define simple-Query mode as if it used
	 * the unnamed statement and portal; this ensures we recover any
	 * storage used by prior unnamed operations.)
774 775 776 777 778 779 780 781
	 */
	unnamed_stmt_pstmt = NULL;
	if (unnamed_stmt_context)
	{
		DropDependentPortals(unnamed_stmt_context);
		MemoryContextDelete(unnamed_stmt_context);
	}
	unnamed_stmt_context = NULL;
782

783 784 785
	/*
	 * Switch to appropriate context for constructing parsetrees.
	 */
786
	oldcontext = MemoryContextSwitchTo(MessageContext);
787

788 789
	QueryContext = CurrentMemoryContext;

Bruce Momjian's avatar
Bruce Momjian committed
790
	/*
791 792
	 * Do basic parsing of the query or queries (this should be safe even
	 * if we are in aborted transaction state!)
793
	 */
794
	parsetree_list = pg_parse_query(query_string);
795

796
	/*
797
	 * Switch back to transaction context to enter the loop.
798 799 800 801
	 */
	MemoryContextSwitchTo(oldcontext);

	/*
802
	 * Run through the raw parsetree(s) and process each one.
803
	 */
804
	foreach(parsetree_item, parsetree_list)
805
	{
806
		Node	   *parsetree = (Node *) lfirst(parsetree_item);
807 808
		const char *commandTag;
		char		completionTag[COMPLETION_TAG_BUFSIZE];
809
		List	   *querytree_list,
810 811
				   *plantree_list;
		Portal		portal;
812 813
		DestReceiver *receiver;
		int16		format;
814

815
		/*
Bruce Momjian's avatar
Bruce Momjian committed
816 817 818 819
		 * Get the command name for use in status display (it also becomes
		 * the default completion tag, down inside PortalRun).	Set
		 * ps_status and do any special start-of-SQL-command processing
		 * needed by the destination.
820 821 822 823 824
		 */
		commandTag = CreateCommandTag(parsetree);

		set_ps_display(commandTag);

825
		BeginCommand(commandTag, dest);
826

827
		/*
828
		 * If we are in an aborted transaction, reject all commands except
829 830
		 * COMMIT/ABORT.  It is important that this test occur before we
		 * try to do parse analysis, rewrite, or planning, since all those
831 832 833
		 * phases try to do database accesses, which may fail in abort
		 * state. (It might be safe to allow some additional utility
		 * commands in this state, but not many...)
834 835
		 */
		if (IsAbortedTransactionBlockState())
836
		{
837
			bool		allowit = false;
838

839
			if (IsA(parsetree, TransactionStmt))
840 841 842
			{
				TransactionStmt *stmt = (TransactionStmt *) parsetree;

843 844
				if (stmt->kind == TRANS_STMT_COMMIT ||
					stmt->kind == TRANS_STMT_ROLLBACK)
845
					allowit = true;
846
			}
847

848
			if (!allowit)
849 850 851
				ereport(ERROR,
						(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
						 errmsg("current transaction is aborted, "
852
					 "commands ignored until end of transaction block")));
853
		}
854

855
		/* Make sure we are in a transaction command */
856
		start_xact_command();
857

858
		/* If we got a cancel signal in parsing or prior command, quit */
859
		CHECK_FOR_INTERRUPTS();
860 861

		/*
862
		 * OK to analyze, rewrite, and plan this query.
863
		 *
864 865
		 * Switch to appropriate context for constructing querytrees (again,
		 * these must outlive the execution context).
866
		 */
867
		oldcontext = MemoryContextSwitchTo(MessageContext);
868

869
		querytree_list = pg_analyze_and_rewrite(parsetree, NULL, 0);
Vadim B. Mikheev's avatar
Vadim B. Mikheev committed
870

871 872 873 874 875
		plantree_list = pg_plan_queries(querytree_list, true);

		/* If we got a cancel signal in analysis or planning, quit */
		CHECK_FOR_INTERRUPTS();

876
		/*
Bruce Momjian's avatar
Bruce Momjian committed
877 878
		 * Create unnamed portal to run the query or queries in. If there
		 * already is one, silently drop it.
879
		 */
880
		portal = CreatePortal("", true, true);
881

882 883 884 885 886 887
		PortalDefineQuery(portal,
						  query_string,
						  commandTag,
						  querytree_list,
						  plantree_list,
						  MessageContext);
888

889
		/*
890
		 * Start the portal.  No parameters here.
891 892
		 */
		PortalStart(portal, NULL);
893

894 895
		/*
		 * Select the appropriate output format: text unless we are doing
Bruce Momjian's avatar
Bruce Momjian committed
896 897 898
		 * a FETCH from a binary cursor.  (Pretty grotty to have to do
		 * this here --- but it avoids grottiness in other places.	Ah,
		 * the joys of backward compatibility...)
899 900 901 902 903 904 905 906 907 908 909 910
		 */
		format = 0;				/* TEXT is default */
		if (IsA(parsetree, FetchStmt))
		{
			FetchStmt  *stmt = (FetchStmt *) parsetree;

			if (!stmt->ismove)
			{
				Portal		fportal = GetPortalByName(stmt->portalname);

				if (PortalIsValid(fportal) &&
					(fportal->cursorOptions & CURSOR_OPT_BINARY))
Bruce Momjian's avatar
Bruce Momjian committed
911
					format = 1; /* BINARY */
912 913 914 915 916 917 918 919 920 921 922 923 924 925 926
			}
		}
		PortalSetResultFormat(portal, 1, &format);

		/*
		 * Now we can create the destination receiver object.
		 */
		receiver = CreateDestReceiver(dest, portal);

		/*
		 * Switch back to transaction context for execution.
		 */
		MemoryContextSwitchTo(oldcontext);

		/*
Bruce Momjian's avatar
Bruce Momjian committed
927 928
		 * Run the portal to completion, and then drop it (and the
		 * receiver).
929
		 */
930 931
		(void) PortalRun(portal,
						 FETCH_ALL,
932 933
						 receiver,
						 receiver,
934
						 completionTag);
935

936
		(*receiver->rDestroy) (receiver);
937

938
		PortalDrop(portal, false);
939

940
		if (IsA(parsetree, TransactionStmt))
941
		{
942
			/*
Bruce Momjian's avatar
Bruce Momjian committed
943 944 945
			 * If this was a transaction control statement, commit it. We
			 * will start a new xact command for the next command (if
			 * any).
946
			 */
947
			finish_xact_command();
948
		}
949
		else if (lnext(parsetree_item) == NIL)
950
		{
951
			/*
Bruce Momjian's avatar
Bruce Momjian committed
952 953 954 955 956 957 958 959 960
			 * If this is the last parsetree of the query string, close
			 * down transaction statement before reporting
			 * command-complete.  This is so that any end-of-transaction
			 * errors are reported before the command-complete message is
			 * issued, to avoid confusing clients who will expect either a
			 * command-complete message or an error, not one and then the
			 * other.  But for compatibility with historical Postgres
			 * behavior, we do not force a transaction boundary between
			 * queries appearing in a single query string.
961
			 */
962
			finish_xact_command();
963
		}
964
		else
965
		{
966
			/*
Bruce Momjian's avatar
Bruce Momjian committed
967 968
			 * We need a CommandCounterIncrement after every query, except
			 * those that start or end a transaction block.
969 970
			 */
			CommandCounterIncrement();
971
		}
972 973 974

		/*
		 * Tell client that we're done with this query.  Note we emit
Bruce Momjian's avatar
Bruce Momjian committed
975 976 977 978
		 * exactly one EndCommand report for each raw parsetree, thus one
		 * for each SQL command the client sent, regardless of rewriting.
		 * (But a command aborted by error will not send an EndCommand
		 * report at all.)
979
		 */
980
		EndCommand(completionTag, dest);
981
	}							/* end loop over parsetrees */
982

983 984 985 986 987
	/*
	 * Close down transaction statement, if one is open.
	 */
	finish_xact_command();

988 989 990
	/*
	 * If there were no parsetrees, return EmptyQueryResponse message.
	 */
991
	if (!parsetree_list)
992 993
		NullCommand(dest);

994
	QueryContext = NULL;
995

996
	/*
Bruce Momjian's avatar
Bruce Momjian committed
997 998
	 * Combine processing here as we need to calculate the query duration
	 * in both instances.
999
	 */
1000
	if (save_log_duration || save_log_min_duration_statement != -1)
1001
	{
Bruce Momjian's avatar
Bruce Momjian committed
1002 1003
		long		usecs;

1004
		gettimeofday(&stop_t, NULL);
1005 1006 1007 1008 1009
		if (stop_t.tv_usec < start_t.tv_usec)
		{
			stop_t.tv_sec--;
			stop_t.tv_usec += 1000000;
		}
1010 1011
		usecs = (long) (stop_t.tv_sec - start_t.tv_sec) * 1000000 + (long) (stop_t.tv_usec - start_t.tv_usec);

1012 1013 1014 1015 1016 1017 1018
		if (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)));

Bruce Momjian's avatar
Bruce Momjian committed
1019
		/*
1020 1021
		 * Output a duration_statement to the log if the query has exceeded
		 * the min duration, or if we are to print all durations.
1022
		 */
1023 1024 1025
		if (save_log_min_duration_statement == 0 ||
			(save_log_min_duration_statement > 0 &&
			 usecs >= save_log_min_duration_statement * 1000))
1026
			ereport(LOG,
1027
					(errmsg("duration: %ld.%03ld ms  statement: %s",
1028 1029 1030
							(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,
1031
							query_string)));
1032
	}
1033

1034 1035 1036
	if (save_log_statement_stats)
		ShowUsage("QUERY STATISTICS");

1037
	debug_query_string = NULL;
1038 1039
}

1040 1041 1042 1043 1044 1045 1046 1047
/*
 * exec_parse_message
 *
 * Execute a "Parse" protocol message.
 */
static void
exec_parse_message(const char *query_string,	/* string to execute */
				   const char *stmt_name,		/* name for prepared stmt */
Bruce Momjian's avatar
Bruce Momjian committed
1048 1049
				   Oid *paramTypes,		/* parameter types */
				   int numParams)		/* number of parameters */
1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081
{
	MemoryContext oldcontext;
	List	   *parsetree_list;
	const char *commandTag;
	List	   *querytree_list,
			   *plantree_list,
			   *param_list;
	bool		is_named;
	bool		save_log_statement_stats = log_statement_stats;

	/*
	 * Report query to various monitoring facilities.
	 */
	debug_query_string = query_string;

	pgstat_report_activity(query_string);

	set_ps_display("PARSE");

	if (save_log_statement_stats)
		ResetUsage();

	/*
	 * Start up a transaction command so we can run parse analysis etc.
	 * (Note that this will normally change current memory context.)
	 * Nothing happens if we are already in one.
	 */
	start_xact_command();

	/*
	 * Switch to appropriate context for constructing parsetrees.
	 *
Bruce Momjian's avatar
Bruce Momjian committed
1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
	 * 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 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.
1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127
	 */
	is_named = (stmt_name[0] != '\0');
	if (is_named)
	{
		/* Named prepared statement --- parse in MessageContext */
		oldcontext = MemoryContextSwitchTo(MessageContext);
	}
	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 */
		unnamed_stmt_context =
			AllocSetContextCreate(TopMemoryContext,
								  "unnamed prepared statement",
								  ALLOCSET_DEFAULT_MINSIZE,
								  ALLOCSET_DEFAULT_INITSIZE,
								  ALLOCSET_DEFAULT_MAXSIZE);
		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!)
	 */
	parsetree_list = pg_parse_query(query_string);

	/*
Bruce Momjian's avatar
Bruce Momjian committed
1128 1129 1130
	 * We only allow a single user statement in a prepared statement. This
	 * is mainly to keep the protocol simple --- otherwise we'd need to
	 * worry about multiple result tupdescs and things like that.
1131 1132
	 */
	if (length(parsetree_list) > 1)
1133 1134 1135
		ereport(ERROR,
				(errcode(ERRCODE_SYNTAX_ERROR),
				 errmsg("cannot insert multiple commands into a prepared statement")));
1136 1137 1138

	if (parsetree_list != NIL)
	{
Bruce Momjian's avatar
Bruce Momjian committed
1139 1140
		Node	   *parsetree = (Node *) lfirst(parsetree_list);
		int			i;
1141 1142 1143 1144 1145 1146 1147 1148

		/*
		 * Get the command name for possible use in status display.
		 */
		commandTag = CreateCommandTag(parsetree);

		/*
		 * If we are in an aborted transaction, reject all commands except
Bruce Momjian's avatar
Bruce Momjian committed
1149 1150 1151 1152
		 * COMMIT/ROLLBACK.  It is important that this test occur before
		 * we try to do parse analysis, rewrite, or planning, since all
		 * those phases try to do database accesses, which may fail in
		 * abort state. (It might be safe to allow some additional utility
1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168
		 * 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_ROLLBACK)
					allowit = true;
			}

			if (!allowit)
1169 1170 1171
				ereport(ERROR,
						(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
						 errmsg("current transaction is aborted, "
1172
					 "commands ignored until end of transaction block")));
1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193
		}

		/*
		 * 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().
		 */
		if (log_parser_stats)
			ResetUsage();

		querytree_list = parse_analyze_varparams(parsetree,
												 &paramTypes,
												 &numParams);

		/*
		 * Check all parameter types got determined, and convert array
		 * representation to a list for storage.
		 */
		param_list = NIL;
		for (i = 0; i < numParams; i++)
		{
Bruce Momjian's avatar
Bruce Momjian committed
1194
			Oid			ptype = paramTypes[i];
1195 1196

			if (ptype == InvalidOid || ptype == UNKNOWNOID)
1197 1198
				ereport(ERROR,
						(errcode(ERRCODE_INDETERMINATE_DATATYPE),
1199
				  errmsg("could not determine data type of parameter $%d",
Bruce Momjian's avatar
Bruce Momjian committed
1200
						 i + 1)));
1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212
			param_list = lappendo(param_list, ptype);
		}

		if (log_parser_stats)
			ShowUsage("PARSE ANALYSIS STATISTICS");

		querytree_list = pg_rewrite_queries(querytree_list);

		plantree_list = pg_plan_queries(querytree_list, true);
	}
	else
	{
Bruce Momjian's avatar
Bruce Momjian committed
1213
		/* Empty input string.	This is legal. */
1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256
		commandTag = NULL;
		querytree_list = NIL;
		plantree_list = NIL;
		param_list = NIL;
	}

	/* If we got a cancel signal in analysis or planning, quit */
	CHECK_FOR_INTERRUPTS();

	/*
	 * Store the query as a prepared statement.  See above comments.
	 */
	if (is_named)
	{
		StorePreparedStatement(stmt_name,
							   query_string,
							   commandTag,
							   querytree_list,
							   plantree_list,
							   param_list);
	}
	else
	{
		PreparedStatement *pstmt;

		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;
	}

	MemoryContextSwitchTo(oldcontext);

	QueryContext = NULL;

	/*
Bruce Momjian's avatar
Bruce Momjian committed
1257 1258 1259 1260
	 * We do NOT close the open transaction command here; that only
	 * happens when the client sends Sync.	Instead, do
	 * CommandCounterIncrement just in case something happened during
	 * parse/plan.
1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285
	 */
	CommandCounterIncrement();

	/*
	 * Send ParseComplete.
	 */
	if (whereToSendOutput == Remote)
		pq_putemptymessage('1');

	if (save_log_statement_stats)
		ShowUsage("PARSE MESSAGE STATISTICS");

	debug_query_string = NULL;
}

/*
 * exec_bind_message
 *
 * Process a "Bind" message to create a portal from a prepared statement
 */
static void
exec_bind_message(StringInfo input_message)
{
	const char *portal_name;
	const char *stmt_name;
1286 1287
	int			numPFormats;
	int16	   *pformats = NULL;
1288
	int			numParams;
1289 1290 1291
	int			numRFormats;
	int16	   *rformats = NULL;
	int			i;
1292 1293 1294 1295 1296 1297 1298 1299 1300
	PreparedStatement *pstmt;
	Portal		portal;
	ParamListInfo params;

	pgstat_report_activity("<BIND>");

	set_ps_display("BIND");

	/*
Bruce Momjian's avatar
Bruce Momjian committed
1301 1302 1303
	 * Start up a transaction command so we can call functions etc. (Note
	 * that this will normally change current memory context.) Nothing
	 * happens if we are already in one.
1304 1305 1306
	 */
	start_xact_command();

1307 1308 1309
	/* Switch back to message context */
	MemoryContextSwitchTo(MessageContext);

1310 1311 1312 1313
	/* Get the fixed part of the message */
	portal_name = pq_getmsgstring(input_message);
	stmt_name = pq_getmsgstring(input_message);

1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326
	/* Get the parameter format codes */
	numPFormats = pq_getmsgint(input_message, 2);
	if (numPFormats > 0)
	{
		pformats = (int16 *) palloc(numPFormats * sizeof(int16));
		for (i = 0; i < numPFormats; i++)
			pformats[i] = pq_getmsgint(input_message, 2);
	}

	/* Get the parameter value count */
	numParams = pq_getmsgint(input_message, 2);

	if (numPFormats > 1 && numPFormats != numParams)
1327 1328
		ereport(ERROR,
				(errcode(ERRCODE_PROTOCOL_VIOLATION),
Bruce Momjian's avatar
Bruce Momjian committed
1329 1330
		errmsg("bind message has %d parameter formats but %d parameters",
			   numPFormats, numParams)));
1331 1332 1333 1334 1335 1336 1337 1338 1339

	/* 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)
1340 1341
			ereport(ERROR,
					(errcode(ERRCODE_UNDEFINED_PSTATEMENT),
Bruce Momjian's avatar
Bruce Momjian committed
1342
				   errmsg("unnamed prepared statement does not exist")));
1343 1344 1345
	}

	if (numParams != length(pstmt->argtype_list))
1346 1347 1348
		ereport(ERROR,
				(errcode(ERRCODE_PROTOCOL_VIOLATION),
				 errmsg("bind message supplies %d parameters, but prepared statement \"%s\" requires %d",
Bruce Momjian's avatar
Bruce Momjian committed
1349
					numParams, stmt_name, length(pstmt->argtype_list))));
1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369

	/*
	 * Create the portal.  Allow silent replacement of an existing portal
	 * only if the unnamed portal is specified.
	 */
	if (portal_name[0] == '\0')
		portal = CreatePortal(portal_name, true, true);
	else
		portal = CreatePortal(portal_name, false, false);

	PortalDefineQuery(portal,
					  pstmt->query_string,
					  pstmt->commandTag,
					  pstmt->query_list,
					  pstmt->plan_list,
					  pstmt->context);

	/*
	 * Fetch parameters, if any, and store in the portal's memory context.
	 *
Bruce Momjian's avatar
Bruce Momjian committed
1370 1371 1372
	 * 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.
1373 1374 1375
	 */
	if (numParams > 0)
	{
Bruce Momjian's avatar
Bruce Momjian committed
1376 1377
		bool		isaborted = IsAbortedTransactionBlockState();
		List	   *l;
1378 1379 1380 1381 1382 1383 1384
		MemoryContext oldContext;

		oldContext = MemoryContextSwitchTo(PortalGetHeapMemory(portal));

		params = (ParamListInfo)
			palloc0((numParams + 1) * sizeof(ParamListInfoData));

1385
		i = 0;
1386 1387 1388
		foreach(l, pstmt->argtype_list)
		{
			Oid			ptype = lfirsto(l);
1389
			int32		plength;
1390 1391
			bool		isNull;

1392 1393 1394
			plength = pq_getmsgint(input_message, 4);
			isNull = (plength == -1);

1395 1396
			if (!isNull)
			{
1397
				const char *pvalue = pq_getmsgbytes(input_message, plength);
1398 1399

				if (isaborted)
1400 1401
				{
					/* We don't bother to check the format in this case */
1402
					isNull = true;
1403
				}
1404 1405
				else
				{
Bruce Momjian's avatar
Bruce Momjian committed
1406
					int16		pformat;
1407
					StringInfoData pbuf;
Bruce Momjian's avatar
Bruce Momjian committed
1408
					char		csave;
1409 1410 1411 1412 1413 1414

					if (numPFormats > 1)
						pformat = pformats[i];
					else if (numPFormats > 0)
						pformat = pformats[0];
					else
Bruce Momjian's avatar
Bruce Momjian committed
1415
						pformat = 0;	/* default = text */
1416

1417
					/*
Bruce Momjian's avatar
Bruce Momjian committed
1418 1419 1420 1421 1422 1423 1424
					 * 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.
1425 1426 1427 1428 1429 1430 1431 1432 1433
					 */
					pbuf.data = (char *) pvalue;
					pbuf.maxlen = plength + 1;
					pbuf.len = plength;
					pbuf.cursor = 0;

					csave = pbuf.data[plength];
					pbuf.data[plength] = '\0';

1434 1435 1436 1437 1438 1439 1440
					if (pformat == 0)
					{
						Oid			typInput;
						Oid			typElem;
						char	   *pstring;

						getTypeInputInfo(ptype, &typInput, &typElem);
Bruce Momjian's avatar
Bruce Momjian committed
1441

1442
						/*
Bruce Momjian's avatar
Bruce Momjian committed
1443 1444
						 * We have to do encoding conversion before
						 * calling the typinput routine.
1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459
						 */
						pstring = (char *)
							pg_client_to_server((unsigned char *) pbuf.data,
												plength);
						params[i].value =
							OidFunctionCall3(typInput,
											 CStringGetDatum(pstring),
											 ObjectIdGetDatum(typElem),
											 Int32GetDatum(-1));
						/* Free result of encoding conversion, if any */
						if (pstring != pbuf.data)
							pfree(pstring);
					}
					else if (pformat == 1)
					{
1460 1461 1462
						Oid			typReceive;
						Oid			typElem;

Bruce Momjian's avatar
Bruce Momjian committed
1463 1464 1465 1466
						/*
						 * Call the parameter type's binary input
						 * converter
						 */
1467 1468 1469 1470 1471 1472 1473 1474 1475
						getTypeBinaryInputInfo(ptype, &typReceive, &typElem);

						params[i].value =
							OidFunctionCall2(typReceive,
											 PointerGetDatum(&pbuf),
											 ObjectIdGetDatum(typElem));

						/* Trouble if it didn't eat the whole buffer */
						if (pbuf.cursor != pbuf.len)
1476 1477 1478
							ereport(ERROR,
									(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
									 errmsg("incorrect binary data format in bind parameter %d",
Bruce Momjian's avatar
Bruce Momjian committed
1479
											i + 1)));
1480 1481 1482
					}
					else
					{
1483 1484 1485 1486
						ereport(ERROR,
								(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
								 errmsg("unsupported format code: %d",
										pformat)));
1487
					}
1488 1489 1490

					/* Restore message buffer contents */
					pbuf.data[plength] = csave;
1491 1492
				}
			}
1493

1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507
			params[i].kind = PARAM_NUM;
			params[i].id = i + 1;
			params[i].isnull = isNull;

			i++;
		}

		params[i].kind = PARAM_INVALID;

		MemoryContextSwitchTo(oldContext);
	}
	else
		params = NULL;

1508 1509 1510 1511 1512 1513 1514 1515 1516
	/* Get the result format codes */
	numRFormats = pq_getmsgint(input_message, 2);
	if (numRFormats > 0)
	{
		rformats = (int16 *) palloc(numRFormats * sizeof(int16));
		for (i = 0; i < numRFormats; i++)
			rformats[i] = pq_getmsgint(input_message, 2);
	}

1517 1518 1519 1520 1521 1522 1523
	pq_getmsgend(input_message);

	/*
	 * Start portal execution.
	 */
	PortalStart(portal, params);

1524 1525 1526 1527 1528
	/*
	 * Apply the result format requests to the portal.
	 */
	PortalSetResultFormat(portal, numRFormats, rformats);

1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541
	/*
	 * Send BindComplete.
	 */
	if (whereToSendOutput == Remote)
		pq_putemptymessage('2');
}

/*
 * exec_execute_message
 *
 * Process an "Execute" message for a portal
 */
static void
1542
exec_execute_message(const char *portal_name, long max_rows)
1543
{
Bruce Momjian's avatar
Bruce Momjian committed
1544
	CommandDest dest;
1545
	DestReceiver *receiver;
1546 1547 1548 1549 1550 1551 1552 1553 1554
	Portal		portal;
	bool		is_trans_stmt = false;
	bool		is_trans_exit = false;
	bool		completed;
	char		completionTag[COMPLETION_TAG_BUFSIZE];

	/* Adjust destination to tell printtup.c what to do */
	dest = whereToSendOutput;
	if (dest == Remote)
1555
		dest = RemoteExecute;
1556 1557 1558

	portal = GetPortalByName(portal_name);
	if (!PortalIsValid(portal))
1559 1560 1561
		ereport(ERROR,
				(errcode(ERRCODE_UNDEFINED_CURSOR),
				 errmsg("portal \"%s\" does not exist", portal_name)));
1562 1563

	/*
Bruce Momjian's avatar
Bruce Momjian committed
1564 1565
	 * If the original query was a null string, just return
	 * EmptyQueryResponse.
1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591
	 */
	if (portal->commandTag == NULL)
	{
		Assert(portal->parseTrees == NIL);
		NullCommand(dest);
		return;
	}

	if (portal->sourceText)
	{
		debug_query_string = portal->sourceText;
		pgstat_report_activity(portal->sourceText);
	}
	else
	{
		debug_query_string = "execute message";
		pgstat_report_activity("<EXECUTE>");
	}

	set_ps_display(portal->commandTag);

	BeginCommand(portal->commandTag, dest);

	/* Check for transaction-control commands */
	if (length(portal->parseTrees) == 1)
	{
Bruce Momjian's avatar
Bruce Momjian committed
1592
		Query	   *query = (Query *) lfirst(portal->parseTrees);
1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606

		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_ROLLBACK)
				is_trans_exit = true;
		}
	}

1607
	/*
Bruce Momjian's avatar
Bruce Momjian committed
1608 1609 1610
	 * Create dest receiver in MessageContext (we don't want it in
	 * transaction context, because that may get deleted if portal
	 * contains VACUUM).
1611 1612 1613
	 */
	receiver = CreateDestReceiver(dest, portal);

1614
	/*
Bruce Momjian's avatar
Bruce Momjian committed
1615 1616
	 * Ensure we are in a transaction command (this should normally be the
	 * case already due to prior BIND).
1617 1618 1619 1620 1621 1622 1623 1624 1625 1626
	 */
	start_xact_command();

	/*
	 * 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)
1627 1628 1629
			ereport(ERROR,
					(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
					 errmsg("current transaction is aborted, "
1630
					 "commands ignored until end of transaction block")));
1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643
	}

	/* Check for cancel signal before we start execution */
	CHECK_FOR_INTERRUPTS();

	/*
	 * Okay to run the portal.
	 */
	if (max_rows <= 0)
		max_rows = FETCH_ALL;

	completed = PortalRun(portal,
						  max_rows,
1644 1645
						  receiver,
						  receiver,
1646 1647
						  completionTag);

1648
	(*receiver->rDestroy) (receiver);
1649

1650 1651 1652 1653 1654
	if (completed)
	{
		if (is_trans_stmt)
		{
			/*
Bruce Momjian's avatar
Bruce Momjian committed
1655 1656 1657
			 * If this was a transaction control statement, commit it.	We
			 * will start a new xact command for the next command (if
			 * any).
1658
			 */
1659
			finish_xact_command();
1660 1661 1662 1663
		}
		else
		{
			/*
Bruce Momjian's avatar
Bruce Momjian committed
1664 1665
			 * We need a CommandCounterIncrement after every query, except
			 * those that start or end a transaction block.
1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691
			 */
			CommandCounterIncrement();
		}

		/* Send appropriate CommandComplete to client */
		EndCommand(completionTag, dest);
	}
	else
	{
		/* Portal run not complete, so send PortalSuspended */
		if (whereToSendOutput == Remote)
			pq_putemptymessage('s');
	}

	debug_query_string = NULL;
}

/*
 * exec_describe_statement_message
 *
 * Process a "Describe" message for a prepared statement
 */
static void
exec_describe_statement_message(const char *stmt_name)
{
	PreparedStatement *pstmt;
1692
	TupleDesc	tupdesc;
1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703
	List	   *l;
	StringInfoData buf;

	/* 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)
1704 1705
			ereport(ERROR,
					(errcode(ERRCODE_UNDEFINED_PSTATEMENT),
Bruce Momjian's avatar
Bruce Momjian committed
1706
				   errmsg("unnamed prepared statement does not exist")));
1707 1708 1709 1710 1711
	}

	if (whereToSendOutput != Remote)
		return;					/* can't actually do anything... */

1712 1713 1714
	/*
	 * First describe the parameters...
	 */
Bruce Momjian's avatar
Bruce Momjian committed
1715
	pq_beginmessage(&buf, 't'); /* parameter description message type */
1716
	pq_sendint(&buf, length(pstmt->argtype_list), 2);
1717 1718 1719 1720 1721 1722 1723 1724

	foreach(l, pstmt->argtype_list)
	{
		Oid			ptype = lfirsto(l);

		pq_sendint(&buf, (int) ptype, 4);
	}
	pq_endmessage(&buf);
1725 1726 1727 1728 1729 1730 1731

	/*
	 * Next send RowDescription or NoData to describe the result...
	 */
	tupdesc = FetchPreparedStatementResultDesc(pstmt);
	if (tupdesc)
	{
Bruce Momjian's avatar
Bruce Momjian committed
1732
		List	   *targetlist;
1733 1734 1735 1736 1737

		if (ChoosePortalStrategy(pstmt->query_list) == PORTAL_ONE_SELECT)
			targetlist = ((Query *) lfirst(pstmt->query_list))->targetList;
		else
			targetlist = NIL;
1738
		SendRowDescriptionMessage(tupdesc, targetlist, NULL);
1739 1740 1741 1742
	}
	else
		pq_putemptymessage('n');	/* NoData */

1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756
}

/*
 * exec_describe_portal_message
 *
 * Process a "Describe" message for a portal
 */
static void
exec_describe_portal_message(const char *portal_name)
{
	Portal		portal;

	portal = GetPortalByName(portal_name);
	if (!PortalIsValid(portal))
1757 1758 1759
		ereport(ERROR,
				(errcode(ERRCODE_UNDEFINED_CURSOR),
				 errmsg("portal \"%s\" does not exist", portal_name)));
1760 1761 1762 1763 1764

	if (whereToSendOutput != Remote)
		return;					/* can't actually do anything... */

	if (portal->tupDesc)
1765
	{
Bruce Momjian's avatar
Bruce Momjian committed
1766
		List	   *targetlist;
1767 1768

		if (portal->strategy == PORTAL_ONE_SELECT)
1769
			targetlist = ((Query *) lfirst(portal->parseTrees))->targetList;
1770 1771
		else
			targetlist = NIL;
1772 1773
		SendRowDescriptionMessage(portal->tupDesc, targetlist,
								  portal->formats);
1774
	}
1775 1776 1777 1778 1779
	else
		pq_putemptymessage('n');	/* NoData */
}


1780 1781 1782 1783 1784 1785
/*
 * Convenience routines for starting/committing a single command.
 */
static void
start_xact_command(void)
{
1786 1787
	if (!xact_started)
	{
1788 1789
		ereport(DEBUG3,
				(errmsg_internal("StartTransactionCommand")));
1790
		StartTransactionCommand();
1791 1792 1793 1794

		/* Set statement timeout running, if any */
		if (StatementTimeout > 0)
			enable_sig_alarm(StatementTimeout, true);
1795

1796 1797
		xact_started = true;
	}
1798 1799 1800
}

static void
1801
finish_xact_command(void)
1802
{
1803 1804 1805 1806
	if (xact_started)
	{
		/* Invoke IMMEDIATE constraint triggers */
		DeferredTriggerEndQuery();
1807

1808 1809
		/* Cancel any active statement timeout before committing */
		disable_sig_alarm(true);
1810

1811
		/* Now commit the command */
1812 1813
		ereport(DEBUG3,
				(errmsg_internal("CommitTransactionCommand")));
1814

1815
		CommitTransactionCommand();
1816

1817 1818 1819 1820 1821 1822
#ifdef MEMORY_CONTEXT_CHECKING
		/* Check all memory contexts that weren't freed during commit */
		/* (those that were, were checked before being deleted) */
		MemoryContextCheck(TopMemoryContext);
#endif

1823
#ifdef SHOW_MEMORY_STATS
1824
		/* Print mem stats after each commit for leak tracking */
1825 1826
		if (ShowStats)
			MemoryContextStats(TopMemoryContext);
1827
#endif
1828 1829 1830

		xact_started = false;
	}
1831 1832 1833
}


1834
/* --------------------------------
1835
 *		signal handler routines used in PostgresMain()
1836 1837 1838
 * --------------------------------
 */

1839
/*
Tom Lane's avatar
Tom Lane committed
1840
 * quickdie() occurs when signalled SIGQUIT by the postmaster.
1841 1842 1843 1844
 *
 * Some backend has bought the farm,
 * so we need to stop what we're doing and exit.
 */
Tom Lane's avatar
Tom Lane committed
1845
void
1846
quickdie(SIGNAL_ARGS)
1847
{
1848
	PG_SETMASK(&BlockSig);
Bruce Momjian's avatar
Bruce Momjian committed
1849

1850
	/*
Bruce Momjian's avatar
Bruce Momjian committed
1851 1852
	 * Ideally this should be ereport(FATAL), but then we'd not get
	 * control back (perhaps could fix by doing local sigsetjmp?)
1853 1854 1855
	 */
	ereport(WARNING,
			(errcode(ERRCODE_CRASH_SHUTDOWN),
1856 1857
		errmsg("terminating connection because of crash of another server process"),
	   errdetail("The postmaster has commanded this server process to roll back"
Bruce Momjian's avatar
Bruce Momjian committed
1858
				 " the current transaction and exit, because another"
1859
				 " server process exited abnormally and possibly corrupted"
Bruce Momjian's avatar
Bruce Momjian committed
1860
				 " shared memory."),
1861
			 errhint("In a moment you should be able to reconnect to the"
1862
					 " database and repeat your command.")));
Bruce Momjian's avatar
Bruce Momjian committed
1863

1864
	/*
1865 1866 1867 1868
	 * DO NOT proc_exit() -- we're here because shared memory may be
	 * corrupted, so we don't want to try to clean up our transaction.
	 * Just nail the windows shut and get out of town.
	 *
1869 1870 1871 1872
	 * Note we do exit(1) 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.
1873
	 */
1874
	exit(1);
1875 1876
}

1877
/*
1878 1879
 * Shutdown signal from postmaster: abort transaction and exit
 * at soonest convenient time
1880
 */
1881
void
1882
die(SIGNAL_ARGS)
1883
{
1884 1885 1886
	int			save_errno = errno;

	/* Don't joggle the elbow of proc_exit */
1887
	if (!proc_exit_inprogress)
1888
	{
1889
		InterruptPending = true;
1890
		ProcDiePending = true;
1891

1892
		/*
1893 1894
		 * If it's safe to interrupt, and we're waiting for input or a
		 * lock, service the interrupt immediately
1895
		 */
1896 1897
		if (ImmediateInterruptOK && InterruptHoldoffCount == 0 &&
			CritSectionCount == 0)
1898
		{
1899 1900 1901
			/* bump holdoff count to make ProcessInterrupts() a no-op */
			/* until we are done getting ready for it */
			InterruptHoldoffCount++;
1902
			DisableNotifyInterrupt();
1903
			/* Make sure CheckDeadLock won't run while shutting down... */
1904
			LockWaitCancel();
1905
			InterruptHoldoffCount--;
1906 1907
			ProcessInterrupts();
		}
1908
	}
1909 1910

	errno = save_errno;
1911 1912
}

1913
/*
1914
 * Timeout or shutdown signal from postmaster during client authentication.
1915
 * Simply exit(0).
1916 1917 1918
 *
 * XXX: possible future improvement: try to send a message indicating
 * why we are disconnecting.  Problem is to be sure we don't block while
1919
 * doing so, nor mess up the authentication message exchange.
1920 1921 1922 1923 1924 1925 1926
 */
void
authdie(SIGNAL_ARGS)
{
	exit(0);
}

1927
/*
1928 1929
 * Query-cancel signal from postmaster: abort current transaction
 * at soonest convenient time
1930
 */
1931
static void
1932
StatementCancelHandler(SIGNAL_ARGS)
1933
{
1934 1935
	int			save_errno = errno;

1936 1937 1938 1939
	/*
	 * Don't joggle the elbow of proc_exit, nor an already-in-progress
	 * abort
	 */
1940
	if (!proc_exit_inprogress && !InError)
1941
	{
1942 1943
		InterruptPending = true;
		QueryCancelPending = true;
1944

1945
		/*
1946
		 * If it's safe to interrupt, and we're waiting for a lock,
1947 1948
		 * service the interrupt immediately.  No point in interrupting if
		 * we're waiting for input, however.
1949
		 */
1950
		if (ImmediateInterruptOK && InterruptHoldoffCount == 0 &&
1951
			CritSectionCount == 0)
1952
		{
1953 1954 1955 1956 1957 1958
			/* bump holdoff count to make ProcessInterrupts() a no-op */
			/* until we are done getting ready for it */
			InterruptHoldoffCount++;
			if (LockWaitCancel())
			{
				DisableNotifyInterrupt();
Tom Lane's avatar
Tom Lane committed
1959
				InterruptHoldoffCount--;
1960 1961 1962 1963
				ProcessInterrupts();
			}
			else
				InterruptHoldoffCount--;
1964
		}
1965 1966
	}

1967
	errno = save_errno;
1968 1969
}

1970 1971 1972 1973
/* signal handler for floating point exception */
static void
FloatExceptionHandler(SIGNAL_ARGS)
{
1974 1975 1976
	ereport(ERROR,
			(errcode(ERRCODE_FLOATING_POINT_EXCEPTION),
			 errmsg("floating-point exception"),
Bruce Momjian's avatar
Bruce Momjian committed
1977 1978 1979
		   errdetail("An invalid floating-point operation was signaled. "
					 "This probably means an out-of-range result or an "
					 "invalid operation, such as division by zero.")));
1980 1981
}

1982
/* SIGHUP: set flag to re-read config file at next convenient time */
1983
static void
1984
SigHupHandler(SIGNAL_ARGS)
1985
{
1986
	got_SIGHUP = true;
1987 1988
}

1989

1990 1991 1992 1993 1994 1995 1996 1997 1998 1999
/*
 * ProcessInterrupts: out-of-line portion of CHECK_FOR_INTERRUPTS() macro
 *
 * If an interrupt condition is pending, and it's safe to service it,
 * then clear the flag and accept the interrupt.  Called only when
 * InterruptPending is true.
 */
void
ProcessInterrupts(void)
{
2000 2001
	/* OK to accept interrupt now? */
	if (InterruptHoldoffCount != 0 || CritSectionCount != 0)
2002 2003 2004 2005 2006
		return;
	InterruptPending = false;
	if (ProcDiePending)
	{
		ProcDiePending = false;
2007 2008
		QueryCancelPending = false;		/* ProcDie trumps QueryCancel */
		ImmediateInterruptOK = false;	/* not idle anymore */
2009
		DisableNotifyInterrupt();
2010 2011
		ereport(FATAL,
				(errcode(ERRCODE_ADMIN_SHUTDOWN),
Bruce Momjian's avatar
Bruce Momjian committed
2012
		 errmsg("terminating connection due to administrator command")));
2013 2014 2015 2016
	}
	if (QueryCancelPending)
	{
		QueryCancelPending = false;
2017
		ImmediateInterruptOK = false;	/* not idle anymore */
2018
		DisableNotifyInterrupt();
2019 2020 2021
		ereport(ERROR,
				(errcode(ERRCODE_QUERY_CANCELED),
				 errmsg("canceling query due to user request")));
2022 2023 2024 2025
	}
	/* If we get here, do nothing (probably, QueryCancelPending was reset) */
}

2026

2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084
/*
 * check_stack_depth: check for excessively deep recursion
 *
 * 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 ...
 */
void
check_stack_depth(void)
{
	char	stack_top_loc;
	int		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);
	/*
	 * Take abs value, since stacks grow up on some machines, down on others
	 */
	if (stack_depth < 0)
		stack_depth = -stack_depth;
	/*
	 * 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.
	 */
	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\".")));
	}
}

/* GUC assign hook to update max_stack_depth_bytes from max_stack_depth */
bool
assign_max_stack_depth(int newval, bool doit, GucSource source)
{
	/* Range check was already handled by guc.c */
	if (doit)
		max_stack_depth_bytes = newval * 1024;
	return true;
}


2085
static void
2086
usage(const char *progname)
2087
{
2088
	printf(gettext("%s is the PostgreSQL stand-alone backend.  It is not\nintended to be used by normal users.\n\n"), progname);
2089

2090 2091
	printf(gettext("Usage:\n  %s [OPTION]... [DBNAME]\n\n"), progname);
	printf(gettext("Options:\n"));
2092
#ifdef USE_ASSERT_CHECKING
2093
	printf(gettext("  -A 1|0          enable/disable run-time assert checking\n"));
2094
#endif
2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105
	printf(gettext("  -B NBUFFERS     number of shared buffers\n"));
	printf(gettext("  -c NAME=VALUE   set run-time parameter\n"));
	printf(gettext("  -d 0-5          debugging level (0 is off)\n"));
	printf(gettext("  -D DATADIR      database directory\n"));
	printf(gettext("  -e              use European date input format (DMY)\n"));
	printf(gettext("  -E              echo query before execution\n"));
	printf(gettext("  -F              turn fsync off\n"));
	printf(gettext("  -N              do not use newline as interactive query delimiter\n"));
	printf(gettext("  -o FILENAME     send stdout and stderr to given file\n"));
	printf(gettext("  -P              disable system indexes\n"));
	printf(gettext("  -s              show statistics after each query\n"));
2106
	printf(gettext("  -S WORK-MEM     set amount of memory for sorts (in kbytes)\n"));
2107
	printf(gettext("  --describe-config  describe configuration parameters, then exit\n"));
2108 2109 2110 2111 2112 2113 2114 2115 2116
	printf(gettext("  --help          show this help, then exit\n"));
	printf(gettext("  --version       output version information, then exit\n"));
	printf(gettext("\nDeveloper options:\n"));
	printf(gettext("  -f s|i|n|m|h    forbid use of some plan types\n"));
	printf(gettext("  -i              do not execute queries\n"));
	printf(gettext("  -O              allow system table structure changes\n"));
	printf(gettext("  -t pa|pl|ex     show timings after each query\n"));
	printf(gettext("  -W NUM          wait NUM seconds to allow attach from a debugger\n"));
	printf(gettext("\nReport bugs to <pgsql-bugs@postgresql.org>.\n"));
2117 2118
}

2119 2120


2121
/* ----------------------------------------------------------------
2122
 * PostgresMain
2123
 *	   postgres main loop -- all backends, interactive or otherwise start here
2124
 *
2125 2126 2127 2128
 * argc/argv are the command line arguments to be used.  (When being forked
 * by the postmaster, these are not the original argv array of the process.)
 * username is the (possibly authenticated) PostgreSQL user name to be used
 * for the session.
2129 2130 2131
 * ----------------------------------------------------------------
 */
int
2132
PostgresMain(int argc, char *argv[], const char *username)
2133
{
2134
	int			flag;
2135
	const char *dbname = NULL;
2136
	char	   *potential_DataDir = NULL;
2137
	bool		secure;
2138
	int			errs = 0;
2139
	int			debug_flag = 0;
Bruce Momjian's avatar
Bruce Momjian committed
2140 2141
	GucContext	ctx,
				debug_context;
2142
	GucSource	gucsource;
2143
	char	   *tmp;
2144
	int			firstchar;
2145
	char		stack_base;
2146
	StringInfoData	input_message;
2147
	volatile bool send_rfq = true;
2148

2149
	/*
2150 2151
	 * Catch standard options before doing much else.  This even works on
	 * systems without getopt_long.
2152 2153 2154
	 */
	if (!IsUnderPostmaster && argc > 1)
	{
2155
		if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
2156 2157 2158 2159
		{
			usage(argv[0]);
			exit(0);
		}
2160
		if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
2161 2162 2163 2164
		{
			puts("postgres (PostgreSQL) " PG_VERSION);
			exit(0);
		}
2165
	}
2166

2167 2168 2169 2170 2171 2172
	/*
	 * initialize globals (already done if under postmaster, but not if
	 * standalone; cheap enough to do over)
	 */
	MyProcPid = getpid();

2173 2174 2175 2176 2177
	/*
	 * Fire up essential subsystems: error and memory management
	 *
	 * If we are running under the postmaster, this is done already.
	 */
2178
	if (!IsUnderPostmaster)
2179 2180
		MemoryContextInit();

2181 2182
	set_ps_display("startup");

2183 2184
	SetProcessingMode(InitProcessing);

2185 2186 2187
	/* Set up reference point for stack depth checking */
	stack_base_ptr = &stack_base;

2188
	/*
2189
	 * Set default values for command-line options.
2190
	 */
2191
	EchoQuery = false;
2192

2193
	if (!IsUnderPostmaster)
2194
	{
2195
		InitializeGUCOptions();
2196
		potential_DataDir = getenv("PGDATA");
2197
	}
2198

2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215
	/* ----------------
	 *	parse command line arguments
	 *
	 *	There are now two styles of command line layout for the backend:
	 *
	 *	For interactive use (not started from postmaster) the format is
	 *		postgres [switches] [databasename]
	 *	If the databasename is omitted it is taken to be the user name.
	 *
	 *	When started from the postmaster, the format is
	 *		postgres [secure switches] -p databasename [insecure switches]
	 *	Switches appearing after -p came from the client (via "options"
	 *	field of connection request).  For security reasons we restrict
	 *	what these switches can do.
	 * ----------------
	 */

2216 2217
	/* all options are allowed until '-p' */
	secure = true;
2218
	ctx = debug_context = PGC_POSTMASTER;
2219
	gucsource = PGC_S_ARGV;		/* initial switches came from command line */
2220

2221
	while ((flag = getopt(argc, argv, "A:B:c:D:d:Eef:FiNOPo:p:S:st:v:W:-:")) != -1)
2222 2223
		switch (flag)
		{
2224 2225
			case 'A':
#ifdef USE_ASSERT_CHECKING
2226
				SetConfigOption("debug_assertions", optarg, ctx, gucsource);
2227
#else
2228 2229 2230
				ereport(WARNING,
						(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
						 errmsg("assert checking is not compiled in")));
2231 2232
#endif
				break;
2233

2234
			case 'B':
2235 2236 2237

				/*
				 * specify the size of buffer pool
2238
				 */
2239
				SetConfigOption("shared_buffers", optarg, ctx, gucsource);
2240
				break;
2241

2242
			case 'D':			/* PGDATA directory */
2243
				if (secure)
2244
					potential_DataDir = optarg;
2245
				break;
2246

2247
			case 'd':			/* debug level */
2248
				{
2249
					/*
Bruce Momjian's avatar
Bruce Momjian committed
2250 2251 2252 2253 2254
					 * Client option can't decrease debug level. We have
					 * to do the test here because we group priv and
					 * client set GUC calls below, after we know the final
					 * debug value.
					 */
2255
					if (ctx != PGC_BACKEND || atoi(optarg) > debug_flag)
2256
					{
2257
						debug_flag = atoi(optarg);
Bruce Momjian's avatar
Bruce Momjian committed
2258 2259
						debug_context = ctx;	/* save context for use
												 * below */
2260 2261 2262 2263
						/* Set server debugging level. */
						if (debug_flag != 0)
						{
							char	   *debugstr = palloc(strlen("debug") + strlen(optarg) + 1);
Bruce Momjian's avatar
Bruce Momjian committed
2264

2265 2266 2267
							sprintf(debugstr, "debug%s", optarg);
							SetConfigOption("log_min_messages", debugstr, ctx, gucsource);
							pfree(debugstr);
Bruce Momjian's avatar
Bruce Momjian committed
2268

2269 2270
						}
						else
Bruce Momjian's avatar
Bruce Momjian committed
2271

2272 2273
							/*
							 * -d0 allows user to prevent postmaster debug
Bruce Momjian's avatar
Bruce Momjian committed
2274 2275 2276
							 * from propagating to backend.  It would be
							 * nice to set it to the postgresql.conf value
							 * here.
2277 2278 2279
							 */
							SetConfigOption("log_min_messages", "notice",
											ctx, gucsource);
2280 2281
					}
				}
2282
				break;
2283 2284

			case 'E':
2285 2286 2287

				/*
				 * E - echo the query the user entered
2288
				 */
2289
				EchoQuery = true;
2290
				break;
2291 2292

			case 'e':
2293 2294

				/*
2295
				 * Use European date input format (DMY)
2296
				 */
2297
				SetConfigOption("datestyle", "euro", ctx, gucsource);
2298
				break;
2299 2300

			case 'F':
2301 2302 2303

				/*
				 * turn off fsync
2304
				 */
2305
				SetConfigOption("fsync", "false", ctx, gucsource);
2306
				break;
2307 2308

			case 'f':
2309 2310 2311

				/*
				 * f - forbid generation of certain plans
2312
				 */
2313
				tmp = NULL;
2314 2315 2316
				switch (optarg[0])
				{
					case 's':	/* seqscan */
2317
						tmp = "enable_seqscan";
2318 2319
						break;
					case 'i':	/* indexscan */
2320
						tmp = "enable_indexscan";
2321 2322
						break;
					case 't':	/* tidscan */
2323
						tmp = "enable_tidscan";
2324 2325
						break;
					case 'n':	/* nestloop */
2326
						tmp = "enable_nestloop";
2327 2328
						break;
					case 'm':	/* mergejoin */
2329
						tmp = "enable_mergejoin";
2330 2331
						break;
					case 'h':	/* hashjoin */
2332
						tmp = "enable_hashjoin";
2333 2334 2335 2336
						break;
					default:
						errs++;
				}
2337
				if (tmp)
2338
					SetConfigOption(tmp, "false", ctx, gucsource);
2339 2340
				break;

2341
			case 'N':
2342 2343 2344

				/*
				 * N - Don't use newline as a query delimiter
2345 2346 2347
				 */
				UseNewLine = 0;
				break;
2348

2349
			case 'O':
2350 2351 2352

				/*
				 * allow system table structure modifications
2353
				 */
2354 2355
				if (secure)		/* XXX safe to allow from client??? */
					allowSystemTableMods = true;
2356 2357
				break;

Hiroshi Inoue's avatar
Hiroshi Inoue committed
2358
			case 'P':
2359 2360 2361

				/*
				 * ignore system indexes
2362 2363 2364 2365
				 *
				 * 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.
Hiroshi Inoue's avatar
Hiroshi Inoue committed
2366
				 */
2367
				IgnoreSystemIndexes(true);
Hiroshi Inoue's avatar
Hiroshi Inoue committed
2368 2369
				break;

2370
			case 'o':
2371 2372 2373

				/*
				 * o - send output (stdout and stderr) to the given file
2374
				 */
2375 2376
				if (secure)
					StrNCpy(OutputFileName, optarg, MAXPGPATH);
2377 2378
				break;

2379
			case 'p':
2380 2381 2382
				/*
				 * p - special flag passed if backend was forked by a
				 * postmaster.
2383
				 */
2384 2385
				if (secure)
				{
2386
					dbname = strdup(optarg);
2387

Bruce Momjian's avatar
Bruce Momjian committed
2388 2389
					secure = false;		/* subsequent switches are NOT
										 * secure */
2390
					ctx = PGC_BACKEND;
2391
					gucsource = PGC_S_CLIENT;
2392
				}
2393
				break;
2394

2395
			case 'S':
2396 2397 2398

				/*
				 * S - amount of sort memory to use in 1k bytes
2399
				 */
2400
				SetConfigOption("work_mem", optarg, ctx, gucsource);
2401
				break;
2402 2403

			case 's':
2404 2405 2406

				/*
				 * s - report usage statistics (timings) after each query
2407
				 */
2408
				SetConfigOption("log_statement_stats", "true", ctx, gucsource);
2409 2410
				break;

2411
			case 't':
2412
				/* ---------------
2413 2414 2415 2416 2417 2418 2419 2420 2421
				 *	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.
				 * ----------------
				 */
2422
				tmp = NULL;
2423 2424 2425 2426
				switch (optarg[0])
				{
					case 'p':
						if (optarg[1] == 'a')
Bruce Momjian's avatar
Bruce Momjian committed
2427
							tmp = "log_parser_stats";
2428
						else if (optarg[1] == 'l')
Bruce Momjian's avatar
Bruce Momjian committed
2429
							tmp = "log_planner_stats";
2430 2431 2432 2433
						else
							errs++;
						break;
					case 'e':
2434
						tmp = "log_executor_stats";
2435 2436 2437 2438 2439
						break;
					default:
						errs++;
						break;
				}
2440
				if (tmp)
2441
					SetConfigOption(tmp, "true", ctx, gucsource);
2442 2443
				break;

2444
			case 'v':
2445 2446
				if (secure)
					FrontendProtocol = (ProtocolVersion) atoi(optarg);
2447 2448
				break;

2449
			case 'W':
2450 2451 2452

				/*
				 * wait N seconds to allow attach from a debugger
2453
				 */
2454
				pg_usleep(atoi(optarg)*1000000L);
2455 2456
				break;

2457
			case 'c':
2458
			case '-':
2459
				{
2460 2461
					char	   *name,
							   *value;
2462

2463 2464 2465 2466
					ParseLongOption(optarg, &name, &value);
					if (!value)
					{
						if (flag == '-')
2467 2468 2469 2470
							ereport(ERROR,
									(errcode(ERRCODE_SYNTAX_ERROR),
									 errmsg("--%s requires a value",
											optarg)));
2471
						else
2472 2473 2474 2475
							ereport(ERROR,
									(errcode(ERRCODE_SYNTAX_ERROR),
									 errmsg("-c %s requires a value",
											optarg)));
2476 2477
					}

2478
					SetConfigOption(name, value, ctx, gucsource);
2479 2480 2481 2482 2483
					free(name);
					if (value)
						free(value);
					break;
				}
2484

2485 2486
			default:
				errs++;
2487
				break;
2488 2489
		}

2490

2491
	/*
2492 2493
	 * -d is not the same as setting log_min_messages because it enables
	 * other output options.
2494 2495
	 */
	if (debug_flag >= 1)
2496
	{
2497
		SetConfigOption("log_connections", "true", debug_context, gucsource);
2498 2499
		SetConfigOption("log_disconnections", "true", debug_context, gucsource);
	}
2500
	if (debug_flag >= 2)
2501
		SetConfigOption("log_statement", "all", debug_context, gucsource);
2502
	if (debug_flag >= 3)
2503
		SetConfigOption("debug_print_parse", "true", debug_context, gucsource);
2504
	if (debug_flag >= 4)
2505
		SetConfigOption("debug_print_plan", "true", debug_context, gucsource);
2506
	if (debug_flag >= 5)
2507
		SetConfigOption("debug_print_rewritten", "true", debug_context, gucsource);
2508

2509
	/*
Bruce Momjian's avatar
Bruce Momjian committed
2510 2511
	 * Process any additional GUC variable settings passed in startup
	 * packet.
2512 2513 2514
	 */
	if (MyProcPort != NULL)
	{
Bruce Momjian's avatar
Bruce Momjian committed
2515
		List	   *gucopts = MyProcPort->guc_options;
2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527

		while (gucopts)
		{
			char	   *name,
					   *value;

			name = lfirst(gucopts);
			gucopts = lnext(gucopts);
			value = lfirst(gucopts);
			gucopts = lnext(gucopts);
			SetConfigOption(name, value, PGC_BACKEND, PGC_S_CLIENT);
		}
2528 2529 2530 2531 2532

		/*
		 * set up handler to log session end.
		 */
		if (IsUnderPostmaster && Log_disconnections)
2533
			on_proc_exit(log_disconnections,0);
2534 2535
	}

2536
	if (!IsUnderPostmaster || ExecBackend)
2537
	{
2538 2539
		if (!potential_DataDir)
		{
2540 2541 2542 2543 2544
			fprintf(stderr,
					gettext("%s does not know where to find the database system data.\n"
							"You must specify the directory that contains the database system\n"
							"either by specifying the -D invocation option or by setting the\n"
							"PGDATA environment variable.\n"),
2545 2546 2547 2548
					argv[0]);
			proc_exit(1);
		}
		SetDataDir(potential_DataDir);
2549
	}
2550
	Assert(DataDir);
2551

2552 2553 2554
	/* Acquire configuration parameters */
	if (IsUnderPostmaster)
	{
2555
#ifdef EXEC_BACKEND
2556
		read_nondefault_variables();
2557
#endif
2558
	} else
2559
		ProcessConfigFile(PGC_POSTMASTER);
2560

2561
	/*
2562
	 * Set up signal handlers and masks.
2563
	 *
2564
	 * Note that postmaster blocked all signals before forking child process,
2565 2566
	 * so there is no race condition whereby we might receive a signal
	 * before we have set up the handler.
Tom Lane's avatar
Tom Lane committed
2567 2568
	 *
	 * Also note: it's best not to use any signals that are SIG_IGNored in
2569
	 * the postmaster.	If such a signal arrives before we are able to
2570
	 * change the handler to non-SIG_IGN, it'll get dropped.  Instead,
Bruce Momjian's avatar
Bruce Momjian committed
2571 2572
	 * make a dummy handler in the postmaster to reserve the signal. (Of
	 * course, this isn't an issue for signals that are locally generated,
2573
	 * such as SIGALRM and SIGPIPE.)
2574
	 */
2575
	pqsignal(SIGHUP, SigHupHandler);	/* set flag to read config file */
Bruce Momjian's avatar
Bruce Momjian committed
2576
	pqsignal(SIGINT, StatementCancelHandler);	/* cancel current query */
2577
	pqsignal(SIGTERM, die);		/* cancel current query and exit */
2578
	pqsignal(SIGQUIT, quickdie);	/* hard crash time */
Bruce Momjian's avatar
Bruce Momjian committed
2579
	pqsignal(SIGALRM, handle_sig_alarm);		/* timeout conditions */
2580 2581 2582 2583 2584

	/*
	 * Ignore failure to write to frontend. Note: if frontend closes
	 * connection, we will notice it and exit cleanly when control next
	 * returns to outer loop.  This seems safer than forcing exit in the
2585 2586 2587
	 * midst of output during who-knows-what operation...
	 */
	pqsignal(SIGPIPE, SIG_IGN);
2588
	pqsignal(SIGUSR1, SIG_IGN); /* this signal available for use */
2589

2590
	pqsignal(SIGUSR2, Async_NotifyHandler);		/* flush also sinval cache */
2591
	pqsignal(SIGFPE, FloatExceptionHandler);
2592 2593

	/*
2594 2595
	 * Reset some signals that are accepted by postmaster but not by
	 * backend
2596
	 */
2597 2598
	pqsignal(SIGCHLD, SIG_DFL); /* system() requires this on some
								 * platforms */
2599

2600 2601
	pqinitmask();

Tom Lane's avatar
Tom Lane committed
2602
	/* We allow SIGQUIT (quickdie) at all times */
2603
#ifdef HAVE_SIGPROCMASK
Tom Lane's avatar
Tom Lane committed
2604
	sigdelset(&BlockSig, SIGQUIT);
2605
#else
Tom Lane's avatar
Tom Lane committed
2606
	BlockSig &= ~(sigmask(SIGQUIT));
2607 2608
#endif

Tom Lane's avatar
Tom Lane committed
2609
	PG_SETMASK(&BlockSig);		/* block everything except SIGQUIT */
2610

2611

2612
	if (IsUnderPostmaster)
2613
	{
2614
		/* noninteractive case: nothing should be left after switches */
2615
		if (errs || argc != optind || dbname == NULL)
2616
		{
2617 2618
			ereport(FATAL,
					(errcode(ERRCODE_SYNTAX_ERROR),
2619 2620
					 errmsg("invalid command-line arguments for server process"),
					 errhint("Try \"%s --help\" for more information.", argv[0])));
2621
		}
2622

2623 2624 2625
		XLOGPathInit();

		BaseInit();
2626
	}
2627
	else
2628
	{
2629 2630 2631
		/* interactive case: database name can be last arg on command line */
		if (errs || argc - optind > 1)
		{
2632 2633 2634 2635
			ereport(FATAL,
					(errcode(ERRCODE_SYNTAX_ERROR),
					 errmsg("%s: invalid command-line arguments",
							argv[0]),
2636
					 errhint("Try \"%s --help\" for more information.", argv[0])));
2637 2638
		}
		else if (argc - optind == 1)
2639 2640
			dbname = argv[optind];
		else if ((dbname = username) == NULL)
2641
		{
2642 2643 2644 2645
			ereport(FATAL,
					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
					 errmsg("%s: no database nor user name specified",
							argv[0])));
2646
		}
2647

2648 2649 2650 2651
		/*
		 * On some systems our dynloader code needs the executable's
		 * pathname.  (If under postmaster, this was done already.)
		 */
2652
		if (find_my_exec(pg_pathname, argv[0]) < 0)
2653 2654 2655
			ereport(FATAL,
					(errmsg("%s: could not locate postgres executable",
							argv[0])));
2656

2657
		/*
2658 2659
		 * Validate we have been given a reasonable-looking DataDir (if
		 * under postmaster, assume postmaster did this already).
2660 2661 2662
		 */
		ValidatePgVersion(DataDir);

2663
		/*
2664
		 * Create lockfile for data directory.
2665
		 */
2666
		CreateDataDirLockFile(DataDir, false);
2667

2668
		XLOGPathInit();
2669
		BaseInit();
2670 2671 2672 2673 2674

		/*
		 * Start up xlog for standalone backend, and register to have it
		 * closed down at exit.
		 */
2675
		StartupXLOG();
2676
		on_shmem_exit(ShutdownXLOG, 0);
2677 2678 2679 2680 2681 2682 2683

		/*
		 * Read any existing FSM cache file, and register to write one out
		 * at exit.
		 */
		LoadFreeSpaceMap();
		on_shmem_exit(DumpFreeSpaceMap, 0);
2684 2685
	}

2686
	/*
2687 2688 2689 2690 2691
	 * 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.
2692
	 */
2693 2694
	ereport(DEBUG3,
			(errmsg_internal("InitPostgres")));
2695
	InitPostgres(dbname, username);
2696

2697
	SetProcessingMode(NormalProcessing);
2698

2699 2700
	/*
	 * Send this backend's cancellation info to the frontend.
2701
	 */
2702 2703 2704
	if (whereToSendOutput == Remote &&
		PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
	{
2705
		StringInfoData buf;
Bruce Momjian's avatar
Bruce Momjian committed
2706

2707
		pq_beginmessage(&buf, 'K');
2708 2709 2710
		pq_sendint(&buf, (int32) MyProcPid, sizeof(int32));
		pq_sendint(&buf, (int32) MyCancelKey, sizeof(int32));
		pq_endmessage(&buf);
2711 2712 2713
		/* Need not flush since ReadyForQuery will do it. */
	}

2714 2715
	/* Welcome banner for standalone case */
	if (whereToSendOutput == Debug)
2716
		printf("\nPostgreSQL stand-alone backend %s\n", PG_VERSION);
2717

2718 2719 2720
	/*
	 * Create the memory context we will use in the main loop.
	 *
2721 2722
	 * MessageContext is reset once per iteration of the main loop, ie, upon
	 * completion of processing of each command message from the client.
2723
	 */
2724 2725 2726 2727 2728
	MessageContext = AllocSetContextCreate(TopMemoryContext,
										   "MessageContext",
										   ALLOCSET_DEFAULT_MINSIZE,
										   ALLOCSET_DEFAULT_INITSIZE,
										   ALLOCSET_DEFAULT_MAXSIZE);
2729

2730 2731 2732 2733 2734 2735 2736
	/* ----------
	 * Tell the statistics collector that we're alive and
	 * to which database we belong.
	 * ----------
	 */
	pgstat_bestart();

2737 2738
	/*
	 * POSTGRES main processing loop begins here
2739
	 *
2740 2741
	 * If an exception is encountered, processing resumes here so we abort
	 * the current transaction and start a new one.
2742 2743 2744 2745
	 */

	if (sigsetjmp(Warn_restart, 1) != 0)
	{
2746
		/*
2747
		 * NOTE: if you are tempted to add more code in this if-block,
2748 2749
		 * consider the probability that it should be in
		 * AbortTransaction() instead.
2750
		 *
2751 2752
		 * Make sure we're not interrupted while cleaning up.  Also forget
		 * any pending QueryCancel request, since we're aborting anyway.
Bruce Momjian's avatar
Bruce Momjian committed
2753 2754
		 * Force InterruptHoldoffCount to a known state in case we
		 * ereport'd from inside a holdoff section.
2755 2756 2757
		 */
		ImmediateInterruptOK = false;
		QueryCancelPending = false;
2758 2759
		InterruptHoldoffCount = 1;
		CritSectionCount = 0;	/* should be unnecessary, but... */
2760
		disable_sig_alarm(true);
Bruce Momjian's avatar
Bruce Momjian committed
2761
		QueryCancelPending = false;		/* again in case timeout occurred */
2762
		DisableNotifyInterrupt();
2763
		debug_query_string = NULL;
2764 2765

		/*
2766 2767 2768 2769 2770 2771
		 * Make sure we are in a valid memory context during recovery.
		 *
		 * We use ErrorContext in hopes that it will have some free space
		 * even if we're otherwise up against it...
		 */
		MemoryContextSwitchTo(ErrorContext);
2772

2773
		/* Do the recovery */
2774 2775
		ereport(DEBUG2,
				(errmsg_internal("AbortCurrentTransaction")));
2776
		AbortCurrentTransaction();
2777 2778

		/*
2779 2780
		 * Now return to normal top-level context and clear ErrorContext
		 * for next time.
2781 2782 2783
		 */
		MemoryContextSwitchTo(TopMemoryContext);
		MemoryContextResetAndDeleteChildren(ErrorContext);
2784
		ActivePortal = NULL;
2785 2786
		PortalContext = NULL;
		QueryContext = NULL;
2787 2788 2789 2790 2791

		/*
		 * Clear flag to indicate that we got out of error recovery mode
		 * successfully.  (Flag was set in elog.c before longjmp().)
		 */
2792
		InError = false;
2793 2794
		xact_started = false;

Jan Wieck's avatar
Jan Wieck committed
2795 2796 2797 2798 2799
		/*
		 * Clear flag that causes accounting for cost based vacuum.
		 */
		VacuumCostActive = false;

2800 2801
		/*
		 * If we were handling an extended-query-protocol message,
Bruce Momjian's avatar
Bruce Momjian committed
2802 2803
		 * initiate skip till next Sync.  This also causes us not to issue
		 * ReadyForQuery (until we get Sync).
2804 2805 2806
		 */
		if (doing_extended_query_message)
			ignore_till_sync = true;
2807 2808

		/*
2809
		 * Exit interrupt holdoff section we implicitly established above.
2810
		 */
2811
		RESUME_INTERRUPTS();
2812
	}
2813

2814
	Warn_restart_ready = true;	/* we can now handle ereport(ERROR) */
2815

2816
	PG_SETMASK(&UnBlockSig);
2817

2818 2819
	if (!ignore_till_sync)
		send_rfq = true;		/* initially, or after error */
2820

2821 2822
	/*
	 * Non-error queries loop here.
2823 2824 2825 2826
	 */

	for (;;)
	{
2827
		/*
Bruce Momjian's avatar
Bruce Momjian committed
2828 2829
		 * At top of loop, reset extended-query-message flag, so that any
		 * errors encountered in "idle" state don't provoke skip.
2830 2831 2832
		 */
		doing_extended_query_message = false;

2833
		/*
2834
		 * Release storage left over from prior query cycle, and create a
2835
		 * new query input buffer in the cleared MessageContext.
2836
		 */
2837 2838
		MemoryContextSwitchTo(MessageContext);
		MemoryContextResetAndDeleteChildren(MessageContext);
2839

2840
		initStringInfo(&input_message);
2841

2842
		/*
2843 2844
		 * (1) If we've reached idle state, tell the frontend we're ready
		 * for a new query.
2845
		 *
2846
		 * Note: this includes fflush()'ing the last of the prior output.
2847 2848 2849 2850 2851
		 *
		 * This is also a good time to send collected statistics to the
		 * collector, and to update the PS stats display.  We avoid doing
		 * those every time through the message loop because it'd slow down
		 * processing of batched messages.
Bruce Momjian's avatar
Bruce Momjian committed
2852
		 */
2853 2854
		if (send_rfq)
		{
2855
			pgstat_report_tabstat();
Bruce Momjian's avatar
Bruce Momjian committed
2856

2857
			if (IsTransactionOrTransactionBlock())
2858 2859 2860 2861 2862 2863 2864 2865 2866
			{
				set_ps_display("idle in transaction");
				pgstat_report_activity("<IDLE> in transaction");
			}
			else
			{
				set_ps_display("idle");
				pgstat_report_activity("<IDLE>");
			}
2867

2868 2869
			ReadyForQuery(whereToSendOutput);
			send_rfq = false;
2870
		}
2871

2872 2873 2874 2875
		/*
		 * (2) deal with pending asynchronous NOTIFY from other backends,
		 * and enable async.c's signal handler to execute NOTIFY directly.
		 * Then set up other stuff needed before blocking for input.
2876
		 */
2877 2878
		QueryCancelPending = false;		/* forget any earlier CANCEL
										 * signal */
2879 2880 2881

		EnableNotifyInterrupt();

2882 2883 2884 2885 2886 2887
		/* Allow "die" interrupt to be processed while waiting */
		ImmediateInterruptOK = true;
		/* and don't forget to detect one that already arrived */
		QueryCancelPending = false;
		CHECK_FOR_INTERRUPTS();

2888 2889
		/*
		 * (3) read a command (loop blocks here)
2890
		 */
2891 2892 2893 2894
		 if (!in_fatal_exit)
			firstchar = ReadCommand(&input_message);
		else
			firstchar = EOF;
2895

2896 2897
		/*
		 * (4) disable async signal conditions again.
2898
		 */
2899
		ImmediateInterruptOK = false;
2900
		QueryCancelPending = false;		/* forget any CANCEL signal */
2901

2902 2903
		DisableNotifyInterrupt();

2904 2905 2906
		/*
		 * (5) check for any other interesting events that happened while
		 * we slept.
2907 2908 2909 2910
		 */
		if (got_SIGHUP)
		{
			got_SIGHUP = false;
2911 2912 2913
#ifdef EXEC_BACKEND
			read_nondefault_variables();
#else
2914
			ProcessConfigFile(PGC_SIGHUP);
2915
#endif
2916 2917
		}

2918
		/*
Bruce Momjian's avatar
Bruce Momjian committed
2919 2920
		 * (6) process the command.  But ignore it if we're skipping till
		 * Sync.
2921
		 */
2922
		if (ignore_till_sync && firstchar != EOF)
2923 2924
			continue;

2925 2926
		switch (firstchar)
		{
2927
			case 'Q':			/* simple query */
2928
				{
2929 2930
					const char *query_string;

2931 2932
					query_string = pq_getmsgstring(&input_message);
					pq_getmsgend(&input_message);
2933

2934
					exec_simple_query(query_string);
2935

2936 2937
					send_rfq = true;
				}
2938 2939
				break;

2940 2941 2942 2943 2944 2945 2946
			case 'P':			/* parse */
				{
					const char *stmt_name;
					const char *query_string;
					int			numParams;
					Oid		   *paramTypes = NULL;

2947 2948 2949
					stmt_name = pq_getmsgstring(&input_message);
					query_string = pq_getmsgstring(&input_message);
					numParams = pq_getmsgint(&input_message, 2);
2950 2951
					if (numParams > 0)
					{
Bruce Momjian's avatar
Bruce Momjian committed
2952
						int			i;
2953 2954 2955

						paramTypes = (Oid *) palloc(numParams * sizeof(Oid));
						for (i = 0; i < numParams; i++)
2956
							paramTypes[i] = pq_getmsgint(&input_message, 4);
2957
					}
2958
					pq_getmsgend(&input_message);
2959 2960 2961 2962 2963 2964 2965

					exec_parse_message(query_string, stmt_name,
									   paramTypes, numParams);
				}
				break;

			case 'B':			/* bind */
Bruce Momjian's avatar
Bruce Momjian committed
2966

2967
				/*
Bruce Momjian's avatar
Bruce Momjian committed
2968 2969
				 * this message is complex enough that it seems best to
				 * put the field extraction out-of-line
2970
				 */
2971
				exec_bind_message(&input_message);
2972 2973 2974 2975 2976
				break;

			case 'E':			/* execute */
				{
					const char *portal_name;
Bruce Momjian's avatar
Bruce Momjian committed
2977
					int			max_rows;
2978

2979 2980 2981
					portal_name = pq_getmsgstring(&input_message);
					max_rows = pq_getmsgint(&input_message, 4);
					pq_getmsgend(&input_message);
2982

2983
					exec_execute_message(portal_name, max_rows);
2984 2985 2986
				}
				break;

2987 2988
			case 'F':			/* fastpath function call */
				/* Tell the collector what we're doing */
2989 2990
				pgstat_report_activity("<FASTPATH> function call");

2991
				/* start an xact for this function invocation */
2992
				start_xact_command();
2993

2994 2995 2996
				/* switch back to message context */
				MemoryContextSwitchTo(MessageContext);

2997
				if (HandleFunctionRequest(&input_message) == EOF)
2998 2999
				{
					/* lost frontend connection during F message input */
Bruce Momjian's avatar
Bruce Momjian committed
3000

3001
					/*
3002
					 * Reset whereToSendOutput to prevent ereport from
Bruce Momjian's avatar
Bruce Momjian committed
3003
					 * attempting to send any more messages to client.
3004 3005 3006 3007
					 */
					if (whereToSendOutput == Remote)
						whereToSendOutput = None;

3008
					proc_exit(0);
3009
				}
3010 3011

				/* commit the function-invocation transaction */
3012
				finish_xact_command();
3013

3014
				send_rfq = true;
3015 3016
				break;

Bruce Momjian's avatar
Bruce Momjian committed
3017
			case 'C':			/* close */
3018
				{
Bruce Momjian's avatar
Bruce Momjian committed
3019
					int			close_type;
3020 3021
					const char *close_target;

3022 3023 3024
					close_type = pq_getmsgbyte(&input_message);
					close_target = pq_getmsgstring(&input_message);
					pq_getmsgend(&input_message);
3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052

					switch (close_type)
					{
						case 'S':
							if (close_target[0] != '\0')
								DropPreparedStatement(close_target, false);
							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;
							}
							break;
						case 'P':
							{
								Portal		portal;

								portal = GetPortalByName(close_target);
								if (PortalIsValid(portal))
									PortalDrop(portal, false);
							}
							break;
						default:
3053 3054
							ereport(ERROR,
									(errcode(ERRCODE_PROTOCOL_VIOLATION),
Bruce Momjian's avatar
Bruce Momjian committed
3055 3056
							   errmsg("invalid CLOSE message subtype %d",
									  close_type)));
3057 3058 3059 3060
							break;
					}

					if (whereToSendOutput == Remote)
Bruce Momjian's avatar
Bruce Momjian committed
3061
						pq_putemptymessage('3');		/* CloseComplete */
3062 3063 3064 3065 3066
				}
				break;

			case 'D':			/* describe */
				{
Bruce Momjian's avatar
Bruce Momjian committed
3067
					int			describe_type;
3068 3069
					const char *describe_target;

3070 3071 3072
					describe_type = pq_getmsgbyte(&input_message);
					describe_target = pq_getmsgstring(&input_message);
					pq_getmsgend(&input_message);
3073 3074 3075 3076 3077 3078 3079 3080 3081 3082

					switch (describe_type)
					{
						case 'S':
							exec_describe_statement_message(describe_target);
							break;
						case 'P':
							exec_describe_portal_message(describe_target);
							break;
						default:
3083 3084
							ereport(ERROR,
									(errcode(ERRCODE_PROTOCOL_VIOLATION),
Bruce Momjian's avatar
Bruce Momjian committed
3085 3086
							errmsg("invalid DESCRIBE message subtype %d",
								   describe_type)));
3087 3088 3089 3090 3091
							break;
					}
				}
				break;

Bruce Momjian's avatar
Bruce Momjian committed
3092
			case 'H':			/* flush */
3093
				pq_getmsgend(&input_message);
3094 3095 3096 3097
				if (whereToSendOutput == Remote)
					pq_flush();
				break;

Bruce Momjian's avatar
Bruce Momjian committed
3098
			case 'S':			/* sync */
3099
				pq_getmsgend(&input_message);
3100
				finish_xact_command();
3101 3102 3103
				send_rfq = true;
				break;

3104
				/*
Bruce Momjian's avatar
Bruce Momjian committed
3105 3106 3107
				 * 'X' means that the frontend is closing down the socket.
				 * EOF means unexpected loss of frontend connection.
				 * Either way, perform normal shutdown.
3108 3109
				 */
			case 'X':
3110
			case EOF:
Bruce Momjian's avatar
Bruce Momjian committed
3111

3112
				/*
Bruce Momjian's avatar
Bruce Momjian committed
3113 3114
				 * Reset whereToSendOutput to prevent ereport from
				 * attempting to send any more messages to client.
3115 3116 3117
				 */
				if (whereToSendOutput == Remote)
					whereToSendOutput = None;
3118

3119 3120
				/*
				 * NOTE: if you are tempted to add more code here, DON'T!
3121 3122
				 * Whatever you had in mind to do should be set up as an
				 * on_proc_exit or on_shmem_exit callback, instead.
3123 3124 3125
				 * Otherwise it will fail to be called during other
				 * backend-shutdown scenarios.
				 */
3126 3127
				proc_exit(!in_fatal_exit ? 0 : proc_exit_inprogress ||
												!IsUnderPostmaster);
3128

Bruce Momjian's avatar
Bruce Momjian committed
3129 3130 3131 3132
			case 'd':			/* copy data */
			case 'c':			/* copy done */
			case 'f':			/* copy fail */

3133
				/*
Bruce Momjian's avatar
Bruce Momjian committed
3134 3135
				 * Accept but ignore these messages, per protocol spec; we
				 * probably got here because a COPY failed, and the
3136 3137 3138 3139
				 * frontend is still sending data.
				 */
				break;

3140
			default:
3141 3142 3143 3144
				ereport(FATAL,
						(errcode(ERRCODE_PROTOCOL_VIOLATION),
						 errmsg("invalid frontend message type %d",
								firstchar)));
3145
		}
3146
	}							/* end of input-reading loop */
3147

3148 3149
	/* can't get here because the above loop never exits */
	Assert(false);
3150

3151
	return 1;					/* keep compiler quiet */
3152 3153
}

3154
#ifndef HAVE_GETRUSAGE
Bruce Momjian's avatar
Bruce Momjian committed
3155 3156
#include "rusagestub.h"
#else
3157
#include <sys/resource.h>
3158
#endif   /* HAVE_GETRUSAGE */
3159

3160 3161
static struct rusage Save_r;
static struct timeval Save_t;
3162 3163

void
3164
ResetUsage(void)
3165
{
3166
	getrusage(RUSAGE_SELF, &Save_r);
3167
	gettimeofday(&Save_t, NULL);
3168
	ResetBufferUsage();
3169
	/* ResetTupleCount(); */
3170 3171 3172
}

void
3173
ShowUsage(const char *title)
3174
{
3175
	StringInfoData str;
3176 3177 3178 3179
	struct timeval user,
				sys;
	struct timeval elapse_t;
	struct rusage r;
Bruce Momjian's avatar
Bruce Momjian committed
3180
	char	   *bufusage;
3181 3182

	getrusage(RUSAGE_SELF, &r);
3183
	gettimeofday(&elapse_t, NULL);
3184 3185
	memcpy((char *) &user, (char *) &r.ru_utime, sizeof(user));
	memcpy((char *) &sys, (char *) &r.ru_stime, sizeof(sys));
3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209
	if (elapse_t.tv_usec < Save_t.tv_usec)
	{
		elapse_t.tv_sec--;
		elapse_t.tv_usec += 1000000;
	}
	if (r.ru_utime.tv_usec < Save_r.ru_utime.tv_usec)
	{
		r.ru_utime.tv_sec--;
		r.ru_utime.tv_usec += 1000000;
	}
	if (r.ru_stime.tv_usec < Save_r.ru_stime.tv_usec)
	{
		r.ru_stime.tv_sec--;
		r.ru_stime.tv_usec += 1000000;
	}

	/*
	 * the only stats we don't show here are for memory usage -- i can't
	 * figure out how to interpret the relevant fields in the rusage
	 * struct, and they change names across o/s platforms, anyway. if you
	 * can figure out what the entries mean, you can somehow extract
	 * resident set size, shared text size, and unshared data and stack
	 * sizes.
	 */
3210
	initStringInfo(&str);
3211

3212 3213
	appendStringInfo(&str, "! system usage stats:\n");
	appendStringInfo(&str,
3214
			"!\t%ld.%06ld elapsed %ld.%06ld user %ld.%06ld system sec\n",
3215 3216 3217
					 (long) (elapse_t.tv_sec - Save_t.tv_sec),
					 (long) (elapse_t.tv_usec - Save_t.tv_usec),
					 (long) (r.ru_utime.tv_sec - Save_r.ru_utime.tv_sec),
Bruce Momjian's avatar
Bruce Momjian committed
3218
				   (long) (r.ru_utime.tv_usec - Save_r.ru_utime.tv_usec),
3219
					 (long) (r.ru_stime.tv_sec - Save_r.ru_stime.tv_sec),
Bruce Momjian's avatar
Bruce Momjian committed
3220
				  (long) (r.ru_stime.tv_usec - Save_r.ru_stime.tv_usec));
3221
	appendStringInfo(&str,
Bruce Momjian's avatar
Bruce Momjian committed
3222
					 "!\t[%ld.%06ld user %ld.%06ld sys total]\n",
3223 3224 3225 3226
					 (long) user.tv_sec,
					 (long) user.tv_usec,
					 (long) sys.tv_sec,
					 (long) sys.tv_usec);
3227
/* BeOS has rusage but only has some fields, and not these... */
3228
#if defined(HAVE_GETRUSAGE)
3229
	appendStringInfo(&str,
Bruce Momjian's avatar
Bruce Momjian committed
3230 3231
					 "!\t%ld/%ld [%ld/%ld] filesystem blocks in/out\n",
					 r.ru_inblock - Save_r.ru_inblock,
3232
	/* they only drink coffee at dec */
Bruce Momjian's avatar
Bruce Momjian committed
3233 3234
					 r.ru_oublock - Save_r.ru_oublock,
					 r.ru_inblock, r.ru_oublock);
3235
	appendStringInfo(&str,
3236
		  "!\t%ld/%ld [%ld/%ld] page faults/reclaims, %ld [%ld] swaps\n",
Bruce Momjian's avatar
Bruce Momjian committed
3237 3238 3239 3240 3241
					 r.ru_majflt - Save_r.ru_majflt,
					 r.ru_minflt - Save_r.ru_minflt,
					 r.ru_majflt, r.ru_minflt,
					 r.ru_nswap - Save_r.ru_nswap,
					 r.ru_nswap);
3242
	appendStringInfo(&str,
3243
	 "!\t%ld [%ld] signals rcvd, %ld/%ld [%ld/%ld] messages rcvd/sent\n",
Bruce Momjian's avatar
Bruce Momjian committed
3244 3245 3246 3247 3248
					 r.ru_nsignals - Save_r.ru_nsignals,
					 r.ru_nsignals,
					 r.ru_msgrcv - Save_r.ru_msgrcv,
					 r.ru_msgsnd - Save_r.ru_msgsnd,
					 r.ru_msgrcv, r.ru_msgsnd);
3249
	appendStringInfo(&str,
3250
		 "!\t%ld/%ld [%ld/%ld] voluntary/involuntary context switches\n",
Bruce Momjian's avatar
Bruce Momjian committed
3251 3252 3253
					 r.ru_nvcsw - Save_r.ru_nvcsw,
					 r.ru_nivcsw - Save_r.ru_nivcsw,
					 r.ru_nvcsw, r.ru_nivcsw);
3254
#endif   /* HAVE_GETRUSAGE */
3255 3256

	bufusage = ShowBufferUsage();
3257
	appendStringInfo(&str, "! buffer usage stats:\n%s", bufusage);
3258 3259 3260
	pfree(bufusage);

	/* remove trailing newline */
Bruce Momjian's avatar
Bruce Momjian committed
3261
	if (str.data[str.len - 1] == '\n')
3262 3263
		str.data[--str.len] = '\0';

3264 3265 3266
	ereport(LOG,
			(errmsg_internal("%s", title),
			 errdetail("%s", str.data)));
3267 3268

	pfree(str.data);
3269
}
3270 3271 3272 3273 3274

/*
 * on_proc_exit handler to log end of session
 */
static void 
3275
log_disconnections(int code, Datum arg)
3276
{
Bruce Momjian's avatar
Add:  
Bruce Momjian committed
3277
	Port *port = MyProcPort;
3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290
	struct timeval end;
	int  hours, minutes, seconds;

	char session_time[20];
	char uname[6+NAMEDATALEN];
	char dbname[10+NAMEDATALEN];
	char remote_host[7 + NI_MAXHOST];
	char remote_port[7 + NI_MAXSERV];
      
	snprintf(uname, sizeof(uname)," user=%s",port->user_name);
	snprintf(dbname, sizeof(dbname)," database=%s",port->database_name);
	snprintf(remote_host,sizeof(remote_host)," host=%s",
			 port->remote_host);
3291
	snprintf(remote_port,sizeof(remote_port)," port=%s",port->remote_port);
3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314


	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;

	hours = end.tv_sec / 3600;
	end.tv_sec %= 3600;
	minutes = end.tv_sec / 60;
	seconds = end.tv_sec % 60;

	/* if time has gone backwards for some reason say so, or print time */

	if (end.tv_sec < 0)
		snprintf(session_time,sizeof(session_time),"negative!");
	else
		/* for stricter accuracy here we could round - this is close enough */
3315 3316 3317
		snprintf(session_time, sizeof(session_time),
			 "%d:%02d:%02d.%02d",
			 hours, minutes, seconds, (int) (end.tv_usec/10000));
3318 3319 3320 3321 3322 3323 3324
      
	ereport(
		LOG,
		(errmsg("disconnection: session time: %s%s%s%s%s",
				session_time,uname,dbname,remote_host,remote_port)));

}