postgres.c 51.3 KB
Newer Older
1 2
/*-------------------------------------------------------------------------
 *
3
 * postgres.c
4
 *	  POSTGRES C Backend Interface
5
 *
6
 * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
B
Add:  
Bruce Momjian 已提交
7
 * Portions Copyright (c) 1994, Regents of the University of California
8 9 10
 *
 *
 * IDENTIFICATION
B
Bruce Momjian 已提交
11
 *	  $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.211 2001/03/14 15:14:35 momjian Exp $
12 13
 *
 * NOTES
14 15
 *	  this is the "main" module of the postgres backend and
 *	  hence the main module of the "traffic cop".
16 17 18
 *
 *-------------------------------------------------------------------------
 */
B
Bruce Momjian 已提交
19

20 21
#include "postgres.h"

B
Bruce Momjian 已提交
22
#include <unistd.h>
23
#include <signal.h>
24 25
#include <time.h>
#include <sys/time.h>
B
Bruce Momjian 已提交
26 27
#include <sys/types.h>
#include <fcntl.h>
28
#include <sys/socket.h>
29
#include <errno.h>
30
#if HAVE_SYS_SELECT_H
31
#include <sys/select.h>
32
#endif
M
 
Marc G. Fournier 已提交
33 34 35
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
36
#ifdef HAVE_GETOPT_H
B
Bruce Momjian 已提交
37
#include <getopt.h>
38
#endif
39

40
#include "access/xlog.h"
41
#include "commands/async.h"
42
#include "commands/trigger.h"
43
#include "commands/variable.h"
44
#include "libpq/libpq.h"
45
#include "libpq/pqformat.h"
46
#include "libpq/pqsignal.h"
B
Bruce Momjian 已提交
47
#include "miscadmin.h"
48 49
#include "nodes/print.h"
#include "optimizer/cost.h"
50
#include "optimizer/planner.h"
51 52
#include "parser/analyze.h"
#include "parser/parse.h"
53
#include "parser/parser.h"
B
Bruce Momjian 已提交
54
#include "rewrite/rewriteHandler.h"
55 56
#include "tcop/fastpath.h"
#include "tcop/pquery.h"
B
Bruce Momjian 已提交
57
#include "tcop/tcopprot.h"
58
#include "tcop/utility.h"
59
#include "storage/proc.h"
60 61
#include "utils/exc.h"
#include "utils/guc.h"
62
#include "utils/memutils.h"
M
 
Marc G. Fournier 已提交
63
#include "utils/ps_status.h"
64
#ifdef MULTIBYTE
B
Bruce Momjian 已提交
65
#include "mb/pg_wchar.h"
66 67
#endif

M
 
Marc G. Fournier 已提交
68

69
/* ----------------
70
 *		global variables
71 72
 * ----------------
 */
73

74 75 76
extern int optind;
extern char *optarg;

77
/*
78
 * for ps display
79 80 81 82 83 84
 */
bool HostnameLookup;
bool ShowPortNumber;

bool Log_connections = false;

85
CommandDest whereToSendOutput = Debug;
86

87
static bool	dontExecute = false;
88

89
/* note: these declarations had better match tcopprot.h */
B
Bruce Momjian 已提交
90
DLLIMPORT sigjmp_buf Warn_restart;
91

92
bool		Warn_restart_ready = false;
93
bool		InError = false;
94

95
static bool EchoQuery = false;	/* default don't echo */
96
char		pg_pathname[MAXPGPATH];
97
FILE	   *StatFp = NULL;
98

99
/* ----------------
100 101
 *		people who want to use EOF should #define DONTUSENEWLINE in
 *		tcop/tcopdebug.h
102 103 104
 * ----------------
 */
#ifndef TCOP_DONTUSENEWLINE
105
int			UseNewLine = 1;		/* Use newlines query delimiters (the
106 107
								 * default) */

108
#else
109
int			UseNewLine = 0;		/* Use EOF as query delimiters */
110

111
#endif	 /* TCOP_DONTUSENEWLINE */
112 113 114 115

/*
** Flags for expensive function optimization -- JMH 3/9/92
*/
116
int			XfuncMode = 0;
117 118

/* ----------------------------------------------------------------
119
 *		decls for routines only used in this file
120 121
 * ----------------------------------------------------------------
 */
122 123 124
static int	InteractiveBackend(StringInfo inBuf);
static int	SocketBackend(StringInfo inBuf);
static int	ReadCommand(StringInfo inBuf);
125 126 127 128
static List *pg_parse_query(char *query_string, Oid *typev, int nargs);
static List *pg_analyze_and_rewrite(Node *parsetree);
static void start_xact_command(void);
static void finish_xact_command(void);
129 130
static void SigHupHandler(SIGNAL_ARGS);
static void FloatExceptionHandler(SIGNAL_ARGS);
131 132 133 134 135 136 137

/*
 * 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;
138 139 140


/* ----------------------------------------------------------------
141
 *		routines to obtain user input
142 143 144 145
 * ----------------------------------------------------------------
 */

/* ----------------
146 147
 *	InteractiveBackend() is called for user interactive connections
 *	the string entered by the user is placed in its parameter inBuf.
148
 *
149
 *	EOF is returned if end-of-file input is seen; time to shut down.
150 151 152
 * ----------------
 */

153
static int
154
InteractiveBackend(StringInfo inBuf)
155
{
156 157 158
	int			c;				/* character read from getc() */
	bool		end = false;	/* end-of-input flag */
	bool		backslashSeen = false;	/* have we seen a \ ? */
159 160 161 162 163

	/* ----------------
	 *	display a prompt and obtain input from the user
	 * ----------------
	 */
164
	printf("backend> ");
165
	fflush(stdout);
166

167 168 169 170
	/* Reset inBuf to empty */
	inBuf->len = 0;
	inBuf->data[0] = '\0';

171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
	for (;;)
	{
		if (UseNewLine)
		{
			/* ----------------
			 *	if we are using \n as a delimiter, then read
			 *	characters until the \n.
			 * ----------------
			 */
			while ((c = getc(stdin)) != EOF)
			{
				if (c == '\n')
				{
					if (backslashSeen)
					{
186 187 188
						/* discard backslash from inBuf */
						inBuf->data[--inBuf->len] = '\0';
						backslashSeen = false;
189 190 191 192 193
						continue;
					}
					else
					{
						/* keep the newline character */
194
						appendStringInfoChar(inBuf, '\n');
195 196 197 198 199 200 201 202
						break;
					}
				}
				else if (c == '\\')
					backslashSeen = true;
				else
					backslashSeen = false;

203
				appendStringInfoChar(inBuf, (char) c);
204 205 206 207 208 209 210 211 212 213 214 215
			}

			if (c == EOF)
				end = true;
		}
		else
		{
			/* ----------------
			 *	otherwise read characters until EOF.
			 * ----------------
			 */
			while ((c = getc(stdin)) != EOF)
216
				appendStringInfoChar(inBuf, (char) c);
217

218
			if (inBuf->len == 0)
219 220 221 222
				end = true;
		}

		if (end)
223
			return EOF;
224 225 226 227 228 229 230 231 232 233 234 235 236

		/* ----------------
		 *	otherwise we have a user query so process it.
		 * ----------------
		 */
		break;
	}

	/* ----------------
	 *	if the query echo flag was given, print the query..
	 * ----------------
	 */
	if (EchoQuery)
237
		printf("query: %s\n", inBuf->data);
238
	fflush(stdout);
239

240
	return 'Q';
241 242 243
}

/* ----------------
244
 *	SocketBackend()		Is called for frontend-backend connections
245
 *
246 247
 *	If the input is a query (case 'Q') then the string entered by
 *	the user is placed in its parameter inBuf.
248
 *
249
 *	If the input is a fastpath function call (case 'F') then
250
 *	the function call is processed in HandleFunctionRequest()
251 252
 *	(now called from PostgresMain()).
 *
253
 *	EOF is returned if the connection is lost.
254 255 256
 * ----------------
 */

257
static int
258
SocketBackend(StringInfo inBuf)
259
{
260
	char		qtype;
261
	char		result = '\0';
262 263 264 265 266

	/* ----------------
	 *	get input from the frontend
	 * ----------------
	 */
267 268
	qtype = '?';
	if (pq_getbytes(&qtype, 1) == EOF)
269
		return EOF;
270

271
	switch (qtype)
272
	{
273 274 275 276 277
			/* ----------------
			 *	'Q': user entered a query
			 * ----------------
			 */
		case 'Q':
278
			if (pq_getstr(inBuf))
279
				return EOF;
280 281
			result = 'Q';
			break;
282

283 284 285 286 287
			/* ----------------
			 *	'F':  calling user/system functions
			 * ----------------
			 */
		case 'F':
288
			if (pq_getstr(inBuf))
289
				return EOF;		/* ignore "string" at start of F message */
290 291
			result = 'F';
			break;
292

293 294 295 296 297 298 299
			/* ----------------
			 *	'X':  frontend is exiting
			 * ----------------
			 */
		case 'X':
			result = 'X';
			break;
300

301 302 303 304 305 306 307 308
			/* ----------------
			 *	otherwise we got garbage from the frontend.
			 *
			 *	XXX are we certain that we want to do an elog(FATAL) here?
			 *		-cim 1/24/90
			 * ----------------
			 */
		default:
309
			elog(FATAL, "Socket command type %c unknown", qtype);
310
			break;
311 312
	}
	return result;
313 314 315
}

/* ----------------
316 317 318
 *		ReadCommand reads a command from either the frontend or
 *		standard input, places it in inBuf, and returns a char
 *		representing whether the string is a 'Q'uery or a 'F'astpath
319
 *		call.  EOF is returned if end of file.
320 321
 * ----------------
 */
322
static int
323
ReadCommand(StringInfo inBuf)
324
{
325
	int			result;
326

327
	if (IsUnderPostmaster)
328
		result = SocketBackend(inBuf);
329
	else
330 331
		result = InteractiveBackend(inBuf);
	return result;
332 333
}

334 335 336 337 338 339

/*
 * 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.
340 341 342
 *
 * NOTE: this routine is no longer used for processing interactive queries,
 * but it is still needed for parsing of SQL function bodies.
343
 */
344
List *
345 346 347
pg_parse_and_rewrite(char *query_string,	/* string to execute */
					 Oid *typev,			/* parameter types */
					 int nargs)				/* number of parameters */
348
{
349
	List	   *raw_parsetree_list;
350
	List	   *querytree_list;
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391
	List	   *list_item;

	/* ----------------
	 *	(1) parse the request string into a list of raw parse trees.
	 * ----------------
	 */
	raw_parsetree_list = pg_parse_query(query_string, typev, nargs);

	/* ----------------
	 *	(2) Do parse analysis and rule rewrite.
	 * ----------------
	 */
	querytree_list = NIL;
	foreach(list_item, raw_parsetree_list)
	{
		Node   *parsetree = (Node *) lfirst(list_item);

		querytree_list = nconc(querytree_list,
							   pg_analyze_and_rewrite(parsetree));
	}

	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.
 */
static List *
pg_parse_query(char *query_string, Oid *typev, int nargs)
{
	List	   *raw_parsetree_list;
392

393 394
	if (Debug_print_query)
		elog(DEBUG, "query: %s", query_string);
395

396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426
	if (Show_parser_stats)
		ResetUsage();

	raw_parsetree_list = parser(query_string, typev, nargs);

	if (Show_parser_stats)
	{
		fprintf(StatFp, "PARSER STATISTICS\n");
		ShowUsage();
	}

	return raw_parsetree_list;
}

/*
 * Given a raw parsetree (gram.y output), perform parse analysis and
 * rule rewriting.
 *
 * 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.
 */
static List *
pg_analyze_and_rewrite(Node *parsetree)
{
	List	   *querytree_list;
	List	   *list_item;
	Query	   *querytree;
	List	   *new_list;

427
	/* ----------------
428
	 *	(1) Perform parse analysis.
429 430
	 * ----------------
	 */
431
	if (Show_parser_stats)
432 433
		ResetUsage();

434
	querytree_list = parse_analyze(parsetree, NULL);
435

436
	if (Show_parser_stats)
437
	{
438
		fprintf(StatFp, "PARSE ANALYSIS STATISTICS\n");
439
		ShowUsage();
440
		ResetUsage();
441 442 443
	}

	/* ----------------
444
	 *	(2) Rewrite the queries, as necessary
445
	 *
B
Bruce Momjian 已提交
446 447
	 *	rewritten queries are collected in new_list.  Note there may be
	 *	more or fewer than in the original list.
448 449
	 * ----------------
	 */
450
	new_list = NIL;
451
	foreach(list_item, querytree_list)
452
	{
453
		querytree = (Query *) lfirst(list_item);
454

455
		if (Debug_print_parse)
456
		{
457
			if (Debug_pretty_print)
B
Bruce Momjian 已提交
458
			{
459
				elog(DEBUG, "parse tree:");
J
Jan Wieck 已提交
460
				nodeDisplay(querytree);
B
Bruce Momjian 已提交
461 462
			}
			else
463
				elog(DEBUG, "parse tree: %s", nodeToString(querytree));
464
		}
465 466 467

		if (querytree->commandType == CMD_UTILITY)
		{
468 469
			/* don't rewrite utilities, just dump 'em into new_list */
			new_list = lappend(new_list, querytree);
470
		}
471
		else
472
		{
473
			/* rewrite regular queries */
474 475
			List	   *rewritten = QueryRewrite(querytree);

476
			new_list = nconc(new_list, rewritten);
477 478 479 480 481
		}
	}

	querytree_list = new_list;

482 483 484 485 486 487
	if (Show_parser_stats)
	{
		fprintf(StatFp, "REWRITER STATISTICS\n");
		ShowUsage();
	}

488
#ifdef COPY_PARSE_PLAN_TREES
489
	/* Optional debugging check: pass querytree output through copyObject() */
490 491 492
	new_list = (List *) copyObject(querytree_list);
	/* This checks both copyObject() and the equal() routines... */
	if (! equal(new_list, querytree_list))
493
		elog(NOTICE, "pg_analyze_and_rewrite: copyObject failed on parse tree");
494 495
	else
		querytree_list = new_list;
496 497
#endif

498
	if (Debug_print_rewritten)
499
	{
500
		if (Debug_pretty_print)
B
Bruce Momjian 已提交
501
		{
502
			elog(DEBUG, "rewritten parse tree:");
503
			foreach(list_item, querytree_list)
J
Jan Wieck 已提交
504
			{
505
				querytree = (Query *) lfirst(list_item);
506
				nodeDisplay(querytree);
J
Jan Wieck 已提交
507 508
				printf("\n");
			}
B
Bruce Momjian 已提交
509 510 511
		}
		else
		{
512
			elog(DEBUG, "rewritten parse tree:");
513
			foreach(list_item, querytree_list)
J
Jan Wieck 已提交
514
			{
515
				querytree = (Query *) lfirst(list_item);
516
				elog(DEBUG, "%s", nodeToString(querytree));
J
Jan Wieck 已提交
517
			}
518 519 520
		}
	}

521 522
	return querytree_list;
}
523 524


525 526 527 528 529
/* Generate a plan for a single query. */
Plan *
pg_plan_query(Query *querytree)
{
	Plan	   *plan;
530

531 532 533
	/* Utility commands have no plans. */
	if (querytree->commandType == CMD_UTILITY)
		return NULL;
534

535
	if (Show_planner_stats)
536
		ResetUsage();
537

538 539
	/* call that optimizer */
	plan = planner(querytree);
540

541
	if (Show_planner_stats)
542
	{
543
		fprintf(stderr, "PLANNER STATISTICS\n");
544 545
		ShowUsage();
	}
546

547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564
#ifdef COPY_PARSE_PLAN_TREES
	/* Optional debugging check: pass plan output through copyObject() */
	{
		Plan   *new_plan = (Plan *) copyObject(plan);

		/* equal() currently does not have routines to compare Plan nodes,
		 * so don't try to test equality here.  Perhaps fix someday?
		 */
#ifdef NOT_USED
		/* This checks both copyObject() and the equal() routines... */
		if (! equal(new_plan, plan))
			elog(NOTICE, "pg_plan_query: copyObject failed on plan tree");
		else
#endif
			plan = new_plan;
	}
#endif

565 566 567 568
	/* ----------------
	 *	Print plan if debugging.
	 * ----------------
	 */
569
	if (Debug_print_plan)
570
	{
571
		if (Debug_pretty_print)
572
		{
573
			elog(DEBUG, "plan:");
574
			nodeDisplay(plan);
575 576
		}
		else
577
			elog(DEBUG, "plan: %s", nodeToString(plan));
578 579
	}

580
	return plan;
581 582
}

583

584
/* ----------------------------------------------------------------
585
 *		pg_exec_query_string()
586 587
 *
 *		Takes a querystring, runs the parser/utilities or
588 589 590 591
 *		parser/planner/executor over it as necessary.
 *
 * Assumptions:
 *
592
 * At call, we are not inside a transaction command.
593
 *
594
 * The CurrentMemoryContext after starting a transaction command must be
595 596 597 598
 * appropriate for execution of individual queries (typically this will be
 * TransactionCommandContext).  Note that this routine resets that context
 * after each individual query, so don't store anything there that
 * must outlive the call!
599
 *
600 601
 * parse_context references a context suitable for holding the
 * parse/rewrite trees (typically this will be QueryContext).
602
 * This context *must* be longer-lived than the transaction context!
603 604 605 606 607 608 609
 * In fact, if the query string might contain BEGIN/COMMIT commands,
 * parse_context had better outlive TopTransactionContext!
 *
 * We could have hard-wired knowledge about QueryContext and
 * TransactionCommandContext into this routine, but it seems better
 * not to, in case callers from outside this module need to use some
 * other contexts.
610 611 612 613 614
 *
 * ----------------------------------------------------------------
 */

void
615 616 617
pg_exec_query_string(char *query_string,	/* string to execute */
					 CommandDest dest,		/* where results should go */
					 MemoryContext parse_context) /* context for parsetrees */
618
{
619
	bool		xact_started;
620
	MemoryContext oldcontext;
621 622
	List	   *parsetree_list,
			   *parsetree_item;
623

624
	/*
625 626 627 628
	 * 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.
629
	 * (Note that this will possibly change current memory context.)
630 631 632 633 634 635 636 637 638 639
	 */
	start_xact_command();
	xact_started = true;

	/*
	 * parse_context *must* be different from the execution memory context,
	 * else the context reset at the bottom of the loop will destroy the
	 * parsetree list.  (We really ought to check that parse_context isn't a
	 * child of CurrentMemoryContext either, but that would take more cycles
	 * than it's likely to be worth.)
640 641 642
	 */
	Assert(parse_context != CurrentMemoryContext);

643 644 645 646
	/*
	 * Switch to appropriate context for constructing parsetrees.
	 */
	oldcontext = MemoryContextSwitchTo(parse_context);
647

B
Bruce Momjian 已提交
648
	/*
649 650
	 * Do basic parsing of the query or queries (this should be safe
	 * even if we are in aborted transaction state!)
651
	 */
652
	parsetree_list = pg_parse_query(query_string, NULL, 0);
653

654
	/*
655
	 * Switch back to execution context to enter the loop.
656 657 658 659
	 */
	MemoryContextSwitchTo(oldcontext);

	/*
660
	 * Run through the parsetree(s) and process each one.
661
	 */
662
	foreach(parsetree_item, parsetree_list)
663
	{
664 665 666 667
		Node   *parsetree = (Node *) lfirst(parsetree_item);
		bool	isTransactionStmt;
		List   *querytree_list,
			   *querytree_item;
668

669 670
		/* Transaction control statements need some special handling */
		isTransactionStmt = IsA(parsetree, TransactionStmt);
671

672 673 674 675 676 677 678 679 680
		/*
		 * If we are in an aborted transaction, ignore all commands except
		 * COMMIT/ABORT.  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())
681
		{
682
			bool	allowit = false;
683

684 685 686 687 688 689 690 691 692 693 694 695 696 697
			if (isTransactionStmt)
			{
				TransactionStmt *stmt = (TransactionStmt *) parsetree;

				switch (stmt->command)
				{
					case COMMIT:
					case ROLLBACK:
						allowit = true;
						break;
					default:
						break;
				}
			}
698

699
			if (! allowit)
700
			{
701 702 703 704 705 706 707 708 709 710 711 712
				/* ----------------
				 *	 the EndCommand() stuff is to tell the frontend
				 *	 that the command ended. -cim 6/1/90
				 * ----------------
				 */
				char	   *tag = "*ABORT STATE*";

				elog(NOTICE, "current transaction is aborted, "
					 "queries ignored until end of transaction block");

				EndCommand(tag, dest);

713 714
				/*
				 * We continue in the loop, on the off chance that there
715 716 717 718
				 * is a COMMIT or ROLLBACK utility command later in the
				 * query string.
				 */
				continue;
719
			}
720
		}
721

722 723 724 725 726 727
		/* Make sure we are in a transaction command */
		if (! xact_started)
		{
			start_xact_command();
			xact_started = true;
		}
728

729
		/* If we got a cancel signal in parsing or prior command, quit */
730
		CHECK_FOR_INTERRUPTS();
731 732 733 734 735 736 737 738

		/*
		 * OK to analyze and rewrite this query.
		 *
		 * Switch to appropriate context for constructing querytrees
		 * (again, these must outlive the execution context).
		 */
		oldcontext = MemoryContextSwitchTo(parse_context);
739

740
		querytree_list = pg_analyze_and_rewrite(parsetree);
V
Vadim B. Mikheev 已提交
741

742 743 744 745 746 747 748 749 750 751 752 753
		/*
		 * Switch back to execution context for planning and execution.
		 */
		MemoryContextSwitchTo(oldcontext);

		/*
		 * Inner loop handles the individual queries generated from a
		 * single parsetree by analysis and rewrite.
		 */
		foreach(querytree_item, querytree_list)
		{
			Query	   *querytree = (Query *) lfirst(querytree_item);
754

755 756
			/* Make sure we are in a transaction command */
			if (! xact_started)
757
			{
758 759 760 761 762
				start_xact_command();
				xact_started = true;
			}

			/* If we got a cancel signal in analysis or prior command, quit */
763
			CHECK_FOR_INTERRUPTS();
764 765 766 767 768 769 770 771 772 773 774 775 776

			if (querytree->commandType == CMD_UTILITY)
			{
				/* ----------------
				 *	 process utility functions (create, destroy, etc..)
				 * ----------------
				 */
				if (Debug_print_query)
					elog(DEBUG, "ProcessUtility: %s", query_string);
				else if (DebugLvl > 1)
					elog(DEBUG, "ProcessUtility");

				ProcessUtility(querytree->utilityStmt, dest);
777 778 779
			}
			else
			{
780 781 782 783 784 785 786 787 788
				/* ----------------
				 *	 process a plannable query.
				 * ----------------
				 */
				Plan	   *plan;

				plan = pg_plan_query(querytree);

				/* if we got a cancel signal whilst planning, quit */
789
				CHECK_FOR_INTERRUPTS();
790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816

				/* Initialize snapshot state for query */
				SetQuerySnapshot();

				/*
				 * execute the plan
				 */
				if (Show_executor_stats)
					ResetUsage();

				if (dontExecute)
				{
					/* don't execute it, just show the query plan */
					print_plan(plan, querytree);
				}
				else
				{
					if (DebugLvl > 1)
						elog(DEBUG, "ProcessQuery");
					ProcessQuery(querytree, plan, dest);
				}

				if (Show_executor_stats)
				{
					fprintf(stderr, "EXECUTOR STATISTICS\n");
					ShowUsage();
				}
817
			}
818

819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844
			/*
			 * In a query block, we want to increment the command counter
			 * between queries so that the effects of early queries are
			 * visible to subsequent ones.  In particular we'd better
			 * do so before checking constraints.
			 */
			if (!isTransactionStmt)
				CommandCounterIncrement();

			/*
			 * Clear the execution context to recover temporary
			 * memory used by the query.  NOTE: if query string contains
			 * BEGIN/COMMIT transaction commands, execution context may
			 * now be different from what we were originally passed;
			 * so be careful to clear current context not "oldcontext".
			 */
			Assert(parse_context != CurrentMemoryContext);

			MemoryContextResetAndDeleteChildren(CurrentMemoryContext);

			/*
			 * If this was a transaction control statement, commit it
			 * and arrange to start a new xact command for the next
			 * command (if any).
			 */
			if (isTransactionStmt)
845
			{
846 847
				finish_xact_command();
				xact_started = false;
848 849
			}

850 851 852 853 854 855 856 857
		} /* end loop over queries generated from a parsetree */
	} /* end loop over parsetrees */

	/*
	 * Close down transaction statement, if one is open.
	 */
	if (xact_started)
		finish_xact_command();
858 859
}

860 861 862 863 864 865 866 867 868 869 870 871 872 873
/*
 * Convenience routines for starting/committing a single command.
 */
static void
start_xact_command(void)
{
	if (DebugLvl >= 1)
		elog(DEBUG, "StartTransactionCommand");
	StartTransactionCommand();
}

static void
finish_xact_command(void)
{
874 875 876 877
	/* Invoke IMMEDIATE constraint triggers */
	DeferredTriggerEndQuery();

	/* Now commit the command */
878 879
	if (DebugLvl >= 1)
		elog(DEBUG, "CommitTransactionCommand");
880

881
	CommitTransactionCommand();
882

883
#ifdef SHOW_MEMORY_STATS
884
	/* Print mem stats at each commit for leak tracking */
885 886 887 888 889 890
	if (ShowStats)
		MemoryContextStats(TopMemoryContext);
#endif
}


891
/* --------------------------------
892
 *		signal handler routines used in PostgresMain()
893 894 895
 * --------------------------------
 */

896
/*
T
Tom Lane 已提交
897
 * quickdie() occurs when signalled SIGQUIT by the postmaster.
898 899 900 901
 *
 * Some backend has bought the farm,
 * so we need to stop what we're doing and exit.
 */
T
Tom Lane 已提交
902
void
903
quickdie(SIGNAL_ARGS)
904
{
905
	PG_SETMASK(&BlockSig);
906
	elog(NOTICE, "Message from PostgreSQL backend:"
907
		 "\n\tThe Postmaster has informed me that some other backend"
B
Bruce Momjian 已提交
908
		 "\tdied abnormally and possibly corrupted shared memory."
909
		 "\n\tI have rolled back the current transaction and am"
B
Bruce Momjian 已提交
910
		 "\tgoing to terminate your database system connection and exit."
911
	"\n\tPlease reconnect to the database system and repeat your query.");
912

913
	/*
914 915 916 917 918
	 * 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.
	 *
	 * Note we do exit(1) not exit(0).  This is to force the postmaster
T
Tom Lane 已提交
919
	 * into a system reset cycle if some idiot DBA sends a manual SIGQUIT
920 921
	 * to a random backend.  This is necessary precisely because we don't
	 * clean up our shared memory state.
922 923
	 */

924
	exit(1);
925 926
}

927
/*
928 929
 * Shutdown signal from postmaster: abort transaction and exit
 * at soonest convenient time
930
 */
931
void
932
die(SIGNAL_ARGS)
933
{
934 935 936
	int			save_errno = errno;

	/* Don't joggle the elbow of proc_exit */
937
	if (! proc_exit_inprogress)
938
	{
939
		InterruptPending = true;
940
		ProcDiePending = true;
941
		/*
942 943
		 * If it's safe to interrupt, and we're waiting for input or a lock,
		 * service the interrupt immediately
944
		 */
945 946
		if (ImmediateInterruptOK && InterruptHoldoffCount == 0 &&
			CritSectionCount == 0)
947
		{
948 949 950
			/* bump holdoff count to make ProcessInterrupts() a no-op */
			/* until we are done getting ready for it */
			InterruptHoldoffCount++;
951
			DisableNotifyInterrupt();
952 953
			/* Make sure HandleDeadLock won't run while shutting down... */
			LockWaitCancel();
954
			InterruptHoldoffCount--;
955 956
			ProcessInterrupts();
		}
957
	}
958 959

	errno = save_errno;
960 961
}

962
/*
963 964
 * Query-cancel signal from postmaster: abort current transaction
 * at soonest convenient time
965
 */
966
static void
967
QueryCancelHandler(SIGNAL_ARGS)
968
{
969 970
	int			save_errno = errno;

971
	/* Don't joggle the elbow of proc_exit, nor an already-in-progress abort */
972
	if (!proc_exit_inprogress && !InError)
973
	{
974 975 976
		InterruptPending = true;
		QueryCancelPending = true;
		/*
977 978 979
		 * If it's safe to interrupt, and we're waiting for a lock,
		 * service the interrupt immediately.  No point in interrupting
		 * if we're waiting for input, however.
980
		 */
981
		if (ImmediateInterruptOK && InterruptHoldoffCount == 0 &&
982
			CritSectionCount == 0)
983
		{
984 985 986 987 988 989
			/* bump holdoff count to make ProcessInterrupts() a no-op */
			/* until we are done getting ready for it */
			InterruptHoldoffCount++;
			if (LockWaitCancel())
			{
				DisableNotifyInterrupt();
T
Tom Lane 已提交
990
				InterruptHoldoffCount--;
991 992 993 994
				ProcessInterrupts();
			}
			else
				InterruptHoldoffCount--;
995
		}
996 997
	}

998
	errno = save_errno;
999 1000
}

1001 1002 1003 1004 1005 1006 1007 1008 1009
/* signal handler for floating point exception */
static void
FloatExceptionHandler(SIGNAL_ARGS)
{
	elog(ERROR, "floating point exception!"
		 " The last floating point operation either exceeded legal ranges"
		 " or was a divide by zero");
}

1010
/* SIGHUP: set flag to re-read config file at next convenient time */
1011
static void
1012
SigHupHandler(SIGNAL_ARGS)
1013
{
1014
	got_SIGHUP = true;
1015 1016
}

1017

1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
/*
 * 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)
{
1028 1029
	/* OK to accept interrupt now? */
	if (InterruptHoldoffCount != 0 || CritSectionCount != 0)
1030 1031 1032 1033 1034 1035 1036
		return;
	InterruptPending = false;
	if (ProcDiePending)
	{
		ProcDiePending = false;
		QueryCancelPending = false;	/* ProcDie trumps QueryCancel */
		ImmediateInterruptOK = false; /* not idle anymore */
B
Bruce Momjian 已提交
1037
		elog(FATAL, "This connection has been terminated by the administrator");
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
	}
	if (QueryCancelPending)
	{
		QueryCancelPending = false;
		ImmediateInterruptOK = false; /* not idle anymore */
		elog(ERROR, "Query was cancelled.");
	}
	/* If we get here, do nothing (probably, QueryCancelPending was reset) */
}

1048

1049 1050
static void
usage(char *progname)
1051
{
1052 1053 1054 1055
	printf("%s is the PostgreSQL stand-alone backend.  It is not\nintended to be used by normal users.\n\n", progname);

	printf("Usage:\n  %s [options...] [dbname]\n\n", progname);
	printf("Options:\n");
M
 
Marc G. Fournier 已提交
1056
#ifdef USE_ASSERT_CHECKING
1057
	printf("  -A 1|0          enable/disable run-time assert checking\n");
M
 
Marc G. Fournier 已提交
1058
#endif
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078
	printf("  -B NBUFFERS     number of shared buffers (default %d)\n", DEF_NBUFFERS);
	printf("  -c NAME=VALUE   set run-time parameter\n");
	printf("  -d 1-5          debugging level\n");
	printf("  -D DATADIR      database directory\n");
	printf("  -e              use European date format\n");
	printf("  -E              echo query before execution\n");
	printf("  -F              turn fsync off\n");
	printf("  -N              do not use newline as interactive query delimiter\n");
	printf("  -o FILENAME     send stdout and stderr to given file\n");
    printf("  -P              disable system indexes\n");
	printf("  -s              show statistics after each query\n");
	printf("  -S SORT-MEM     set amount of memory for sorts (in kbytes)\n");
	printf("Developer options:\n");
	printf("  -f [s|i|n|m|h]  forbid use of some plan types\n");
	printf("  -i              do not execute queries\n");
	printf("  -L              turn off locking\n");
	printf("  -O              allow system table structure changes\n");
	printf("  -t [pa|pl|ex]   show timings after each query\n");
	printf("  -W NUM          wait NUM seconds to allow attach from a debugger\n");
	printf("\nReport bugs to <pgsql-bugs@postgresql.org>.\n");
1079 1080
}

1081 1082


1083
/* ----------------------------------------------------------------
1084 1085
 * PostgresMain
 *     postgres main loop -- all backends, interactive or otherwise start here
1086
 *
1087 1088 1089 1090 1091
 * 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.
 * real_argc/real_argv point to the original argv array, which is needed by
 * `ps' display on some platforms. username is the (possibly authenticated)
 * PostgreSQL user name to be used for the session.
1092 1093 1094
 * ----------------------------------------------------------------
 */
int
1095
PostgresMain(int argc, char *argv[], int real_argc, char *real_argv[], const char * username)
1096
{
1097
	int			flag;
1098

1099
	const char	   *DBName = NULL;
1100
	bool		secure = true;
1101
	int			errs = 0;
1102

1103
	int			firstchar;
1104
	StringInfo	parser_input;
M
 
Marc G. Fournier 已提交
1105

1106 1107
	char	   *remote_host;
	unsigned short remote_port;
1108

1109 1110
	char       *potential_DataDir = NULL;

1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128
	/*
	 * Catch standard options before doing much else.  This even works
	 * on systems without getopt_long.
	 */
	if (!IsUnderPostmaster && argc > 1)
	{
		if (strcmp(argv[1], "--help")==0 || strcmp(argv[1], "-?")==0)
		{
			usage(argv[0]);
			exit(0);
		}
		if (strcmp(argv[1], "--version")==0 || strcmp(argv[1], "-V")==0)
		{
			puts("postgres (PostgreSQL) " PG_VERSION);
			exit(0);
		}
	}		

1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
	/*
	 * Fire up essential subsystems: error and memory management
	 *
	 * If we are running under the postmaster, this is done already.
	 */
	if (!IsUnderPostmaster)
	{
		EnableExceptionHandling(true);
		MemoryContextInit();
	}

1140 1141
	SetProcessingMode(InitProcessing);

1142
	/*
1143
	 * Set default values for command-line options.
1144
	 */
1145 1146
	Noversion = false;
	EchoQuery = false;
1147 1148 1149 1150

	if (!IsUnderPostmaster)
	{
		ResetAllOptions();
1151
		potential_DataDir = getenv("PGDATA");
1152
	}
1153
	StatFp = stderr;
1154

1155 1156
	/* Check for PGDATESTYLE environment variable */
	set_default_datestyle();
1157

1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175
	/* ----------------
	 *	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.
	 * ----------------
	 */

	optind = 1;					/* reset after postmaster's usage */
1176

1177
	while ((flag = getopt(argc, argv,  "A:B:c:CD:d:Eef:FiLNOPo:p:S:st:v:W:x:-:")) != EOF)
1178 1179
		switch (flag)
		{
M
 
Marc G. Fournier 已提交
1180 1181 1182 1183
			case 'A':
#ifdef USE_ASSERT_CHECKING
				assert_enabled = atoi(optarg);
#else
1184
				fprintf(stderr, "Assert checking is not compiled in\n");
M
 
Marc G. Fournier 已提交
1185 1186
#endif
				break;
1187

1188 1189 1190 1191 1192
			case 'B':
				/* ----------------
				 *	specify the size of buffer pool
				 * ----------------
				 */
1193 1194
				if (secure)
					NBuffers = atoi(optarg);
1195
				break;
1196

1197 1198
			case 'C':
				/* ----------------
1199
				 *	don't print version string
1200 1201
				 * ----------------
				 */
1202
				Noversion = true;
1203
				break;
1204

1205
			case 'D':			/* PGDATA directory */
1206
				if (secure)
1207
					potential_DataDir = optarg;
M
 
Marc G. Fournier 已提交
1208
				break;
1209

1210
			case 'd':			/* debug level */
1211
				DebugLvl = atoi(optarg);
1212 1213
				if (DebugLvl >= 1);
					Log_connections = true;
M
 
Marc G. Fournier 已提交
1214
				if (DebugLvl >= 2)
1215
					Debug_print_query = true;
M
 
Marc G. Fournier 已提交
1216
				if (DebugLvl >= 3)
1217
					Debug_print_parse = true;
B
Bruce Momjian 已提交
1218
				if (DebugLvl >= 4)
1219
					Debug_print_plan = true;
J
Jan Wieck 已提交
1220
				if (DebugLvl >= 5)
1221
					Debug_print_rewritten = true;
1222
				break;
1223 1224 1225 1226 1227 1228

			case 'E':
				/* ----------------
				 *	E - echo the query the user entered
				 * ----------------
				 */
1229
				EchoQuery = true;
1230
				break;
1231 1232 1233 1234 1235 1236

			case 'e':
				/* --------------------------
				 * Use european date formats.
				 * --------------------------
				 */
1237
				EuroDates = true;
1238
				break;
1239 1240 1241 1242 1243 1244

			case 'F':
				/* --------------------
				 *	turn off fsync
				 * --------------------
				 */
T
Tom Lane 已提交
1245 1246
				if (secure)
					enableFsync = false;
1247
				break;
1248 1249 1250 1251 1252 1253 1254 1255 1256

			case 'f':
				/* -----------------
				 *	  f - forbid generation of certain plans
				 * -----------------
				 */
				switch (optarg[0])
				{
					case 's':	/* seqscan */
1257
						enable_seqscan = false;
1258 1259
						break;
					case 'i':	/* indexscan */
1260 1261 1262 1263
						enable_indexscan = false;
						break;
					case 't':	/* tidscan */
						enable_tidscan = false;
1264 1265
						break;
					case 'n':	/* nestloop */
1266
						enable_nestloop = false;
1267 1268
						break;
					case 'm':	/* mergejoin */
1269
						enable_mergejoin = false;
1270 1271
						break;
					case 'h':	/* hashjoin */
1272
						enable_hashjoin = false;
1273 1274 1275 1276
						break;
					default:
						errs++;
				}
1277 1278
				break;

1279
			case 'i':
1280
				dontExecute = true;
1281
				break;
1282

1283 1284 1285 1286 1287
			case 'L':
				/* --------------------
				 *	turn off locking
				 * --------------------
				 */
1288 1289
				if (secure)
					lockingOff = 1;
T
Tom Lane 已提交
1290 1291
				break;

1292 1293 1294 1295 1296 1297 1298
			case 'N':
				/* ----------------
				 *	N - Don't use newline as a query delimiter
				 * ----------------
				 */
				UseNewLine = 0;
				break;
1299

1300 1301 1302 1303 1304
			case 'O':
				/* --------------------
				 *	allow system table structure modifications
				 * --------------------
				 */
1305 1306
				if (secure)		/* XXX safe to allow from client??? */
					allowSystemTableMods = true;
1307 1308
				break;

H
Hiroshi Inoue 已提交
1309 1310 1311 1312 1313 1314 1315 1316 1317
			case 'P':
				/* --------------------
				 *	ignore system indexes
				 * --------------------
				 */
				if (secure)		/* XXX safe to allow from client??? */
					IgnoreSystemIndexes(true);
				break;

T
Tom Lane 已提交
1318 1319 1320 1321 1322
			case 'o':
				/* ----------------
				 *	o - send output (stdout and stderr) to the given file
				 * ----------------
				 */
1323 1324
				if (secure)
					StrNCpy(OutputFileName, optarg, MAXPGPATH);
T
Tom Lane 已提交
1325 1326
				break;

1327
			case 'p':
1328 1329 1330 1331 1332
				/* ----------------
				 *	p - special flag passed if backend was forked
				 *		by a postmaster.
				 * ----------------
				 */
1333 1334
				if (secure)
				{
1335
					DBName = strdup(optarg);
B
Bruce Momjian 已提交
1336 1337
					secure = false;		/* subsequent switches are NOT
										 * secure */
1338
				}
1339
				break;
1340

1341 1342
			case 'S':
				/* ----------------
V
Vadim B. Mikheev 已提交
1343
				 *	S - amount of sort memory to use in 1k bytes
1344 1345
				 * ----------------
				 */
1346
				{
1347 1348
					int			S;

V
Vadim B. Mikheev 已提交
1349
					S = atoi(optarg);
1350
					if (S >= 4 * BLCKSZ / 1024)
V
Vadim B. Mikheev 已提交
1351
						SortMem = S;
1352
				}
1353
				break;
1354 1355 1356 1357 1358 1359

			case 's':
				/* ----------------
				 *	  s - report usage statistics (timings) after each query
				 * ----------------
				 */
1360
				Show_query_stats = 1;
M
 
Marc G. Fournier 已提交
1361 1362
				break;

1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377
			case 't':
				/* ----------------
				 *	tell postgres to report usage statistics (timings) for
				 *	each query
				 *
				 *	-tpa[rser] = print stats for parser time of each query
				 *	-tpl[anner] = print stats for planner time of each query
				 *	-te[xecutor] = print stats for executor time of each query
				 *	caution: -s can not be used together with -t.
				 * ----------------
				 */
				switch (optarg[0])
				{
					case 'p':
						if (optarg[1] == 'a')
1378
							Show_parser_stats = 1;
1379
						else if (optarg[1] == 'l')
1380
							Show_planner_stats = 1;
1381 1382 1383 1384
						else
							errs++;
						break;
					case 'e':
1385
						Show_executor_stats = 1;
1386 1387 1388 1389 1390
						break;
					default:
						errs++;
						break;
				}
1391 1392
				break;

1393
			case 'v':
1394 1395
				if (secure)
					FrontendProtocol = (ProtocolVersion) atoi(optarg);
1396 1397
				break;

M
 
Marc G. Fournier 已提交
1398 1399
			case 'W':
				/* ----------------
1400
				 *	wait N seconds to allow attach from a debugger
M
 
Marc G. Fournier 已提交
1401 1402 1403 1404 1405
				 * ----------------
				 */
				sleep(atoi(optarg));
				break;

1406
			case 'x':
B
Bruce Momjian 已提交
1407
#ifdef NOT_USED					/* planner/xfunc.h */
1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435

				/*
				 * control joey hellerstein's expensive function
				 * optimization
				 */
				if (XfuncMode != 0)
				{
					fprintf(stderr, "only one -x flag is allowed\n");
					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
				{
					fprintf(stderr, "use -x {off,nor,nopull,nopm,pullall,wait}\n");
					errs++;
				}
1436
#endif
1437
				break;
1438

1439
			case 'c':
1440 1441
			case '-':
			{
1442
				char *name, *value;
1443

1444 1445
				ParseLongOption(optarg, &name, &value);
				if (!value)
1446 1447 1448 1449 1450 1451
				{
					if (flag == '-')
						elog(ERROR, "--%s requires argument", optarg);
					else
						elog(ERROR, "-c %s requires argument", optarg);
				}
1452

1453 1454 1455
				/* all options are allowed if not under postmaster */
				SetConfigOption(name, value, 
					(IsUnderPostmaster) ? PGC_BACKEND : PGC_POSTMASTER);
1456 1457 1458
				free(name);
				if (value)
					free(value);
1459 1460 1461
				break;
			}

1462 1463
			default:
				errs++;
T
Tom Lane 已提交
1464
				break;
1465 1466
		}

1467 1468 1469 1470 1471 1472
	/*
	 * Post-processing for command line options.
	 *
	 * XXX It'd be nice if libpq were already running here, so we could do
	 * elog(NOTICE) instead of just writing on stderr...
	 */
1473 1474
	if (Show_query_stats &&
		(Show_parser_stats || Show_planner_stats || Show_executor_stats))
1475
	{
1476
		fprintf(stderr, "Query statistics are disabled because parser, planner, or executor statistics are on.\n");
1477
		Show_query_stats = false;
1478 1479
	}

1480
	if (!IsUnderPostmaster)
1481
	{
1482 1483 1484 1485 1486 1487 1488 1489 1490 1491
		if (!potential_DataDir)
		{
			fprintf(stderr, "%s does not know where to find the database system "
					"data.  You must specify the directory that contains the "
					"database system either by specifying the -D invocation "
					"option or by setting the PGDATA environment variable.\n\n",
					argv[0]);
			proc_exit(1);
		}
		SetDataDir(potential_DataDir);
1492
	}
1493
	Assert(DataDir);
1494 1495

	/*
1496
	 * Set up signal handlers and masks.
1497
	 *
1498 1499 1500
	 * Note that postmaster blocked all signals before forking child process,
	 * so there is no race condition whereby we might receive a signal before
	 * we have set up the handler.
T
Tom Lane 已提交
1501 1502 1503 1504 1505
	 *
	 * Also note: it's best not to use any signals that are SIG_IGNored in
	 * the postmaster.  If such a signal arrives before we are able to change
	 * the handler to non-SIG_IGN, it'll get dropped.  If necessary, make a
	 * dummy handler in the postmaster to reserve the signal.
1506
	 */
1507

1508
	pqsignal(SIGHUP, SigHupHandler);	/* set flag to read config file */
1509 1510
	pqsignal(SIGINT, QueryCancelHandler); /* cancel current query */
	pqsignal(SIGTERM, die);		/* cancel current query and exit */
T
Tom Lane 已提交
1511 1512
	pqsignal(SIGQUIT, quickdie); /* hard crash time */
	pqsignal(SIGALRM, HandleDeadLock); /* check for deadlock after timeout */
1513 1514 1515 1516 1517

	/*
	 * 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
1518 1519 1520
	 * midst of output during who-knows-what operation...
	 */
	pqsignal(SIGPIPE, SIG_IGN);
T
Tom Lane 已提交
1521
	pqsignal(SIGUSR1, SIG_IGN);	/* this signal available for use */
1522
	pqsignal(SIGUSR2, Async_NotifyHandler);		/* flush also sinval cache */
1523
	pqsignal(SIGFPE, FloatExceptionHandler);
1524 1525 1526 1527 1528
	pqsignal(SIGCHLD, SIG_IGN);	/* ignored (may get this in system() calls) */

	/*
	 * Reset some signals that are accepted by postmaster but not by backend
	 */
1529 1530 1531
	pqsignal(SIGTTIN, SIG_DFL);
	pqsignal(SIGTTOU, SIG_DFL);
	pqsignal(SIGCONT, SIG_DFL);
1532
	pqsignal(SIGWINCH, SIG_DFL);
1533

1534 1535
	pqinitmask();

T
Tom Lane 已提交
1536
	/* We allow SIGQUIT (quickdie) at all times */
1537
#ifdef HAVE_SIGPROCMASK
T
Tom Lane 已提交
1538
	sigdelset(&BlockSig, SIGQUIT);
1539
#else
T
Tom Lane 已提交
1540
	BlockSig &= ~(sigmask(SIGQUIT));
1541 1542
#endif

T
Tom Lane 已提交
1543
	PG_SETMASK(&BlockSig);		/* block everything except SIGQUIT */
1544

1545

1546
	if (IsUnderPostmaster)
1547
	{
1548 1549 1550
		/* noninteractive case: nothing should be left after switches */
		if (errs || argc != optind || DBName == NULL)
		{
1551
			fprintf(stderr, "%s: invalid command line arguments\nTry -? for help.\n", argv[0]);
1552
			proc_exit(0);		/* not 1, that causes system-wide restart... */
1553
		}
1554 1555 1556
		pq_init();				/* initialize libpq at backend startup */
		whereToSendOutput = Remote;
		BaseInit();
1557
	}
1558
	else
1559
	{
1560
		/* interactive case: database name can be last arg on command line */
1561
		whereToSendOutput = Debug;
1562 1563
		if (errs || argc - optind > 1)
		{
1564 1565
			fprintf(stderr, "%s: invalid command line arguments\nTry -? for help.\n", argv[0]);
			proc_exit(1);
1566 1567 1568
		}
		else if (argc - optind == 1)
			DBName = argv[optind];
1569
		else if ((DBName = username) == NULL)
1570
		{
1571
			fprintf(stderr, "%s: user name undefined and no database specified\n",
1572
					argv[0]);
1573
			proc_exit(1);
1574
		}
1575 1576

		/*
1577
		 * Create lockfile for data directory.
1578
		 */
1579 1580
		if (! CreateDataDirLockFile(DataDir, false))
			proc_exit(1);
1581

1582
		XLOGPathInit();
1583
		BaseInit();
1584 1585 1586 1587 1588

		/*
		 * Start up xlog for standalone backend, and register to have it
		 * closed down at exit.
		 */
1589
		StartupXLOG();
1590
		on_shmem_exit(ShutdownXLOG, 0);
1591 1592
	}

1593 1594 1595 1596 1597 1598 1599 1600
	/*
	 * Set up additional info.
	 */

#ifdef CYR_RECODE
	SetCharSet();
#endif

1601
	/* On some systems our dynloader code needs the executable's pathname */
1602
	if (FindExec(pg_pathname, real_argv[0], "postgres") < 0)
1603
		elog(FATAL, "%s: could not locate executable, bailing out...",
1604
			 real_argv[0]);
1605

M
 
Marc G. Fournier 已提交
1606 1607 1608
	/*
	 * Find remote host name or address.
	 */
1609 1610
	remote_host = NULL;

1611 1612
	if (IsUnderPostmaster)
	{
1613
		if (MyProcPort->raddr.sa.sa_family == AF_INET)
1614
		{
1615 1616
			struct hostent *host_ent;
			char * host_addr;
M
 
Marc G. Fournier 已提交
1617

1618 1619 1620 1621 1622 1623 1624 1625
			remote_port = ntohs(MyProcPort->raddr.in.sin_port);
			host_addr = inet_ntoa(MyProcPort->raddr.in.sin_addr);

			if (HostnameLookup)
			{
				host_ent = gethostbyaddr((char *) &MyProcPort->raddr.in.sin_addr, sizeof(MyProcPort->raddr.in.sin_addr), AF_INET);

				if (host_ent)
1626
				{
1627 1628
					remote_host = palloc(strlen(host_addr) + strlen(host_ent->h_name) + 3);
					sprintf(remote_host, "%s[%s]", host_ent->h_name, host_addr);
M
 
Marc G. Fournier 已提交
1629
				}
1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641
			}

			if (remote_host == NULL)
				remote_host = pstrdup(host_addr);

			if (ShowPortNumber)
			{
				char * str = palloc(strlen(remote_host) + 7);
				sprintf(str, "%s:%hu", remote_host, remote_port);
				pfree(remote_host);
				remote_host = str;
			}
M
 
Marc G. Fournier 已提交
1642
		}
1643 1644 1645
		else /* not AF_INET */
			remote_host = "[local]";

1646

1647
		/*
1648 1649 1650 1651 1652 1653
		 * Set process parameters for ps
		 *
		 * WARNING: On some platforms the environment will be moved
		 * around to make room for the ps display string. So any
		 * references to optarg or getenv() from above will be invalid
		 * after this call. Better use strdup or something similar.
1654
		 */
1655
		init_ps_display(real_argc, real_argv, username, DBName, remote_host);
1656
		set_ps_display("startup");
1657 1658
	}

1659 1660
	if (Log_connections)
		elog(DEBUG, "connection: host=%s user=%s database=%s",
1661
			 remote_host, username, DBName);
1662

1663
	/*
1664 1665 1666 1667 1668
	 * 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.
1669
	 */
1670 1671
	if (DebugLvl > 1)
		elog(DEBUG, "InitPostgres");
1672
	InitPostgres(DBName, username);
1673

1674
	SetProcessingMode(NormalProcessing);
1675

1676 1677
	/*
	 * Send this backend's cancellation info to the frontend.
1678
	 */
M
 
Marc G. Fournier 已提交
1679 1680 1681
	if (whereToSendOutput == Remote &&
		PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
	{
1682
		StringInfoData buf;
B
Bruce Momjian 已提交
1683

1684 1685 1686 1687 1688
		pq_beginmessage(&buf);
		pq_sendbyte(&buf, 'K');
		pq_sendint(&buf, (int32) MyProcPid, sizeof(int32));
		pq_sendint(&buf, (int32) MyCancelKey, sizeof(int32));
		pq_endmessage(&buf);
M
 
Marc G. Fournier 已提交
1689 1690 1691
		/* Need not flush since ReadyForQuery will do it. */
	}

1692 1693 1694
	if (!IsUnderPostmaster)
	{
		puts("\nPOSTGRES backend interactive interface ");
B
Bruce Momjian 已提交
1695
		puts("$Revision: 1.211 $ $Date: 2001/03/14 15:14:35 $\n");
1696 1697
	}

1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711
	/*
	 * Create the memory context we will use in the main loop.
	 *
	 * QueryContext is reset once per iteration of the main loop,
	 * ie, upon completion of processing of each supplied query string.
	 * It can therefore be used for any data that should live just as
	 * long as the query string --- parse trees, for example.
	 */
	QueryContext = AllocSetContextCreate(TopMemoryContext,
										 "QueryContext",
										 ALLOCSET_DEFAULT_MINSIZE,
										 ALLOCSET_DEFAULT_INITSIZE,
										 ALLOCSET_DEFAULT_MAXSIZE);

1712 1713
	/*
	 * POSTGRES main processing loop begins here
1714
	 *
1715 1716
	 * If an exception is encountered, processing resumes here so we abort
	 * the current transaction and start a new one.
1717 1718 1719 1720
	 */

	if (sigsetjmp(Warn_restart, 1) != 0)
	{
1721
		/*
1722 1723 1724 1725
		 * NOTE: if you are tempted to add more code in this if-block,
		 * consider the probability that it should be in AbortTransaction()
		 * instead.
		 *
1726 1727
		 * Make sure we're not interrupted while cleaning up.  Also forget
		 * any pending QueryCancel request, since we're aborting anyway.
1728 1729
		 * Force InterruptHoldoffCount to a known state in case we elog'd
		 * from inside a holdoff section.
1730 1731 1732
		 */
		ImmediateInterruptOK = false;
		QueryCancelPending = false;
1733 1734
		InterruptHoldoffCount = 1;
		CritSectionCount = 0;	/* should be unnecessary, but... */
1735 1736

		/*
1737 1738 1739 1740 1741 1742
		 * 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);
1743

1744
		/* Do the recovery */
1745 1746
		if (DebugLvl >= 1)
			elog(DEBUG, "AbortCurrentTransaction");
1747
		AbortCurrentTransaction();
1748 1749

		/*
1750 1751
		 * Now return to normal top-level context and clear ErrorContext
		 * for next time.
1752 1753 1754
		 */
		MemoryContextSwitchTo(TopMemoryContext);
		MemoryContextResetAndDeleteChildren(ErrorContext);
1755 1756 1757 1758 1759

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

		/*
1763
		 * Exit interrupt holdoff section we implicitly established above.
1764 1765
		 * (This could result in accepting a cancel or die interrupt.)
		 */
1766
		RESUME_INTERRUPTS();
1767
	}
1768

1769 1770
	Warn_restart_ready = true;	/* we can now handle elog(ERROR) */

1771
	PG_SETMASK(&UnBlockSig);
1772

1773 1774
	/*
	 * Non-error queries loop here.
1775 1776 1777 1778
	 */

	for (;;)
	{
1779 1780 1781 1782 1783 1784 1785 1786
		/*
		 * Release storage left over from prior query cycle, and
		 * create a new query input buffer in the cleared QueryContext.
		 */
		MemoryContextSwitchTo(QueryContext);
		MemoryContextResetAndDeleteChildren(QueryContext);

		parser_input = makeStringInfo();
1787

B
Bruce Momjian 已提交
1788
		/* ----------------
1789 1790
		 *	 (1) tell the frontend we're ready for a new query.
		 *
B
Bruce Momjian 已提交
1791
		 *	 Note: this includes fflush()'ing the last of the prior output.
B
Bruce Momjian 已提交
1792 1793
		 * ----------------
		 */
1794
		ReadyForQuery(whereToSendOutput);
B
Bruce Momjian 已提交
1795

1796 1797 1798 1799 1800
		if (IsTransactionBlock())
			set_ps_display("idle in transaction");
		else
			set_ps_display("idle");

1801
		/* ----------------
1802
		 *	 (2) deal with pending asynchronous NOTIFY from other backends,
B
Bruce Momjian 已提交
1803
		 *	 and enable async.c's signal handler to execute NOTIFY directly.
1804
		 *	 Then set up other stuff needed before blocking for input.
1805 1806
		 * ----------------
		 */
1807
		QueryCancelPending = false;	/* forget any earlier CANCEL signal */
1808 1809 1810

		EnableNotifyInterrupt();

1811 1812 1813 1814 1815 1816
		/* 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();

1817
		/* ----------------
1818
		 *	 (3) read a command (loop blocks here)
1819 1820
		 * ----------------
		 */
1821
		firstchar = ReadCommand(parser_input);
1822

1823
		/* ----------------
1824
		 *	 (4) disable async signal conditions again.
1825 1826
		 * ----------------
		 */
1827 1828 1829
		ImmediateInterruptOK = false;
		QueryCancelPending = false;	/* forget any CANCEL signal */

1830 1831 1832
		DisableNotifyInterrupt();

		/* ----------------
1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844
		 *	 (5) check for any other interesting events that happened
		 *		 while we slept.
		 * ----------------
		 */
		if (got_SIGHUP)
		{
			got_SIGHUP = false;
			ProcessConfigFile(PGC_SIGHUP);
		}

		/* ----------------
		 *	 (6) process the command.
1845 1846
		 * ----------------
		 */
1847 1848 1849
		switch (firstchar)
		{
				/* ----------------
1850
				 *	'F' indicates a fastpath call.
1851 1852
				 * ----------------
				 */
1853 1854
			case 'F':
				/* start an xact for this function invocation */
1855
				start_xact_command();
1856

1857 1858 1859
				if (HandleFunctionRequest() == EOF)
				{
					/* lost frontend connection during F message input */
1860
					proc_exit(0);
1861
				}
1862 1863 1864

				/* commit the function-invocation transaction */
				finish_xact_command();
1865
				break;
1866

1867 1868 1869 1870 1871
				/* ----------------
				 *	'Q' indicates a user query
				 * ----------------
				 */
			case 'Q':
1872
				if (strspn(parser_input->data, " \t\r\n") == parser_input->len)
1873 1874 1875
				{
					/* ----------------
					 *	if there is nothing in the input buffer, don't bother
1876 1877
					 *	trying to parse and execute anything; just send
					 *	back a quick NullCommand response.
1878 1879
					 * ----------------
					 */
1880 1881
					if (IsUnderPostmaster)
						NullCommand(Remote);
1882 1883 1884 1885 1886
				}
				else
				{
					/* ----------------
					 *	otherwise, process the input string.
1887 1888 1889
					 *
					 * Note: transaction command start/end is now done
					 * within pg_exec_query_string(), not here.
1890 1891
					 * ----------------
					 */
1892
					if (Show_query_stats)
1893 1894
						ResetUsage();

1895 1896 1897
					pg_exec_query_string(parser_input->data,
										 whereToSendOutput,
										 QueryContext);
1898

1899
					if (Show_query_stats)
1900 1901
					{
						fprintf(StatFp, "QUERY STATISTICS\n");
1902
						ShowUsage();
1903
					}
1904 1905 1906 1907
				}
				break;

				/* ----------------
1908 1909 1910
				 *	'X' means that the frontend is closing down the socket.
				 *	EOF means unexpected loss of frontend connection.
				 *	Either way, perform normal shutdown.
1911 1912 1913
				 * ----------------
				 */
			case 'X':
1914
			case EOF:
1915 1916 1917 1918 1919 1920 1921 1922
				/*
				 * NOTE: if you are tempted to add more code here, DON'T!
				 * Whatever you had in mind to do should be set up as
				 * an on_proc_exit or on_shmem_exit callback, instead.
				 * Otherwise it will fail to be called during other
				 * backend-shutdown scenarios.
				 */
				proc_exit(0);
1923 1924

			default:
M
 
Marc G. Fournier 已提交
1925
				elog(ERROR, "unknown frontend message was received");
1926 1927
		}

1928 1929
#ifdef MEMORY_CONTEXT_CHECKING
		/*
1930 1931
		 * Check all memory after each backend loop.  This is a rather
		 * weird place to do it, perhaps.
1932 1933 1934
		 */
		MemoryContextCheck(TopMemoryContext);	
#endif
1935
	}							/* end of input-reading loop */
1936

1937 1938
	/* can't get here because the above loop never exits */
	Assert(false);
1939

1940
	return 1;					/* keep compiler quiet */
1941 1942
}

1943
#ifndef HAVE_GETRUSAGE
B
Bruce Momjian 已提交
1944 1945
#include "rusagestub.h"
#else
1946
#include <sys/resource.h>
1947
#endif	 /* HAVE_GETRUSAGE */
1948

1949 1950
struct rusage Save_r;
struct timeval Save_t;
1951 1952

void
1953
ResetUsage(void)
1954
{
1955 1956 1957 1958 1959 1960
	struct timezone tz;

	getrusage(RUSAGE_SELF, &Save_r);
	gettimeofday(&Save_t, &tz);
	ResetBufferUsage();
/*	  ResetTupleCount(); */
1961 1962 1963
}

void
1964
ShowUsage(void)
1965
{
1966 1967 1968
	struct timeval user,
				sys;
	struct timeval elapse_t;
1969
	struct timezone tz;
1970
	struct rusage r;
1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991

	getrusage(RUSAGE_SELF, &r);
	gettimeofday(&elapse_t, &tz);
	memmove((char *) &user, (char *) &r.ru_utime, sizeof(user));
	memmove((char *) &sys, (char *) &r.ru_stime, sizeof(sys));
	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;
	}

1992 1993 1994 1995 1996 1997
	/*
	 * Set output destination if not otherwise set
	 */
	if (StatFp == NULL)
		StatFp = stderr;

1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021
	/*
	 * 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.
	 */

	fprintf(StatFp, "! system usage stats:\n");
	fprintf(StatFp,
			"!\t%ld.%06ld elapsed %ld.%06ld user %ld.%06ld system sec\n",
			(long int) elapse_t.tv_sec - Save_t.tv_sec,
			(long int) elapse_t.tv_usec - Save_t.tv_usec,
			(long int) r.ru_utime.tv_sec - Save_r.ru_utime.tv_sec,
			(long int) r.ru_utime.tv_usec - Save_r.ru_utime.tv_usec,
			(long int) r.ru_stime.tv_sec - Save_r.ru_stime.tv_sec,
			(long int) r.ru_stime.tv_usec - Save_r.ru_stime.tv_usec);
	fprintf(StatFp,
			"!\t[%ld.%06ld user %ld.%06ld sys total]\n",
			(long int) user.tv_sec,
			(long int) user.tv_usec,
			(long int) sys.tv_sec,
			(long int) sys.tv_usec);
2022
/* BeOS has rusage but only has some fields, and not these... */
2023
#if defined(HAVE_GETRUSAGE)
2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048
	fprintf(StatFp,
			"!\t%ld/%ld [%ld/%ld] filesystem blocks in/out\n",
			r.ru_inblock - Save_r.ru_inblock,
	/* they only drink coffee at dec */
			r.ru_oublock - Save_r.ru_oublock,
			r.ru_inblock, r.ru_oublock);
	fprintf(StatFp,
		  "!\t%ld/%ld [%ld/%ld] page faults/reclaims, %ld [%ld] swaps\n",
			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);
	fprintf(StatFp,
	 "!\t%ld [%ld] signals rcvd, %ld/%ld [%ld/%ld] messages rcvd/sent\n",
			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);
	fprintf(StatFp,
		 "!\t%ld/%ld [%ld/%ld] voluntary/involuntary context switches\n",
			r.ru_nvcsw - Save_r.ru_nvcsw,
			r.ru_nivcsw - Save_r.ru_nivcsw,
			r.ru_nvcsw, r.ru_nivcsw);
2049
#endif	 /* HAVE_GETRUSAGE */
2050 2051 2052
	fprintf(StatFp, "! postgres usage stats:\n");
	PrintBufferUsage(StatFp);
/*	   DisplayTupleCount(StatFp); */
2053
}
M
 
Marc G. Fournier 已提交
2054

2055 2056
#ifdef NOT_USED
static int
M
 
Marc G. Fournier 已提交
2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068
assertEnable(int val)
{
	assert_enabled = val;
	return val;
}

#ifdef ASSERT_CHECKING_TEST
int
assertTest(int val)
{
	Assert(val == 0);

2069 2070
	if (assert_enabled)
	{
M
 
Marc G. Fournier 已提交
2071 2072 2073
		/* val != 0 should be trapped by previous Assert */
		elog(NOTICE, "Assert test successfull (val = %d)", val);
	}
2074 2075
	else
		elog(NOTICE, "Assert checking is disabled (val = %d)", val);
M
 
Marc G. Fournier 已提交
2076 2077 2078

	return val;
}
2079

M
 
Marc G. Fournier 已提交
2080 2081
#endif
#endif