postgres.c 79.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-2002, 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.353 2003/07/29 00:03:18 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) */
136
#else
137
static int	UseNewLine = 0;		/* Use EOF as query delimiters */
138
#endif   /* TCOP_DONTUSENEWLINE */
139 140 141


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


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

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

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

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

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

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

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

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

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

		if (end)
237
			return EOF;
238

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

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

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

255
	return 'Q';
256 257 258
}

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

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

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

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

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

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

345 346 347
		case 'd':				/* copy data */
		case 'c':				/* copy done */
		case 'f':				/* copy fail */
348 349 350
			doing_extended_query_message = false;
			/* these are only legal in protocol 3 */
			if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
351 352 353
				ereport(FATAL,
						(errcode(ERRCODE_PROTOCOL_VIOLATION),
						 errmsg("invalid frontend message type %d", qtype)));
354
			break;
355

356
		default:
357
			/*
358 359 360
			 * 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.
361
			 */
362 363 364
			ereport(FATAL,
					(errcode(ERRCODE_PROTOCOL_VIOLATION),
					 errmsg("invalid frontend message type %d", qtype)));
365
			break;
366
	}
367

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

379
	return qtype;
380 381 382
}

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

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

401 402 403 404 405 406

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

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

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

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

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

Bruce Momjian's avatar
Bruce Momjian committed
460
	if (log_statement)
461 462
		ereport(LOG,
				(errmsg("query: %s", query_string)));
463

Bruce Momjian's avatar
Bruce Momjian committed
464
	if (log_parser_stats)
465 466
		ResetUsage();

467
	raw_parsetree_list = raw_parser(query_string);
468

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

	return raw_parsetree_list;
}

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

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

495
	querytree_list = parse_analyze(parsetree, paramTypes, numParams);
496

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

500 501
	/*
	 * (2) Rewrite the queries, as necessary
502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520
	 */
	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();

	/*
521 522
	 * rewritten queries are collected in new_list.  Note there may be more
	 * or fewer than in the original list.
523
	 */
524
	foreach(list_item, querytree_list)
525
	{
526
		Query	   *querytree = (Query *) lfirst(list_item);
527

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

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

542
			new_list = nconc(new_list, rewritten);
543 544 545 546 547
		}
	}

	querytree_list = new_list;

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

551
#ifdef COPY_PARSE_PLAN_TREES
552 553 554 555 556

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

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

570 571
	return querytree_list;
}
572 573


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

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

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

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

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

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

598 599
		/*
		 * equal() currently does not have routines to compare Plan nodes,
600 601 602 603
		 * so don't try to test equality here.  Perhaps fix someday?
		 */
#ifdef NOT_USED
		/* This checks both copyObject() and the equal() routines... */
604
		if (!equal(new_plan, plan))
605 606
			ereport(WARNING,
					(errmsg("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
{
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
	/*
692 693 694
	 * 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.
695
	 * Similarly, log_statement_stats has to be captured once.
696
	 */
697
	if (save_log_duration || save_log_min_duration_statement > 0)
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 713 714 715 716 717 718 719 720 721 722 723 724

	/*
	 * 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.)
	 */
	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
		/*
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 795
				ereport(ERROR,
						(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
						 errmsg("current transaction is aborted, "
					 "queries 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
		/*
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 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871
		/*
		 * Select the appropriate output format: text unless we are doing
		 * 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...)
		 */
		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))
					format = 1;		/* BINARY */
			}
		}
		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);

		/*
		 * Run the portal to completion, and then drop it (and the receiver).
		 */
872 873
		(void) PortalRun(portal,
						 FETCH_ALL,
874 875
						 receiver,
						 receiver,
876
						 completionTag);
877

878 879
		(*receiver->destroy) (receiver);

880
		PortalDrop(portal, false);
881

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

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

923 924 925 926 927
	/*
	 * Close down transaction statement, if one is open.
	 */
	finish_xact_command();

928 929 930
	/*
	 * If there were no parsetrees, return EmptyQueryResponse message.
	 */
931
	if (!parsetree_list)
932 933
		NullCommand(dest);

934
	QueryContext = NULL;
935

936
	/*
937 938
	 * Combine processing here as we need to calculate the query
	 * duration in both instances.
939
	 */
940
	if (save_log_duration || save_log_min_duration_statement > 0)
941
	{
942
		long usecs;
943
		gettimeofday(&stop_t, NULL);
944 945 946 947 948
		if (stop_t.tv_usec < start_t.tv_usec)
		{
			stop_t.tv_sec--;
			stop_t.tv_usec += 1000000;
		}
949 950 951 952 953 954 955
		usecs = (long) (stop_t.tv_sec - start_t.tv_sec) * 1000000 + (long) (stop_t.tv_usec - start_t.tv_usec);

		/* 
		 * Output a duration_query to the log if the query has exceeded the
		 * min duration.
		 */
		if (usecs >= save_log_min_duration_statement * 1000)
956 957 958 959 960
			ereport(LOG,
					(errmsg("duration_statement: %ld.%06ld %s",
							(long) (stop_t.tv_sec - start_t.tv_sec),
							(long) (stop_t.tv_usec - start_t.tv_usec),
							query_string)));
961 962 963 964 965 966

		/* 
		 * If the user is requesting logging of all durations, then log
		 * that as well.
		 */
		if (save_log_duration)
967 968 969 970
			ereport(LOG,
					(errmsg("duration: %ld.%06ld sec",
							(long) (stop_t.tv_sec - start_t.tv_sec),
							(long) (stop_t.tv_usec - start_t.tv_usec))));
971
	}
972

973 974 975
	if (save_log_statement_stats)
		ShowUsage("QUERY STATISTICS");

976
	debug_query_string = NULL;
977 978
}

979 980 981 982 983 984 985 986 987 988 989 990 991 992 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 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 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 1071
/*
 * 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 */
				   Oid *paramTypes,				/* parameter types */
				   int numParams)				/* number of parameters */
{
	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.
	 *
	 * 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.
	 */
	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);

	/*
	 * 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.
	 */
	if (length(parsetree_list) > 1)
1072 1073 1074
		ereport(ERROR,
				(errcode(ERRCODE_SYNTAX_ERROR),
				 errmsg("cannot insert multiple commands into a prepared statement")));
1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107

	if (parsetree_list != NIL)
	{
		Node   *parsetree = (Node *) lfirst(parsetree_list);
		int		i;

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

		/*
		 * If we are in an aborted transaction, reject all commands except
		 * 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
		 * 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)
1108 1109 1110 1111
				ereport(ERROR,
						(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
						 errmsg("current transaction is aborted, "
					 "queries ignored until end of transaction block")));
1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135
		}

		/*
		 * 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++)
		{
			Oid		ptype = paramTypes[i];

			if (ptype == InvalidOid || ptype == UNKNOWNOID)
1136 1137 1138 1139
				ereport(ERROR,
						(errcode(ERRCODE_INDETERMINATE_DATATYPE),
						 errmsg("could not determine datatype of parameter $%d",
								i + 1)));
1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 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 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223
			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
	{
		/* Empty input string.  This is legal. */
		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;

	/*
	 * 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.
	 */
	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;
1224 1225
	int			numPFormats;
	int16	   *pformats = NULL;
1226
	int			numParams;
1227 1228 1229
	int			numRFormats;
	int16	   *rformats = NULL;
	int			i;
1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244
	PreparedStatement *pstmt;
	Portal		portal;
	ParamListInfo params;

	pgstat_report_activity("<BIND>");

	set_ps_display("BIND");

	/*
	 * 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.
	 */
	start_xact_command();

1245 1246 1247
	/* Switch back to message context */
	MemoryContextSwitchTo(MessageContext);

1248 1249 1250 1251
	/* Get the fixed part of the message */
	portal_name = pq_getmsgstring(input_message);
	stmt_name = pq_getmsgstring(input_message);

1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264
	/* 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)
1265 1266 1267 1268
		ereport(ERROR,
				(errcode(ERRCODE_PROTOCOL_VIOLATION),
				 errmsg("bind message has %d parameter formats but %d parameters",
						numPFormats, numParams)));
1269 1270 1271 1272 1273 1274 1275 1276 1277

	/* 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)
1278 1279 1280
			ereport(ERROR,
					(errcode(ERRCODE_UNDEFINED_PSTATEMENT),
					 errmsg("unnamed prepared statement does not exist")));
1281 1282 1283
	}

	if (numParams != length(pstmt->argtype_list))
1284 1285 1286 1287
		ereport(ERROR,
				(errcode(ERRCODE_PROTOCOL_VIOLATION),
				 errmsg("bind message supplies %d parameters, but prepared statement \"%s\" requires %d",
						numParams, stmt_name, length(pstmt->argtype_list))));
1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308

	/*
	 * 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.
	 *
	 * In an aborted transaction, we can't risk calling user-defined functions,
1309
	 * but we can't fail to Bind either, so bind all parameters to null values.
1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321
	 */
	if (numParams > 0)
	{
		bool	isaborted = IsAbortedTransactionBlockState();
		List   *l;
		MemoryContext oldContext;

		oldContext = MemoryContextSwitchTo(PortalGetHeapMemory(portal));

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

1322
		i = 0;
1323 1324 1325
		foreach(l, pstmt->argtype_list)
		{
			Oid			ptype = lfirsto(l);
1326
			int32		plength;
1327 1328
			bool		isNull;

1329 1330 1331
			plength = pq_getmsgint(input_message, 4);
			isNull = (plength == -1);

1332 1333
			if (!isNull)
			{
1334
				const char *pvalue = pq_getmsgbytes(input_message, plength);
1335 1336

				if (isaborted)
1337 1338
				{
					/* We don't bother to check the format in this case */
1339
					isNull = true;
1340
				}
1341 1342
				else
				{
1343
					int16	pformat;
1344 1345
					StringInfoData pbuf;
					char	csave;
1346 1347 1348 1349 1350 1351 1352 1353

					if (numPFormats > 1)
						pformat = pformats[i];
					else if (numPFormats > 0)
						pformat = pformats[0];
					else
						pformat = 0;		/* default = text */

1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370
					/*
					 * Rather than copying data around, we just set up a phony
					 * StringInfo pointing to the correct portion of the
					 * message buffer.  We assume we can scribble on the
					 * message buffer so as to maintain the convention that
					 * StringInfos have a trailing null.  This is grotty but
					 * is a big win when dealing with very large parameter
					 * strings.
					 */
					pbuf.data = (char *) pvalue;
					pbuf.maxlen = plength + 1;
					pbuf.len = plength;
					pbuf.cursor = 0;

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

1371 1372 1373 1374 1375 1376 1377 1378
					if (pformat == 0)
					{
						Oid			typInput;
						Oid			typElem;
						char	   *pstring;

						getTypeInputInfo(ptype, &typInput, &typElem);
						/*
1379 1380
						 * We have to do encoding conversion before calling
						 * the typinput routine.
1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395
						 */
						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)
					{
1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408
						Oid			typReceive;
						Oid			typElem;

						/* Call the parameter type's binary input converter */
						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)
1409 1410 1411 1412
							ereport(ERROR,
									(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
									 errmsg("incorrect binary data format in bind parameter %d",
								 i + 1)));
1413 1414 1415
					}
					else
					{
1416 1417 1418 1419
						ereport(ERROR,
								(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
								 errmsg("unsupported format code: %d",
										pformat)));
1420
					}
1421 1422 1423

					/* Restore message buffer contents */
					pbuf.data[plength] = csave;
1424 1425
				}
			}
1426

1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440
			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;

1441 1442 1443 1444 1445 1446 1447 1448 1449
	/* 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);
	}

1450 1451 1452 1453 1454 1455 1456
	pq_getmsgend(input_message);

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

1457 1458 1459 1460 1461
	/*
	 * Apply the result format requests to the portal.
	 */
	PortalSetResultFormat(portal, numRFormats, rformats);

1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474
	/*
	 * Send BindComplete.
	 */
	if (whereToSendOutput == Remote)
		pq_putemptymessage('2');
}

/*
 * exec_execute_message
 *
 * Process an "Execute" message for a portal
 */
static void
1475
exec_execute_message(const char *portal_name, long max_rows)
1476 1477
{
	CommandDest	dest;
1478
	DestReceiver *receiver;
1479 1480 1481 1482 1483 1484 1485 1486 1487
	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)
1488
		dest = RemoteExecute;
1489 1490 1491

	portal = GetPortalByName(portal_name);
	if (!PortalIsValid(portal))
1492 1493 1494
		ereport(ERROR,
				(errcode(ERRCODE_UNDEFINED_CURSOR),
				 errmsg("portal \"%s\" does not exist", portal_name)));
1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 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 1535 1536 1537 1538

	/*
	 * If the original query was a null string, just return EmptyQueryResponse.
	 */
	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)
	{
		Query *query = (Query *) lfirst(portal->parseTrees);

		if (query->commandType == CMD_UTILITY &&
			query->utilityStmt != NULL &&
			IsA(query->utilityStmt, TransactionStmt))
		{
			TransactionStmt *stmt = (TransactionStmt *) query->utilityStmt;

			is_trans_stmt = true;
			if (stmt->kind == TRANS_STMT_COMMIT ||
				stmt->kind == TRANS_STMT_ROLLBACK)
				is_trans_exit = true;
		}
	}

1539 1540 1541 1542 1543 1544
	/*
	 * Create dest receiver in MessageContext (we don't want it in transaction
	 * context, because that may get deleted if portal contains VACUUM).
	 */
	receiver = CreateDestReceiver(dest, portal);

1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557
	/*
	 * Ensure we are in a transaction command (this should normally be
	 * the case already due to prior BIND).
	 */
	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)
1558 1559 1560 1561
			ereport(ERROR,
					(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
					 errmsg("current transaction is aborted, "
				 "queries ignored until end of transaction block")));
1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574
	}

	/* 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,
1575 1576
						  receiver,
						  receiver,
1577 1578
						  completionTag);

1579 1580
	(*receiver->destroy) (receiver);

1581 1582 1583 1584 1585 1586 1587 1588
	if (completed)
	{
		if (is_trans_stmt)
		{
			/*
			 * If this was a transaction control statement, commit it.  We will
			 * start a new xact command for the next command (if any).
			 */
1589
			finish_xact_command();
1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621
		}
		else
		{
			/*
			 * We need a CommandCounterIncrement after every query,
			 * except those that start or end a transaction block.
			 */
			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;
1622
	TupleDesc	tupdesc;
1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633
	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)
1634 1635 1636
			ereport(ERROR,
					(errcode(ERRCODE_UNDEFINED_PSTATEMENT),
					 errmsg("unnamed prepared statement does not exist")));
1637 1638 1639 1640 1641
	}

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

1642 1643 1644
	/*
	 * First describe the parameters...
	 */
1645
	pq_beginmessage(&buf, 't');		/* parameter description message type */
1646
	pq_sendint(&buf, length(pstmt->argtype_list), 2);
1647 1648 1649 1650 1651 1652 1653 1654

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

		pq_sendint(&buf, (int) ptype, 4);
	}
	pq_endmessage(&buf);
1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667

	/*
	 * Next send RowDescription or NoData to describe the result...
	 */
	tupdesc = FetchPreparedStatementResultDesc(pstmt);
	if (tupdesc)
	{
		List   *targetlist;

		if (ChoosePortalStrategy(pstmt->query_list) == PORTAL_ONE_SELECT)
			targetlist = ((Query *) lfirst(pstmt->query_list))->targetList;
		else
			targetlist = NIL;
1668
		SendRowDescriptionMessage(tupdesc, targetlist, NULL);
1669 1670 1671 1672
	}
	else
		pq_putemptymessage('n');	/* NoData */

1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686
}

/*
 * 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))
1687 1688 1689
		ereport(ERROR,
				(errcode(ERRCODE_UNDEFINED_CURSOR),
				 errmsg("portal \"%s\" does not exist", portal_name)));
1690 1691 1692 1693 1694

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

	if (portal->tupDesc)
1695 1696 1697 1698
	{
		List   *targetlist;

		if (portal->strategy == PORTAL_ONE_SELECT)
1699
			targetlist = ((Query *) lfirst(portal->parseTrees))->targetList;
1700 1701
		else
			targetlist = NIL;
1702 1703
		SendRowDescriptionMessage(portal->tupDesc, targetlist,
								  portal->formats);
1704
	}
1705 1706 1707 1708 1709
	else
		pq_putemptymessage('n');	/* NoData */
}


1710 1711 1712 1713 1714 1715
/*
 * Convenience routines for starting/committing a single command.
 */
static void
start_xact_command(void)
{
1716 1717
	if (!xact_started)
	{
1718
		elog(DEBUG3, "StartTransactionCommand");
1719
		StartTransactionCommand();
1720 1721 1722 1723

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

1725 1726
		xact_started = true;
	}
1727 1728 1729
}

static void
1730
finish_xact_command(void)
1731
{
1732 1733 1734 1735
	if (xact_started)
	{
		/* Invoke IMMEDIATE constraint triggers */
		DeferredTriggerEndQuery();
1736

1737 1738
		/* Cancel any active statement timeout before committing */
		disable_sig_alarm(true);
1739

1740
		/* Now commit the command */
1741
		elog(DEBUG3, "CommitTransactionCommand");
1742

1743
		CommitTransactionCommand();
1744

1745
#ifdef SHOW_MEMORY_STATS
1746 1747 1748
		/* Print mem stats at each commit for leak tracking */
		if (ShowStats)
			MemoryContextStats(TopMemoryContext);
1749
#endif
1750 1751 1752

		xact_started = false;
	}
1753 1754 1755
}


1756
/* --------------------------------
1757
 *		signal handler routines used in PostgresMain()
1758 1759 1760
 * --------------------------------
 */

1761
/*
Tom Lane's avatar
Tom Lane committed
1762
 * quickdie() occurs when signalled SIGQUIT by the postmaster.
1763 1764 1765 1766
 *
 * Some backend has bought the farm,
 * so we need to stop what we're doing and exit.
 */
Tom Lane's avatar
Tom Lane committed
1767
void
1768
quickdie(SIGNAL_ARGS)
1769
{
1770
	PG_SETMASK(&BlockSig);
1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783
	/*
	 * Ideally this should be ereport(FATAL), but then we'd not get control
	 * back (perhaps could fix by doing local sigsetjmp?)
	 */
	ereport(WARNING,
			(errcode(ERRCODE_CRASH_SHUTDOWN),
			 errmsg("terminating connection due to crash of another backend"),
			 errdetail("The postmaster has commanded this backend to roll back"
					   " the current transaction and exit, because another"
					   " backend exited abnormally and possibly corrupted"
					   " shared memory."),
			 errhint("In a moment you should be able to reconnect to the"
					 " database and repeat your query.")));
1784
	/*
1785 1786 1787 1788
	 * 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.
	 *
1789 1790 1791 1792
	 * 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.
1793
	 */
1794
	exit(1);
1795 1796
}

1797
/*
1798 1799
 * Shutdown signal from postmaster: abort transaction and exit
 * at soonest convenient time
1800
 */
1801
void
1802
die(SIGNAL_ARGS)
1803
{
1804 1805 1806
	int			save_errno = errno;

	/* Don't joggle the elbow of proc_exit */
1807
	if (!proc_exit_inprogress)
1808
	{
1809
		InterruptPending = true;
1810
		ProcDiePending = true;
1811

1812
		/*
1813 1814
		 * If it's safe to interrupt, and we're waiting for input or a
		 * lock, service the interrupt immediately
1815
		 */
1816 1817
		if (ImmediateInterruptOK && InterruptHoldoffCount == 0 &&
			CritSectionCount == 0)
1818
		{
1819 1820 1821
			/* bump holdoff count to make ProcessInterrupts() a no-op */
			/* until we are done getting ready for it */
			InterruptHoldoffCount++;
1822
			DisableNotifyInterrupt();
1823
			/* Make sure CheckDeadLock won't run while shutting down... */
1824
			LockWaitCancel();
1825
			InterruptHoldoffCount--;
1826 1827
			ProcessInterrupts();
		}
1828
	}
1829 1830

	errno = save_errno;
1831 1832
}

1833
/*
1834
 * Timeout or shutdown signal from postmaster during client authentication.
1835
 * Simply exit(0).
1836 1837 1838
 *
 * XXX: possible future improvement: try to send a message indicating
 * why we are disconnecting.  Problem is to be sure we don't block while
1839
 * doing so, nor mess up the authentication message exchange.
1840 1841 1842 1843 1844 1845 1846
 */
void
authdie(SIGNAL_ARGS)
{
	exit(0);
}

1847
/*
1848 1849
 * Query-cancel signal from postmaster: abort current transaction
 * at soonest convenient time
1850
 */
1851
static void
1852
StatementCancelHandler(SIGNAL_ARGS)
1853
{
1854 1855
	int			save_errno = errno;

1856 1857 1858 1859
	/*
	 * Don't joggle the elbow of proc_exit, nor an already-in-progress
	 * abort
	 */
1860
	if (!proc_exit_inprogress && !InError)
1861
	{
1862 1863
		InterruptPending = true;
		QueryCancelPending = true;
1864

1865
		/*
1866
		 * If it's safe to interrupt, and we're waiting for a lock,
1867 1868
		 * service the interrupt immediately.  No point in interrupting if
		 * we're waiting for input, however.
1869
		 */
1870
		if (ImmediateInterruptOK && InterruptHoldoffCount == 0 &&
1871
			CritSectionCount == 0)
1872
		{
1873 1874 1875 1876 1877 1878
			/* 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
1879
				InterruptHoldoffCount--;
1880 1881 1882 1883
				ProcessInterrupts();
			}
			else
				InterruptHoldoffCount--;
1884
		}
1885 1886
	}

1887
	errno = save_errno;
1888 1889
}

1890 1891 1892 1893
/* signal handler for floating point exception */
static void
FloatExceptionHandler(SIGNAL_ARGS)
{
1894 1895 1896 1897 1898 1899
	ereport(ERROR,
			(errcode(ERRCODE_FLOATING_POINT_EXCEPTION),
			 errmsg("floating-point exception"),
			 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.")));
1900 1901
}

1902
/* SIGHUP: set flag to re-read config file at next convenient time */
1903
static void
1904
SigHupHandler(SIGNAL_ARGS)
1905
{
1906
	got_SIGHUP = true;
1907 1908
}

1909

1910 1911 1912 1913 1914 1915 1916 1917 1918 1919
/*
 * 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)
{
1920 1921
	/* OK to accept interrupt now? */
	if (InterruptHoldoffCount != 0 || CritSectionCount != 0)
1922 1923 1924 1925 1926
		return;
	InterruptPending = false;
	if (ProcDiePending)
	{
		ProcDiePending = false;
1927 1928
		QueryCancelPending = false;		/* ProcDie trumps QueryCancel */
		ImmediateInterruptOK = false;	/* not idle anymore */
1929
		DisableNotifyInterrupt();
1930 1931 1932
		ereport(FATAL,
				(errcode(ERRCODE_ADMIN_SHUTDOWN),
				 errmsg("terminating connection due to administrator command")));
1933 1934 1935 1936
	}
	if (QueryCancelPending)
	{
		QueryCancelPending = false;
1937
		ImmediateInterruptOK = false;	/* not idle anymore */
1938
		DisableNotifyInterrupt();
1939 1940 1941
		ereport(ERROR,
				(errcode(ERRCODE_QUERY_CANCELED),
				 errmsg("canceling query due to user request")));
1942 1943 1944 1945
	}
	/* If we get here, do nothing (probably, QueryCancelPending was reset) */
}

1946

1947 1948
static void
usage(char *progname)
1949
{
1950 1951
	printf("%s is the PostgreSQL stand-alone backend.  It is not\nintended to be used by normal users.\n\n", progname);

1952
	printf("Usage:\n  %s [OPTION]... [DBNAME]\n\n", progname);
1953
	printf("Options:\n");
1954
#ifdef USE_ASSERT_CHECKING
1955
	printf("  -A 1|0          enable/disable run-time assert checking\n");
1956
#endif
1957 1958
	printf("  -B NBUFFERS     number of shared buffers (default %d)\n", DEF_NBUFFERS);
	printf("  -c NAME=VALUE   set run-time parameter\n");
1959
	printf("  -d 0-5          debugging level (0 is off)\n");
1960
	printf("  -D DATADIR      database directory\n");
1961
	printf("  -e              use European date input format (DMY)\n");
1962 1963 1964 1965
	printf("  -E              echo query before execution\n");
	printf("  -F              turn fsync off\n");
	printf("  -N              do not use newline as interactive query delimiter\n");
	printf("  -o FILENAME     send stdout and stderr to given file\n");
1966
	printf("  -P              disable system indexes\n");
1967 1968
	printf("  -s              show statistics after each query\n");
	printf("  -S SORT-MEM     set amount of memory for sorts (in kbytes)\n");
1969
	printf("  --help-config   show configuration options, then exit. Details: --help-config -h\n");
1970 1971 1972 1973
	printf("  --help          show this help, then exit\n");
	printf("  --version       output version information, then exit\n");
	printf("\nDeveloper options:\n");
	printf("  -f s|i|n|m|h    forbid use of some plan types\n");
1974 1975
	printf("  -i              do not execute queries\n");
	printf("  -O              allow system table structure changes\n");
1976
	printf("  -t pa|pl|ex     show timings after each query\n");
1977 1978
	printf("  -W NUM          wait NUM seconds to allow attach from a debugger\n");
	printf("\nReport bugs to <pgsql-bugs@postgresql.org>.\n");
1979 1980
}

1981 1982


1983
/* ----------------------------------------------------------------
1984
 * PostgresMain
1985
 *	   postgres main loop -- all backends, interactive or otherwise start here
1986
 *
1987 1988 1989 1990
 * 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.
1991 1992 1993
 * ----------------------------------------------------------------
 */
int
1994
PostgresMain(int argc, char *argv[], const char *username)
1995
{
1996
	int			flag;
1997
	const char *dbname = NULL;
1998
	char	   *potential_DataDir = NULL;
1999
	bool		secure;
2000
	int			errs = 0;
2001
	int			debug_flag = 0;
2002
	GucContext	ctx, debug_context;
2003
	GucSource	gucsource;
2004
	char	   *tmp;
2005
	int			firstchar;
2006
	StringInfo	input_message;
2007
	volatile bool send_rfq = true;
2008

2009
	/*
2010 2011
	 * Catch standard options before doing much else.  This even works on
	 * systems without getopt_long.
2012 2013 2014
	 */
	if (!IsUnderPostmaster && argc > 1)
	{
2015
		if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
2016 2017 2018 2019
		{
			usage(argv[0]);
			exit(0);
		}
2020
		if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
2021 2022 2023 2024
		{
			puts("postgres (PostgreSQL) " PG_VERSION);
			exit(0);
		}
2025
	}
2026

2027 2028 2029 2030 2031 2032 2033
	/*
	 * initialize globals (already done if under postmaster, but not if
	 * standalone; cheap enough to do over)
	 */

	MyProcPid = getpid();

2034 2035 2036 2037 2038
	/*
	 * Fire up essential subsystems: error and memory management
	 *
	 * If we are running under the postmaster, this is done already.
	 */
2039
	if (!IsUnderPostmaster)
2040 2041
		MemoryContextInit();

2042 2043
	set_ps_display("startup");

2044 2045
	SetProcessingMode(InitProcessing);

2046
	/*
2047
	 * Set default values for command-line options.
2048
	 */
2049 2050
	Noversion = false;
	EchoQuery = false;
2051

2052
	if (!IsUnderPostmaster /* when exec || ExecBackend*/)
2053
	{
2054
		InitializeGUCOptions();
2055
		potential_DataDir = getenv("PGDATA");
2056
	}
2057

2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074
	/* ----------------
	 *	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.
	 * ----------------
	 */

2075 2076
	/* all options are allowed until '-p' */
	secure = true;
2077
	ctx = debug_context = PGC_POSTMASTER;
2078
	gucsource = PGC_S_ARGV;		/* initial switches came from command line */
2079

2080
	while ((flag = getopt(argc, argv, "A:B:c:CD:d:Eef:FiNOPo:p:S:st:v:W:x:-:")) != -1)
2081 2082
		switch (flag)
		{
2083 2084
			case 'A':
#ifdef USE_ASSERT_CHECKING
2085
				SetConfigOption("debug_assertions", optarg, ctx, gucsource);
2086
#else
2087 2088 2089
				ereport(WARNING,
						(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
						 errmsg("assert checking is not compiled in")));
2090 2091
#endif
				break;
2092

2093
			case 'B':
2094 2095 2096

				/*
				 * specify the size of buffer pool
2097
				 */
2098
				SetConfigOption("shared_buffers", optarg, ctx, gucsource);
2099
				break;
2100

2101
			case 'C':
2102 2103 2104

				/*
				 * don't print version string
2105
				 */
2106
				Noversion = true;
2107
				break;
2108

2109
			case 'D':			/* PGDATA directory */
2110
				if (secure)
2111
					potential_DataDir = optarg;
2112
				break;
2113

2114
			case 'd':			/* debug level */
2115
				{
2116 2117 2118 2119 2120 2121
					/*
					 *	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.
					 */					   
					if (ctx != PGC_BACKEND || atoi(optarg) > debug_flag)
2122
					{
2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142
						debug_flag = atoi(optarg);
						debug_context = ctx;	/* save context for use below */
						/* Set server debugging level. */
						if (debug_flag != 0)
						{
							char	   *debugstr = palloc(strlen("debug") + strlen(optarg) + 1);
	
							sprintf(debugstr, "debug%s", optarg);
							SetConfigOption("log_min_messages", debugstr, ctx, gucsource);
							pfree(debugstr);
	
						}
						else
							/*
							 * -d0 allows user to prevent postmaster debug
							 * from propagating to backend.  It would be nice
							 * to set it to the postgresql.conf value here.
							 */
							SetConfigOption("log_min_messages", "notice",
											ctx, gucsource);
2143 2144
					}
				}
2145
				break;
2146 2147

			case 'E':
2148 2149 2150

				/*
				 * E - echo the query the user entered
2151
				 */
2152
				EchoQuery = true;
2153
				break;
2154 2155

			case 'e':
2156 2157

				/*
2158
				 * Use European date input format (DMY)
2159
				 */
2160
				SetConfigOption("datestyle", "euro", ctx, gucsource);
2161
				break;
2162 2163

			case 'F':
2164 2165 2166

				/*
				 * turn off fsync
2167
				 */
2168
				SetConfigOption("fsync", "false", ctx, gucsource);
2169
				break;
2170 2171

			case 'f':
2172 2173 2174

				/*
				 * f - forbid generation of certain plans
2175
				 */
2176
				tmp = NULL;
2177 2178 2179
				switch (optarg[0])
				{
					case 's':	/* seqscan */
2180
						tmp = "enable_seqscan";
2181 2182
						break;
					case 'i':	/* indexscan */
2183
						tmp = "enable_indexscan";
2184 2185
						break;
					case 't':	/* tidscan */
2186
						tmp = "enable_tidscan";
2187 2188
						break;
					case 'n':	/* nestloop */
2189
						tmp = "enable_nestloop";
2190 2191
						break;
					case 'm':	/* mergejoin */
2192
						tmp = "enable_mergejoin";
2193 2194
						break;
					case 'h':	/* hashjoin */
2195
						tmp = "enable_hashjoin";
2196 2197 2198 2199
						break;
					default:
						errs++;
				}
2200
				if (tmp)
2201
					SetConfigOption(tmp, "false", ctx, gucsource);
2202 2203
				break;

2204
			case 'N':
2205 2206 2207

				/*
				 * N - Don't use newline as a query delimiter
2208 2209 2210
				 */
				UseNewLine = 0;
				break;
2211

2212
			case 'O':
2213 2214 2215

				/*
				 * allow system table structure modifications
2216
				 */
2217 2218
				if (secure)		/* XXX safe to allow from client??? */
					allowSystemTableMods = true;
2219 2220
				break;

Hiroshi Inoue's avatar
Hiroshi Inoue committed
2221
			case 'P':
2222 2223 2224

				/*
				 * ignore system indexes
Hiroshi Inoue's avatar
Hiroshi Inoue committed
2225 2226 2227 2228 2229
				 */
				if (secure)		/* XXX safe to allow from client??? */
					IgnoreSystemIndexes(true);
				break;

2230
			case 'o':
2231 2232 2233

				/*
				 * o - send output (stdout and stderr) to the given file
2234
				 */
2235 2236
				if (secure)
					StrNCpy(OutputFileName, optarg, MAXPGPATH);
2237 2238
				break;

2239
			case 'p':
2240 2241 2242 2243

				/*
				 * p - special flag passed if backend was forked by a
				 * postmaster.
2244
				 */
2245 2246
				if (secure)
				{
2247
#ifdef EXEC_BACKEND
2248
					char *p;
2249 2250 2251 2252
					int	i;
					int PMcanAcceptConnections;	/* will eventually be global or static, when fork */
					
					sscanf(optarg, "%d,%d,%d,%p,", &MyProcPort->sock, &PMcanAcceptConnections,
2253
									&UsedShmemSegID, &UsedShmemSegAddr);
2254
					/* Grab dbname as last param */
2255
					for (i = 0, p = optarg-1; i < 4 && p; i++)
2256
						p = strchr(p+1, ',');
2257
					if (i == 4 && p)
2258 2259
						dbname = strdup(p+1);
#else
2260
					dbname = strdup(optarg);
2261
#endif
Bruce Momjian's avatar
Bruce Momjian committed
2262 2263
					secure = false;		/* subsequent switches are NOT
										 * secure */
2264
					ctx = PGC_BACKEND;
2265
					gucsource = PGC_S_CLIENT;
2266
				}
2267
				break;
2268

2269
			case 'S':
2270 2271 2272

				/*
				 * S - amount of sort memory to use in 1k bytes
2273
				 */
2274
				SetConfigOption("sort_mem", optarg, ctx, gucsource);
2275
				break;
2276 2277

			case 's':
2278 2279 2280

				/*
				 * s - report usage statistics (timings) after each query
2281
				 */
2282
				SetConfigOption("show_statement_stats", "true", ctx, gucsource);
2283 2284
				break;

2285
			case 't':
2286
				/* ---------------
2287 2288 2289 2290 2291 2292 2293 2294 2295
				 *	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.
				 * ----------------
				 */
2296
				tmp = NULL;
2297 2298 2299 2300
				switch (optarg[0])
				{
					case 'p':
						if (optarg[1] == 'a')
Bruce Momjian's avatar
Bruce Momjian committed
2301
							tmp = "log_parser_stats";
2302
						else if (optarg[1] == 'l')
Bruce Momjian's avatar
Bruce Momjian committed
2303
							tmp = "log_planner_stats";
2304 2305 2306 2307
						else
							errs++;
						break;
					case 'e':
2308
						tmp = "show_executor_stats";
2309 2310 2311 2312 2313
						break;
					default:
						errs++;
						break;
				}
2314
				if (tmp)
2315
					SetConfigOption(tmp, "true", ctx, gucsource);
2316 2317
				break;

2318
			case 'v':
2319 2320
				if (secure)
					FrontendProtocol = (ProtocolVersion) atoi(optarg);
2321 2322
				break;

2323
			case 'W':
2324 2325 2326

				/*
				 * wait N seconds to allow attach from a debugger
2327 2328 2329 2330
				 */
				sleep(atoi(optarg));
				break;

2331
			case 'x':
Bruce Momjian's avatar
Bruce Momjian committed
2332
#ifdef NOT_USED					/* planner/xfunc.h */
2333 2334 2335 2336 2337 2338 2339

				/*
				 * control joey hellerstein's expensive function
				 * optimization
				 */
				if (XfuncMode != 0)
				{
Bruce Momjian's avatar
Bruce Momjian committed
2340
					elog(WARNING, "only one -x flag is allowed");
2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357
					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
2358
					elog(WARNING, "use -x {off,nor,nopull,nopm,pullall,wait}");
2359 2360
					errs++;
				}
2361
#endif
2362
				break;
2363

2364
			case 'c':
2365
			case '-':
2366
				{
2367 2368
					char	   *name,
							   *value;
2369

2370 2371 2372 2373
					ParseLongOption(optarg, &name, &value);
					if (!value)
					{
						if (flag == '-')
2374 2375 2376 2377
							ereport(ERROR,
									(errcode(ERRCODE_SYNTAX_ERROR),
									 errmsg("--%s requires a value",
											optarg)));
2378
						else
2379 2380 2381 2382
							ereport(ERROR,
									(errcode(ERRCODE_SYNTAX_ERROR),
									 errmsg("-c %s requires a value",
											optarg)));
2383 2384
					}

2385
					SetConfigOption(name, value, ctx, gucsource);
2386 2387 2388 2389 2390
					free(name);
					if (value)
						free(value);
					break;
				}
2391

2392 2393
			default:
				errs++;
2394
				break;
2395 2396
		}

2397

2398
	/*
2399 2400
	 * -d is not the same as setting log_min_messages because it enables
	 * other output options.
2401 2402
	 */
	if (debug_flag >= 1)
2403
		SetConfigOption("log_connections", "true", debug_context, gucsource);
2404
	if (debug_flag >= 2)
2405
		SetConfigOption("log_statement", "true", debug_context, gucsource);
2406
	if (debug_flag >= 3)
2407
		SetConfigOption("debug_print_parse", "true", debug_context, gucsource);
2408
	if (debug_flag >= 4)
2409
		SetConfigOption("debug_print_plan", "true", debug_context, gucsource);
2410
	if (debug_flag >= 5)
2411
		SetConfigOption("debug_print_rewritten", "true", debug_context, gucsource);
2412

2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432
	/*
	 * Process any additional GUC variable settings passed in startup packet.
	 */
	if (MyProcPort != NULL)
	{
		List   *gucopts = MyProcPort->guc_options;

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

2433 2434 2435
	/*
	 * Post-processing for command line options.
	 */
Bruce Momjian's avatar
Bruce Momjian committed
2436 2437
	if (log_statement_stats &&
		(log_parser_stats || log_planner_stats || log_executor_stats))
2438
	{
2439 2440 2441
		ereport(WARNING,
				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
				 errmsg("query-level statistics are disabled because parser, planner, or executor statistics are on")));
2442
		SetConfigOption("show_statement_stats", "false", ctx, gucsource);
2443 2444
	}

2445
	if (!IsUnderPostmaster)
2446
	{
2447 2448
		if (!potential_DataDir)
		{
2449 2450 2451 2452 2453
			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"),
2454 2455 2456 2457
					argv[0]);
			proc_exit(1);
		}
		SetDataDir(potential_DataDir);
2458
	}
2459
	Assert(DataDir);
2460

2461 2462 2463 2464
#ifdef EXEC_BACKEND
	read_nondefault_variables();
#endif

2465
	/*
2466
	 * Set up signal handlers and masks.
2467
	 *
2468
	 * Note that postmaster blocked all signals before forking child process,
2469 2470
	 * 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
2471 2472
	 *
	 * Also note: it's best not to use any signals that are SIG_IGNored in
2473
	 * the postmaster.	If such a signal arrives before we are able to
2474
	 * change the handler to non-SIG_IGN, it'll get dropped.  Instead,
Bruce Momjian's avatar
Bruce Momjian committed
2475 2476
	 * make a dummy handler in the postmaster to reserve the signal. (Of
	 * course, this isn't an issue for signals that are locally generated,
2477
	 * such as SIGALRM and SIGPIPE.)
2478
	 */
2479

2480
	pqsignal(SIGHUP, SigHupHandler);	/* set flag to read config file */
Bruce Momjian's avatar
Bruce Momjian committed
2481
	pqsignal(SIGINT, StatementCancelHandler);	/* cancel current query */
2482
	pqsignal(SIGTERM, die);		/* cancel current query and exit */
2483
	pqsignal(SIGQUIT, quickdie);	/* hard crash time */
2484
	pqsignal(SIGALRM, handle_sig_alarm);	/* timeout conditions */
2485 2486 2487 2488 2489

	/*
	 * 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
2490 2491 2492
	 * midst of output during who-knows-what operation...
	 */
	pqsignal(SIGPIPE, SIG_IGN);
2493
	pqsignal(SIGUSR1, SIG_IGN); /* this signal available for use */
2494

2495
	pqsignal(SIGUSR2, Async_NotifyHandler);		/* flush also sinval cache */
2496
	pqsignal(SIGFPE, FloatExceptionHandler);
2497 2498

	/*
2499 2500
	 * Reset some signals that are accepted by postmaster but not by
	 * backend
2501
	 */
2502 2503
	pqsignal(SIGCHLD, SIG_DFL); /* system() requires this on some
								 * platforms */
2504

2505 2506
	pqinitmask();

Tom Lane's avatar
Tom Lane committed
2507
	/* We allow SIGQUIT (quickdie) at all times */
2508
#ifdef HAVE_SIGPROCMASK
Tom Lane's avatar
Tom Lane committed
2509
	sigdelset(&BlockSig, SIGQUIT);
2510
#else
Tom Lane's avatar
Tom Lane committed
2511
	BlockSig &= ~(sigmask(SIGQUIT));
2512 2513
#endif

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

2516

2517
	if (IsUnderPostmaster)
2518
	{
2519
		/* noninteractive case: nothing should be left after switches */
2520
		if (errs || argc != optind || dbname == NULL)
2521
		{
2522 2523 2524 2525
			ereport(FATAL,
					(errcode(ERRCODE_SYNTAX_ERROR),
					 errmsg("invalid backend command-line arguments"),
					 errhint("Try -? for help.")));
2526
		}
2527
		BaseInit();
2528 2529 2530
#ifdef EXECBACKEND
		AttachSharedMemoryAndSemaphores();
#endif
2531
	}
2532
	else
2533
	{
2534 2535 2536
		/* interactive case: database name can be last arg on command line */
		if (errs || argc - optind > 1)
		{
2537 2538 2539 2540 2541
			ereport(FATAL,
					(errcode(ERRCODE_SYNTAX_ERROR),
					 errmsg("%s: invalid command-line arguments",
							argv[0]),
					 errhint("Try -? for help.")));
2542 2543
		}
		else if (argc - optind == 1)
2544 2545
			dbname = argv[optind];
		else if ((dbname = username) == NULL)
2546
		{
2547 2548 2549 2550
			ereport(FATAL,
					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
					 errmsg("%s: no database nor user name specified",
							argv[0])));
2551
		}
2552

2553 2554 2555 2556 2557
		/*
		 * 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)
2558 2559 2560
			ereport(FATAL,
					(errmsg("%s: could not locate postgres executable",
							argv[0])));
2561

2562
		/*
2563 2564
		 * Validate we have been given a reasonable-looking DataDir (if
		 * under postmaster, assume postmaster did this already).
2565 2566 2567
		 */
		ValidatePgVersion(DataDir);

2568
		/*
2569
		 * Create lockfile for data directory.
2570
		 */
2571
		CreateDataDirLockFile(DataDir, false);
2572

2573
		XLOGPathInit();
2574
		BaseInit();
2575 2576 2577 2578 2579

		/*
		 * Start up xlog for standalone backend, and register to have it
		 * closed down at exit.
		 */
2580
		StartupXLOG();
2581
		on_shmem_exit(ShutdownXLOG, 0);
2582 2583 2584 2585 2586 2587 2588

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

2591 2592 2593 2594 2595 2596 2597 2598
	/*
	 * Set up additional info.
	 */

#ifdef CYR_RECODE
	SetCharSet();
#endif

2599
	/*
2600 2601 2602 2603 2604
	 * 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.
2605
	 */
2606
	elog(DEBUG3, "InitPostgres");
2607
	InitPostgres(dbname, username);
2608

2609
	SetProcessingMode(NormalProcessing);
2610

2611 2612
	/*
	 * Send this backend's cancellation info to the frontend.
2613
	 */
2614 2615 2616
	if (whereToSendOutput == Remote &&
		PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
	{
2617
		StringInfoData buf;
Bruce Momjian's avatar
Bruce Momjian committed
2618

2619
		pq_beginmessage(&buf, 'K');
2620 2621 2622
		pq_sendint(&buf, (int32) MyProcPid, sizeof(int32));
		pq_sendint(&buf, (int32) MyCancelKey, sizeof(int32));
		pq_endmessage(&buf);
2623 2624 2625
		/* Need not flush since ReadyForQuery will do it. */
	}

2626 2627 2628
	if (!IsUnderPostmaster)
	{
		puts("\nPOSTGRES backend interactive interface ");
2629
		puts("$Revision: 1.353 $ $Date: 2003/07/29 00:03:18 $\n");
2630 2631
	}

2632 2633 2634
	/*
	 * Create the memory context we will use in the main loop.
	 *
2635 2636
	 * MessageContext is reset once per iteration of the main loop, ie, upon
	 * completion of processing of each command message from the client.
2637
	 */
2638 2639 2640 2641 2642
	MessageContext = AllocSetContextCreate(TopMemoryContext,
										   "MessageContext",
										   ALLOCSET_DEFAULT_MINSIZE,
										   ALLOCSET_DEFAULT_INITSIZE,
										   ALLOCSET_DEFAULT_MAXSIZE);
2643

2644 2645 2646 2647 2648 2649 2650
	/* ----------
	 * Tell the statistics collector that we're alive and
	 * to which database we belong.
	 * ----------
	 */
	pgstat_bestart();

2651 2652
	/*
	 * POSTGRES main processing loop begins here
2653
	 *
2654 2655
	 * If an exception is encountered, processing resumes here so we abort
	 * the current transaction and start a new one.
2656 2657 2658 2659
	 */

	if (sigsetjmp(Warn_restart, 1) != 0)
	{
2660
		/*
2661
		 * NOTE: if you are tempted to add more code in this if-block,
2662 2663
		 * consider the probability that it should be in
		 * AbortTransaction() instead.
2664
		 *
2665 2666
		 * Make sure we're not interrupted while cleaning up.  Also forget
		 * any pending QueryCancel request, since we're aborting anyway.
2667
		 * Force InterruptHoldoffCount to a known state in case we ereport'd
2668
		 * from inside a holdoff section.
2669 2670 2671
		 */
		ImmediateInterruptOK = false;
		QueryCancelPending = false;
2672 2673
		InterruptHoldoffCount = 1;
		CritSectionCount = 0;	/* should be unnecessary, but... */
2674 2675
		disable_sig_alarm(true);
		QueryCancelPending = false;	/* again in case timeout occurred */
2676
		DisableNotifyInterrupt();
2677
		debug_query_string = NULL;
2678 2679

		/*
2680 2681 2682 2683 2684 2685
		 * 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);
2686

2687
		/* Do the recovery */
2688
		elog(DEBUG2, "AbortCurrentTransaction");
2689
		AbortCurrentTransaction();
2690 2691

		/*
2692 2693
		 * Now return to normal top-level context and clear ErrorContext
		 * for next time.
2694 2695 2696
		 */
		MemoryContextSwitchTo(TopMemoryContext);
		MemoryContextResetAndDeleteChildren(ErrorContext);
2697 2698
		PortalContext = NULL;
		QueryContext = NULL;
2699 2700 2701 2702 2703

		/*
		 * Clear flag to indicate that we got out of error recovery mode
		 * successfully.  (Flag was set in elog.c before longjmp().)
		 */
2704
		InError = false;
2705 2706 2707 2708
		xact_started = false;

		/*
		 * If we were handling an extended-query-protocol message,
2709 2710
		 * initiate skip till next Sync.  This also causes us not
		 * to issue ReadyForQuery (until we get Sync).
2711 2712 2713
		 */
		if (doing_extended_query_message)
			ignore_till_sync = true;
2714 2715

		/*
2716
		 * Exit interrupt holdoff section we implicitly established above.
2717
		 */
2718
		RESUME_INTERRUPTS();
2719
	}
2720

2721
	Warn_restart_ready = true;	/* we can now handle ereport(ERROR) */
2722

2723
	PG_SETMASK(&UnBlockSig);
2724

2725 2726
	if (!ignore_till_sync)
		send_rfq = true;		/* initially, or after error */
2727

2728 2729
	/*
	 * Non-error queries loop here.
2730 2731 2732 2733
	 */

	for (;;)
	{
2734 2735 2736 2737 2738 2739
		/*
		 * At top of loop, reset extended-query-message flag, so that
		 * any errors encountered in "idle" state don't provoke skip.
		 */
		doing_extended_query_message = false;

2740
		/*
2741
		 * Release storage left over from prior query cycle, and create a
2742
		 * new query input buffer in the cleared MessageContext.
2743
		 */
2744 2745
		MemoryContextSwitchTo(MessageContext);
		MemoryContextResetAndDeleteChildren(MessageContext);
2746

2747
		input_message = makeStringInfo();
2748

2749 2750
		/*
		 * (1) tell the frontend we're ready for a new query.
2751
		 *
2752
		 * Note: this includes fflush()'ing the last of the prior output.
Bruce Momjian's avatar
Bruce Momjian committed
2753
		 */
2754 2755 2756 2757 2758
		if (send_rfq)
		{
			ReadyForQuery(whereToSendOutput);
			send_rfq = false;
		}
Bruce Momjian's avatar
Bruce Momjian committed
2759

2760 2761 2762 2763 2764 2765 2766
		/* ----------
		 * Tell the statistics collector what we've collected
		 * so far.
		 * ----------
		 */
		pgstat_report_tabstat();

2767
		if (IsTransactionBlock())
2768
		{
2769
			set_ps_display("idle in transaction");
2770 2771
			pgstat_report_activity("<IDLE> in transaction");
		}
2772
		else
2773
		{
2774
			set_ps_display("idle");
2775 2776
			pgstat_report_activity("<IDLE>");
		}
2777

2778 2779 2780 2781
		/*
		 * (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.
2782
		 */
2783 2784
		QueryCancelPending = false;		/* forget any earlier CANCEL
										 * signal */
2785 2786 2787

		EnableNotifyInterrupt();

2788 2789 2790 2791 2792 2793
		/* 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();

2794 2795
		/*
		 * (3) read a command (loop blocks here)
2796
		 */
2797
		firstchar = ReadCommand(input_message);
2798

2799 2800
		/*
		 * (4) disable async signal conditions again.
2801
		 */
2802
		ImmediateInterruptOK = false;
2803
		QueryCancelPending = false;		/* forget any CANCEL signal */
2804

2805 2806
		DisableNotifyInterrupt();

2807 2808 2809
		/*
		 * (5) check for any other interesting events that happened while
		 * we slept.
2810 2811 2812 2813 2814 2815 2816
		 */
		if (got_SIGHUP)
		{
			got_SIGHUP = false;
			ProcessConfigFile(PGC_SIGHUP);
		}

2817
		/*
2818
		 * (6) process the command.  But ignore it if we're skipping till Sync.
2819
		 */
2820
		if (ignore_till_sync && firstchar != EOF)
2821 2822
			continue;

2823 2824
		switch (firstchar)
		{
2825
			case 'Q':			/* simple query */
2826
				{
2827 2828 2829 2830
					const char *query_string;

					query_string = pq_getmsgstring(input_message);
					pq_getmsgend(input_message);
2831

2832
					exec_simple_query(query_string);
2833

2834 2835
					send_rfq = true;
				}
2836 2837
				break;

2838 2839 2840 2841 2842 2843 2844 2845 2846
			case 'P':			/* parse */
				{
					const char *stmt_name;
					const char *query_string;
					int			numParams;
					Oid		   *paramTypes = NULL;

					stmt_name = pq_getmsgstring(input_message);
					query_string = pq_getmsgstring(input_message);
2847
					numParams = pq_getmsgint(input_message, 2);
2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879
					if (numParams > 0)
					{
						int		i;

						paramTypes = (Oid *) palloc(numParams * sizeof(Oid));
						for (i = 0; i < numParams; i++)
							paramTypes[i] = pq_getmsgint(input_message, 4);
					}
					pq_getmsgend(input_message);

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

			case 'B':			/* bind */
				/*
				 * this message is complex enough that it seems best to put
				 * the field extraction out-of-line
				 */
				exec_bind_message(input_message);
				break;

			case 'E':			/* execute */
				{
					const char *portal_name;
					int		max_rows;

					portal_name = pq_getmsgstring(input_message);
					max_rows = pq_getmsgint(input_message, 4);
					pq_getmsgend(input_message);

2880
					exec_execute_message(portal_name, max_rows);
2881 2882 2883
				}
				break;

2884 2885
			case 'F':			/* fastpath function call */
				/* Tell the collector what we're doing */
2886 2887
				pgstat_report_activity("<FASTPATH> function call");

2888
				/* start an xact for this function invocation */
2889
				start_xact_command();
2890

2891 2892 2893
				/* switch back to message context */
				MemoryContextSwitchTo(MessageContext);

2894
				if (HandleFunctionRequest(input_message) == EOF)
2895 2896
				{
					/* lost frontend connection during F message input */
Bruce Momjian's avatar
Bruce Momjian committed
2897

2898
					/*
2899
					 * Reset whereToSendOutput to prevent ereport from
Bruce Momjian's avatar
Bruce Momjian committed
2900
					 * attempting to send any more messages to client.
2901 2902 2903 2904
					 */
					if (whereToSendOutput == Remote)
						whereToSendOutput = None;

2905
					proc_exit(0);
2906
				}
2907 2908

				/* commit the function-invocation transaction */
2909
				finish_xact_command();
2910

2911
				send_rfq = true;
2912 2913
				break;

2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949
			case 'C':				/* close */
				{
					int		close_type;
					const char *close_target;

					close_type = pq_getmsgbyte(input_message);
					close_target = pq_getmsgstring(input_message);
					pq_getmsgend(input_message);

					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:
2950 2951 2952 2953
							ereport(ERROR,
									(errcode(ERRCODE_PROTOCOL_VIOLATION),
									 errmsg("invalid CLOSE message subtype %d",
											close_type)));
2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979
							break;
					}

					if (whereToSendOutput == Remote)
						pq_putemptymessage('3'); /* CloseComplete */
				}
				break;

			case 'D':			/* describe */
				{
					int		describe_type;
					const char *describe_target;

					describe_type = pq_getmsgbyte(input_message);
					describe_target = pq_getmsgstring(input_message);
					pq_getmsgend(input_message);

					switch (describe_type)
					{
						case 'S':
							exec_describe_statement_message(describe_target);
							break;
						case 'P':
							exec_describe_portal_message(describe_target);
							break;
						default:
2980 2981 2982 2983
							ereport(ERROR,
									(errcode(ERRCODE_PROTOCOL_VIOLATION),
									 errmsg("invalid DESCRIBE message subtype %d",
											describe_type)));
2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996
							break;
					}
				}
				break;

			case 'H':				/* flush */
				pq_getmsgend(input_message);
				if (whereToSendOutput == Remote)
					pq_flush();
				break;

			case 'S':				/* sync */
				pq_getmsgend(input_message);
2997
				finish_xact_command();
2998 2999 3000
				send_rfq = true;
				break;

3001
				/*
Bruce Momjian's avatar
Bruce Momjian committed
3002 3003 3004
				 * 'X' means that the frontend is closing down the socket.
				 * EOF means unexpected loss of frontend connection.
				 * Either way, perform normal shutdown.
3005 3006
				 */
			case 'X':
3007
			case EOF:
Bruce Momjian's avatar
Bruce Momjian committed
3008

3009
				/*
3010
				 * Reset whereToSendOutput to prevent ereport from attempting
3011 3012 3013 3014
				 * to send any more messages to client.
				 */
				if (whereToSendOutput == Remote)
					whereToSendOutput = None;
3015

3016 3017
				/*
				 * NOTE: if you are tempted to add more code here, DON'T!
3018 3019
				 * Whatever you had in mind to do should be set up as an
				 * on_proc_exit or on_shmem_exit callback, instead.
3020 3021 3022 3023
				 * Otherwise it will fail to be called during other
				 * backend-shutdown scenarios.
				 */
				proc_exit(0);
3024

3025 3026 3027 3028 3029 3030 3031 3032 3033 3034
			case 'd':				/* copy data */
			case 'c':				/* copy done */
			case 'f':				/* copy fail */
				/*
				 * Accept but ignore these messages, per protocol spec;
				 * we probably got here because a COPY failed, and the
				 * frontend is still sending data.
				 */
				break;

3035
			default:
3036 3037 3038 3039
				ereport(FATAL,
						(errcode(ERRCODE_PROTOCOL_VIOLATION),
						 errmsg("invalid frontend message type %d",
								firstchar)));
3040 3041
		}

3042
#ifdef MEMORY_CONTEXT_CHECKING
3043

3044
		/*
3045 3046
		 * Check all memory after each backend loop.  This is a rather
		 * weird place to do it, perhaps.
3047
		 */
3048
		MemoryContextCheck(TopMemoryContext);
3049
#endif
3050
	}							/* end of input-reading loop */
3051

3052 3053
	/* can't get here because the above loop never exits */
	Assert(false);
3054

3055
	return 1;					/* keep compiler quiet */
3056 3057
}

3058
#ifndef HAVE_GETRUSAGE
Bruce Momjian's avatar
Bruce Momjian committed
3059 3060
#include "rusagestub.h"
#else
3061
#include <sys/resource.h>
3062
#endif   /* HAVE_GETRUSAGE */
3063

3064 3065
struct rusage Save_r;
struct timeval Save_t;
3066 3067

void
3068
ResetUsage(void)
3069
{
3070
	getrusage(RUSAGE_SELF, &Save_r);
3071
	gettimeofday(&Save_t, NULL);
3072
	ResetBufferUsage();
3073
	/* ResetTupleCount(); */
3074 3075 3076
}

void
3077
ShowUsage(const char *title)
3078
{
3079
	StringInfoData str;
3080 3081 3082 3083
	struct timeval user,
				sys;
	struct timeval elapse_t;
	struct rusage r;
Bruce Momjian's avatar
Bruce Momjian committed
3084
	char	   *bufusage;
3085 3086

	getrusage(RUSAGE_SELF, &r);
3087
	gettimeofday(&elapse_t, NULL);
3088 3089
	memcpy((char *) &user, (char *) &r.ru_utime, sizeof(user));
	memcpy((char *) &sys, (char *) &r.ru_stime, sizeof(sys));
3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113
	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.
	 */
3114
	initStringInfo(&str);
3115

3116 3117
	appendStringInfo(&str, "! system usage stats:\n");
	appendStringInfo(&str,
3118
			"!\t%ld.%06ld elapsed %ld.%06ld user %ld.%06ld system sec\n",
3119 3120 3121 3122 3123 3124
					 (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),
					 (long) (r.ru_utime.tv_usec - Save_r.ru_utime.tv_usec),
					 (long) (r.ru_stime.tv_sec - Save_r.ru_stime.tv_sec),
					 (long) (r.ru_stime.tv_usec - Save_r.ru_stime.tv_usec));
3125
	appendStringInfo(&str,
Bruce Momjian's avatar
Bruce Momjian committed
3126
					 "!\t[%ld.%06ld user %ld.%06ld sys total]\n",
3127 3128 3129 3130
					 (long) user.tv_sec,
					 (long) user.tv_usec,
					 (long) sys.tv_sec,
					 (long) sys.tv_usec);
3131
/* BeOS has rusage but only has some fields, and not these... */
3132
#if defined(HAVE_GETRUSAGE)
3133
	appendStringInfo(&str,
Bruce Momjian's avatar
Bruce Momjian committed
3134 3135
					 "!\t%ld/%ld [%ld/%ld] filesystem blocks in/out\n",
					 r.ru_inblock - Save_r.ru_inblock,
3136
	/* they only drink coffee at dec */
Bruce Momjian's avatar
Bruce Momjian committed
3137 3138
					 r.ru_oublock - Save_r.ru_oublock,
					 r.ru_inblock, r.ru_oublock);
3139
	appendStringInfo(&str,
3140
		  "!\t%ld/%ld [%ld/%ld] page faults/reclaims, %ld [%ld] swaps\n",
Bruce Momjian's avatar
Bruce Momjian committed
3141 3142 3143 3144 3145
					 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);
3146
	appendStringInfo(&str,
3147
	 "!\t%ld [%ld] signals rcvd, %ld/%ld [%ld/%ld] messages rcvd/sent\n",
Bruce Momjian's avatar
Bruce Momjian committed
3148 3149 3150 3151 3152
					 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);
3153
	appendStringInfo(&str,
3154
		 "!\t%ld/%ld [%ld/%ld] voluntary/involuntary context switches\n",
Bruce Momjian's avatar
Bruce Momjian committed
3155 3156 3157
					 r.ru_nvcsw - Save_r.ru_nvcsw,
					 r.ru_nivcsw - Save_r.ru_nivcsw,
					 r.ru_nvcsw, r.ru_nivcsw);
3158
#endif   /* HAVE_GETRUSAGE */
3159 3160

	bufusage = ShowBufferUsage();
3161
	appendStringInfo(&str, "! buffer usage stats:\n%s", bufusage);
3162 3163 3164
	pfree(bufusage);

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

3168 3169 3170
	ereport(LOG,
			(errmsg_internal("%s", title),
			 errdetail("%s", str.data)));
3171 3172

	pfree(str.data);
3173
}