postgres.c 50.7 KB
Newer Older
1 2
/*-------------------------------------------------------------------------
 *
3
 * postgres.c
4
 *	  POSTGRES C Backend Interface
5
 *
Bruce Momjian's avatar
Add:  
Bruce Momjian committed
6 7
 * Portions Copyright (c) 1996-2000, PostgreSQL, Inc
 * 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.203 2001/01/19 22:08:47 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 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
33 34 35
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
36
#ifdef HAVE_GETOPT_H
Bruce Momjian's avatar
Bruce Momjian committed
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"
Bruce Momjian's avatar
Bruce Momjian committed
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"
Bruce Momjian's avatar
Bruce Momjian committed
54
#include "rewrite/rewriteHandler.h"
55 56
#include "tcop/fastpath.h"
#include "tcop/pquery.h"
Bruce Momjian's avatar
Bruce Momjian committed
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"
63
#include "utils/ps_status.h"
64
#ifdef MULTIBYTE
Bruce Momjian's avatar
Bruce Momjian committed
65
#include "mb/pg_wchar.h"
66 67
#endif

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 */
Bruce Momjian's avatar
Bruce Momjian committed
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 131
static void SigHupHandler(SIGNAL_ARGS);
static void FloatExceptionHandler(SIGNAL_ARGS);
static void quickdie(SIGNAL_ARGS);
132 133 134 135 136 137 138

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


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

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

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

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

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

172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
	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)
					{
187 188 189
						/* discard backslash from inBuf */
						inBuf->data[--inBuf->len] = '\0';
						backslashSeen = false;
190 191 192 193 194
						continue;
					}
					else
					{
						/* keep the newline character */
195
						appendStringInfoChar(inBuf, '\n');
196 197 198 199 200 201 202 203
						break;
					}
				}
				else if (c == '\\')
					backslashSeen = true;
				else
					backslashSeen = false;

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

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

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

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

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

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

241
	return 'Q';
242 243 244
}

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

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

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

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

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

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

302 303 304 305 306 307 308 309
			/* ----------------
			 *	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:
310
			elog(FATAL, "Socket command type %c unknown", qtype);
311
			break;
312 313
	}
	return result;
314 315 316
}

/* ----------------
317 318 319
 *		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
320
 *		call.  EOF is returned if end of file.
321 322
 * ----------------
 */
323
static int
324
ReadCommand(StringInfo inBuf)
325
{
326
	int			result;
327

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

335 336 337 338 339 340

/*
 * 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.
341 342 343
 *
 * NOTE: this routine is no longer used for processing interactive queries,
 * but it is still needed for parsing of SQL function bodies.
344
 */
345
List *
346 347 348
pg_parse_and_rewrite(char *query_string,	/* string to execute */
					 Oid *typev,			/* parameter types */
					 int nargs)				/* number of parameters */
349
{
350
	List	   *raw_parsetree_list;
351
	List	   *querytree_list;
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 392
	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;
393

394 395
	if (Debug_print_query)
		elog(DEBUG, "query: %s", query_string);
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 427
	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;

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

435
	querytree_list = parse_analyze(parsetree, NULL);
436

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

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

456
		if (Debug_print_parse)
457
		{
458
			if (Debug_pretty_print)
Bruce Momjian's avatar
Bruce Momjian committed
459
			{
460
				elog(DEBUG, "parse tree:");
Jan Wieck's avatar
Jan Wieck committed
461
				nodeDisplay(querytree);
Bruce Momjian's avatar
Bruce Momjian committed
462 463
			}
			else
464
				elog(DEBUG, "parse tree: %s", nodeToString(querytree));
465
		}
466 467 468

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

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

	querytree_list = new_list;

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

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

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

522 523
	return querytree_list;
}
524 525


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

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

536
	if (Show_planner_stats)
537
		ResetUsage();
538

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

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

548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565
#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

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

581
	return plan;
582 583
}

584

585
/* ----------------------------------------------------------------
586
 *		pg_exec_query_string()
587 588
 *
 *		Takes a querystring, runs the parser/utilities or
589 590 591 592
 *		parser/planner/executor over it as necessary.
 *
 * Assumptions:
 *
593
 * At call, we are not inside a transaction command.
594
 *
595
 * The CurrentMemoryContext after starting a transaction command must be
596 597 598 599
 * 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!
600
 *
601 602
 * parse_context references a context suitable for holding the
 * parse/rewrite trees (typically this will be QueryContext).
603
 * This context *must* be longer-lived than the transaction context!
604 605 606 607 608 609 610
 * 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.
611 612 613 614 615
 *
 * ----------------------------------------------------------------
 */

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

625
	/*
626 627 628 629
	 * 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.
630
	 * (Note that this will possibly change current memory context.)
631 632 633 634 635 636 637 638 639 640
	 */
	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.)
641 642 643
	 */
	Assert(parse_context != CurrentMemoryContext);

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

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

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

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

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

673 674 675 676 677 678 679 680 681
		/*
		 * 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())
682
		{
683
			bool	allowit = false;
684

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

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

700
			if (! allowit)
701
			{
702 703 704 705 706 707 708 709 710 711 712 713
				/* ----------------
				 *	 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);

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

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

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

		/*
		 * 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);
740

741
		querytree_list = pg_analyze_and_rewrite(parsetree);
Vadim B. Mikheev's avatar
Vadim B. Mikheev committed
742

743 744 745 746 747 748 749 750 751 752 753 754
		/*
		 * 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);
755

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

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

			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);
778 779 780
			}
			else
			{
781 782 783 784 785 786 787 788 789
				/* ----------------
				 *	 process a plannable query.
				 * ----------------
				 */
				Plan	   *plan;

				plan = pg_plan_query(querytree);

				/* if we got a cancel signal whilst planning, quit */
790
				CHECK_FOR_INTERRUPTS();
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 817

				/* 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();
				}
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 845
			/*
			 * 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)
846
			{
847 848
				finish_xact_command();
				xact_started = false;
849 850
			}

851 852 853 854 855 856 857 858
		} /* 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();
859 860
}

861 862 863 864 865 866 867 868 869 870 871 872 873 874
/*
 * 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)
{
875 876 877 878
	/* Invoke IMMEDIATE constraint triggers */
	DeferredTriggerEndQuery();

	/* Now commit the command */
879 880 881 882
	if (DebugLvl >= 1)
		elog(DEBUG, "CommitTransactionCommand");
	set_ps_display("commit");	/* XXX probably the wrong place to do this */
	CommitTransactionCommand();
883

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


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

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

914
	/*
915 916 917 918 919 920 921 922
	 * 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
	 * into a system reset cycle if some idiot DBA sends a manual SIGUSR1
	 * to a random backend.  This is necessary precisely because we don't
	 * clean up our shared memory state.
923 924
	 */

925
	exit(1);
926 927
}

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

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

	errno = save_errno;
957 958
}

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

968
	/* Don't joggle the elbow of proc_exit, nor an already-in-progress abort */
969
	if (!proc_exit_inprogress && !InError)
970
	{
971 972 973
		InterruptPending = true;
		QueryCancelPending = true;
		/*
974 975 976
		 * 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.
977
		 */
978 979
		if (ImmediateInterruptOK && InterruptHoldoffCount == 0 &&
			CritSectionCount == 0 && LockWaitCancel())
980 981 982 983
		{
			DisableNotifyInterrupt();
			ProcessInterrupts();
		}
984 985
	}

986
	errno = save_errno;
987 988
}

989 990 991 992 993 994 995 996 997
/* 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");
}

998
/* SIGHUP: set flag to re-read config file at next convenient time */
999
static void
1000
SigHupHandler(SIGNAL_ARGS)
1001
{
1002
	got_SIGHUP = true;
1003 1004
}

1005

1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
/*
 * 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)
{
1016 1017
	/* OK to accept interrupt now? */
	if (InterruptHoldoffCount != 0 || CritSectionCount != 0)
1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
		return;
	InterruptPending = false;
	if (ProcDiePending)
	{
		ProcDiePending = false;
		QueryCancelPending = false;	/* ProcDie trumps QueryCancel */
		ImmediateInterruptOK = false; /* not idle anymore */
		elog(FATAL, "The system is shutting down");
	}
	if (QueryCancelPending)
	{
		QueryCancelPending = false;
		ImmediateInterruptOK = false; /* not idle anymore */
		elog(ERROR, "Query was cancelled.");
	}
	/* If we get here, do nothing (probably, QueryCancelPending was reset) */
}

1036

1037 1038
static void
usage(char *progname)
1039
{
1040 1041 1042 1043
	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");
1044
#ifdef USE_ASSERT_CHECKING
1045
	printf("  -A 1|0          enable/disable run-time assert checking\n");
1046
#endif
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066
	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");
1067 1068
}

1069 1070


1071
/* ----------------------------------------------------------------
1072 1073
 * PostgresMain
 *     postgres main loop -- all backends, interactive or otherwise start here
1074
 *
1075 1076 1077 1078 1079
 * 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.
1080 1081 1082
 * ----------------------------------------------------------------
 */
int
1083
PostgresMain(int argc, char *argv[], int real_argc, char *real_argv[], const char * username)
1084
{
1085
	int			flag;
1086

1087
	const char	   *DBName = NULL;
1088
	bool		secure = true;
1089
	int			errs = 0;
1090

1091
	int			firstchar;
1092
	StringInfo	parser_input;
1093

1094 1095
	char	   *remote_host;
	unsigned short remote_port;
1096

1097 1098
	char       *potential_DataDir = NULL;

1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116
	/*
	 * 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);
		}
	}		

1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127
	/*
	 * Fire up essential subsystems: error and memory management
	 *
	 * If we are running under the postmaster, this is done already.
	 */
	if (!IsUnderPostmaster)
	{
		EnableExceptionHandling(true);
		MemoryContextInit();
	}

1128 1129
	SetProcessingMode(InitProcessing);

1130
	/*
1131
	 * Set default values for command-line options.
1132
	 */
1133 1134
	Noversion = false;
	EchoQuery = false;
1135 1136 1137 1138

	if (!IsUnderPostmaster)
	{
		ResetAllOptions();
1139
		potential_DataDir = getenv("PGDATA");
1140
	}
1141
	StatFp = stderr;
1142

1143 1144
	/* Check for PGDATESTYLE environment variable */
	set_default_datestyle();
1145

1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163
	/* ----------------
	 *	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 */
1164

1165
	while ((flag = getopt(argc, argv,  "A:B:c:CD:d:Eef:FiLNOPo:p:S:st:v:W:x:-:")) != EOF)
1166 1167
		switch (flag)
		{
1168 1169 1170 1171
			case 'A':
#ifdef USE_ASSERT_CHECKING
				assert_enabled = atoi(optarg);
#else
1172
				fprintf(stderr, "Assert checking is not compiled in\n");
1173 1174
#endif
				break;
1175

1176 1177 1178 1179 1180
			case 'B':
				/* ----------------
				 *	specify the size of buffer pool
				 * ----------------
				 */
1181 1182
				if (secure)
					NBuffers = atoi(optarg);
1183
				break;
1184

1185 1186
			case 'C':
				/* ----------------
1187
				 *	don't print version string
1188 1189
				 * ----------------
				 */
1190
				Noversion = true;
1191
				break;
1192

1193
			case 'D':			/* PGDATA directory */
1194
				if (secure)
1195
				{
1196
					potential_DataDir = optarg;
1197
				}
1198
				break;
1199

1200
			case 'd':			/* debug level */
1201
				DebugLvl = atoi(optarg);
1202 1203
				if (DebugLvl >= 1);
					Log_connections = true;
1204
				if (DebugLvl >= 2)
1205
					Debug_print_query = true;
1206
				if (DebugLvl >= 3)
1207
					Debug_print_parse = true;
Bruce Momjian's avatar
Bruce Momjian committed
1208
				if (DebugLvl >= 4)
1209
					Debug_print_plan = true;
Jan Wieck's avatar
Jan Wieck committed
1210
				if (DebugLvl >= 5)
1211
					Debug_print_rewritten = true;
1212
				break;
1213 1214 1215 1216 1217 1218

			case 'E':
				/* ----------------
				 *	E - echo the query the user entered
				 * ----------------
				 */
1219
				EchoQuery = true;
1220
				break;
1221 1222 1223 1224 1225 1226

			case 'e':
				/* --------------------------
				 * Use european date formats.
				 * --------------------------
				 */
1227
				EuroDates = true;
1228
				break;
1229 1230 1231 1232

			case 'F':
				/* --------------------
				 *	turn off fsync
1233 1234 1235 1236
				 *
				 *	7.0 buffer manager can support different backends running
				 *	with different fsync settings, so this no longer needs
				 *	to be "if (secure)".
1237 1238
				 * --------------------
				 */
1239
				enableFsync = false;
1240
				break;
1241 1242 1243 1244 1245 1246 1247 1248 1249

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

1272
			case 'i':
1273
				dontExecute = true;
1274
				break;
1275

1276 1277 1278 1279 1280
			case 'L':
				/* --------------------
				 *	turn off locking
				 * --------------------
				 */
1281 1282
				if (secure)
					lockingOff = 1;
1283 1284
				break;

1285 1286 1287 1288 1289 1290 1291
			case 'N':
				/* ----------------
				 *	N - Don't use newline as a query delimiter
				 * ----------------
				 */
				UseNewLine = 0;
				break;
1292

1293 1294 1295 1296 1297
			case 'O':
				/* --------------------
				 *	allow system table structure modifications
				 * --------------------
				 */
1298 1299
				if (secure)		/* XXX safe to allow from client??? */
					allowSystemTableMods = true;
1300 1301
				break;

Hiroshi Inoue's avatar
Hiroshi Inoue committed
1302 1303 1304 1305 1306 1307 1308 1309 1310
			case 'P':
				/* --------------------
				 *	ignore system indexes
				 * --------------------
				 */
				if (secure)		/* XXX safe to allow from client??? */
					IgnoreSystemIndexes(true);
				break;

1311 1312 1313 1314 1315
			case 'o':
				/* ----------------
				 *	o - send output (stdout and stderr) to the given file
				 * ----------------
				 */
1316 1317
				if (secure)
					StrNCpy(OutputFileName, optarg, MAXPGPATH);
1318 1319
				break;

1320
			case 'p':
1321 1322 1323 1324 1325
				/* ----------------
				 *	p - special flag passed if backend was forked
				 *		by a postmaster.
				 * ----------------
				 */
1326 1327
				if (secure)
				{
1328
					DBName = strdup(optarg);
Bruce Momjian's avatar
Bruce Momjian committed
1329 1330
					secure = false;		/* subsequent switches are NOT
										 * secure */
1331
				}
1332
				break;
1333

1334 1335
			case 'S':
				/* ----------------
1336
				 *	S - amount of sort memory to use in 1k bytes
1337 1338
				 * ----------------
				 */
1339
				{
1340 1341
					int			S;

1342
					S = atoi(optarg);
1343
					if (S >= 4 * BLCKSZ / 1024)
1344
						SortMem = S;
1345
				}
1346
				break;
1347 1348 1349 1350 1351 1352

			case 's':
				/* ----------------
				 *	  s - report usage statistics (timings) after each query
				 * ----------------
				 */
1353
				Show_query_stats = 1;
1354 1355
				break;

1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370
			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')
1371
							Show_parser_stats = 1;
1372
						else if (optarg[1] == 'l')
1373
							Show_planner_stats = 1;
1374 1375 1376 1377
						else
							errs++;
						break;
					case 'e':
1378
						Show_executor_stats = 1;
1379 1380 1381 1382 1383
						break;
					default:
						errs++;
						break;
				}
1384 1385
				break;

1386
			case 'v':
1387 1388
				if (secure)
					FrontendProtocol = (ProtocolVersion) atoi(optarg);
1389 1390
				break;

1391 1392
			case 'W':
				/* ----------------
1393
				 *	wait N seconds to allow attach from a debugger
1394 1395 1396 1397 1398
				 * ----------------
				 */
				sleep(atoi(optarg));
				break;

1399
			case 'x':
Bruce Momjian's avatar
Bruce Momjian committed
1400
#ifdef NOT_USED					/* planner/xfunc.h */
1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428

				/*
				 * 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++;
				}
1429
#endif
1430
				break;
1431

1432
			case 'c':
1433 1434
			case '-':
			{
1435
				char *name, *value;
1436

1437 1438
				ParseLongOption(optarg, &name, &value);
				if (!value)
1439 1440 1441 1442 1443 1444
				{
					if (flag == '-')
						elog(ERROR, "--%s requires argument", optarg);
					else
						elog(ERROR, "-c %s requires argument", optarg);
				}
1445

1446 1447 1448
				/* all options are allowed if not under postmaster */
				SetConfigOption(name, value, 
					(IsUnderPostmaster) ? PGC_BACKEND : PGC_POSTMASTER);
1449 1450 1451
				free(name);
				if (value)
					free(value);
1452 1453 1454
				break;
			}

1455 1456
			default:
				errs++;
1457
				break;
1458 1459
		}

1460 1461 1462 1463 1464 1465
	/*
	 * 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...
	 */
1466 1467
	if (Show_query_stats &&
		(Show_parser_stats || Show_planner_stats || Show_executor_stats))
1468
	{
1469
		fprintf(stderr, "Query statistics are disabled because parser, planner, or executor statistics are on.\n");
1470
		Show_query_stats = false;
1471 1472
	}

1473
	if (!IsUnderPostmaster)
1474
	{
1475 1476 1477 1478 1479 1480 1481 1482 1483 1484
		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);
1485
	}
1486
	Assert(DataDir);
1487 1488

	/*
1489
	 * Set up signal handlers and masks.
1490
	 *
1491 1492 1493
	 * 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.
1494
	 */
1495

1496
	pqsignal(SIGHUP, SigHupHandler);	/* set flag to read config file */
1497 1498 1499
	pqsignal(SIGINT, QueryCancelHandler); /* cancel current query */
	pqsignal(SIGTERM, die);		/* cancel current query and exit */
	pqsignal(SIGQUIT, die);		/* could reassign this sig for another use */
1500
	pqsignal(SIGALRM, HandleDeadLock);
1501 1502 1503 1504 1505

	/*
	 * 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
1506 1507 1508 1509
	 * midst of output during who-knows-what operation...
	 */
	pqsignal(SIGPIPE, SIG_IGN);
	pqsignal(SIGUSR1, quickdie);
1510
	pqsignal(SIGUSR2, Async_NotifyHandler);		/* flush also sinval cache */
1511
	pqsignal(SIGFPE, FloatExceptionHandler);
1512 1513 1514 1515 1516
	pqsignal(SIGCHLD, SIG_IGN);	/* ignored (may get this in system() calls) */

	/*
	 * Reset some signals that are accepted by postmaster but not by backend
	 */
1517 1518 1519
	pqsignal(SIGTTIN, SIG_DFL);
	pqsignal(SIGTTOU, SIG_DFL);
	pqsignal(SIGCONT, SIG_DFL);
1520
	pqsignal(SIGWINCH, SIG_DFL);
1521

1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532
	pqinitmask();

	/* We allow SIGUSR1 (quickdie) at all times */
#ifdef HAVE_SIGPROCMASK
	sigdelset(&BlockSig, SIGUSR1);
#else
	BlockSig &= ~(sigmask(SIGUSR1));
#endif

	PG_SETMASK(&BlockSig);		/* block everything except SIGUSR1 */

1533

1534
	if (IsUnderPostmaster)
1535
	{
1536 1537 1538
		/* noninteractive case: nothing should be left after switches */
		if (errs || argc != optind || DBName == NULL)
		{
1539 1540
			fprintf(stderr, "%s: invalid command line arguments\nTry -? for help.\n", argv[0]);
			proc_exit(1);
1541
		}
1542 1543 1544
		pq_init();				/* initialize libpq at backend startup */
		whereToSendOutput = Remote;
		BaseInit();
1545
	}
1546
	else
1547
	{
1548
		/* interactive case: database name can be last arg on command line */
1549
		whereToSendOutput = Debug;
1550 1551
		if (errs || argc - optind > 1)
		{
1552 1553
			fprintf(stderr, "%s: invalid command line arguments\nTry -? for help.\n", argv[0]);
			proc_exit(1);
1554 1555 1556
		}
		else if (argc - optind == 1)
			DBName = argv[optind];
1557
		else if ((DBName = username) == NULL)
1558
		{
1559
			fprintf(stderr, "%s: user name undefined and no database specified\n",
1560
					argv[0]);
1561
			proc_exit(1);
1562
		}
1563 1564

		/*
1565
		 * Create lockfile for data directory.
1566
		 */
1567 1568
		if (! CreateDataDirLockFile(DataDir, false))
			proc_exit(1);
1569

1570
		XLOGPathInit();
1571
		BaseInit();
1572 1573 1574 1575 1576

		/*
		 * Start up xlog for standalone backend, and register to have it
		 * closed down at exit.
		 */
1577
		StartupXLOG();
1578
		on_shmem_exit(ShutdownXLOG, 0);
1579 1580
	}

1581 1582 1583 1584 1585 1586 1587 1588
	/*
	 * Set up additional info.
	 */

#ifdef CYR_RECODE
	SetCharSet();
#endif

1589
	/* On some systems our dynloader code needs the executable's pathname */
1590
	if (FindExec(pg_pathname, real_argv[0], "postgres") < 0)
1591
		elog(FATAL, "%s: could not locate executable, bailing out...",
1592
			 real_argv[0]);
1593

1594 1595 1596
	/*
	 * Find remote host name or address.
	 */
1597 1598
	remote_host = NULL;

1599 1600
	if (IsUnderPostmaster)
	{
1601
		if (MyProcPort->raddr.sa.sa_family == AF_INET)
1602
		{
1603 1604
			struct hostent *host_ent;
			char * host_addr;
1605

1606 1607 1608 1609 1610 1611 1612 1613
			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)
1614
				{
1615 1616
					remote_host = palloc(strlen(host_addr) + strlen(host_ent->h_name) + 3);
					sprintf(remote_host, "%s[%s]", host_ent->h_name, host_addr);
1617
				}
1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629
			}

			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;
			}
1630
		}
1631 1632 1633
		else /* not AF_INET */
			remote_host = "[local]";

1634

1635
		/*
1636 1637 1638 1639 1640 1641
		 * 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.
1642
		 */
1643
		init_ps_display(real_argc, real_argv, username, DBName, remote_host);
1644
		set_ps_display("startup");
1645 1646
	}

1647 1648
	if (Log_connections)
		elog(DEBUG, "connection: host=%s user=%s database=%s",
1649
			 remote_host, username, DBName);
1650

1651
	/*
1652 1653 1654 1655 1656
	 * 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.
1657
	 */
1658 1659
	if (DebugLvl > 1)
		elog(DEBUG, "InitPostgres");
1660
	InitPostgres(DBName, username);
1661

1662
	SetProcessingMode(NormalProcessing);
1663

1664 1665
	/*
	 * Send this backend's cancellation info to the frontend.
1666
	 */
1667 1668 1669
	if (whereToSendOutput == Remote &&
		PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
	{
1670
		StringInfoData buf;
Bruce Momjian's avatar
Bruce Momjian committed
1671

1672 1673 1674 1675 1676
		pq_beginmessage(&buf);
		pq_sendbyte(&buf, 'K');
		pq_sendint(&buf, (int32) MyProcPid, sizeof(int32));
		pq_sendint(&buf, (int32) MyCancelKey, sizeof(int32));
		pq_endmessage(&buf);
1677 1678 1679
		/* Need not flush since ReadyForQuery will do it. */
	}

1680 1681 1682
	if (!IsUnderPostmaster)
	{
		puts("\nPOSTGRES backend interactive interface ");
1683
		puts("$Revision: 1.203 $ $Date: 2001/01/19 22:08:47 $\n");
1684 1685
	}

1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699
	/*
	 * 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);

1700 1701
	/*
	 * POSTGRES main processing loop begins here
1702
	 *
1703 1704
	 * If an exception is encountered, processing resumes here so we abort
	 * the current transaction and start a new one.
1705 1706 1707 1708
	 */

	if (sigsetjmp(Warn_restart, 1) != 0)
	{
1709
		/*
1710 1711 1712 1713
		 * NOTE: if you are tempted to add more code in this if-block,
		 * consider the probability that it should be in AbortTransaction()
		 * instead.
		 *
1714 1715
		 * Make sure we're not interrupted while cleaning up.  Also forget
		 * any pending QueryCancel request, since we're aborting anyway.
1716 1717
		 * Force InterruptHoldoffCount to a known state in case we elog'd
		 * from inside a holdoff section.
1718 1719 1720
		 */
		ImmediateInterruptOK = false;
		QueryCancelPending = false;
1721 1722
		InterruptHoldoffCount = 1;
		CritSectionCount = 0;	/* should be unnecessary, but... */
1723 1724

		/*
1725 1726 1727 1728 1729 1730
		 * 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);
1731

1732
		/* Do the recovery */
1733 1734
		if (DebugLvl >= 1)
			elog(DEBUG, "AbortCurrentTransaction");
1735
		AbortCurrentTransaction();
1736 1737

		/*
1738 1739
		 * Now return to normal top-level context and clear ErrorContext
		 * for next time.
1740 1741 1742
		 */
		MemoryContextSwitchTo(TopMemoryContext);
		MemoryContextResetAndDeleteChildren(ErrorContext);
1743 1744 1745 1746 1747

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

		/*
1751
		 * Exit interrupt holdoff section we implicitly established above.
1752 1753
		 * (This could result in accepting a cancel or die interrupt.)
		 */
1754
		RESUME_INTERRUPTS();
1755
	}
1756

1757 1758
	Warn_restart_ready = true;	/* we can now handle elog(ERROR) */

1759
	PG_SETMASK(&UnBlockSig);
1760

1761 1762
	/*
	 * Non-error queries loop here.
1763 1764 1765 1766
	 */

	for (;;)
	{
1767 1768 1769 1770 1771 1772 1773 1774
		/*
		 * 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();
1775

Bruce Momjian's avatar
Bruce Momjian committed
1776
		/* ----------------
1777 1778
		 *	 (1) tell the frontend we're ready for a new query.
		 *
Bruce Momjian's avatar
Bruce Momjian committed
1779
		 *	 Note: this includes fflush()'ing the last of the prior output.
Bruce Momjian's avatar
Bruce Momjian committed
1780 1781
		 * ----------------
		 */
1782
		ReadyForQuery(whereToSendOutput);
Bruce Momjian's avatar
Bruce Momjian committed
1783

1784
		/* ----------------
1785
		 *	 (2) deal with pending asynchronous NOTIFY from other backends,
Bruce Momjian's avatar
Bruce Momjian committed
1786
		 *	 and enable async.c's signal handler to execute NOTIFY directly.
1787
		 *	 Then set up other stuff needed before blocking for input.
1788 1789
		 * ----------------
		 */
1790
		QueryCancelPending = false;	/* forget any earlier CANCEL signal */
1791 1792 1793

		EnableNotifyInterrupt();

1794 1795 1796 1797 1798 1799 1800 1801
		set_ps_display("idle");

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

1802
		/* ----------------
1803
		 *	 (3) read a command (loop blocks here)
1804 1805
		 * ----------------
		 */
1806
		firstchar = ReadCommand(parser_input);
1807

1808
		/* ----------------
1809
		 *	 (4) disable async signal conditions again.
1810 1811
		 * ----------------
		 */
1812 1813 1814
		ImmediateInterruptOK = false;
		QueryCancelPending = false;	/* forget any CANCEL signal */

1815 1816 1817
		DisableNotifyInterrupt();

		/* ----------------
1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829
		 *	 (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.
1830 1831
		 * ----------------
		 */
1832 1833 1834
		switch (firstchar)
		{
				/* ----------------
1835
				 *	'F' indicates a fastpath call.
1836 1837
				 * ----------------
				 */
1838 1839
			case 'F':
				/* start an xact for this function invocation */
1840
				start_xact_command();
1841

1842 1843 1844
				if (HandleFunctionRequest() == EOF)
				{
					/* lost frontend connection during F message input */
1845
					proc_exit(0);
1846
				}
1847 1848 1849

				/* commit the function-invocation transaction */
				finish_xact_command();
1850
				break;
1851

1852 1853 1854 1855 1856
				/* ----------------
				 *	'Q' indicates a user query
				 * ----------------
				 */
			case 'Q':
1857
				if (strspn(parser_input->data, " \t\r\n") == parser_input->len)
1858 1859 1860
				{
					/* ----------------
					 *	if there is nothing in the input buffer, don't bother
1861 1862
					 *	trying to parse and execute anything; just send
					 *	back a quick NullCommand response.
1863 1864
					 * ----------------
					 */
1865 1866
					if (IsUnderPostmaster)
						NullCommand(Remote);
1867 1868 1869 1870 1871
				}
				else
				{
					/* ----------------
					 *	otherwise, process the input string.
1872 1873 1874
					 *
					 * Note: transaction command start/end is now done
					 * within pg_exec_query_string(), not here.
1875 1876
					 * ----------------
					 */
1877
					if (Show_query_stats)
1878 1879
						ResetUsage();

1880 1881 1882
					pg_exec_query_string(parser_input->data,
										 whereToSendOutput,
										 QueryContext);
1883

1884
					if (Show_query_stats)
1885 1886
					{
						fprintf(StatFp, "QUERY STATISTICS\n");
1887
						ShowUsage();
1888
					}
1889 1890 1891 1892
				}
				break;

				/* ----------------
1893 1894 1895
				 *	'X' means that the frontend is closing down the socket.
				 *	EOF means unexpected loss of frontend connection.
				 *	Either way, perform normal shutdown.
1896 1897 1898
				 * ----------------
				 */
			case 'X':
1899
			case EOF:
1900 1901 1902 1903 1904 1905 1906 1907
				/*
				 * 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);
1908 1909

			default:
1910
				elog(ERROR, "unknown frontend message was received");
1911 1912
		}

1913 1914
#ifdef MEMORY_CONTEXT_CHECKING
		/*
1915 1916
		 * Check all memory after each backend loop.  This is a rather
		 * weird place to do it, perhaps.
1917 1918 1919
		 */
		MemoryContextCheck(TopMemoryContext);	
#endif
1920
	}							/* end of input-reading loop */
1921

1922 1923
	/* can't get here because the above loop never exits */
	Assert(false);
1924

1925
	return 1;					/* keep compiler quiet */
1926 1927
}

1928
#ifndef HAVE_GETRUSAGE
Bruce Momjian's avatar
Bruce Momjian committed
1929 1930
#include "rusagestub.h"
#else
1931
#include <sys/resource.h>
1932
#endif	 /* HAVE_GETRUSAGE */
1933

1934 1935
struct rusage Save_r;
struct timeval Save_t;
1936 1937

void
1938
ResetUsage(void)
1939
{
1940 1941 1942 1943 1944 1945
	struct timezone tz;

	getrusage(RUSAGE_SELF, &Save_r);
	gettimeofday(&Save_t, &tz);
	ResetBufferUsage();
/*	  ResetTupleCount(); */
1946 1947 1948
}

void
1949
ShowUsage(void)
1950
{
1951 1952 1953
	struct timeval user,
				sys;
	struct timeval elapse_t;
1954
	struct timezone tz;
1955
	struct rusage r;
1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976

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

1977 1978 1979 1980 1981 1982
	/*
	 * Set output destination if not otherwise set
	 */
	if (StatFp == NULL)
		StatFp = stderr;

1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006
	/*
	 * 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);
2007
/* BeOS has rusage but only has some fields, and not these... */
2008
#if defined(HAVE_GETRUSAGE)
2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033
	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);
2034
#endif	 /* HAVE_GETRUSAGE */
2035 2036 2037
	fprintf(StatFp, "! postgres usage stats:\n");
	PrintBufferUsage(StatFp);
/*	   DisplayTupleCount(StatFp); */
2038
}
2039

2040 2041
#ifdef NOT_USED
static int
2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053
assertEnable(int val)
{
	assert_enabled = val;
	return val;
}

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

2054 2055
	if (assert_enabled)
	{
2056 2057 2058
		/* val != 0 should be trapped by previous Assert */
		elog(NOTICE, "Assert test successfull (val = %d)", val);
	}
2059 2060
	else
		elog(NOTICE, "Assert checking is disabled (val = %d)", val);
2061 2062 2063

	return val;
}
2064

2065 2066
#endif
#endif