postgres.c 80.6 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
 *	  $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.376 2003/11/24 14:49:51 tgl 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
/* ----------------
73
 *		global variables
74 75
 * ----------------
 */
76
const char *debug_query_string; /* for pgmonitor and
Bruce Momjian's avatar
Bruce Momjian committed
77
								 * log_min_error_statement */
78

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

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

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

88 89 90 91 92 93 94 95 96
/*
 * Flags for expensive function optimization -- JMH 3/9/92
 */
int			XfuncMode = 0;

/* ----------------
 *		private variables
 * ----------------
 */
97

98 99 100 101 102 103 104
/*
 * 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;

105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
/*
 * 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
132 133
 */
#ifndef TCOP_DONTUSENEWLINE
134
static int	UseNewLine = 1;		/* Use newlines query delimiters (the
135
								 * default) */
Bruce Momjian's avatar
Bruce Momjian committed
136

137
#else
138
static int	UseNewLine = 0;		/* Use EOF as query delimiters */
139
#endif   /* TCOP_DONTUSENEWLINE */
140 141 142


/* ----------------------------------------------------------------
143
 *		decls for routines only used in this file
144 145
 * ----------------------------------------------------------------
 */
146 147 148
static int	InteractiveBackend(StringInfo inBuf);
static int	SocketBackend(StringInfo inBuf);
static int	ReadCommand(StringInfo inBuf);
149
static void start_xact_command(void);
150
static void finish_xact_command(void);
151 152
static void SigHupHandler(SIGNAL_ARGS);
static void FloatExceptionHandler(SIGNAL_ARGS);
153 154 155


/* ----------------------------------------------------------------
156
 *		routines to obtain user input
157 158 159 160
 * ----------------------------------------------------------------
 */

/* ----------------
161
 *	InteractiveBackend() is called for user interactive connections
162 163 164
 *
 *	the string entered by the user is placed in its parameter inBuf,
 *	and we act like a Q message was received.
165
 *
166
 *	EOF is returned if end-of-file input is seen; time to shut down.
167 168 169
 * ----------------
 */

170
static int
171
InteractiveBackend(StringInfo inBuf)
172
{
173 174 175
	int			c;				/* character read from getc() */
	bool		end = false;	/* end-of-input flag */
	bool		backslashSeen = false;	/* have we seen a \ ? */
176

177 178
	/*
	 * display a prompt and obtain input from the user
179
	 */
180
	printf("backend> ");
181
	fflush(stdout);
182

183 184 185
	/* Reset inBuf to empty */
	inBuf->len = 0;
	inBuf->data[0] = '\0';
186
	inBuf->cursor = 0;
187

188 189 190 191
	for (;;)
	{
		if (UseNewLine)
		{
192 193 194
			/*
			 * if we are using \n as a delimiter, then read characters
			 * until the \n.
195 196 197 198 199 200 201
			 */
			while ((c = getc(stdin)) != EOF)
			{
				if (c == '\n')
				{
					if (backslashSeen)
					{
202 203 204
						/* discard backslash from inBuf */
						inBuf->data[--inBuf->len] = '\0';
						backslashSeen = false;
205 206 207 208 209
						continue;
					}
					else
					{
						/* keep the newline character */
210
						appendStringInfoChar(inBuf, '\n');
211 212 213 214 215 216 217 218
						break;
					}
				}
				else if (c == '\\')
					backslashSeen = true;
				else
					backslashSeen = false;

219
				appendStringInfoChar(inBuf, (char) c);
220 221 222 223 224 225 226
			}

			if (c == EOF)
				end = true;
		}
		else
		{
227 228
			/*
			 * otherwise read characters until EOF.
229 230
			 */
			while ((c = getc(stdin)) != EOF)
231
				appendStringInfoChar(inBuf, (char) c);
232

233
			if (inBuf->len == 0)
234 235 236 237
				end = true;
		}

		if (end)
238
			return EOF;
239

240 241
		/*
		 * otherwise we have a user query so process it.
242 243 244 245
		 */
		break;
	}

246 247 248
	/* Add '\0' to make it look the same as message case. */
	appendStringInfoChar(inBuf, (char) '\0');

249 250
	/*
	 * if the query echo flag was given, print the query..
251 252
	 */
	if (EchoQuery)
253
		printf("statement: %s\n", inBuf->data);
254
	fflush(stdout);
255

256
	return 'Q';
257 258 259
}

/* ----------------
260
 *	SocketBackend()		Is called for frontend-backend connections
261
 *
262
 *	Returns the message type code, and loads message body data into inBuf.
263
 *
264
 *	EOF is returned if the connection is lost.
265 266
 * ----------------
 */
267
static int
268
SocketBackend(StringInfo inBuf)
269
{
270
	int			qtype;
271

272
	/*
273
	 * Get message type code from the frontend.
274
	 */
275
	qtype = pq_getbyte();
276

277 278
	if (qtype == EOF)			/* frontend disconnected */
	{
279 280 281
		ereport(COMMERROR,
				(errcode(ERRCODE_PROTOCOL_VIOLATION),
				 errmsg("unexpected EOF on client connection")));
282 283 284 285 286
		return qtype;
	}

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

310
		case 'F':				/* fastpath function call */
311 312
			/* we let fastpath.c cope with old-style input of this */
			doing_extended_query_message = false;
313
			break;
314

315
		case 'X':				/* terminate */
316
			doing_extended_query_message = false;
317
			ignore_till_sync = false;
318 319 320 321 322 323 324 325 326 327 328
			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)
329 330
				ereport(FATAL,
						(errcode(ERRCODE_PROTOCOL_VIOLATION),
Bruce Momjian's avatar
Bruce Momjian committed
331
					 errmsg("invalid frontend message type %d", qtype)));
332 333 334 335 336 337 338 339 340
			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)
341 342
				ereport(FATAL,
						(errcode(ERRCODE_PROTOCOL_VIOLATION),
Bruce Momjian's avatar
Bruce Momjian committed
343
					 errmsg("invalid frontend message type %d", qtype)));
344
			break;
345

346 347 348
		case 'd':				/* copy data */
		case 'c':				/* copy done */
		case 'f':				/* copy fail */
349 350 351
			doing_extended_query_message = false;
			/* these are 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
		default:
Bruce Momjian's avatar
Bruce Momjian committed
358

359
			/*
Bruce Momjian's avatar
Bruce Momjian committed
360 361 362
			 * 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.
363
			 */
364 365 366
			ereport(FATAL,
					(errcode(ERRCODE_PROTOCOL_VIOLATION),
					 errmsg("invalid frontend message type %d", qtype)));
367
			break;
368
	}
369

370 371 372 373 374 375 376 377 378 379 380
	/*
	 * 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 */
	}

381
	return qtype;
382 383 384
}

/* ----------------
385
 *		ReadCommand reads a command from either the frontend or
386 387 388
 *		standard input, places it in inBuf, and returns the
 *		message type code (first byte of the message).
 *		EOF is returned if end of file.
389 390
 * ----------------
 */
391
static int
392
ReadCommand(StringInfo inBuf)
393
{
394
	int			result;
395

396
	if (IsUnderPostmaster)
397
		result = SocketBackend(inBuf);
398
	else
399 400
		result = InteractiveBackend(inBuf);
	return result;
401 402
}

403 404 405 406 407 408

/*
 * 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.
409 410 411
 *
 * NOTE: this routine is no longer used for processing interactive queries,
 * but it is still needed for parsing of SQL function bodies.
412
 */
413
List *
Bruce Momjian's avatar
Bruce Momjian committed
414
pg_parse_and_rewrite(const char *query_string,	/* string to execute */
415
					 Oid *paramTypes,	/* parameter types */
Bruce Momjian's avatar
Bruce Momjian committed
416
					 int numParams)		/* number of parameters */
417
{
418
	List	   *raw_parsetree_list;
419
	List	   *querytree_list;
420 421
	List	   *list_item;

422 423
	/*
	 * (1) parse the request string into a list of raw parse trees.
424
	 */
425
	raw_parsetree_list = pg_parse_query(query_string);
426

427 428
	/*
	 * (2) Do parse analysis and rule rewrite.
429 430 431 432
	 */
	querytree_list = NIL;
	foreach(list_item, raw_parsetree_list)
	{
433
		Node	   *parsetree = (Node *) lfirst(list_item);
434 435

		querytree_list = nconc(querytree_list,
436 437 438
							   pg_analyze_and_rewrite(parsetree,
													  paramTypes,
													  numParams));
439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456
	}

	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.
 */
457
List *
458
pg_parse_query(const char *query_string)
459 460
{
	List	   *raw_parsetree_list;
461

Bruce Momjian's avatar
Bruce Momjian committed
462
	if (log_statement)
463
		ereport(LOG,
464
				(errmsg("statement: %s", query_string)));
465

Bruce Momjian's avatar
Bruce Momjian committed
466
	if (log_parser_stats)
467 468
		ResetUsage();

469
	raw_parsetree_list = raw_parser(query_string);
470

Bruce Momjian's avatar
Bruce Momjian committed
471
	if (log_parser_stats)
472
		ShowUsage("PARSER STATISTICS");
473 474 475 476 477

	return raw_parsetree_list;
}

/*
478 479
 * Given a raw parsetree (gram.y output), and optionally information about
 * types of parameter symbols ($n), perform parse analysis and rule rewriting.
480 481 482 483 484 485
 *
 * 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.
 */
486
List *
487
pg_analyze_and_rewrite(Node *parsetree, Oid *paramTypes, int numParams)
488 489 490
{
	List	   *querytree_list;

491 492
	/*
	 * (1) Perform parse analysis.
493
	 */
Bruce Momjian's avatar
Bruce Momjian committed
494
	if (log_parser_stats)
495 496
		ResetUsage();

497
	querytree_list = parse_analyze(parsetree, paramTypes, numParams);
498

Bruce Momjian's avatar
Bruce Momjian committed
499
	if (log_parser_stats)
500
		ShowUsage("PARSE ANALYSIS STATISTICS");
501

502 503
	/*
	 * (2) Rewrite the queries, as necessary
504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
	 */
	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
523 524
	 * rewritten queries are collected in new_list.  Note there may be
	 * more or fewer than in the original list.
525
	 */
526
	foreach(list_item, querytree_list)
527
	{
528
		Query	   *querytree = (Query *) lfirst(list_item);
529

530
		if (Debug_print_parse)
531
			elog_node_display(DEBUG1, "parse tree", querytree,
532
							  Debug_pretty_print);
533 534 535

		if (querytree->commandType == CMD_UTILITY)
		{
536 537
			/* don't rewrite utilities, just dump 'em into new_list */
			new_list = lappend(new_list, querytree);
538
		}
539
		else
540
		{
541
			/* rewrite regular queries */
542 543
			List	   *rewritten = QueryRewrite(querytree);

544
			new_list = nconc(new_list, rewritten);
545 546 547 548 549
		}
	}

	querytree_list = new_list;

Bruce Momjian's avatar
Bruce Momjian committed
550
	if (log_parser_stats)
551
		ShowUsage("REWRITER STATISTICS");
552

553
#ifdef COPY_PARSE_PLAN_TREES
554 555 556 557 558

	/*
	 * Optional debugging check: pass querytree output through
	 * copyObject()
	 */
559 560
	new_list = (List *) copyObject(querytree_list);
	/* This checks both copyObject() and the equal() routines... */
561
	if (!equal(new_list, querytree_list))
562
		elog(WARNING, "copyObject() failed to produce an equal parse tree");
563 564
	else
		querytree_list = new_list;
565 566
#endif

567
	if (Debug_print_rewritten)
568
		elog_node_display(DEBUG1, "rewritten parse tree", querytree_list,
569
						  Debug_pretty_print);
570

571 572
	return querytree_list;
}
573 574


575
/* Generate a plan for a single already-rewritten query. */
576 577 578 579
Plan *
pg_plan_query(Query *querytree)
{
	Plan	   *plan;
580

581 582 583
	/* Utility commands have no plans. */
	if (querytree->commandType == CMD_UTILITY)
		return NULL;
584

Bruce Momjian's avatar
Bruce Momjian committed
585
	if (log_planner_stats)
586
		ResetUsage();
587

588
	/* call the optimizer */
589
	plan = planner(querytree, false, 0);
590

Bruce Momjian's avatar
Bruce Momjian committed
591
	if (log_planner_stats)
592
		ShowUsage("PLANNER STATISTICS");
593

594 595 596
#ifdef COPY_PARSE_PLAN_TREES
	/* Optional debugging check: pass plan output through copyObject() */
	{
597
		Plan	   *new_plan = (Plan *) copyObject(plan);
598

599 600
		/*
		 * equal() currently does not have routines to compare Plan nodes,
601 602 603 604
		 * so don't try to test equality here.  Perhaps fix someday?
		 */
#ifdef NOT_USED
		/* This checks both copyObject() and the equal() routines... */
605
		if (!equal(new_plan, plan))
606
			elog(WARNING, "copyObject() failed to produce an equal plan tree");
607 608 609 610 611 612
		else
#endif
			plan = new_plan;
	}
#endif

613 614
	/*
	 * Print plan if debugging.
615
	 */
616
	if (Debug_print_plan)
617
		elog_node_display(DEBUG1, "plan", plan, Debug_pretty_print);
618

619
	return plan;
620 621
}

622 623
/*
 * Generate plans for a list of already-rewritten queries.
624
 *
625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666
 * 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;
}


/*
667
 * exec_simple_query
668
 *
669
 * Execute a "simple Query" protocol message.
670
 */
671
static void
672
exec_simple_query(const char *query_string)
673
{
Bruce Momjian's avatar
Bruce Momjian committed
674
	CommandDest dest = whereToSendOutput;
675
	MemoryContext oldcontext;
676 677
	List	   *parsetree_list,
			   *parsetree_item;
Bruce Momjian's avatar
Bruce Momjian committed
678 679
	struct timeval start_t,
				stop_t;
Bruce Momjian's avatar
Bruce Momjian committed
680
	bool		save_log_duration = log_duration;
681
	int			save_log_min_duration_statement = log_min_duration_statement;
682
	bool		save_log_statement_stats = log_statement_stats;
683

684 685 686
	/*
	 * Report query to various monitoring facilities.
	 */
687
	debug_query_string = query_string;
688

689 690
	pgstat_report_activity(query_string);

691
	/*
Bruce Momjian's avatar
Bruce Momjian committed
692 693 694 695
	 * 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.
696
	 */
697
	if (save_log_duration || save_log_min_duration_statement != -1)
698
		gettimeofday(&start_t, NULL);
699

700 701 702
	if (save_log_statement_stats)
		ResetUsage();

703
	/*
704 705 706 707
	 * 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
708
	 * that this will normally change current memory context.)
709 710
	 */
	start_xact_command();
711 712

	/*
Bruce Momjian's avatar
Bruce Momjian committed
713 714 715 716
	 * 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.)
717 718 719 720 721 722 723 724
	 */
	unnamed_stmt_pstmt = NULL;
	if (unnamed_stmt_context)
	{
		DropDependentPortals(unnamed_stmt_context);
		MemoryContextDelete(unnamed_stmt_context);
	}
	unnamed_stmt_context = NULL;
725

726 727 728
	/*
	 * Switch to appropriate context for constructing parsetrees.
	 */
729
	oldcontext = MemoryContextSwitchTo(MessageContext);
730

731 732
	QueryContext = CurrentMemoryContext;

Bruce Momjian's avatar
Bruce Momjian committed
733
	/*
734 735
	 * Do basic parsing of the query or queries (this should be safe even
	 * if we are in aborted transaction state!)
736
	 */
737
	parsetree_list = pg_parse_query(query_string);
738

739
	/*
740
	 * Switch back to transaction context to enter the loop.
741 742 743 744
	 */
	MemoryContextSwitchTo(oldcontext);

	/*
745
	 * Run through the raw parsetree(s) and process each one.
746
	 */
747
	foreach(parsetree_item, parsetree_list)
748
	{
749
		Node	   *parsetree = (Node *) lfirst(parsetree_item);
750 751
		const char *commandTag;
		char		completionTag[COMPLETION_TAG_BUFSIZE];
752
		List	   *querytree_list,
753 754
				   *plantree_list;
		Portal		portal;
755 756
		DestReceiver *receiver;
		int16		format;
757

758
		/*
Bruce Momjian's avatar
Bruce Momjian committed
759 760 761 762
		 * 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.
763 764 765 766 767
		 */
		commandTag = CreateCommandTag(parsetree);

		set_ps_display(commandTag);

768
		BeginCommand(commandTag, dest);
769

770
		/*
771
		 * If we are in an aborted transaction, reject all commands except
772 773
		 * COMMIT/ABORT.  It is important that this test occur before we
		 * try to do parse analysis, rewrite, or planning, since all those
774 775 776
		 * 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...)
777 778
		 */
		if (IsAbortedTransactionBlockState())
779
		{
780
			bool		allowit = false;
781

782
			if (IsA(parsetree, TransactionStmt))
783 784 785
			{
				TransactionStmt *stmt = (TransactionStmt *) parsetree;

786 787
				if (stmt->kind == TRANS_STMT_COMMIT ||
					stmt->kind == TRANS_STMT_ROLLBACK)
788
					allowit = true;
789
			}
790

791
			if (!allowit)
792 793 794
				ereport(ERROR,
						(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
						 errmsg("current transaction is aborted, "
795
					 "commands ignored until end of transaction block")));
796
		}
797

798
		/* Make sure we are in a transaction command */
799
		start_xact_command();
800

801
		/* If we got a cancel signal in parsing or prior command, quit */
802
		CHECK_FOR_INTERRUPTS();
803 804

		/*
805
		 * OK to analyze, rewrite, and plan this query.
806
		 *
807 808
		 * Switch to appropriate context for constructing querytrees (again,
		 * these must outlive the execution context).
809
		 */
810
		oldcontext = MemoryContextSwitchTo(MessageContext);
811

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

814 815 816 817 818
		plantree_list = pg_plan_queries(querytree_list, true);

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

819
		/*
Bruce Momjian's avatar
Bruce Momjian committed
820 821
		 * Create unnamed portal to run the query or queries in. If there
		 * already is one, silently drop it.
822
		 */
823
		portal = CreatePortal("", true, true);
824

825 826 827 828 829 830
		PortalDefineQuery(portal,
						  query_string,
						  commandTag,
						  querytree_list,
						  plantree_list,
						  MessageContext);
831

832
		/*
833
		 * Start the portal.  No parameters here.
834 835
		 */
		PortalStart(portal, NULL);
836

837 838
		/*
		 * Select the appropriate output format: text unless we are doing
Bruce Momjian's avatar
Bruce Momjian committed
839 840 841
		 * 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...)
842 843 844 845 846 847 848 849 850 851 852 853
		 */
		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
854
					format = 1; /* BINARY */
855 856 857 858 859 860 861 862 863 864 865 866 867 868 869
			}
		}
		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
870 871
		 * Run the portal to completion, and then drop it (and the
		 * receiver).
872
		 */
873 874
		(void) PortalRun(portal,
						 FETCH_ALL,
875 876
						 receiver,
						 receiver,
877
						 completionTag);
878

879
		(*receiver->rDestroy) (receiver);
880

881
		PortalDrop(portal, false);
882

883
		if (IsA(parsetree, TransactionStmt))
884
		{
885
			/*
Bruce Momjian's avatar
Bruce Momjian committed
886 887 888
			 * If this was a transaction control statement, commit it. We
			 * will start a new xact command for the next command (if
			 * any).
889
			 */
890
			finish_xact_command();
891
		}
892
		else if (lnext(parsetree_item) == NIL)
893
		{
894
			/*
Bruce Momjian's avatar
Bruce Momjian committed
895 896 897 898 899 900 901 902 903
			 * 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.
904
			 */
905
			finish_xact_command();
906
		}
907
		else
908
		{
909
			/*
Bruce Momjian's avatar
Bruce Momjian committed
910 911
			 * We need a CommandCounterIncrement after every query, except
			 * those that start or end a transaction block.
912 913
			 */
			CommandCounterIncrement();
914
		}
915 916 917

		/*
		 * Tell client that we're done with this query.  Note we emit
Bruce Momjian's avatar
Bruce Momjian committed
918 919 920 921
		 * 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.)
922
		 */
923
		EndCommand(completionTag, dest);
924
	}							/* end loop over parsetrees */
925

926 927 928 929 930
	/*
	 * Close down transaction statement, if one is open.
	 */
	finish_xact_command();

931 932 933
	/*
	 * If there were no parsetrees, return EmptyQueryResponse message.
	 */
934
	if (!parsetree_list)
935 936
		NullCommand(dest);

937
	QueryContext = NULL;
938

939
	/*
Bruce Momjian's avatar
Bruce Momjian committed
940 941
	 * Combine processing here as we need to calculate the query duration
	 * in both instances.
942
	 */
943
	if (save_log_duration || save_log_min_duration_statement != -1)
944
	{
Bruce Momjian's avatar
Bruce Momjian committed
945 946
		long		usecs;

947
		gettimeofday(&stop_t, NULL);
948 949 950 951 952
		if (stop_t.tv_usec < start_t.tv_usec)
		{
			stop_t.tv_sec--;
			stop_t.tv_usec += 1000000;
		}
953 954
		usecs = (long) (stop_t.tv_sec - start_t.tv_sec) * 1000000 + (long) (stop_t.tv_usec - start_t.tv_usec);

955 956 957 958 959 960 961
		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
962
		/*
963 964
		 * Output a duration_statement to the log if the query has exceeded
		 * the min duration, or if we are to print all durations.
965
		 */
966 967 968
		if (save_log_min_duration_statement == 0 ||
			(save_log_min_duration_statement > 0 &&
			 usecs >= save_log_min_duration_statement * 1000))
969
			ereport(LOG,
970
					(errmsg("duration: %ld.%03ld ms  statement: %s",
971 972 973
							(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,
974
							query_string)));
975
	}
976

977 978 979
	if (save_log_statement_stats)
		ShowUsage("QUERY STATISTICS");

980
	debug_query_string = NULL;
981 982
}

983 984 985 986 987 988 989 990
/*
 * 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
991 992
				   Oid *paramTypes,		/* parameter types */
				   int numParams)		/* number of parameters */
993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024
{
	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
1025 1026 1027 1028 1029 1030 1031 1032 1033 1034
	 * 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.
1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070
	 */
	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
1071 1072 1073
	 * 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.
1074 1075
	 */
	if (length(parsetree_list) > 1)
1076 1077 1078
		ereport(ERROR,
				(errcode(ERRCODE_SYNTAX_ERROR),
				 errmsg("cannot insert multiple commands into a prepared statement")));
1079 1080 1081

	if (parsetree_list != NIL)
	{
Bruce Momjian's avatar
Bruce Momjian committed
1082 1083
		Node	   *parsetree = (Node *) lfirst(parsetree_list);
		int			i;
1084 1085 1086 1087 1088 1089 1090 1091

		/*
		 * 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
1092 1093 1094 1095
		 * 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
1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111
		 * 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)
1112 1113 1114
				ereport(ERROR,
						(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
						 errmsg("current transaction is aborted, "
1115
					 "commands ignored until end of transaction block")));
1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136
		}

		/*
		 * 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
1137
			Oid			ptype = paramTypes[i];
1138 1139

			if (ptype == InvalidOid || ptype == UNKNOWNOID)
1140 1141
				ereport(ERROR,
						(errcode(ERRCODE_INDETERMINATE_DATATYPE),
1142
				  errmsg("could not determine data type of parameter $%d",
Bruce Momjian's avatar
Bruce Momjian committed
1143
						 i + 1)));
1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155
			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
1156
		/* Empty input string.	This is legal. */
1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199
		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
1200 1201 1202 1203
	 * 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.
1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228
	 */
	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;
1229 1230
	int			numPFormats;
	int16	   *pformats = NULL;
1231
	int			numParams;
1232 1233 1234
	int			numRFormats;
	int16	   *rformats = NULL;
	int			i;
1235 1236 1237 1238 1239 1240 1241 1242 1243
	PreparedStatement *pstmt;
	Portal		portal;
	ParamListInfo params;

	pgstat_report_activity("<BIND>");

	set_ps_display("BIND");

	/*
Bruce Momjian's avatar
Bruce Momjian committed
1244 1245 1246
	 * 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.
1247 1248 1249
	 */
	start_xact_command();

1250 1251 1252
	/* Switch back to message context */
	MemoryContextSwitchTo(MessageContext);

1253 1254 1255 1256
	/* Get the fixed part of the message */
	portal_name = pq_getmsgstring(input_message);
	stmt_name = pq_getmsgstring(input_message);

1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269
	/* 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)
1270 1271
		ereport(ERROR,
				(errcode(ERRCODE_PROTOCOL_VIOLATION),
Bruce Momjian's avatar
Bruce Momjian committed
1272 1273
		errmsg("bind message has %d parameter formats but %d parameters",
			   numPFormats, numParams)));
1274 1275 1276 1277 1278 1279 1280 1281 1282

	/* 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)
1283 1284
			ereport(ERROR,
					(errcode(ERRCODE_UNDEFINED_PSTATEMENT),
Bruce Momjian's avatar
Bruce Momjian committed
1285
				   errmsg("unnamed prepared statement does not exist")));
1286 1287 1288
	}

	if (numParams != length(pstmt->argtype_list))
1289 1290 1291
		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
1292
					numParams, stmt_name, length(pstmt->argtype_list))));
1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312

	/*
	 * 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
1313 1314 1315
	 * 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.
1316 1317 1318
	 */
	if (numParams > 0)
	{
Bruce Momjian's avatar
Bruce Momjian committed
1319 1320
		bool		isaborted = IsAbortedTransactionBlockState();
		List	   *l;
1321 1322 1323 1324 1325 1326 1327
		MemoryContext oldContext;

		oldContext = MemoryContextSwitchTo(PortalGetHeapMemory(portal));

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

1328
		i = 0;
1329 1330 1331
		foreach(l, pstmt->argtype_list)
		{
			Oid			ptype = lfirsto(l);
1332
			int32		plength;
1333 1334
			bool		isNull;

1335 1336 1337
			plength = pq_getmsgint(input_message, 4);
			isNull = (plength == -1);

1338 1339
			if (!isNull)
			{
1340
				const char *pvalue = pq_getmsgbytes(input_message, plength);
1341 1342

				if (isaborted)
1343 1344
				{
					/* We don't bother to check the format in this case */
1345
					isNull = true;
1346
				}
1347 1348
				else
				{
Bruce Momjian's avatar
Bruce Momjian committed
1349
					int16		pformat;
1350
					StringInfoData pbuf;
Bruce Momjian's avatar
Bruce Momjian committed
1351
					char		csave;
1352 1353 1354 1355 1356 1357

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

1360
					/*
Bruce Momjian's avatar
Bruce Momjian committed
1361 1362 1363 1364 1365 1366 1367
					 * 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.
1368 1369 1370 1371 1372 1373 1374 1375 1376
					 */
					pbuf.data = (char *) pvalue;
					pbuf.maxlen = plength + 1;
					pbuf.len = plength;
					pbuf.cursor = 0;

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

1377 1378 1379 1380 1381 1382 1383
					if (pformat == 0)
					{
						Oid			typInput;
						Oid			typElem;
						char	   *pstring;

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

1385
						/*
Bruce Momjian's avatar
Bruce Momjian committed
1386 1387
						 * We have to do encoding conversion before
						 * calling the typinput routine.
1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402
						 */
						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)
					{
1403 1404 1405
						Oid			typReceive;
						Oid			typElem;

Bruce Momjian's avatar
Bruce Momjian committed
1406 1407 1408 1409
						/*
						 * Call the parameter type's binary input
						 * converter
						 */
1410 1411 1412 1413 1414 1415 1416 1417 1418
						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)
1419 1420 1421
							ereport(ERROR,
									(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
									 errmsg("incorrect binary data format in bind parameter %d",
Bruce Momjian's avatar
Bruce Momjian committed
1422
											i + 1)));
1423 1424 1425
					}
					else
					{
1426 1427 1428 1429
						ereport(ERROR,
								(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
								 errmsg("unsupported format code: %d",
										pformat)));
1430
					}
1431 1432 1433

					/* Restore message buffer contents */
					pbuf.data[plength] = csave;
1434 1435
				}
			}
1436

1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450
			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;

1451 1452 1453 1454 1455 1456 1457 1458 1459
	/* 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);
	}

1460 1461 1462 1463 1464 1465 1466
	pq_getmsgend(input_message);

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

1467 1468 1469 1470 1471
	/*
	 * Apply the result format requests to the portal.
	 */
	PortalSetResultFormat(portal, numRFormats, rformats);

1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484
	/*
	 * Send BindComplete.
	 */
	if (whereToSendOutput == Remote)
		pq_putemptymessage('2');
}

/*
 * exec_execute_message
 *
 * Process an "Execute" message for a portal
 */
static void
1485
exec_execute_message(const char *portal_name, long max_rows)
1486
{
Bruce Momjian's avatar
Bruce Momjian committed
1487
	CommandDest dest;
1488
	DestReceiver *receiver;
1489 1490 1491 1492 1493 1494 1495 1496 1497
	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)
1498
		dest = RemoteExecute;
1499 1500 1501

	portal = GetPortalByName(portal_name);
	if (!PortalIsValid(portal))
1502 1503 1504
		ereport(ERROR,
				(errcode(ERRCODE_UNDEFINED_CURSOR),
				 errmsg("portal \"%s\" does not exist", portal_name)));
1505 1506

	/*
Bruce Momjian's avatar
Bruce Momjian committed
1507 1508
	 * If the original query was a null string, just return
	 * EmptyQueryResponse.
1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534
	 */
	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
1535
		Query	   *query = (Query *) lfirst(portal->parseTrees);
1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549

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

1550
	/*
Bruce Momjian's avatar
Bruce Momjian committed
1551 1552 1553
	 * Create dest receiver in MessageContext (we don't want it in
	 * transaction context, because that may get deleted if portal
	 * contains VACUUM).
1554 1555 1556
	 */
	receiver = CreateDestReceiver(dest, portal);

1557
	/*
Bruce Momjian's avatar
Bruce Momjian committed
1558 1559
	 * Ensure we are in a transaction command (this should normally be the
	 * case already due to prior BIND).
1560 1561 1562 1563 1564 1565 1566 1567 1568 1569
	 */
	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)
1570 1571 1572
			ereport(ERROR,
					(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
					 errmsg("current transaction is aborted, "
1573
					 "commands ignored until end of transaction block")));
1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586
	}

	/* 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,
1587 1588
						  receiver,
						  receiver,
1589 1590
						  completionTag);

1591
	(*receiver->rDestroy) (receiver);
1592

1593 1594 1595 1596 1597
	if (completed)
	{
		if (is_trans_stmt)
		{
			/*
Bruce Momjian's avatar
Bruce Momjian committed
1598 1599 1600
			 * If this was a transaction control statement, commit it.	We
			 * will start a new xact command for the next command (if
			 * any).
1601
			 */
1602
			finish_xact_command();
1603 1604 1605 1606
		}
		else
		{
			/*
Bruce Momjian's avatar
Bruce Momjian committed
1607 1608
			 * We need a CommandCounterIncrement after every query, except
			 * those that start or end a transaction block.
1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634
			 */
			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;
1635
	TupleDesc	tupdesc;
1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646
	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)
1647 1648
			ereport(ERROR,
					(errcode(ERRCODE_UNDEFINED_PSTATEMENT),
Bruce Momjian's avatar
Bruce Momjian committed
1649
				   errmsg("unnamed prepared statement does not exist")));
1650 1651 1652 1653 1654
	}

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

1655 1656 1657
	/*
	 * First describe the parameters...
	 */
Bruce Momjian's avatar
Bruce Momjian committed
1658
	pq_beginmessage(&buf, 't'); /* parameter description message type */
1659
	pq_sendint(&buf, length(pstmt->argtype_list), 2);
1660 1661 1662 1663 1664 1665 1666 1667

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

		pq_sendint(&buf, (int) ptype, 4);
	}
	pq_endmessage(&buf);
1668 1669 1670 1671 1672 1673 1674

	/*
	 * Next send RowDescription or NoData to describe the result...
	 */
	tupdesc = FetchPreparedStatementResultDesc(pstmt);
	if (tupdesc)
	{
Bruce Momjian's avatar
Bruce Momjian committed
1675
		List	   *targetlist;
1676 1677 1678 1679 1680

		if (ChoosePortalStrategy(pstmt->query_list) == PORTAL_ONE_SELECT)
			targetlist = ((Query *) lfirst(pstmt->query_list))->targetList;
		else
			targetlist = NIL;
1681
		SendRowDescriptionMessage(tupdesc, targetlist, NULL);
1682 1683 1684 1685
	}
	else
		pq_putemptymessage('n');	/* NoData */

1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699
}

/*
 * 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))
1700 1701 1702
		ereport(ERROR,
				(errcode(ERRCODE_UNDEFINED_CURSOR),
				 errmsg("portal \"%s\" does not exist", portal_name)));
1703 1704 1705 1706 1707

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

	if (portal->tupDesc)
1708
	{
Bruce Momjian's avatar
Bruce Momjian committed
1709
		List	   *targetlist;
1710 1711

		if (portal->strategy == PORTAL_ONE_SELECT)
1712
			targetlist = ((Query *) lfirst(portal->parseTrees))->targetList;
1713 1714
		else
			targetlist = NIL;
1715 1716
		SendRowDescriptionMessage(portal->tupDesc, targetlist,
								  portal->formats);
1717
	}
1718 1719 1720 1721 1722
	else
		pq_putemptymessage('n');	/* NoData */
}


1723 1724 1725 1726 1727 1728
/*
 * Convenience routines for starting/committing a single command.
 */
static void
start_xact_command(void)
{
1729 1730
	if (!xact_started)
	{
1731 1732
		ereport(DEBUG3,
				(errmsg_internal("StartTransactionCommand")));
1733
		StartTransactionCommand();
1734 1735 1736 1737

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

1739 1740
		xact_started = true;
	}
1741 1742 1743
}

static void
1744
finish_xact_command(void)
1745
{
1746 1747 1748 1749
	if (xact_started)
	{
		/* Invoke IMMEDIATE constraint triggers */
		DeferredTriggerEndQuery();
1750

1751 1752
		/* Cancel any active statement timeout before committing */
		disable_sig_alarm(true);
1753

1754
		/* Now commit the command */
1755 1756
		ereport(DEBUG3,
				(errmsg_internal("CommitTransactionCommand")));
1757

1758
		CommitTransactionCommand();
1759

1760 1761 1762 1763 1764 1765
#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

1766
#ifdef SHOW_MEMORY_STATS
1767
		/* Print mem stats after each commit for leak tracking */
1768 1769
		if (ShowStats)
			MemoryContextStats(TopMemoryContext);
1770
#endif
1771 1772 1773

		xact_started = false;
	}
1774 1775 1776
}


1777
/* --------------------------------
1778
 *		signal handler routines used in PostgresMain()
1779 1780 1781
 * --------------------------------
 */

1782
/*
Tom Lane's avatar
Tom Lane committed
1783
 * quickdie() occurs when signalled SIGQUIT by the postmaster.
1784 1785 1786 1787
 *
 * Some backend has bought the farm,
 * so we need to stop what we're doing and exit.
 */
Tom Lane's avatar
Tom Lane committed
1788
void
1789
quickdie(SIGNAL_ARGS)
1790
{
1791
	PG_SETMASK(&BlockSig);
Bruce Momjian's avatar
Bruce Momjian committed
1792

1793
	/*
Bruce Momjian's avatar
Bruce Momjian committed
1794 1795
	 * Ideally this should be ereport(FATAL), but then we'd not get
	 * control back (perhaps could fix by doing local sigsetjmp?)
1796 1797 1798
	 */
	ereport(WARNING,
			(errcode(ERRCODE_CRASH_SHUTDOWN),
1799 1800
		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
1801
				 " the current transaction and exit, because another"
1802
				 " server process exited abnormally and possibly corrupted"
Bruce Momjian's avatar
Bruce Momjian committed
1803
				 " shared memory."),
1804
			 errhint("In a moment you should be able to reconnect to the"
1805
					 " database and repeat your command.")));
Bruce Momjian's avatar
Bruce Momjian committed
1806

1807
	/*
1808 1809 1810 1811
	 * 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.
	 *
1812 1813 1814 1815
	 * 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.
1816
	 */
1817
	exit(1);
1818 1819
}

1820
/*
1821 1822
 * Shutdown signal from postmaster: abort transaction and exit
 * at soonest convenient time
1823
 */
1824
void
1825
die(SIGNAL_ARGS)
1826
{
1827 1828 1829
	int			save_errno = errno;

	/* Don't joggle the elbow of proc_exit */
1830
	if (!proc_exit_inprogress)
1831
	{
1832
		InterruptPending = true;
1833
		ProcDiePending = true;
1834

1835
		/*
1836 1837
		 * If it's safe to interrupt, and we're waiting for input or a
		 * lock, service the interrupt immediately
1838
		 */
1839 1840
		if (ImmediateInterruptOK && InterruptHoldoffCount == 0 &&
			CritSectionCount == 0)
1841
		{
1842 1843 1844
			/* bump holdoff count to make ProcessInterrupts() a no-op */
			/* until we are done getting ready for it */
			InterruptHoldoffCount++;
1845
			DisableNotifyInterrupt();
1846
			/* Make sure CheckDeadLock won't run while shutting down... */
1847
			LockWaitCancel();
1848
			InterruptHoldoffCount--;
1849 1850
			ProcessInterrupts();
		}
1851
	}
1852 1853

	errno = save_errno;
1854 1855
}

1856
/*
1857
 * Timeout or shutdown signal from postmaster during client authentication.
1858
 * Simply exit(0).
1859 1860 1861
 *
 * XXX: possible future improvement: try to send a message indicating
 * why we are disconnecting.  Problem is to be sure we don't block while
1862
 * doing so, nor mess up the authentication message exchange.
1863 1864 1865 1866 1867 1868 1869
 */
void
authdie(SIGNAL_ARGS)
{
	exit(0);
}

1870
/*
1871 1872
 * Query-cancel signal from postmaster: abort current transaction
 * at soonest convenient time
1873
 */
1874
static void
1875
StatementCancelHandler(SIGNAL_ARGS)
1876
{
1877 1878
	int			save_errno = errno;

1879 1880 1881 1882
	/*
	 * Don't joggle the elbow of proc_exit, nor an already-in-progress
	 * abort
	 */
1883
	if (!proc_exit_inprogress && !InError)
1884
	{
1885 1886
		InterruptPending = true;
		QueryCancelPending = true;
1887

1888
		/*
1889
		 * If it's safe to interrupt, and we're waiting for a lock,
1890 1891
		 * service the interrupt immediately.  No point in interrupting if
		 * we're waiting for input, however.
1892
		 */
1893
		if (ImmediateInterruptOK && InterruptHoldoffCount == 0 &&
1894
			CritSectionCount == 0)
1895
		{
1896 1897 1898 1899 1900 1901
			/* 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
1902
				InterruptHoldoffCount--;
1903 1904 1905 1906
				ProcessInterrupts();
			}
			else
				InterruptHoldoffCount--;
1907
		}
1908 1909
	}

1910
	errno = save_errno;
1911 1912
}

1913 1914 1915 1916
/* signal handler for floating point exception */
static void
FloatExceptionHandler(SIGNAL_ARGS)
{
1917 1918 1919
	ereport(ERROR,
			(errcode(ERRCODE_FLOATING_POINT_EXCEPTION),
			 errmsg("floating-point exception"),
Bruce Momjian's avatar
Bruce Momjian committed
1920 1921 1922
		   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.")));
1923 1924
}

1925
/* SIGHUP: set flag to re-read config file at next convenient time */
1926
static void
1927
SigHupHandler(SIGNAL_ARGS)
1928
{
1929
	got_SIGHUP = true;
1930 1931
}

1932

1933 1934 1935 1936 1937 1938 1939 1940 1941 1942
/*
 * 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)
{
1943 1944
	/* OK to accept interrupt now? */
	if (InterruptHoldoffCount != 0 || CritSectionCount != 0)
1945 1946 1947 1948 1949
		return;
	InterruptPending = false;
	if (ProcDiePending)
	{
		ProcDiePending = false;
1950 1951
		QueryCancelPending = false;		/* ProcDie trumps QueryCancel */
		ImmediateInterruptOK = false;	/* not idle anymore */
1952
		DisableNotifyInterrupt();
1953 1954
		ereport(FATAL,
				(errcode(ERRCODE_ADMIN_SHUTDOWN),
Bruce Momjian's avatar
Bruce Momjian committed
1955
		 errmsg("terminating connection due to administrator command")));
1956 1957 1958 1959
	}
	if (QueryCancelPending)
	{
		QueryCancelPending = false;
1960
		ImmediateInterruptOK = false;	/* not idle anymore */
1961
		DisableNotifyInterrupt();
1962 1963 1964
		ereport(ERROR,
				(errcode(ERRCODE_QUERY_CANCELED),
				 errmsg("canceling query due to user request")));
1965 1966 1967 1968
	}
	/* If we get here, do nothing (probably, QueryCancelPending was reset) */
}

1969

1970 1971
static void
usage(char *progname)
1972
{
1973
	printf(gettext("%s is the PostgreSQL stand-alone backend.  It is not\nintended to be used by normal users.\n\n"), progname);
1974

1975 1976
	printf(gettext("Usage:\n  %s [OPTION]... [DBNAME]\n\n"), progname);
	printf(gettext("Options:\n"));
1977
#ifdef USE_ASSERT_CHECKING
1978
	printf(gettext("  -A 1|0          enable/disable run-time assert checking\n"));
1979
#endif
1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991
	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"));
	printf(gettext("  -S SORT-MEM     set amount of memory for sorts (in kbytes)\n"));
1992
	printf(gettext("  --describe-config  describe configuration parameters, then exit\n"));
1993 1994 1995 1996 1997 1998 1999 2000 2001
	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"));
2002 2003
}

2004 2005


2006
/* ----------------------------------------------------------------
2007
 * PostgresMain
2008
 *	   postgres main loop -- all backends, interactive or otherwise start here
2009
 *
2010 2011 2012 2013
 * 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.
2014 2015 2016
 * ----------------------------------------------------------------
 */
int
2017
PostgresMain(int argc, char *argv[], const char *username)
2018
{
2019
	int			flag;
2020
	const char *dbname = NULL;
2021
	char	   *potential_DataDir = NULL;
2022
	bool		secure;
2023
	int			errs = 0;
2024
	int			debug_flag = 0;
Bruce Momjian's avatar
Bruce Momjian committed
2025 2026
	GucContext	ctx,
				debug_context;
2027
	GucSource	gucsource;
2028
	char	   *tmp;
2029
	int			firstchar;
2030
	StringInfoData	input_message;
2031
	volatile bool send_rfq = true;
2032

2033
	/*
2034 2035
	 * Catch standard options before doing much else.  This even works on
	 * systems without getopt_long.
2036 2037 2038
	 */
	if (!IsUnderPostmaster && argc > 1)
	{
2039
		if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
2040 2041 2042 2043
		{
			usage(argv[0]);
			exit(0);
		}
2044
		if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
2045 2046 2047 2048
		{
			puts("postgres (PostgreSQL) " PG_VERSION);
			exit(0);
		}
2049
	}
2050

2051 2052 2053 2054 2055 2056 2057
	/*
	 * initialize globals (already done if under postmaster, but not if
	 * standalone; cheap enough to do over)
	 */

	MyProcPid = getpid();

2058 2059 2060 2061 2062
	/*
	 * Fire up essential subsystems: error and memory management
	 *
	 * If we are running under the postmaster, this is done already.
	 */
2063
	if (!IsUnderPostmaster)
2064 2065
		MemoryContextInit();

2066 2067
	set_ps_display("startup");

2068 2069
	SetProcessingMode(InitProcessing);

2070
	/*
2071
	 * Set default values for command-line options.
2072
	 */
2073 2074
	Noversion = false;
	EchoQuery = false;
2075

Bruce Momjian's avatar
Bruce Momjian committed
2076
	if (!IsUnderPostmaster /* when exec || ExecBackend */ )
2077
	{
2078
		InitializeGUCOptions();
2079
		potential_DataDir = getenv("PGDATA");
2080
	}
2081

2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098
	/* ----------------
	 *	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.
	 * ----------------
	 */

2099 2100
	/* all options are allowed until '-p' */
	secure = true;
2101
	ctx = debug_context = PGC_POSTMASTER;
2102
	gucsource = PGC_S_ARGV;		/* initial switches came from command line */
2103

2104
	while ((flag = getopt(argc, argv, "A:B:c:CD:d:Eef:FiNOPo:p:S:st:v:W:x:-:")) != -1)
2105 2106
		switch (flag)
		{
2107 2108
			case 'A':
#ifdef USE_ASSERT_CHECKING
2109
				SetConfigOption("debug_assertions", optarg, ctx, gucsource);
2110
#else
2111 2112 2113
				ereport(WARNING,
						(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
						 errmsg("assert checking is not compiled in")));
2114 2115
#endif
				break;
2116

2117
			case 'B':
2118 2119 2120

				/*
				 * specify the size of buffer pool
2121
				 */
2122
				SetConfigOption("shared_buffers", optarg, ctx, gucsource);
2123
				break;
2124

2125
			case 'C':
2126 2127 2128

				/*
				 * don't print version string
2129
				 */
2130
				Noversion = true;
2131
				break;
2132

2133
			case 'D':			/* PGDATA directory */
2134
				if (secure)
2135
					potential_DataDir = optarg;
2136
				break;
2137

2138
			case 'd':			/* debug level */
2139
				{
2140
					/*
Bruce Momjian's avatar
Bruce Momjian committed
2141 2142 2143 2144 2145
					 * 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.
					 */
2146
					if (ctx != PGC_BACKEND || atoi(optarg) > debug_flag)
2147
					{
2148
						debug_flag = atoi(optarg);
Bruce Momjian's avatar
Bruce Momjian committed
2149 2150
						debug_context = ctx;	/* save context for use
												 * below */
2151 2152 2153 2154
						/* Set server debugging level. */
						if (debug_flag != 0)
						{
							char	   *debugstr = palloc(strlen("debug") + strlen(optarg) + 1);
Bruce Momjian's avatar
Bruce Momjian committed
2155

2156 2157 2158
							sprintf(debugstr, "debug%s", optarg);
							SetConfigOption("log_min_messages", debugstr, ctx, gucsource);
							pfree(debugstr);
Bruce Momjian's avatar
Bruce Momjian committed
2159

2160 2161
						}
						else
Bruce Momjian's avatar
Bruce Momjian committed
2162

2163 2164
							/*
							 * -d0 allows user to prevent postmaster debug
Bruce Momjian's avatar
Bruce Momjian committed
2165 2166 2167
							 * from propagating to backend.  It would be
							 * nice to set it to the postgresql.conf value
							 * here.
2168 2169 2170
							 */
							SetConfigOption("log_min_messages", "notice",
											ctx, gucsource);
2171 2172
					}
				}
2173
				break;
2174 2175

			case 'E':
2176 2177 2178

				/*
				 * E - echo the query the user entered
2179
				 */
2180
				EchoQuery = true;
2181
				break;
2182 2183

			case 'e':
2184 2185

				/*
2186
				 * Use European date input format (DMY)
2187
				 */
2188
				SetConfigOption("datestyle", "euro", ctx, gucsource);
2189
				break;
2190 2191

			case 'F':
2192 2193 2194

				/*
				 * turn off fsync
2195
				 */
2196
				SetConfigOption("fsync", "false", ctx, gucsource);
2197
				break;
2198 2199

			case 'f':
2200 2201 2202

				/*
				 * f - forbid generation of certain plans
2203
				 */
2204
				tmp = NULL;
2205 2206 2207
				switch (optarg[0])
				{
					case 's':	/* seqscan */
2208
						tmp = "enable_seqscan";
2209 2210
						break;
					case 'i':	/* indexscan */
2211
						tmp = "enable_indexscan";
2212 2213
						break;
					case 't':	/* tidscan */
2214
						tmp = "enable_tidscan";
2215 2216
						break;
					case 'n':	/* nestloop */
2217
						tmp = "enable_nestloop";
2218 2219
						break;
					case 'm':	/* mergejoin */
2220
						tmp = "enable_mergejoin";
2221 2222
						break;
					case 'h':	/* hashjoin */
2223
						tmp = "enable_hashjoin";
2224 2225 2226 2227
						break;
					default:
						errs++;
				}
2228
				if (tmp)
2229
					SetConfigOption(tmp, "false", ctx, gucsource);
2230 2231
				break;

2232
			case 'N':
2233 2234 2235

				/*
				 * N - Don't use newline as a query delimiter
2236 2237 2238
				 */
				UseNewLine = 0;
				break;
2239

2240
			case 'O':
2241 2242 2243

				/*
				 * allow system table structure modifications
2244
				 */
2245 2246
				if (secure)		/* XXX safe to allow from client??? */
					allowSystemTableMods = true;
2247 2248
				break;

Hiroshi Inoue's avatar
Hiroshi Inoue committed
2249
			case 'P':
2250 2251 2252

				/*
				 * ignore system indexes
2253 2254 2255 2256
				 *
				 * 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
2257
				 */
2258
				IgnoreSystemIndexes(true);
Hiroshi Inoue's avatar
Hiroshi Inoue committed
2259 2260
				break;

2261
			case 'o':
2262 2263 2264

				/*
				 * o - send output (stdout and stderr) to the given file
2265
				 */
2266 2267
				if (secure)
					StrNCpy(OutputFileName, optarg, MAXPGPATH);
2268 2269
				break;

2270
			case 'p':
2271 2272 2273 2274

				/*
				 * p - special flag passed if backend was forked by a
				 * postmaster.
2275
				 */
2276 2277
				if (secure)
				{
2278
#ifdef EXEC_BACKEND
Bruce Momjian's avatar
Bruce Momjian committed
2279 2280 2281 2282 2283 2284
					char	   *p;
					int			i;
					int			PMcanAcceptConnections; /* will eventually be
														 * global or static,
														 * when fork */

2285
					sscanf(optarg, "%d,%d,%d,%p,", &MyProcPort->sock, &PMcanAcceptConnections,
Bruce Momjian's avatar
Bruce Momjian committed
2286
						   &UsedShmemSegID, &UsedShmemSegAddr);
2287
					/* Grab dbname as last param */
Bruce Momjian's avatar
Bruce Momjian committed
2288 2289
					for (i = 0, p = optarg - 1; i < 4 && p; i++)
						p = strchr(p + 1, ',');
2290
					if (i == 4 && p)
Bruce Momjian's avatar
Bruce Momjian committed
2291
						dbname = strdup(p + 1);
2292
#else
2293
					dbname = strdup(optarg);
2294
#endif
Bruce Momjian's avatar
Bruce Momjian committed
2295 2296
					secure = false;		/* subsequent switches are NOT
										 * secure */
2297
					ctx = PGC_BACKEND;
2298
					gucsource = PGC_S_CLIENT;
2299
				}
2300
				break;
2301

2302
			case 'S':
2303 2304 2305

				/*
				 * S - amount of sort memory to use in 1k bytes
2306
				 */
2307
				SetConfigOption("sort_mem", optarg, ctx, gucsource);
2308
				break;
2309 2310

			case 's':
2311 2312 2313

				/*
				 * s - report usage statistics (timings) after each query
2314
				 */
2315
				SetConfigOption("log_statement_stats", "true", ctx, gucsource);
2316 2317
				break;

2318
			case 't':
2319
				/* ---------------
2320 2321 2322 2323 2324 2325 2326 2327 2328
				 *	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.
				 * ----------------
				 */
2329
				tmp = NULL;
2330 2331 2332 2333
				switch (optarg[0])
				{
					case 'p':
						if (optarg[1] == 'a')
Bruce Momjian's avatar
Bruce Momjian committed
2334
							tmp = "log_parser_stats";
2335
						else if (optarg[1] == 'l')
Bruce Momjian's avatar
Bruce Momjian committed
2336
							tmp = "log_planner_stats";
2337 2338 2339 2340
						else
							errs++;
						break;
					case 'e':
2341
						tmp = "log_executor_stats";
2342 2343 2344 2345 2346
						break;
					default:
						errs++;
						break;
				}
2347
				if (tmp)
2348
					SetConfigOption(tmp, "true", ctx, gucsource);
2349 2350
				break;

2351
			case 'v':
2352 2353
				if (secure)
					FrontendProtocol = (ProtocolVersion) atoi(optarg);
2354 2355
				break;

2356
			case 'W':
2357 2358 2359

				/*
				 * wait N seconds to allow attach from a debugger
2360 2361 2362 2363
				 */
				sleep(atoi(optarg));
				break;

2364
			case 'x':
Bruce Momjian's avatar
Bruce Momjian committed
2365
#ifdef NOT_USED					/* planner/xfunc.h */
2366 2367 2368 2369 2370 2371 2372

				/*
				 * control joey hellerstein's expensive function
				 * optimization
				 */
				if (XfuncMode != 0)
				{
Bruce Momjian's avatar
Bruce Momjian committed
2373
					elog(WARNING, "only one -x flag is allowed");
2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390
					errs++;
					break;
				}
				if (strcmp(optarg, "off") == 0)
					XfuncMode = XFUNC_OFF;
				else if (strcmp(optarg, "nor") == 0)
					XfuncMode = XFUNC_NOR;
				else if (strcmp(optarg, "nopull") == 0)
					XfuncMode = XFUNC_NOPULL;
				else if (strcmp(optarg, "nopm") == 0)
					XfuncMode = XFUNC_NOPM;
				else if (strcmp(optarg, "pullall") == 0)
					XfuncMode = XFUNC_PULLALL;
				else if (strcmp(optarg, "wait") == 0)
					XfuncMode = XFUNC_WAIT;
				else
				{
Bruce Momjian's avatar
Bruce Momjian committed
2391
					elog(WARNING, "use -x {off,nor,nopull,nopm,pullall,wait}");
2392 2393
					errs++;
				}
2394
#endif
2395
				break;
2396

2397
			case 'c':
2398
			case '-':
2399
				{
2400 2401
					char	   *name,
							   *value;
2402

2403 2404 2405 2406
					ParseLongOption(optarg, &name, &value);
					if (!value)
					{
						if (flag == '-')
2407 2408 2409 2410
							ereport(ERROR,
									(errcode(ERRCODE_SYNTAX_ERROR),
									 errmsg("--%s requires a value",
											optarg)));
2411
						else
2412 2413 2414 2415
							ereport(ERROR,
									(errcode(ERRCODE_SYNTAX_ERROR),
									 errmsg("-c %s requires a value",
											optarg)));
2416 2417
					}

2418
					SetConfigOption(name, value, ctx, gucsource);
2419 2420 2421 2422 2423
					free(name);
					if (value)
						free(value);
					break;
				}
2424

2425 2426
			default:
				errs++;
2427
				break;
2428 2429
		}

2430

2431
	/*
2432 2433
	 * -d is not the same as setting log_min_messages because it enables
	 * other output options.
2434 2435
	 */
	if (debug_flag >= 1)
2436
		SetConfigOption("log_connections", "true", debug_context, gucsource);
2437
	if (debug_flag >= 2)
2438
		SetConfigOption("log_statement", "true", debug_context, gucsource);
2439
	if (debug_flag >= 3)
2440
		SetConfigOption("debug_print_parse", "true", debug_context, gucsource);
2441
	if (debug_flag >= 4)
2442
		SetConfigOption("debug_print_plan", "true", debug_context, gucsource);
2443
	if (debug_flag >= 5)
2444
		SetConfigOption("debug_print_rewritten", "true", debug_context, gucsource);
2445

2446
	/*
Bruce Momjian's avatar
Bruce Momjian committed
2447 2448
	 * Process any additional GUC variable settings passed in startup
	 * packet.
2449 2450 2451
	 */
	if (MyProcPort != NULL)
	{
Bruce Momjian's avatar
Bruce Momjian committed
2452
		List	   *gucopts = MyProcPort->guc_options;
2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466

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

2467 2468 2469
	/*
	 * Post-processing for command line options.
	 */
Bruce Momjian's avatar
Bruce Momjian committed
2470 2471
	if (log_statement_stats &&
		(log_parser_stats || log_planner_stats || log_executor_stats))
2472
	{
2473 2474
		ereport(WARNING,
				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
2475
				 errmsg("statement-level statistics are disabled because parser, planner, or executor statistics are on")));
2476
		SetConfigOption("log_statement_stats", "false", ctx, gucsource);
2477 2478
	}

2479
	if (!IsUnderPostmaster)
2480
	{
2481 2482
		if (!potential_DataDir)
		{
2483 2484 2485 2486 2487
			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"),
2488 2489 2490 2491
					argv[0]);
			proc_exit(1);
		}
		SetDataDir(potential_DataDir);
2492
	}
2493
	Assert(DataDir);
2494

2495 2496 2497
	/* Acquire configuration parameters */
	if (IsUnderPostmaster)
	{
2498
#ifdef EXEC_BACKEND
2499
		read_nondefault_variables();
2500
#endif
2501 2502 2503
	}
	else
		ProcessConfigFile(PGC_POSTMASTER);
2504

2505
	/*
2506
	 * Set up signal handlers and masks.
2507
	 *
2508
	 * Note that postmaster blocked all signals before forking child process,
2509 2510
	 * 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
2511 2512
	 *
	 * Also note: it's best not to use any signals that are SIG_IGNored in
2513
	 * the postmaster.	If such a signal arrives before we are able to
2514
	 * change the handler to non-SIG_IGN, it'll get dropped.  Instead,
Bruce Momjian's avatar
Bruce Momjian committed
2515 2516
	 * make a dummy handler in the postmaster to reserve the signal. (Of
	 * course, this isn't an issue for signals that are locally generated,
2517
	 * such as SIGALRM and SIGPIPE.)
2518
	 */
2519

2520
	pqsignal(SIGHUP, SigHupHandler);	/* set flag to read config file */
Bruce Momjian's avatar
Bruce Momjian committed
2521
	pqsignal(SIGINT, StatementCancelHandler);	/* cancel current query */
2522
	pqsignal(SIGTERM, die);		/* cancel current query and exit */
2523
	pqsignal(SIGQUIT, quickdie);	/* hard crash time */
Bruce Momjian's avatar
Bruce Momjian committed
2524
	pqsignal(SIGALRM, handle_sig_alarm);		/* timeout conditions */
2525 2526 2527 2528 2529

	/*
	 * 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
2530 2531 2532
	 * midst of output during who-knows-what operation...
	 */
	pqsignal(SIGPIPE, SIG_IGN);
2533
	pqsignal(SIGUSR1, SIG_IGN); /* this signal available for use */
2534

2535
	pqsignal(SIGUSR2, Async_NotifyHandler);		/* flush also sinval cache */
2536
	pqsignal(SIGFPE, FloatExceptionHandler);
2537 2538

	/*
2539 2540
	 * Reset some signals that are accepted by postmaster but not by
	 * backend
2541
	 */
2542 2543
	pqsignal(SIGCHLD, SIG_DFL); /* system() requires this on some
								 * platforms */
2544

2545 2546
	pqinitmask();

Tom Lane's avatar
Tom Lane committed
2547
	/* We allow SIGQUIT (quickdie) at all times */
2548
#ifdef HAVE_SIGPROCMASK
Tom Lane's avatar
Tom Lane committed
2549
	sigdelset(&BlockSig, SIGQUIT);
2550
#else
Tom Lane's avatar
Tom Lane committed
2551
	BlockSig &= ~(sigmask(SIGQUIT));
2552 2553
#endif

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

2556

2557
	if (IsUnderPostmaster)
2558
	{
2559
		/* noninteractive case: nothing should be left after switches */
2560
		if (errs || argc != optind || dbname == NULL)
2561
		{
2562 2563
			ereport(FATAL,
					(errcode(ERRCODE_SYNTAX_ERROR),
2564 2565
					 errmsg("invalid command-line arguments for server process"),
					 errhint("Try \"%s --help\" for more information.", argv[0])));
2566
		}
2567
		BaseInit();
2568 2569 2570
#ifdef EXECBACKEND
		AttachSharedMemoryAndSemaphores();
#endif
2571
	}
2572
	else
2573
	{
2574 2575 2576
		/* interactive case: database name can be last arg on command line */
		if (errs || argc - optind > 1)
		{
2577 2578 2579 2580
			ereport(FATAL,
					(errcode(ERRCODE_SYNTAX_ERROR),
					 errmsg("%s: invalid command-line arguments",
							argv[0]),
2581
					 errhint("Try \"%s --help\" for more information.", argv[0])));
2582 2583
		}
		else if (argc - optind == 1)
2584 2585
			dbname = argv[optind];
		else if ((dbname = username) == NULL)
2586
		{
2587 2588 2589 2590
			ereport(FATAL,
					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
					 errmsg("%s: no database nor user name specified",
							argv[0])));
2591
		}
2592

2593 2594 2595 2596 2597
		/*
		 * On some systems our dynloader code needs the executable's
		 * pathname.  (If under postmaster, this was done already.)
		 */
		if (FindExec(pg_pathname, argv[0], "postgres") < 0)
2598 2599 2600
			ereport(FATAL,
					(errmsg("%s: could not locate postgres executable",
							argv[0])));
2601

2602
		/*
2603 2604
		 * Validate we have been given a reasonable-looking DataDir (if
		 * under postmaster, assume postmaster did this already).
2605 2606 2607
		 */
		ValidatePgVersion(DataDir);

2608
		/*
2609
		 * Create lockfile for data directory.
2610
		 */
2611
		CreateDataDirLockFile(DataDir, false);
2612

2613
		XLOGPathInit();
2614
		BaseInit();
2615 2616 2617 2618 2619

		/*
		 * Start up xlog for standalone backend, and register to have it
		 * closed down at exit.
		 */
2620
		StartupXLOG();
2621
		on_shmem_exit(ShutdownXLOG, 0);
2622 2623 2624 2625 2626 2627 2628

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

2631
	/*
2632 2633 2634 2635 2636
	 * 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.
2637
	 */
2638 2639
	ereport(DEBUG3,
			(errmsg_internal("InitPostgres")));
2640
	InitPostgres(dbname, username);
2641

2642
	SetProcessingMode(NormalProcessing);
2643

2644 2645
	/*
	 * Send this backend's cancellation info to the frontend.
2646
	 */
2647 2648 2649
	if (whereToSendOutput == Remote &&
		PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
	{
2650
		StringInfoData buf;
Bruce Momjian's avatar
Bruce Momjian committed
2651

2652
		pq_beginmessage(&buf, 'K');
2653 2654 2655
		pq_sendint(&buf, (int32) MyProcPid, sizeof(int32));
		pq_sendint(&buf, (int32) MyCancelKey, sizeof(int32));
		pq_endmessage(&buf);
2656 2657 2658
		/* Need not flush since ReadyForQuery will do it. */
	}

2659 2660 2661
	if (!IsUnderPostmaster)
	{
		puts("\nPOSTGRES backend interactive interface ");
2662
		puts("$Revision: 1.376 $ $Date: 2003/11/24 14:49:51 $\n");
2663 2664
	}

2665 2666 2667
	/*
	 * Create the memory context we will use in the main loop.
	 *
2668 2669
	 * MessageContext is reset once per iteration of the main loop, ie, upon
	 * completion of processing of each command message from the client.
2670
	 */
2671 2672 2673 2674 2675
	MessageContext = AllocSetContextCreate(TopMemoryContext,
										   "MessageContext",
										   ALLOCSET_DEFAULT_MINSIZE,
										   ALLOCSET_DEFAULT_INITSIZE,
										   ALLOCSET_DEFAULT_MAXSIZE);
2676

2677 2678 2679 2680 2681 2682 2683
	/* ----------
	 * Tell the statistics collector that we're alive and
	 * to which database we belong.
	 * ----------
	 */
	pgstat_bestart();

2684 2685
	/*
	 * POSTGRES main processing loop begins here
2686
	 *
2687 2688
	 * If an exception is encountered, processing resumes here so we abort
	 * the current transaction and start a new one.
2689 2690 2691 2692
	 */

	if (sigsetjmp(Warn_restart, 1) != 0)
	{
2693
		/*
2694
		 * NOTE: if you are tempted to add more code in this if-block,
2695 2696
		 * consider the probability that it should be in
		 * AbortTransaction() instead.
2697
		 *
2698 2699
		 * 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
2700 2701
		 * Force InterruptHoldoffCount to a known state in case we
		 * ereport'd from inside a holdoff section.
2702 2703 2704
		 */
		ImmediateInterruptOK = false;
		QueryCancelPending = false;
2705 2706
		InterruptHoldoffCount = 1;
		CritSectionCount = 0;	/* should be unnecessary, but... */
2707
		disable_sig_alarm(true);
Bruce Momjian's avatar
Bruce Momjian committed
2708
		QueryCancelPending = false;		/* again in case timeout occurred */
2709
		DisableNotifyInterrupt();
2710
		debug_query_string = NULL;
2711 2712

		/*
2713 2714 2715 2716 2717 2718
		 * 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);
2719

2720
		/* Do the recovery */
2721 2722
		ereport(DEBUG2,
				(errmsg_internal("AbortCurrentTransaction")));
2723
		AbortCurrentTransaction();
2724 2725

		/*
2726 2727
		 * Now return to normal top-level context and clear ErrorContext
		 * for next time.
2728 2729 2730
		 */
		MemoryContextSwitchTo(TopMemoryContext);
		MemoryContextResetAndDeleteChildren(ErrorContext);
2731 2732
		PortalContext = NULL;
		QueryContext = NULL;
2733 2734 2735 2736 2737

		/*
		 * Clear flag to indicate that we got out of error recovery mode
		 * successfully.  (Flag was set in elog.c before longjmp().)
		 */
2738
		InError = false;
2739 2740 2741 2742
		xact_started = false;

		/*
		 * If we were handling an extended-query-protocol message,
Bruce Momjian's avatar
Bruce Momjian committed
2743 2744
		 * initiate skip till next Sync.  This also causes us not to issue
		 * ReadyForQuery (until we get Sync).
2745 2746 2747
		 */
		if (doing_extended_query_message)
			ignore_till_sync = true;
2748 2749

		/*
2750
		 * Exit interrupt holdoff section we implicitly established above.
2751
		 */
2752
		RESUME_INTERRUPTS();
2753
	}
2754

2755
	Warn_restart_ready = true;	/* we can now handle ereport(ERROR) */
2756

2757
	PG_SETMASK(&UnBlockSig);
2758

2759 2760
	if (!ignore_till_sync)
		send_rfq = true;		/* initially, or after error */
2761

2762 2763
	/*
	 * Non-error queries loop here.
2764 2765 2766 2767
	 */

	for (;;)
	{
2768
		/*
Bruce Momjian's avatar
Bruce Momjian committed
2769 2770
		 * At top of loop, reset extended-query-message flag, so that any
		 * errors encountered in "idle" state don't provoke skip.
2771 2772 2773
		 */
		doing_extended_query_message = false;

2774
		/*
2775
		 * Release storage left over from prior query cycle, and create a
2776
		 * new query input buffer in the cleared MessageContext.
2777
		 */
2778 2779
		MemoryContextSwitchTo(MessageContext);
		MemoryContextResetAndDeleteChildren(MessageContext);
2780

2781
		initStringInfo(&input_message);
2782

2783
		/*
2784 2785
		 * (1) If we've reached idle state, tell the frontend we're ready
		 * for a new query.
2786
		 *
2787
		 * Note: this includes fflush()'ing the last of the prior output.
2788 2789 2790 2791 2792
		 *
		 * 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
2793
		 */
2794 2795
		if (send_rfq)
		{
2796
			pgstat_report_tabstat();
Bruce Momjian's avatar
Bruce Momjian committed
2797

2798
			if (IsTransactionOrTransactionBlock())
2799 2800 2801 2802 2803 2804 2805 2806 2807
			{
				set_ps_display("idle in transaction");
				pgstat_report_activity("<IDLE> in transaction");
			}
			else
			{
				set_ps_display("idle");
				pgstat_report_activity("<IDLE>");
			}
2808

2809 2810
			ReadyForQuery(whereToSendOutput);
			send_rfq = false;
2811
		}
2812

2813 2814 2815 2816
		/*
		 * (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.
2817
		 */
2818 2819
		QueryCancelPending = false;		/* forget any earlier CANCEL
										 * signal */
2820 2821 2822

		EnableNotifyInterrupt();

2823 2824 2825 2826 2827 2828
		/* 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();

2829 2830
		/*
		 * (3) read a command (loop blocks here)
2831
		 */
2832
		firstchar = ReadCommand(&input_message);
2833

2834 2835
		/*
		 * (4) disable async signal conditions again.
2836
		 */
2837
		ImmediateInterruptOK = false;
2838
		QueryCancelPending = false;		/* forget any CANCEL signal */
2839

2840 2841
		DisableNotifyInterrupt();

2842 2843 2844
		/*
		 * (5) check for any other interesting events that happened while
		 * we slept.
2845 2846 2847 2848 2849 2850 2851
		 */
		if (got_SIGHUP)
		{
			got_SIGHUP = false;
			ProcessConfigFile(PGC_SIGHUP);
		}

2852
		/*
Bruce Momjian's avatar
Bruce Momjian committed
2853 2854
		 * (6) process the command.  But ignore it if we're skipping till
		 * Sync.
2855
		 */
2856
		if (ignore_till_sync && firstchar != EOF)
2857 2858
			continue;

2859 2860
		switch (firstchar)
		{
2861
			case 'Q':			/* simple query */
2862
				{
2863 2864
					const char *query_string;

2865 2866
					query_string = pq_getmsgstring(&input_message);
					pq_getmsgend(&input_message);
2867

2868
					exec_simple_query(query_string);
2869

2870 2871
					send_rfq = true;
				}
2872 2873
				break;

2874 2875 2876 2877 2878 2879 2880
			case 'P':			/* parse */
				{
					const char *stmt_name;
					const char *query_string;
					int			numParams;
					Oid		   *paramTypes = NULL;

2881 2882 2883
					stmt_name = pq_getmsgstring(&input_message);
					query_string = pq_getmsgstring(&input_message);
					numParams = pq_getmsgint(&input_message, 2);
2884 2885
					if (numParams > 0)
					{
Bruce Momjian's avatar
Bruce Momjian committed
2886
						int			i;
2887 2888 2889

						paramTypes = (Oid *) palloc(numParams * sizeof(Oid));
						for (i = 0; i < numParams; i++)
2890
							paramTypes[i] = pq_getmsgint(&input_message, 4);
2891
					}
2892
					pq_getmsgend(&input_message);
2893 2894 2895 2896 2897 2898 2899

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

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

2901
				/*
Bruce Momjian's avatar
Bruce Momjian committed
2902 2903
				 * this message is complex enough that it seems best to
				 * put the field extraction out-of-line
2904
				 */
2905
				exec_bind_message(&input_message);
2906 2907 2908 2909 2910
				break;

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

2913 2914 2915
					portal_name = pq_getmsgstring(&input_message);
					max_rows = pq_getmsgint(&input_message, 4);
					pq_getmsgend(&input_message);
2916

2917
					exec_execute_message(portal_name, max_rows);
2918 2919 2920
				}
				break;

2921 2922
			case 'F':			/* fastpath function call */
				/* Tell the collector what we're doing */
2923 2924
				pgstat_report_activity("<FASTPATH> function call");

2925
				/* start an xact for this function invocation */
2926
				start_xact_command();
2927

2928 2929 2930
				/* switch back to message context */
				MemoryContextSwitchTo(MessageContext);

2931
				if (HandleFunctionRequest(&input_message) == EOF)
2932 2933
				{
					/* lost frontend connection during F message input */
Bruce Momjian's avatar
Bruce Momjian committed
2934

2935
					/*
2936
					 * Reset whereToSendOutput to prevent ereport from
Bruce Momjian's avatar
Bruce Momjian committed
2937
					 * attempting to send any more messages to client.
2938 2939 2940 2941
					 */
					if (whereToSendOutput == Remote)
						whereToSendOutput = None;

2942
					proc_exit(0);
2943
				}
2944 2945

				/* commit the function-invocation transaction */
2946
				finish_xact_command();
2947

2948
				send_rfq = true;
2949 2950
				break;

Bruce Momjian's avatar
Bruce Momjian committed
2951
			case 'C':			/* close */
2952
				{
Bruce Momjian's avatar
Bruce Momjian committed
2953
					int			close_type;
2954 2955
					const char *close_target;

2956 2957 2958
					close_type = pq_getmsgbyte(&input_message);
					close_target = pq_getmsgstring(&input_message);
					pq_getmsgend(&input_message);
2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986

					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:
2987 2988
							ereport(ERROR,
									(errcode(ERRCODE_PROTOCOL_VIOLATION),
Bruce Momjian's avatar
Bruce Momjian committed
2989 2990
							   errmsg("invalid CLOSE message subtype %d",
									  close_type)));
2991 2992 2993 2994
							break;
					}

					if (whereToSendOutput == Remote)
Bruce Momjian's avatar
Bruce Momjian committed
2995
						pq_putemptymessage('3');		/* CloseComplete */
2996 2997 2998 2999 3000
				}
				break;

			case 'D':			/* describe */
				{
Bruce Momjian's avatar
Bruce Momjian committed
3001
					int			describe_type;
3002 3003
					const char *describe_target;

3004 3005 3006
					describe_type = pq_getmsgbyte(&input_message);
					describe_target = pq_getmsgstring(&input_message);
					pq_getmsgend(&input_message);
3007 3008 3009 3010 3011 3012 3013 3014 3015 3016

					switch (describe_type)
					{
						case 'S':
							exec_describe_statement_message(describe_target);
							break;
						case 'P':
							exec_describe_portal_message(describe_target);
							break;
						default:
3017 3018
							ereport(ERROR,
									(errcode(ERRCODE_PROTOCOL_VIOLATION),
Bruce Momjian's avatar
Bruce Momjian committed
3019 3020
							errmsg("invalid DESCRIBE message subtype %d",
								   describe_type)));
3021 3022 3023 3024 3025
							break;
					}
				}
				break;

Bruce Momjian's avatar
Bruce Momjian committed
3026
			case 'H':			/* flush */
3027
				pq_getmsgend(&input_message);
3028 3029 3030 3031
				if (whereToSendOutput == Remote)
					pq_flush();
				break;

Bruce Momjian's avatar
Bruce Momjian committed
3032
			case 'S':			/* sync */
3033
				pq_getmsgend(&input_message);
3034
				finish_xact_command();
3035 3036 3037
				send_rfq = true;
				break;

3038
				/*
Bruce Momjian's avatar
Bruce Momjian committed
3039 3040 3041
				 * 'X' means that the frontend is closing down the socket.
				 * EOF means unexpected loss of frontend connection.
				 * Either way, perform normal shutdown.
3042 3043
				 */
			case 'X':
3044
			case EOF:
Bruce Momjian's avatar
Bruce Momjian committed
3045

3046
				/*
Bruce Momjian's avatar
Bruce Momjian committed
3047 3048
				 * Reset whereToSendOutput to prevent ereport from
				 * attempting to send any more messages to client.
3049 3050 3051
				 */
				if (whereToSendOutput == Remote)
					whereToSendOutput = None;
3052

3053 3054
				/*
				 * NOTE: if you are tempted to add more code here, DON'T!
3055 3056
				 * Whatever you had in mind to do should be set up as an
				 * on_proc_exit or on_shmem_exit callback, instead.
3057 3058 3059 3060
				 * Otherwise it will fail to be called during other
				 * backend-shutdown scenarios.
				 */
				proc_exit(0);
3061

Bruce Momjian's avatar
Bruce Momjian committed
3062 3063 3064 3065
			case 'd':			/* copy data */
			case 'c':			/* copy done */
			case 'f':			/* copy fail */

3066
				/*
Bruce Momjian's avatar
Bruce Momjian committed
3067 3068
				 * Accept but ignore these messages, per protocol spec; we
				 * probably got here because a COPY failed, and the
3069 3070 3071 3072
				 * frontend is still sending data.
				 */
				break;

3073
			default:
3074 3075 3076 3077
				ereport(FATAL,
						(errcode(ERRCODE_PROTOCOL_VIOLATION),
						 errmsg("invalid frontend message type %d",
								firstchar)));
3078
		}
3079
	}							/* end of input-reading loop */
3080

3081 3082
	/* can't get here because the above loop never exits */
	Assert(false);
3083

3084
	return 1;					/* keep compiler quiet */
3085 3086
}

3087
#ifndef HAVE_GETRUSAGE
Bruce Momjian's avatar
Bruce Momjian committed
3088 3089
#include "rusagestub.h"
#else
3090
#include <sys/resource.h>
3091
#endif   /* HAVE_GETRUSAGE */
3092

3093 3094
static struct rusage Save_r;
static struct timeval Save_t;
3095 3096

void
3097
ResetUsage(void)
3098
{
3099
	getrusage(RUSAGE_SELF, &Save_r);
3100
	gettimeofday(&Save_t, NULL);
3101
	ResetBufferUsage();
3102
	/* ResetTupleCount(); */
3103 3104 3105
}

void
3106
ShowUsage(const char *title)
3107
{
3108
	StringInfoData str;
3109 3110 3111 3112
	struct timeval user,
				sys;
	struct timeval elapse_t;
	struct rusage r;
Bruce Momjian's avatar
Bruce Momjian committed
3113
	char	   *bufusage;
3114 3115

	getrusage(RUSAGE_SELF, &r);
3116
	gettimeofday(&elapse_t, NULL);
3117 3118
	memcpy((char *) &user, (char *) &r.ru_utime, sizeof(user));
	memcpy((char *) &sys, (char *) &r.ru_stime, sizeof(sys));
3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142
	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.
	 */
3143
	initStringInfo(&str);
3144

3145 3146
	appendStringInfo(&str, "! system usage stats:\n");
	appendStringInfo(&str,
3147
			"!\t%ld.%06ld elapsed %ld.%06ld user %ld.%06ld system sec\n",
3148 3149 3150
					 (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
3151
				   (long) (r.ru_utime.tv_usec - Save_r.ru_utime.tv_usec),
3152
					 (long) (r.ru_stime.tv_sec - Save_r.ru_stime.tv_sec),
Bruce Momjian's avatar
Bruce Momjian committed
3153
				  (long) (r.ru_stime.tv_usec - Save_r.ru_stime.tv_usec));
3154
	appendStringInfo(&str,
Bruce Momjian's avatar
Bruce Momjian committed
3155
					 "!\t[%ld.%06ld user %ld.%06ld sys total]\n",
3156 3157 3158 3159
					 (long) user.tv_sec,
					 (long) user.tv_usec,
					 (long) sys.tv_sec,
					 (long) sys.tv_usec);
3160
/* BeOS has rusage but only has some fields, and not these... */
3161
#if defined(HAVE_GETRUSAGE)
3162
	appendStringInfo(&str,
Bruce Momjian's avatar
Bruce Momjian committed
3163 3164
					 "!\t%ld/%ld [%ld/%ld] filesystem blocks in/out\n",
					 r.ru_inblock - Save_r.ru_inblock,
3165
	/* they only drink coffee at dec */
Bruce Momjian's avatar
Bruce Momjian committed
3166 3167
					 r.ru_oublock - Save_r.ru_oublock,
					 r.ru_inblock, r.ru_oublock);
3168
	appendStringInfo(&str,
3169
		  "!\t%ld/%ld [%ld/%ld] page faults/reclaims, %ld [%ld] swaps\n",
Bruce Momjian's avatar
Bruce Momjian committed
3170 3171 3172 3173 3174
					 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);
3175
	appendStringInfo(&str,
3176
	 "!\t%ld [%ld] signals rcvd, %ld/%ld [%ld/%ld] messages rcvd/sent\n",
Bruce Momjian's avatar
Bruce Momjian committed
3177 3178 3179 3180 3181
					 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);
3182
	appendStringInfo(&str,
3183
		 "!\t%ld/%ld [%ld/%ld] voluntary/involuntary context switches\n",
Bruce Momjian's avatar
Bruce Momjian committed
3184 3185 3186
					 r.ru_nvcsw - Save_r.ru_nvcsw,
					 r.ru_nivcsw - Save_r.ru_nivcsw,
					 r.ru_nvcsw, r.ru_nivcsw);
3187
#endif   /* HAVE_GETRUSAGE */
3188 3189

	bufusage = ShowBufferUsage();
3190
	appendStringInfo(&str, "! buffer usage stats:\n%s", bufusage);
3191 3192 3193
	pfree(bufusage);

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

3197 3198 3199
	ereport(LOG,
			(errmsg_internal("%s", title),
			 errdetail("%s", str.data)));
3200 3201

	pfree(str.data);
3202
}
3203