1 /*-------------------------------------------------------------------------
2  *
3  * postgres.c
4  *	  POSTGRES C Backend Interface
5  *
6  * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  *
10  * IDENTIFICATION
11  *	  src/backend/tcop/postgres.c
12  *
13  * NOTES
14  *	  this is the "main" module of the postgres backend and
15  *	  hence the main module of the "traffic cop".
16  *
17  *-------------------------------------------------------------------------
18  */
19 
20 #include "postgres.h"
21 
22 #include <fcntl.h>
23 #include <limits.h>
24 #include <signal.h>
25 #include <unistd.h>
26 #include <sys/socket.h>
27 #ifdef HAVE_SYS_SELECT_H
28 #include <sys/select.h>
29 #endif
30 #ifdef HAVE_SYS_RESOURCE_H
31 #include <sys/time.h>
32 #include <sys/resource.h>
33 #endif
34 
35 #ifndef HAVE_GETRUSAGE
36 #include "rusagestub.h"
37 #endif
38 
39 #include "access/parallel.h"
40 #include "access/printtup.h"
41 #include "access/xact.h"
42 #include "catalog/pg_type.h"
43 #include "commands/async.h"
44 #include "commands/prepare.h"
45 #include "executor/spi.h"
46 #include "jit/jit.h"
47 #include "libpq/libpq.h"
48 #include "libpq/pqformat.h"
49 #include "libpq/pqsignal.h"
50 #include "miscadmin.h"
51 #include "nodes/print.h"
52 #include "optimizer/optimizer.h"
53 #include "pgstat.h"
54 #include "pg_trace.h"
55 #include "parser/analyze.h"
56 #include "parser/parser.h"
57 #include "pg_getopt.h"
58 #include "postmaster/autovacuum.h"
59 #include "postmaster/postmaster.h"
60 #include "replication/logicallauncher.h"
61 #include "replication/logicalworker.h"
62 #include "replication/slot.h"
63 #include "replication/walsender.h"
64 #include "rewrite/rewriteHandler.h"
65 #include "storage/bufmgr.h"
66 #include "storage/ipc.h"
67 #include "storage/proc.h"
68 #include "storage/procsignal.h"
69 #include "storage/sinval.h"
70 #include "tcop/fastpath.h"
71 #include "tcop/pquery.h"
72 #include "tcop/tcopprot.h"
73 #include "tcop/utility.h"
74 #include "utils/lsyscache.h"
75 #include "utils/memutils.h"
76 #include "utils/ps_status.h"
77 #include "utils/snapmgr.h"
78 #include "utils/timeout.h"
79 #include "utils/timestamp.h"
80 #include "mb/pg_wchar.h"
81 
82 
83 /* ----------------
84  *		global variables
85  * ----------------
86  */
87 const char *debug_query_string; /* client-supplied query string */
88 
89 /* Note: whereToSendOutput is initialized for the bootstrap/standalone case */
90 CommandDest whereToSendOutput = DestDebug;
91 
92 /* flag for logging end of session */
93 bool		Log_disconnections = false;
94 
95 int			log_statement = LOGSTMT_NONE;
96 
97 /* GUC variable for maximum stack depth (measured in kilobytes) */
98 int			max_stack_depth = 100;
99 
100 /* wait N seconds to allow attach from a debugger */
101 int			PostAuthDelay = 0;
102 
103 
104 
105 /* ----------------
106  *		private variables
107  * ----------------
108  */
109 
110 /* max_stack_depth converted to bytes for speed of checking */
111 static long max_stack_depth_bytes = 100 * 1024L;
112 
113 /*
114  * Stack base pointer -- initialized by PostmasterMain and inherited by
115  * subprocesses. This is not static because old versions of PL/Java modify
116  * it directly. Newer versions use set_stack_base(), but we want to stay
117  * binary-compatible for the time being.
118  */
119 char	   *stack_base_ptr = NULL;
120 
121 /*
122  * On IA64 we also have to remember the register stack base.
123  */
124 #if defined(__ia64__) || defined(__ia64)
125 char	   *register_stack_base_ptr = NULL;
126 #endif
127 
128 /*
129  * Flag to keep track of whether we have started a transaction.
130  * For extended query protocol this has to be remembered across messages.
131  */
132 static bool xact_started = false;
133 
134 /*
135  * Flag to indicate that we are doing the outer loop's read-from-client,
136  * as opposed to any random read from client that might happen within
137  * commands like COPY FROM STDIN.
138  */
139 static bool DoingCommandRead = false;
140 
141 /*
142  * Flags to implement skip-till-Sync-after-error behavior for messages of
143  * the extended query protocol.
144  */
145 static bool doing_extended_query_message = false;
146 static bool ignore_till_sync = false;
147 
148 /*
149  * Flag to keep track of whether statement timeout timer is active.
150  */
151 static bool stmt_timeout_active = false;
152 
153 /*
154  * If an unnamed prepared statement exists, it's stored here.
155  * We keep it separate from the hashtable kept by commands/prepare.c
156  * in order to reduce overhead for short-lived queries.
157  */
158 static CachedPlanSource *unnamed_stmt_psrc = NULL;
159 
160 /* assorted command-line switches */
161 static const char *userDoption = NULL;	/* -D switch */
162 static bool EchoQuery = false;	/* -E switch */
163 static bool UseSemiNewlineNewline = false;	/* -j switch */
164 
165 /* whether or not, and why, we were canceled by conflict with recovery */
166 static bool RecoveryConflictPending = false;
167 static bool RecoveryConflictRetryable = true;
168 static ProcSignalReason RecoveryConflictReason;
169 
170 /* reused buffer to pass to SendRowDescriptionMessage() */
171 static MemoryContext row_description_context = NULL;
172 static StringInfoData row_description_buf;
173 
174 /* ----------------------------------------------------------------
175  *		decls for routines only used in this file
176  * ----------------------------------------------------------------
177  */
178 static int	InteractiveBackend(StringInfo inBuf);
179 static int	interactive_getc(void);
180 static int	SocketBackend(StringInfo inBuf);
181 static int	ReadCommand(StringInfo inBuf);
182 static void forbidden_in_wal_sender(char firstchar);
183 static List *pg_rewrite_query(Query *query);
184 static bool check_log_statement(List *stmt_list);
185 static int	errdetail_execute(List *raw_parsetree_list);
186 static int	errdetail_params(ParamListInfo params);
187 static int	errdetail_abort(void);
188 static int	errdetail_recovery_conflict(void);
189 static void start_xact_command(void);
190 static void finish_xact_command(void);
191 static bool IsTransactionExitStmt(Node *parsetree);
192 static bool IsTransactionExitStmtList(List *pstmts);
193 static bool IsTransactionStmtList(List *pstmts);
194 static void drop_unnamed_stmt(void);
195 static void log_disconnections(int code, Datum arg);
196 static void enable_statement_timeout(void);
197 static void disable_statement_timeout(void);
198 
199 
200 /* ----------------------------------------------------------------
201  *		routines to obtain user input
202  * ----------------------------------------------------------------
203  */
204 
205 /* ----------------
206  *	InteractiveBackend() is called for user interactive connections
207  *
208  *	the string entered by the user is placed in its parameter inBuf,
209  *	and we act like a Q message was received.
210  *
211  *	EOF is returned if end-of-file input is seen; time to shut down.
212  * ----------------
213  */
214 
215 static int
InteractiveBackend(StringInfo inBuf)216 InteractiveBackend(StringInfo inBuf)
217 {
218 	int			c;				/* character read from getc() */
219 
220 	/*
221 	 * display a prompt and obtain input from the user
222 	 */
223 	printf("backend> ");
224 	fflush(stdout);
225 
226 	resetStringInfo(inBuf);
227 
228 	/*
229 	 * Read characters until EOF or the appropriate delimiter is seen.
230 	 */
231 	while ((c = interactive_getc()) != EOF)
232 	{
233 		if (c == '\n')
234 		{
235 			if (UseSemiNewlineNewline)
236 			{
237 				/*
238 				 * In -j mode, semicolon followed by two newlines ends the
239 				 * command; otherwise treat newline as regular character.
240 				 */
241 				if (inBuf->len > 1 &&
242 					inBuf->data[inBuf->len - 1] == '\n' &&
243 					inBuf->data[inBuf->len - 2] == ';')
244 				{
245 					/* might as well drop the second newline */
246 					break;
247 				}
248 			}
249 			else
250 			{
251 				/*
252 				 * In plain mode, newline ends the command unless preceded by
253 				 * backslash.
254 				 */
255 				if (inBuf->len > 0 &&
256 					inBuf->data[inBuf->len - 1] == '\\')
257 				{
258 					/* discard backslash from inBuf */
259 					inBuf->data[--inBuf->len] = '\0';
260 					/* discard newline too */
261 					continue;
262 				}
263 				else
264 				{
265 					/* keep the newline character, but end the command */
266 					appendStringInfoChar(inBuf, '\n');
267 					break;
268 				}
269 			}
270 		}
271 
272 		/* Not newline, or newline treated as regular character */
273 		appendStringInfoChar(inBuf, (char) c);
274 	}
275 
276 	/* No input before EOF signal means time to quit. */
277 	if (c == EOF && inBuf->len == 0)
278 		return EOF;
279 
280 	/*
281 	 * otherwise we have a user query so process it.
282 	 */
283 
284 	/* Add '\0' to make it look the same as message case. */
285 	appendStringInfoChar(inBuf, (char) '\0');
286 
287 	/*
288 	 * if the query echo flag was given, print the query..
289 	 */
290 	if (EchoQuery)
291 		printf("statement: %s\n", inBuf->data);
292 	fflush(stdout);
293 
294 	return 'Q';
295 }
296 
297 /*
298  * interactive_getc -- collect one character from stdin
299  *
300  * Even though we are not reading from a "client" process, we still want to
301  * respond to signals, particularly SIGTERM/SIGQUIT.
302  */
303 static int
interactive_getc(void)304 interactive_getc(void)
305 {
306 	int			c;
307 
308 	/*
309 	 * This will not process catchup interrupts or notifications while
310 	 * reading. But those can't really be relevant for a standalone backend
311 	 * anyway. To properly handle SIGTERM there's a hack in die() that
312 	 * directly processes interrupts at this stage...
313 	 */
314 	CHECK_FOR_INTERRUPTS();
315 
316 	c = getc(stdin);
317 
318 	ProcessClientReadInterrupt(false);
319 
320 	return c;
321 }
322 
323 /* ----------------
324  *	SocketBackend()		Is called for frontend-backend connections
325  *
326  *	Returns the message type code, and loads message body data into inBuf.
327  *
328  *	EOF is returned if the connection is lost.
329  * ----------------
330  */
331 static int
SocketBackend(StringInfo inBuf)332 SocketBackend(StringInfo inBuf)
333 {
334 	int			qtype;
335 
336 	/*
337 	 * Get message type code from the frontend.
338 	 */
339 	HOLD_CANCEL_INTERRUPTS();
340 	pq_startmsgread();
341 	qtype = pq_getbyte();
342 
343 	if (qtype == EOF)			/* frontend disconnected */
344 	{
345 		if (IsTransactionState())
346 			ereport(COMMERROR,
347 					(errcode(ERRCODE_CONNECTION_FAILURE),
348 					 errmsg("unexpected EOF on client connection with an open transaction")));
349 		else
350 		{
351 			/*
352 			 * Can't send DEBUG log messages to client at this point. Since
353 			 * we're disconnecting right away, we don't need to restore
354 			 * whereToSendOutput.
355 			 */
356 			whereToSendOutput = DestNone;
357 			ereport(DEBUG1,
358 					(errcode(ERRCODE_CONNECTION_DOES_NOT_EXIST),
359 					 errmsg("unexpected EOF on client connection")));
360 		}
361 		return qtype;
362 	}
363 
364 	/*
365 	 * Validate message type code before trying to read body; if we have lost
366 	 * sync, better to say "command unknown" than to run out of memory because
367 	 * we used garbage as a length word.
368 	 *
369 	 * This also gives us a place to set the doing_extended_query_message flag
370 	 * as soon as possible.
371 	 */
372 	switch (qtype)
373 	{
374 		case 'Q':				/* simple query */
375 			doing_extended_query_message = false;
376 			if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
377 			{
378 				/* old style without length word; convert */
379 				if (pq_getstring(inBuf))
380 				{
381 					if (IsTransactionState())
382 						ereport(COMMERROR,
383 								(errcode(ERRCODE_CONNECTION_FAILURE),
384 								 errmsg("unexpected EOF on client connection with an open transaction")));
385 					else
386 					{
387 						/*
388 						 * Can't send DEBUG log messages to client at this
389 						 * point. Since we're disconnecting right away, we
390 						 * don't need to restore whereToSendOutput.
391 						 */
392 						whereToSendOutput = DestNone;
393 						ereport(DEBUG1,
394 								(errcode(ERRCODE_CONNECTION_DOES_NOT_EXIST),
395 								 errmsg("unexpected EOF on client connection")));
396 					}
397 					return EOF;
398 				}
399 			}
400 			break;
401 
402 		case 'F':				/* fastpath function call */
403 			doing_extended_query_message = false;
404 			if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
405 			{
406 				if (GetOldFunctionMessage(inBuf))
407 				{
408 					if (IsTransactionState())
409 						ereport(COMMERROR,
410 								(errcode(ERRCODE_CONNECTION_FAILURE),
411 								 errmsg("unexpected EOF on client connection with an open transaction")));
412 					else
413 					{
414 						/*
415 						 * Can't send DEBUG log messages to client at this
416 						 * point. Since we're disconnecting right away, we
417 						 * don't need to restore whereToSendOutput.
418 						 */
419 						whereToSendOutput = DestNone;
420 						ereport(DEBUG1,
421 								(errcode(ERRCODE_CONNECTION_DOES_NOT_EXIST),
422 								 errmsg("unexpected EOF on client connection")));
423 					}
424 					return EOF;
425 				}
426 			}
427 			break;
428 
429 		case 'X':				/* terminate */
430 			doing_extended_query_message = false;
431 			ignore_till_sync = false;
432 			break;
433 
434 		case 'B':				/* bind */
435 		case 'C':				/* close */
436 		case 'D':				/* describe */
437 		case 'E':				/* execute */
438 		case 'H':				/* flush */
439 		case 'P':				/* parse */
440 			doing_extended_query_message = true;
441 			/* these are only legal in protocol 3 */
442 			if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
443 				ereport(FATAL,
444 						(errcode(ERRCODE_PROTOCOL_VIOLATION),
445 						 errmsg("invalid frontend message type %d", qtype)));
446 			break;
447 
448 		case 'S':				/* sync */
449 			/* stop any active skip-till-Sync */
450 			ignore_till_sync = false;
451 			/* mark not-extended, so that a new error doesn't begin skip */
452 			doing_extended_query_message = false;
453 			/* only legal in protocol 3 */
454 			if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
455 				ereport(FATAL,
456 						(errcode(ERRCODE_PROTOCOL_VIOLATION),
457 						 errmsg("invalid frontend message type %d", qtype)));
458 			break;
459 
460 		case 'd':				/* copy data */
461 		case 'c':				/* copy done */
462 		case 'f':				/* copy fail */
463 			doing_extended_query_message = false;
464 			/* these are only legal in protocol 3 */
465 			if (PG_PROTOCOL_MAJOR(FrontendProtocol) < 3)
466 				ereport(FATAL,
467 						(errcode(ERRCODE_PROTOCOL_VIOLATION),
468 						 errmsg("invalid frontend message type %d", qtype)));
469 			break;
470 
471 		default:
472 
473 			/*
474 			 * Otherwise we got garbage from the frontend.  We treat this as
475 			 * fatal because we have probably lost message boundary sync, and
476 			 * there's no good way to recover.
477 			 */
478 			ereport(FATAL,
479 					(errcode(ERRCODE_PROTOCOL_VIOLATION),
480 					 errmsg("invalid frontend message type %d", qtype)));
481 			break;
482 	}
483 
484 	/*
485 	 * In protocol version 3, all frontend messages have a length word next
486 	 * after the type code; we can read the message contents independently of
487 	 * the type.
488 	 */
489 	if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 3)
490 	{
491 		if (pq_getmessage(inBuf, 0))
492 			return EOF;			/* suitable message already logged */
493 	}
494 	else
495 		pq_endmsgread();
496 	RESUME_CANCEL_INTERRUPTS();
497 
498 	return qtype;
499 }
500 
501 /* ----------------
502  *		ReadCommand reads a command from either the frontend or
503  *		standard input, places it in inBuf, and returns the
504  *		message type code (first byte of the message).
505  *		EOF is returned if end of file.
506  * ----------------
507  */
508 static int
ReadCommand(StringInfo inBuf)509 ReadCommand(StringInfo inBuf)
510 {
511 	int			result;
512 
513 	if (whereToSendOutput == DestRemote)
514 		result = SocketBackend(inBuf);
515 	else
516 		result = InteractiveBackend(inBuf);
517 	return result;
518 }
519 
520 /*
521  * ProcessClientReadInterrupt() - Process interrupts specific to client reads
522  *
523  * This is called just before and after low-level reads.
524  * 'blocked' is true if no data was available to read and we plan to retry,
525  * false if about to read or done reading.
526  *
527  * Must preserve errno!
528  */
529 void
ProcessClientReadInterrupt(bool blocked)530 ProcessClientReadInterrupt(bool blocked)
531 {
532 	int			save_errno = errno;
533 
534 	if (DoingCommandRead)
535 	{
536 		/* Check for general interrupts that arrived before/while reading */
537 		CHECK_FOR_INTERRUPTS();
538 
539 		/* Process sinval catchup interrupts, if any */
540 		if (catchupInterruptPending)
541 			ProcessCatchupInterrupt();
542 
543 		/* Process notify interrupts, if any */
544 		if (notifyInterruptPending)
545 			ProcessNotifyInterrupt();
546 	}
547 	else if (ProcDiePending)
548 	{
549 		/*
550 		 * We're dying.  If there is no data available to read, then it's safe
551 		 * (and sane) to handle that now.  If we haven't tried to read yet,
552 		 * make sure the process latch is set, so that if there is no data
553 		 * then we'll come back here and die.  If we're done reading, also
554 		 * make sure the process latch is set, as we might've undesirably
555 		 * cleared it while reading.
556 		 */
557 		if (blocked)
558 			CHECK_FOR_INTERRUPTS();
559 		else
560 			SetLatch(MyLatch);
561 	}
562 
563 	errno = save_errno;
564 }
565 
566 /*
567  * ProcessClientWriteInterrupt() - Process interrupts specific to client writes
568  *
569  * This is called just before and after low-level writes.
570  * 'blocked' is true if no data could be written and we plan to retry,
571  * false if about to write or done writing.
572  *
573  * Must preserve errno!
574  */
575 void
ProcessClientWriteInterrupt(bool blocked)576 ProcessClientWriteInterrupt(bool blocked)
577 {
578 	int			save_errno = errno;
579 
580 	if (ProcDiePending)
581 	{
582 		/*
583 		 * We're dying.  If it's not possible to write, then we should handle
584 		 * that immediately, else a stuck client could indefinitely delay our
585 		 * response to the signal.  If we haven't tried to write yet, make
586 		 * sure the process latch is set, so that if the write would block
587 		 * then we'll come back here and die.  If we're done writing, also
588 		 * make sure the process latch is set, as we might've undesirably
589 		 * cleared it while writing.
590 		 */
591 		if (blocked)
592 		{
593 			/*
594 			 * Don't mess with whereToSendOutput if ProcessInterrupts wouldn't
595 			 * service ProcDiePending.
596 			 */
597 			if (InterruptHoldoffCount == 0 && CritSectionCount == 0)
598 			{
599 				/*
600 				 * We don't want to send the client the error message, as a)
601 				 * that would possibly block again, and b) it would likely
602 				 * lead to loss of protocol sync because we may have already
603 				 * sent a partial protocol message.
604 				 */
605 				if (whereToSendOutput == DestRemote)
606 					whereToSendOutput = DestNone;
607 
608 				CHECK_FOR_INTERRUPTS();
609 			}
610 		}
611 		else
612 			SetLatch(MyLatch);
613 	}
614 
615 	errno = save_errno;
616 }
617 
618 /*
619  * Do raw parsing (only).
620  *
621  * A list of parsetrees (RawStmt nodes) is returned, since there might be
622  * multiple commands in the given string.
623  *
624  * NOTE: for interactive queries, it is important to keep this routine
625  * separate from the analysis & rewrite stages.  Analysis and rewriting
626  * cannot be done in an aborted transaction, since they require access to
627  * database tables.  So, we rely on the raw parser to determine whether
628  * we've seen a COMMIT or ABORT command; when we are in abort state, other
629  * commands are not processed any further than the raw parse stage.
630  */
631 List *
pg_parse_query(const char * query_string)632 pg_parse_query(const char *query_string)
633 {
634 	List	   *raw_parsetree_list;
635 
636 	TRACE_POSTGRESQL_QUERY_PARSE_START(query_string);
637 
638 	if (log_parser_stats)
639 		ResetUsage();
640 
641 	raw_parsetree_list = raw_parser(query_string);
642 
643 	if (log_parser_stats)
644 		ShowUsage("PARSER STATISTICS");
645 
646 #ifdef COPY_PARSE_PLAN_TREES
647 	/* Optional debugging check: pass raw parsetrees through copyObject() */
648 	{
649 		List	   *new_list = copyObject(raw_parsetree_list);
650 
651 		/* This checks both copyObject() and the equal() routines... */
652 		if (!equal(new_list, raw_parsetree_list))
653 			elog(WARNING, "copyObject() failed to produce an equal raw parse tree");
654 		else
655 			raw_parsetree_list = new_list;
656 	}
657 #endif
658 
659 	/*
660 	 * Currently, outfuncs/readfuncs support is missing for many raw parse
661 	 * tree nodes, so we don't try to implement WRITE_READ_PARSE_PLAN_TREES
662 	 * here.
663 	 */
664 
665 	TRACE_POSTGRESQL_QUERY_PARSE_DONE(query_string);
666 
667 	return raw_parsetree_list;
668 }
669 
670 /*
671  * Given a raw parsetree (gram.y output), and optionally information about
672  * types of parameter symbols ($n), perform parse analysis and rule rewriting.
673  *
674  * A list of Query nodes is returned, since either the analyzer or the
675  * rewriter might expand one query to several.
676  *
677  * NOTE: for reasons mentioned above, this must be separate from raw parsing.
678  */
679 List *
pg_analyze_and_rewrite(RawStmt * parsetree,const char * query_string,Oid * paramTypes,int numParams,QueryEnvironment * queryEnv)680 pg_analyze_and_rewrite(RawStmt *parsetree, const char *query_string,
681 					   Oid *paramTypes, int numParams,
682 					   QueryEnvironment *queryEnv)
683 {
684 	Query	   *query;
685 	List	   *querytree_list;
686 
687 	TRACE_POSTGRESQL_QUERY_REWRITE_START(query_string);
688 
689 	/*
690 	 * (1) Perform parse analysis.
691 	 */
692 	if (log_parser_stats)
693 		ResetUsage();
694 
695 	query = parse_analyze(parsetree, query_string, paramTypes, numParams,
696 						  queryEnv);
697 
698 	if (log_parser_stats)
699 		ShowUsage("PARSE ANALYSIS STATISTICS");
700 
701 	/*
702 	 * (2) Rewrite the queries, as necessary
703 	 */
704 	querytree_list = pg_rewrite_query(query);
705 
706 	TRACE_POSTGRESQL_QUERY_REWRITE_DONE(query_string);
707 
708 	return querytree_list;
709 }
710 
711 /*
712  * Do parse analysis and rewriting.  This is the same as pg_analyze_and_rewrite
713  * except that external-parameter resolution is determined by parser callback
714  * hooks instead of a fixed list of parameter datatypes.
715  */
716 List *
pg_analyze_and_rewrite_params(RawStmt * parsetree,const char * query_string,ParserSetupHook parserSetup,void * parserSetupArg,QueryEnvironment * queryEnv)717 pg_analyze_and_rewrite_params(RawStmt *parsetree,
718 							  const char *query_string,
719 							  ParserSetupHook parserSetup,
720 							  void *parserSetupArg,
721 							  QueryEnvironment *queryEnv)
722 {
723 	ParseState *pstate;
724 	Query	   *query;
725 	List	   *querytree_list;
726 
727 	Assert(query_string != NULL);	/* required as of 8.4 */
728 
729 	TRACE_POSTGRESQL_QUERY_REWRITE_START(query_string);
730 
731 	/*
732 	 * (1) Perform parse analysis.
733 	 */
734 	if (log_parser_stats)
735 		ResetUsage();
736 
737 	pstate = make_parsestate(NULL);
738 	pstate->p_sourcetext = query_string;
739 	pstate->p_queryEnv = queryEnv;
740 	(*parserSetup) (pstate, parserSetupArg);
741 
742 	query = transformTopLevelStmt(pstate, parsetree);
743 
744 	if (post_parse_analyze_hook)
745 		(*post_parse_analyze_hook) (pstate, query);
746 
747 	free_parsestate(pstate);
748 
749 	if (log_parser_stats)
750 		ShowUsage("PARSE ANALYSIS STATISTICS");
751 
752 	/*
753 	 * (2) Rewrite the queries, as necessary
754 	 */
755 	querytree_list = pg_rewrite_query(query);
756 
757 	TRACE_POSTGRESQL_QUERY_REWRITE_DONE(query_string);
758 
759 	return querytree_list;
760 }
761 
762 /*
763  * Perform rewriting of a query produced by parse analysis.
764  *
765  * Note: query must just have come from the parser, because we do not do
766  * AcquireRewriteLocks() on it.
767  */
768 static List *
pg_rewrite_query(Query * query)769 pg_rewrite_query(Query *query)
770 {
771 	List	   *querytree_list;
772 
773 	if (Debug_print_parse)
774 		elog_node_display(LOG, "parse tree", query,
775 						  Debug_pretty_print);
776 
777 	if (log_parser_stats)
778 		ResetUsage();
779 
780 	if (query->commandType == CMD_UTILITY)
781 	{
782 		/* don't rewrite utilities, just dump 'em into result list */
783 		querytree_list = list_make1(query);
784 	}
785 	else
786 	{
787 		/* rewrite regular queries */
788 		querytree_list = QueryRewrite(query);
789 	}
790 
791 	if (log_parser_stats)
792 		ShowUsage("REWRITER STATISTICS");
793 
794 #ifdef COPY_PARSE_PLAN_TREES
795 	/* Optional debugging check: pass querytree through copyObject() */
796 	{
797 		List	   *new_list;
798 
799 		new_list = copyObject(querytree_list);
800 		/* This checks both copyObject() and the equal() routines... */
801 		if (!equal(new_list, querytree_list))
802 			elog(WARNING, "copyObject() failed to produce equal parse tree");
803 		else
804 			querytree_list = new_list;
805 	}
806 #endif
807 
808 #ifdef WRITE_READ_PARSE_PLAN_TREES
809 	/* Optional debugging check: pass querytree through outfuncs/readfuncs */
810 	{
811 		List	   *new_list = NIL;
812 		ListCell   *lc;
813 
814 		/*
815 		 * We currently lack outfuncs/readfuncs support for most utility
816 		 * statement types, so only attempt to write/read non-utility queries.
817 		 */
818 		foreach(lc, querytree_list)
819 		{
820 			Query	   *query = castNode(Query, lfirst(lc));
821 
822 			if (query->commandType != CMD_UTILITY)
823 			{
824 				char	   *str = nodeToString(query);
825 				Query	   *new_query = stringToNodeWithLocations(str);
826 
827 				/*
828 				 * queryId is not saved in stored rules, but we must preserve
829 				 * it here to avoid breaking pg_stat_statements.
830 				 */
831 				new_query->queryId = query->queryId;
832 
833 				new_list = lappend(new_list, new_query);
834 				pfree(str);
835 			}
836 			else
837 				new_list = lappend(new_list, query);
838 		}
839 
840 		/* This checks both outfuncs/readfuncs and the equal() routines... */
841 		if (!equal(new_list, querytree_list))
842 			elog(WARNING, "outfuncs/readfuncs failed to produce equal parse tree");
843 		else
844 			querytree_list = new_list;
845 	}
846 #endif
847 
848 	if (Debug_print_rewritten)
849 		elog_node_display(LOG, "rewritten parse tree", querytree_list,
850 						  Debug_pretty_print);
851 
852 	return querytree_list;
853 }
854 
855 
856 /*
857  * Generate a plan for a single already-rewritten query.
858  * This is a thin wrapper around planner() and takes the same parameters.
859  */
860 PlannedStmt *
pg_plan_query(Query * querytree,int cursorOptions,ParamListInfo boundParams)861 pg_plan_query(Query *querytree, int cursorOptions, ParamListInfo boundParams)
862 {
863 	PlannedStmt *plan;
864 
865 	/* Utility commands have no plans. */
866 	if (querytree->commandType == CMD_UTILITY)
867 		return NULL;
868 
869 	/* Planner must have a snapshot in case it calls user-defined functions. */
870 	Assert(ActiveSnapshotSet());
871 
872 	TRACE_POSTGRESQL_QUERY_PLAN_START();
873 
874 	if (log_planner_stats)
875 		ResetUsage();
876 
877 	/* call the optimizer */
878 	plan = planner(querytree, cursorOptions, boundParams);
879 
880 	if (log_planner_stats)
881 		ShowUsage("PLANNER STATISTICS");
882 
883 #ifdef COPY_PARSE_PLAN_TREES
884 	/* Optional debugging check: pass plan tree through copyObject() */
885 	{
886 		PlannedStmt *new_plan = copyObject(plan);
887 
888 		/*
889 		 * equal() currently does not have routines to compare Plan nodes, so
890 		 * don't try to test equality here.  Perhaps fix someday?
891 		 */
892 #ifdef NOT_USED
893 		/* This checks both copyObject() and the equal() routines... */
894 		if (!equal(new_plan, plan))
895 			elog(WARNING, "copyObject() failed to produce an equal plan tree");
896 		else
897 #endif
898 			plan = new_plan;
899 	}
900 #endif
901 
902 #ifdef WRITE_READ_PARSE_PLAN_TREES
903 	/* Optional debugging check: pass plan tree through outfuncs/readfuncs */
904 	{
905 		char	   *str;
906 		PlannedStmt *new_plan;
907 
908 		str = nodeToString(plan);
909 		new_plan = stringToNodeWithLocations(str);
910 		pfree(str);
911 
912 		/*
913 		 * equal() currently does not have routines to compare Plan nodes, so
914 		 * don't try to test equality here.  Perhaps fix someday?
915 		 */
916 #ifdef NOT_USED
917 		/* This checks both outfuncs/readfuncs and the equal() routines... */
918 		if (!equal(new_plan, plan))
919 			elog(WARNING, "outfuncs/readfuncs failed to produce an equal plan tree");
920 		else
921 #endif
922 			plan = new_plan;
923 	}
924 #endif
925 
926 	/*
927 	 * Print plan if debugging.
928 	 */
929 	if (Debug_print_plan)
930 		elog_node_display(LOG, "plan", plan, Debug_pretty_print);
931 
932 	TRACE_POSTGRESQL_QUERY_PLAN_DONE();
933 
934 	return plan;
935 }
936 
937 /*
938  * Generate plans for a list of already-rewritten queries.
939  *
940  * For normal optimizable statements, invoke the planner.  For utility
941  * statements, just make a wrapper PlannedStmt node.
942  *
943  * The result is a list of PlannedStmt nodes.
944  */
945 List *
pg_plan_queries(List * querytrees,int cursorOptions,ParamListInfo boundParams)946 pg_plan_queries(List *querytrees, int cursorOptions, ParamListInfo boundParams)
947 {
948 	List	   *stmt_list = NIL;
949 	ListCell   *query_list;
950 
951 	foreach(query_list, querytrees)
952 	{
953 		Query	   *query = lfirst_node(Query, query_list);
954 		PlannedStmt *stmt;
955 
956 		if (query->commandType == CMD_UTILITY)
957 		{
958 			/* Utility commands require no planning. */
959 			stmt = makeNode(PlannedStmt);
960 			stmt->commandType = CMD_UTILITY;
961 			stmt->canSetTag = query->canSetTag;
962 			stmt->utilityStmt = query->utilityStmt;
963 			stmt->stmt_location = query->stmt_location;
964 			stmt->stmt_len = query->stmt_len;
965 		}
966 		else
967 		{
968 			stmt = pg_plan_query(query, cursorOptions, boundParams);
969 		}
970 
971 		stmt_list = lappend(stmt_list, stmt);
972 	}
973 
974 	return stmt_list;
975 }
976 
977 
978 /*
979  * exec_simple_query
980  *
981  * Execute a "simple Query" protocol message.
982  */
983 static void
exec_simple_query(const char * query_string)984 exec_simple_query(const char *query_string)
985 {
986 	CommandDest dest = whereToSendOutput;
987 	MemoryContext oldcontext;
988 	List	   *parsetree_list;
989 	ListCell   *parsetree_item;
990 	bool		save_log_statement_stats = log_statement_stats;
991 	bool		was_logged = false;
992 	bool		use_implicit_block;
993 	char		msec_str[32];
994 
995 	/*
996 	 * Report query to various monitoring facilities.
997 	 */
998 	debug_query_string = query_string;
999 
1000 	pgstat_report_activity(STATE_RUNNING, query_string);
1001 
1002 	TRACE_POSTGRESQL_QUERY_START(query_string);
1003 
1004 	/*
1005 	 * We use save_log_statement_stats so ShowUsage doesn't report incorrect
1006 	 * results because ResetUsage wasn't called.
1007 	 */
1008 	if (save_log_statement_stats)
1009 		ResetUsage();
1010 
1011 	/*
1012 	 * Start up a transaction command.  All queries generated by the
1013 	 * query_string will be in this same command block, *unless* we find a
1014 	 * BEGIN/COMMIT/ABORT statement; we have to force a new xact command after
1015 	 * one of those, else bad things will happen in xact.c. (Note that this
1016 	 * will normally change current memory context.)
1017 	 */
1018 	start_xact_command();
1019 
1020 	/*
1021 	 * Zap any pre-existing unnamed statement.  (While not strictly necessary,
1022 	 * it seems best to define simple-Query mode as if it used the unnamed
1023 	 * statement and portal; this ensures we recover any storage used by prior
1024 	 * unnamed operations.)
1025 	 */
1026 	drop_unnamed_stmt();
1027 
1028 	/*
1029 	 * Switch to appropriate context for constructing parsetrees.
1030 	 */
1031 	oldcontext = MemoryContextSwitchTo(MessageContext);
1032 
1033 	/*
1034 	 * Do basic parsing of the query or queries (this should be safe even if
1035 	 * we are in aborted transaction state!)
1036 	 */
1037 	parsetree_list = pg_parse_query(query_string);
1038 
1039 	/* Log immediately if dictated by log_statement */
1040 	if (check_log_statement(parsetree_list))
1041 	{
1042 		ereport(LOG,
1043 				(errmsg("statement: %s", query_string),
1044 				 errhidestmt(true),
1045 				 errdetail_execute(parsetree_list)));
1046 		was_logged = true;
1047 	}
1048 
1049 	/*
1050 	 * Switch back to transaction context to enter the loop.
1051 	 */
1052 	MemoryContextSwitchTo(oldcontext);
1053 
1054 	/*
1055 	 * For historical reasons, if multiple SQL statements are given in a
1056 	 * single "simple Query" message, we execute them as a single transaction,
1057 	 * unless explicit transaction control commands are included to make
1058 	 * portions of the list be separate transactions.  To represent this
1059 	 * behavior properly in the transaction machinery, we use an "implicit"
1060 	 * transaction block.
1061 	 */
1062 	use_implicit_block = (list_length(parsetree_list) > 1);
1063 
1064 	/*
1065 	 * Run through the raw parsetree(s) and process each one.
1066 	 */
1067 	foreach(parsetree_item, parsetree_list)
1068 	{
1069 		RawStmt    *parsetree = lfirst_node(RawStmt, parsetree_item);
1070 		bool		snapshot_set = false;
1071 		const char *commandTag;
1072 		char		completionTag[COMPLETION_TAG_BUFSIZE];
1073 		List	   *querytree_list,
1074 				   *plantree_list;
1075 		Portal		portal;
1076 		DestReceiver *receiver;
1077 		int16		format;
1078 
1079 		/*
1080 		 * Get the command name for use in status display (it also becomes the
1081 		 * default completion tag, down inside PortalRun).  Set ps_status and
1082 		 * do any special start-of-SQL-command processing needed by the
1083 		 * destination.
1084 		 */
1085 		commandTag = CreateCommandTag(parsetree->stmt);
1086 
1087 		set_ps_display(commandTag, false);
1088 
1089 		BeginCommand(commandTag, dest);
1090 
1091 		/*
1092 		 * If we are in an aborted transaction, reject all commands except
1093 		 * COMMIT/ABORT.  It is important that this test occur before we try
1094 		 * to do parse analysis, rewrite, or planning, since all those phases
1095 		 * try to do database accesses, which may fail in abort state. (It
1096 		 * might be safe to allow some additional utility commands in this
1097 		 * state, but not many...)
1098 		 */
1099 		if (IsAbortedTransactionBlockState() &&
1100 			!IsTransactionExitStmt(parsetree->stmt))
1101 			ereport(ERROR,
1102 					(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
1103 					 errmsg("current transaction is aborted, "
1104 							"commands ignored until end of transaction block"),
1105 					 errdetail_abort()));
1106 
1107 		/* Make sure we are in a transaction command */
1108 		start_xact_command();
1109 
1110 		/*
1111 		 * If using an implicit transaction block, and we're not already in a
1112 		 * transaction block, start an implicit block to force this statement
1113 		 * to be grouped together with any following ones.  (We must do this
1114 		 * each time through the loop; otherwise, a COMMIT/ROLLBACK in the
1115 		 * list would cause later statements to not be grouped.)
1116 		 */
1117 		if (use_implicit_block)
1118 			BeginImplicitTransactionBlock();
1119 
1120 		/* If we got a cancel signal in parsing or prior command, quit */
1121 		CHECK_FOR_INTERRUPTS();
1122 
1123 		/*
1124 		 * Set up a snapshot if parse analysis/planning will need one.
1125 		 */
1126 		if (analyze_requires_snapshot(parsetree))
1127 		{
1128 			PushActiveSnapshot(GetTransactionSnapshot());
1129 			snapshot_set = true;
1130 		}
1131 
1132 		/*
1133 		 * OK to analyze, rewrite, and plan this query.
1134 		 *
1135 		 * Switch to appropriate context for constructing querytrees (again,
1136 		 * these must outlive the execution context).
1137 		 */
1138 		oldcontext = MemoryContextSwitchTo(MessageContext);
1139 
1140 		querytree_list = pg_analyze_and_rewrite(parsetree, query_string,
1141 												NULL, 0, NULL);
1142 
1143 		plantree_list = pg_plan_queries(querytree_list,
1144 										CURSOR_OPT_PARALLEL_OK, NULL);
1145 
1146 		/* Done with the snapshot used for parsing/planning */
1147 		if (snapshot_set)
1148 			PopActiveSnapshot();
1149 
1150 		/* If we got a cancel signal in analysis or planning, quit */
1151 		CHECK_FOR_INTERRUPTS();
1152 
1153 		/*
1154 		 * Create unnamed portal to run the query or queries in. If there
1155 		 * already is one, silently drop it.
1156 		 */
1157 		portal = CreatePortal("", true, true);
1158 		/* Don't display the portal in pg_cursors */
1159 		portal->visible = false;
1160 
1161 		/*
1162 		 * We don't have to copy anything into the portal, because everything
1163 		 * we are passing here is in MessageContext, which will outlive the
1164 		 * portal anyway.
1165 		 */
1166 		PortalDefineQuery(portal,
1167 						  NULL,
1168 						  query_string,
1169 						  commandTag,
1170 						  plantree_list,
1171 						  NULL);
1172 
1173 		/*
1174 		 * Start the portal.  No parameters here.
1175 		 */
1176 		PortalStart(portal, NULL, 0, InvalidSnapshot);
1177 
1178 		/*
1179 		 * Select the appropriate output format: text unless we are doing a
1180 		 * FETCH from a binary cursor.  (Pretty grotty to have to do this here
1181 		 * --- but it avoids grottiness in other places.  Ah, the joys of
1182 		 * backward compatibility...)
1183 		 */
1184 		format = 0;				/* TEXT is default */
1185 		if (IsA(parsetree->stmt, FetchStmt))
1186 		{
1187 			FetchStmt  *stmt = (FetchStmt *) parsetree->stmt;
1188 
1189 			if (!stmt->ismove)
1190 			{
1191 				Portal		fportal = GetPortalByName(stmt->portalname);
1192 
1193 				if (PortalIsValid(fportal) &&
1194 					(fportal->cursorOptions & CURSOR_OPT_BINARY))
1195 					format = 1; /* BINARY */
1196 			}
1197 		}
1198 		PortalSetResultFormat(portal, 1, &format);
1199 
1200 		/*
1201 		 * Now we can create the destination receiver object.
1202 		 */
1203 		receiver = CreateDestReceiver(dest);
1204 		if (dest == DestRemote)
1205 			SetRemoteDestReceiverParams(receiver, portal);
1206 
1207 		/*
1208 		 * Switch back to transaction context for execution.
1209 		 */
1210 		MemoryContextSwitchTo(oldcontext);
1211 
1212 		/*
1213 		 * Run the portal to completion, and then drop it (and the receiver).
1214 		 */
1215 		(void) PortalRun(portal,
1216 						 FETCH_ALL,
1217 						 true,	/* always top level */
1218 						 true,
1219 						 receiver,
1220 						 receiver,
1221 						 completionTag);
1222 
1223 		receiver->rDestroy(receiver);
1224 
1225 		PortalDrop(portal, false);
1226 
1227 		if (lnext(parsetree_item) == NULL)
1228 		{
1229 			/*
1230 			 * If this is the last parsetree of the query string, close down
1231 			 * transaction statement before reporting command-complete.  This
1232 			 * is so that any end-of-transaction errors are reported before
1233 			 * the command-complete message is issued, to avoid confusing
1234 			 * clients who will expect either a command-complete message or an
1235 			 * error, not one and then the other.  Also, if we're using an
1236 			 * implicit transaction block, we must close that out first.
1237 			 */
1238 			if (use_implicit_block)
1239 				EndImplicitTransactionBlock();
1240 			finish_xact_command();
1241 		}
1242 		else if (IsA(parsetree->stmt, TransactionStmt))
1243 		{
1244 			/*
1245 			 * If this was a transaction control statement, commit it. We will
1246 			 * start a new xact command for the next command.
1247 			 */
1248 			finish_xact_command();
1249 		}
1250 		else
1251 		{
1252 			/*
1253 			 * We need a CommandCounterIncrement after every query, except
1254 			 * those that start or end a transaction block.
1255 			 */
1256 			CommandCounterIncrement();
1257 		}
1258 
1259 		/*
1260 		 * Tell client that we're done with this query.  Note we emit exactly
1261 		 * one EndCommand report for each raw parsetree, thus one for each SQL
1262 		 * command the client sent, regardless of rewriting. (But a command
1263 		 * aborted by error will not send an EndCommand report at all.)
1264 		 */
1265 		EndCommand(completionTag, dest);
1266 	}							/* end loop over parsetrees */
1267 
1268 	/*
1269 	 * Close down transaction statement, if one is open.  (This will only do
1270 	 * something if the parsetree list was empty; otherwise the last loop
1271 	 * iteration already did it.)
1272 	 */
1273 	finish_xact_command();
1274 
1275 	/*
1276 	 * If there were no parsetrees, return EmptyQueryResponse message.
1277 	 */
1278 	if (!parsetree_list)
1279 		NullCommand(dest);
1280 
1281 	/*
1282 	 * Emit duration logging if appropriate.
1283 	 */
1284 	switch (check_log_duration(msec_str, was_logged))
1285 	{
1286 		case 1:
1287 			ereport(LOG,
1288 					(errmsg("duration: %s ms", msec_str),
1289 					 errhidestmt(true)));
1290 			break;
1291 		case 2:
1292 			ereport(LOG,
1293 					(errmsg("duration: %s ms  statement: %s",
1294 							msec_str, query_string),
1295 					 errhidestmt(true),
1296 					 errdetail_execute(parsetree_list)));
1297 			break;
1298 	}
1299 
1300 	if (save_log_statement_stats)
1301 		ShowUsage("QUERY STATISTICS");
1302 
1303 	TRACE_POSTGRESQL_QUERY_DONE(query_string);
1304 
1305 	debug_query_string = NULL;
1306 }
1307 
1308 /*
1309  * exec_parse_message
1310  *
1311  * Execute a "Parse" protocol message.
1312  */
1313 static void
exec_parse_message(const char * query_string,const char * stmt_name,Oid * paramTypes,int numParams)1314 exec_parse_message(const char *query_string,	/* string to execute */
1315 				   const char *stmt_name,	/* name for prepared stmt */
1316 				   Oid *paramTypes, /* parameter types */
1317 				   int numParams)	/* number of parameters */
1318 {
1319 	MemoryContext unnamed_stmt_context = NULL;
1320 	MemoryContext oldcontext;
1321 	List	   *parsetree_list;
1322 	RawStmt    *raw_parse_tree;
1323 	const char *commandTag;
1324 	List	   *querytree_list;
1325 	CachedPlanSource *psrc;
1326 	bool		is_named;
1327 	bool		save_log_statement_stats = log_statement_stats;
1328 	char		msec_str[32];
1329 
1330 	/*
1331 	 * Report query to various monitoring facilities.
1332 	 */
1333 	debug_query_string = query_string;
1334 
1335 	pgstat_report_activity(STATE_RUNNING, query_string);
1336 
1337 	set_ps_display("PARSE", false);
1338 
1339 	if (save_log_statement_stats)
1340 		ResetUsage();
1341 
1342 	ereport(DEBUG2,
1343 			(errmsg("parse %s: %s",
1344 					*stmt_name ? stmt_name : "<unnamed>",
1345 					query_string)));
1346 
1347 	/*
1348 	 * Start up a transaction command so we can run parse analysis etc. (Note
1349 	 * that this will normally change current memory context.) Nothing happens
1350 	 * if we are already in one.  This also arms the statement timeout if
1351 	 * necessary.
1352 	 */
1353 	start_xact_command();
1354 
1355 	/*
1356 	 * Switch to appropriate context for constructing parsetrees.
1357 	 *
1358 	 * We have two strategies depending on whether the prepared statement is
1359 	 * named or not.  For a named prepared statement, we do parsing in
1360 	 * MessageContext and copy the finished trees into the prepared
1361 	 * statement's plancache entry; then the reset of MessageContext releases
1362 	 * temporary space used by parsing and rewriting. For an unnamed prepared
1363 	 * statement, we assume the statement isn't going to hang around long, so
1364 	 * getting rid of temp space quickly is probably not worth the costs of
1365 	 * copying parse trees.  So in this case, we create the plancache entry's
1366 	 * query_context here, and do all the parsing work therein.
1367 	 */
1368 	is_named = (stmt_name[0] != '\0');
1369 	if (is_named)
1370 	{
1371 		/* Named prepared statement --- parse in MessageContext */
1372 		oldcontext = MemoryContextSwitchTo(MessageContext);
1373 	}
1374 	else
1375 	{
1376 		/* Unnamed prepared statement --- release any prior unnamed stmt */
1377 		drop_unnamed_stmt();
1378 		/* Create context for parsing */
1379 		unnamed_stmt_context =
1380 			AllocSetContextCreate(MessageContext,
1381 								  "unnamed prepared statement",
1382 								  ALLOCSET_DEFAULT_SIZES);
1383 		oldcontext = MemoryContextSwitchTo(unnamed_stmt_context);
1384 	}
1385 
1386 	/*
1387 	 * Do basic parsing of the query or queries (this should be safe even if
1388 	 * we are in aborted transaction state!)
1389 	 */
1390 	parsetree_list = pg_parse_query(query_string);
1391 
1392 	/*
1393 	 * We only allow a single user statement in a prepared statement. This is
1394 	 * mainly to keep the protocol simple --- otherwise we'd need to worry
1395 	 * about multiple result tupdescs and things like that.
1396 	 */
1397 	if (list_length(parsetree_list) > 1)
1398 		ereport(ERROR,
1399 				(errcode(ERRCODE_SYNTAX_ERROR),
1400 				 errmsg("cannot insert multiple commands into a prepared statement")));
1401 
1402 	if (parsetree_list != NIL)
1403 	{
1404 		Query	   *query;
1405 		bool		snapshot_set = false;
1406 
1407 		raw_parse_tree = linitial_node(RawStmt, parsetree_list);
1408 
1409 		/*
1410 		 * Get the command name for possible use in status display.
1411 		 */
1412 		commandTag = CreateCommandTag(raw_parse_tree->stmt);
1413 
1414 		/*
1415 		 * If we are in an aborted transaction, reject all commands except
1416 		 * COMMIT/ROLLBACK.  It is important that this test occur before we
1417 		 * try to do parse analysis, rewrite, or planning, since all those
1418 		 * phases try to do database accesses, which may fail in abort state.
1419 		 * (It might be safe to allow some additional utility commands in this
1420 		 * state, but not many...)
1421 		 */
1422 		if (IsAbortedTransactionBlockState() &&
1423 			!IsTransactionExitStmt(raw_parse_tree->stmt))
1424 			ereport(ERROR,
1425 					(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
1426 					 errmsg("current transaction is aborted, "
1427 							"commands ignored until end of transaction block"),
1428 					 errdetail_abort()));
1429 
1430 		/*
1431 		 * Create the CachedPlanSource before we do parse analysis, since it
1432 		 * needs to see the unmodified raw parse tree.
1433 		 */
1434 		psrc = CreateCachedPlan(raw_parse_tree, query_string, commandTag);
1435 
1436 		/*
1437 		 * Set up a snapshot if parse analysis will need one.
1438 		 */
1439 		if (analyze_requires_snapshot(raw_parse_tree))
1440 		{
1441 			PushActiveSnapshot(GetTransactionSnapshot());
1442 			snapshot_set = true;
1443 		}
1444 
1445 		/*
1446 		 * Analyze and rewrite the query.  Note that the originally specified
1447 		 * parameter set is not required to be complete, so we have to use
1448 		 * parse_analyze_varparams().
1449 		 */
1450 		if (log_parser_stats)
1451 			ResetUsage();
1452 
1453 		query = parse_analyze_varparams(raw_parse_tree,
1454 										query_string,
1455 										&paramTypes,
1456 										&numParams);
1457 
1458 		/*
1459 		 * Check all parameter types got determined.
1460 		 */
1461 		for (int i = 0; i < numParams; i++)
1462 		{
1463 			Oid			ptype = paramTypes[i];
1464 
1465 			if (ptype == InvalidOid || ptype == UNKNOWNOID)
1466 				ereport(ERROR,
1467 						(errcode(ERRCODE_INDETERMINATE_DATATYPE),
1468 						 errmsg("could not determine data type of parameter $%d",
1469 								i + 1)));
1470 		}
1471 
1472 		if (log_parser_stats)
1473 			ShowUsage("PARSE ANALYSIS STATISTICS");
1474 
1475 		querytree_list = pg_rewrite_query(query);
1476 
1477 		/* Done with the snapshot used for parsing */
1478 		if (snapshot_set)
1479 			PopActiveSnapshot();
1480 	}
1481 	else
1482 	{
1483 		/* Empty input string.  This is legal. */
1484 		raw_parse_tree = NULL;
1485 		commandTag = NULL;
1486 		psrc = CreateCachedPlan(raw_parse_tree, query_string, commandTag);
1487 		querytree_list = NIL;
1488 	}
1489 
1490 	/*
1491 	 * CachedPlanSource must be a direct child of MessageContext before we
1492 	 * reparent unnamed_stmt_context under it, else we have a disconnected
1493 	 * circular subgraph.  Klugy, but less so than flipping contexts even more
1494 	 * above.
1495 	 */
1496 	if (unnamed_stmt_context)
1497 		MemoryContextSetParent(psrc->context, MessageContext);
1498 
1499 	/* Finish filling in the CachedPlanSource */
1500 	CompleteCachedPlan(psrc,
1501 					   querytree_list,
1502 					   unnamed_stmt_context,
1503 					   paramTypes,
1504 					   numParams,
1505 					   NULL,
1506 					   NULL,
1507 					   CURSOR_OPT_PARALLEL_OK,	/* allow parallel mode */
1508 					   true);	/* fixed result */
1509 
1510 	/* If we got a cancel signal during analysis, quit */
1511 	CHECK_FOR_INTERRUPTS();
1512 
1513 	if (is_named)
1514 	{
1515 		/*
1516 		 * Store the query as a prepared statement.
1517 		 */
1518 		StorePreparedStatement(stmt_name, psrc, false);
1519 	}
1520 	else
1521 	{
1522 		/*
1523 		 * We just save the CachedPlanSource into unnamed_stmt_psrc.
1524 		 */
1525 		SaveCachedPlan(psrc);
1526 		unnamed_stmt_psrc = psrc;
1527 	}
1528 
1529 	MemoryContextSwitchTo(oldcontext);
1530 
1531 	/*
1532 	 * We do NOT close the open transaction command here; that only happens
1533 	 * when the client sends Sync.  Instead, do CommandCounterIncrement just
1534 	 * in case something happened during parse/plan.
1535 	 */
1536 	CommandCounterIncrement();
1537 
1538 	/*
1539 	 * Send ParseComplete.
1540 	 */
1541 	if (whereToSendOutput == DestRemote)
1542 		pq_putemptymessage('1');
1543 
1544 	/*
1545 	 * Emit duration logging if appropriate.
1546 	 */
1547 	switch (check_log_duration(msec_str, false))
1548 	{
1549 		case 1:
1550 			ereport(LOG,
1551 					(errmsg("duration: %s ms", msec_str),
1552 					 errhidestmt(true)));
1553 			break;
1554 		case 2:
1555 			ereport(LOG,
1556 					(errmsg("duration: %s ms  parse %s: %s",
1557 							msec_str,
1558 							*stmt_name ? stmt_name : "<unnamed>",
1559 							query_string),
1560 					 errhidestmt(true)));
1561 			break;
1562 	}
1563 
1564 	if (save_log_statement_stats)
1565 		ShowUsage("PARSE MESSAGE STATISTICS");
1566 
1567 	debug_query_string = NULL;
1568 }
1569 
1570 /*
1571  * exec_bind_message
1572  *
1573  * Process a "Bind" message to create a portal from a prepared statement
1574  */
1575 static void
exec_bind_message(StringInfo input_message)1576 exec_bind_message(StringInfo input_message)
1577 {
1578 	const char *portal_name;
1579 	const char *stmt_name;
1580 	int			numPFormats;
1581 	int16	   *pformats = NULL;
1582 	int			numParams;
1583 	int			numRFormats;
1584 	int16	   *rformats = NULL;
1585 	CachedPlanSource *psrc;
1586 	CachedPlan *cplan;
1587 	Portal		portal;
1588 	char	   *query_string;
1589 	char	   *saved_stmt_name;
1590 	ParamListInfo params;
1591 	MemoryContext oldContext;
1592 	bool		save_log_statement_stats = log_statement_stats;
1593 	bool		snapshot_set = false;
1594 	char		msec_str[32];
1595 
1596 	/* Get the fixed part of the message */
1597 	portal_name = pq_getmsgstring(input_message);
1598 	stmt_name = pq_getmsgstring(input_message);
1599 
1600 	ereport(DEBUG2,
1601 			(errmsg("bind %s to %s",
1602 					*portal_name ? portal_name : "<unnamed>",
1603 					*stmt_name ? stmt_name : "<unnamed>")));
1604 
1605 	/* Find prepared statement */
1606 	if (stmt_name[0] != '\0')
1607 	{
1608 		PreparedStatement *pstmt;
1609 
1610 		pstmt = FetchPreparedStatement(stmt_name, true);
1611 		psrc = pstmt->plansource;
1612 	}
1613 	else
1614 	{
1615 		/* special-case the unnamed statement */
1616 		psrc = unnamed_stmt_psrc;
1617 		if (!psrc)
1618 			ereport(ERROR,
1619 					(errcode(ERRCODE_UNDEFINED_PSTATEMENT),
1620 					 errmsg("unnamed prepared statement does not exist")));
1621 	}
1622 
1623 	/*
1624 	 * Report query to various monitoring facilities.
1625 	 */
1626 	debug_query_string = psrc->query_string;
1627 
1628 	pgstat_report_activity(STATE_RUNNING, psrc->query_string);
1629 
1630 	set_ps_display("BIND", false);
1631 
1632 	if (save_log_statement_stats)
1633 		ResetUsage();
1634 
1635 	/*
1636 	 * Start up a transaction command so we can call functions etc. (Note that
1637 	 * this will normally change current memory context.) Nothing happens if
1638 	 * we are already in one.  This also arms the statement timeout if
1639 	 * necessary.
1640 	 */
1641 	start_xact_command();
1642 
1643 	/* Switch back to message context */
1644 	MemoryContextSwitchTo(MessageContext);
1645 
1646 	/* Get the parameter format codes */
1647 	numPFormats = pq_getmsgint(input_message, 2);
1648 	if (numPFormats > 0)
1649 	{
1650 		pformats = (int16 *) palloc(numPFormats * sizeof(int16));
1651 		for (int i = 0; i < numPFormats; i++)
1652 			pformats[i] = pq_getmsgint(input_message, 2);
1653 	}
1654 
1655 	/* Get the parameter value count */
1656 	numParams = pq_getmsgint(input_message, 2);
1657 
1658 	if (numPFormats > 1 && numPFormats != numParams)
1659 		ereport(ERROR,
1660 				(errcode(ERRCODE_PROTOCOL_VIOLATION),
1661 				 errmsg("bind message has %d parameter formats but %d parameters",
1662 						numPFormats, numParams)));
1663 
1664 	if (numParams != psrc->num_params)
1665 		ereport(ERROR,
1666 				(errcode(ERRCODE_PROTOCOL_VIOLATION),
1667 				 errmsg("bind message supplies %d parameters, but prepared statement \"%s\" requires %d",
1668 						numParams, stmt_name, psrc->num_params)));
1669 
1670 	/*
1671 	 * If we are in aborted transaction state, the only portals we can
1672 	 * actually run are those containing COMMIT or ROLLBACK commands. We
1673 	 * disallow binding anything else to avoid problems with infrastructure
1674 	 * that expects to run inside a valid transaction.  We also disallow
1675 	 * binding any parameters, since we can't risk calling user-defined I/O
1676 	 * functions.
1677 	 */
1678 	if (IsAbortedTransactionBlockState() &&
1679 		(!(psrc->raw_parse_tree &&
1680 		   IsTransactionExitStmt(psrc->raw_parse_tree->stmt)) ||
1681 		 numParams != 0))
1682 		ereport(ERROR,
1683 				(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
1684 				 errmsg("current transaction is aborted, "
1685 						"commands ignored until end of transaction block"),
1686 				 errdetail_abort()));
1687 
1688 	/*
1689 	 * Create the portal.  Allow silent replacement of an existing portal only
1690 	 * if the unnamed portal is specified.
1691 	 */
1692 	if (portal_name[0] == '\0')
1693 		portal = CreatePortal(portal_name, true, true);
1694 	else
1695 		portal = CreatePortal(portal_name, false, false);
1696 
1697 	/*
1698 	 * Prepare to copy stuff into the portal's memory context.  We do all this
1699 	 * copying first, because it could possibly fail (out-of-memory) and we
1700 	 * don't want a failure to occur between GetCachedPlan and
1701 	 * PortalDefineQuery; that would result in leaking our plancache refcount.
1702 	 */
1703 	oldContext = MemoryContextSwitchTo(portal->portalContext);
1704 
1705 	/* Copy the plan's query string into the portal */
1706 	query_string = pstrdup(psrc->query_string);
1707 
1708 	/* Likewise make a copy of the statement name, unless it's unnamed */
1709 	if (stmt_name[0])
1710 		saved_stmt_name = pstrdup(stmt_name);
1711 	else
1712 		saved_stmt_name = NULL;
1713 
1714 	/*
1715 	 * Set a snapshot if we have parameters to fetch (since the input
1716 	 * functions might need it) or the query isn't a utility command (and
1717 	 * hence could require redoing parse analysis and planning).  We keep the
1718 	 * snapshot active till we're done, so that plancache.c doesn't have to
1719 	 * take new ones.
1720 	 */
1721 	if (numParams > 0 ||
1722 		(psrc->raw_parse_tree &&
1723 		 analyze_requires_snapshot(psrc->raw_parse_tree)))
1724 	{
1725 		PushActiveSnapshot(GetTransactionSnapshot());
1726 		snapshot_set = true;
1727 	}
1728 
1729 	/*
1730 	 * Fetch parameters, if any, and store in the portal's memory context.
1731 	 */
1732 	if (numParams > 0)
1733 	{
1734 		params = makeParamList(numParams);
1735 
1736 		for (int paramno = 0; paramno < numParams; paramno++)
1737 		{
1738 			Oid			ptype = psrc->param_types[paramno];
1739 			int32		plength;
1740 			Datum		pval;
1741 			bool		isNull;
1742 			StringInfoData pbuf;
1743 			char		csave;
1744 			int16		pformat;
1745 
1746 			plength = pq_getmsgint(input_message, 4);
1747 			isNull = (plength == -1);
1748 
1749 			if (!isNull)
1750 			{
1751 				const char *pvalue = pq_getmsgbytes(input_message, plength);
1752 
1753 				/*
1754 				 * Rather than copying data around, we just set up a phony
1755 				 * StringInfo pointing to the correct portion of the message
1756 				 * buffer.  We assume we can scribble on the message buffer so
1757 				 * as to maintain the convention that StringInfos have a
1758 				 * trailing null.  This is grotty but is a big win when
1759 				 * dealing with very large parameter strings.
1760 				 */
1761 				pbuf.data = unconstify(char *, pvalue);
1762 				pbuf.maxlen = plength + 1;
1763 				pbuf.len = plength;
1764 				pbuf.cursor = 0;
1765 
1766 				csave = pbuf.data[plength];
1767 				pbuf.data[plength] = '\0';
1768 			}
1769 			else
1770 			{
1771 				pbuf.data = NULL;	/* keep compiler quiet */
1772 				csave = 0;
1773 			}
1774 
1775 			if (numPFormats > 1)
1776 				pformat = pformats[paramno];
1777 			else if (numPFormats > 0)
1778 				pformat = pformats[0];
1779 			else
1780 				pformat = 0;	/* default = text */
1781 
1782 			if (pformat == 0)	/* text mode */
1783 			{
1784 				Oid			typinput;
1785 				Oid			typioparam;
1786 				char	   *pstring;
1787 
1788 				getTypeInputInfo(ptype, &typinput, &typioparam);
1789 
1790 				/*
1791 				 * We have to do encoding conversion before calling the
1792 				 * typinput routine.
1793 				 */
1794 				if (isNull)
1795 					pstring = NULL;
1796 				else
1797 					pstring = pg_client_to_server(pbuf.data, plength);
1798 
1799 				pval = OidInputFunctionCall(typinput, pstring, typioparam, -1);
1800 
1801 				/* Free result of encoding conversion, if any */
1802 				if (pstring && pstring != pbuf.data)
1803 					pfree(pstring);
1804 			}
1805 			else if (pformat == 1)	/* binary mode */
1806 			{
1807 				Oid			typreceive;
1808 				Oid			typioparam;
1809 				StringInfo	bufptr;
1810 
1811 				/*
1812 				 * Call the parameter type's binary input converter
1813 				 */
1814 				getTypeBinaryInputInfo(ptype, &typreceive, &typioparam);
1815 
1816 				if (isNull)
1817 					bufptr = NULL;
1818 				else
1819 					bufptr = &pbuf;
1820 
1821 				pval = OidReceiveFunctionCall(typreceive, bufptr, typioparam, -1);
1822 
1823 				/* Trouble if it didn't eat the whole buffer */
1824 				if (!isNull && pbuf.cursor != pbuf.len)
1825 					ereport(ERROR,
1826 							(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
1827 							 errmsg("incorrect binary data format in bind parameter %d",
1828 									paramno + 1)));
1829 			}
1830 			else
1831 			{
1832 				ereport(ERROR,
1833 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1834 						 errmsg("unsupported format code: %d",
1835 								pformat)));
1836 				pval = 0;		/* keep compiler quiet */
1837 			}
1838 
1839 			/* Restore message buffer contents */
1840 			if (!isNull)
1841 				pbuf.data[plength] = csave;
1842 
1843 			params->params[paramno].value = pval;
1844 			params->params[paramno].isnull = isNull;
1845 
1846 			/*
1847 			 * We mark the params as CONST.  This ensures that any custom plan
1848 			 * makes full use of the parameter values.
1849 			 */
1850 			params->params[paramno].pflags = PARAM_FLAG_CONST;
1851 			params->params[paramno].ptype = ptype;
1852 		}
1853 	}
1854 	else
1855 		params = NULL;
1856 
1857 	/* Done storing stuff in portal's context */
1858 	MemoryContextSwitchTo(oldContext);
1859 
1860 	/* Get the result format codes */
1861 	numRFormats = pq_getmsgint(input_message, 2);
1862 	if (numRFormats > 0)
1863 	{
1864 		rformats = (int16 *) palloc(numRFormats * sizeof(int16));
1865 		for (int i = 0; i < numRFormats; i++)
1866 			rformats[i] = pq_getmsgint(input_message, 2);
1867 	}
1868 
1869 	pq_getmsgend(input_message);
1870 
1871 	/*
1872 	 * Obtain a plan from the CachedPlanSource.  Any cruft from (re)planning
1873 	 * will be generated in MessageContext.  The plan refcount will be
1874 	 * assigned to the Portal, so it will be released at portal destruction.
1875 	 */
1876 	cplan = GetCachedPlan(psrc, params, false, NULL);
1877 
1878 	/*
1879 	 * Now we can define the portal.
1880 	 *
1881 	 * DO NOT put any code that could possibly throw an error between the
1882 	 * above GetCachedPlan call and here.
1883 	 */
1884 	PortalDefineQuery(portal,
1885 					  saved_stmt_name,
1886 					  query_string,
1887 					  psrc->commandTag,
1888 					  cplan->stmt_list,
1889 					  cplan);
1890 
1891 	/* Done with the snapshot used for parameter I/O and parsing/planning */
1892 	if (snapshot_set)
1893 		PopActiveSnapshot();
1894 
1895 	/*
1896 	 * And we're ready to start portal execution.
1897 	 */
1898 	PortalStart(portal, params, 0, InvalidSnapshot);
1899 
1900 	/*
1901 	 * Apply the result format requests to the portal.
1902 	 */
1903 	PortalSetResultFormat(portal, numRFormats, rformats);
1904 
1905 	/*
1906 	 * Send BindComplete.
1907 	 */
1908 	if (whereToSendOutput == DestRemote)
1909 		pq_putemptymessage('2');
1910 
1911 	/*
1912 	 * Emit duration logging if appropriate.
1913 	 */
1914 	switch (check_log_duration(msec_str, false))
1915 	{
1916 		case 1:
1917 			ereport(LOG,
1918 					(errmsg("duration: %s ms", msec_str),
1919 					 errhidestmt(true)));
1920 			break;
1921 		case 2:
1922 			ereport(LOG,
1923 					(errmsg("duration: %s ms  bind %s%s%s: %s",
1924 							msec_str,
1925 							*stmt_name ? stmt_name : "<unnamed>",
1926 							*portal_name ? "/" : "",
1927 							*portal_name ? portal_name : "",
1928 							psrc->query_string),
1929 					 errhidestmt(true),
1930 					 errdetail_params(params)));
1931 			break;
1932 	}
1933 
1934 	if (save_log_statement_stats)
1935 		ShowUsage("BIND MESSAGE STATISTICS");
1936 
1937 	debug_query_string = NULL;
1938 }
1939 
1940 /*
1941  * exec_execute_message
1942  *
1943  * Process an "Execute" message for a portal
1944  */
1945 static void
exec_execute_message(const char * portal_name,long max_rows)1946 exec_execute_message(const char *portal_name, long max_rows)
1947 {
1948 	CommandDest dest;
1949 	DestReceiver *receiver;
1950 	Portal		portal;
1951 	bool		completed;
1952 	char		completionTag[COMPLETION_TAG_BUFSIZE];
1953 	const char *sourceText;
1954 	const char *prepStmtName;
1955 	ParamListInfo portalParams;
1956 	bool		save_log_statement_stats = log_statement_stats;
1957 	bool		is_xact_command;
1958 	bool		execute_is_fetch;
1959 	bool		was_logged = false;
1960 	char		msec_str[32];
1961 
1962 	/* Adjust destination to tell printtup.c what to do */
1963 	dest = whereToSendOutput;
1964 	if (dest == DestRemote)
1965 		dest = DestRemoteExecute;
1966 
1967 	portal = GetPortalByName(portal_name);
1968 	if (!PortalIsValid(portal))
1969 		ereport(ERROR,
1970 				(errcode(ERRCODE_UNDEFINED_CURSOR),
1971 				 errmsg("portal \"%s\" does not exist", portal_name)));
1972 
1973 	/*
1974 	 * If the original query was a null string, just return
1975 	 * EmptyQueryResponse.
1976 	 */
1977 	if (portal->commandTag == NULL)
1978 	{
1979 		Assert(portal->stmts == NIL);
1980 		NullCommand(dest);
1981 		return;
1982 	}
1983 
1984 	/* Does the portal contain a transaction command? */
1985 	is_xact_command = IsTransactionStmtList(portal->stmts);
1986 
1987 	/*
1988 	 * We must copy the sourceText and prepStmtName into MessageContext in
1989 	 * case the portal is destroyed during finish_xact_command. Can avoid the
1990 	 * copy if it's not an xact command, though.
1991 	 */
1992 	if (is_xact_command)
1993 	{
1994 		sourceText = pstrdup(portal->sourceText);
1995 		if (portal->prepStmtName)
1996 			prepStmtName = pstrdup(portal->prepStmtName);
1997 		else
1998 			prepStmtName = "<unnamed>";
1999 
2000 		/*
2001 		 * An xact command shouldn't have any parameters, which is a good
2002 		 * thing because they wouldn't be around after finish_xact_command.
2003 		 */
2004 		portalParams = NULL;
2005 	}
2006 	else
2007 	{
2008 		sourceText = portal->sourceText;
2009 		if (portal->prepStmtName)
2010 			prepStmtName = portal->prepStmtName;
2011 		else
2012 			prepStmtName = "<unnamed>";
2013 		portalParams = portal->portalParams;
2014 	}
2015 
2016 	/*
2017 	 * Report query to various monitoring facilities.
2018 	 */
2019 	debug_query_string = sourceText;
2020 
2021 	pgstat_report_activity(STATE_RUNNING, sourceText);
2022 
2023 	set_ps_display(portal->commandTag, false);
2024 
2025 	if (save_log_statement_stats)
2026 		ResetUsage();
2027 
2028 	BeginCommand(portal->commandTag, dest);
2029 
2030 	/*
2031 	 * Create dest receiver in MessageContext (we don't want it in transaction
2032 	 * context, because that may get deleted if portal contains VACUUM).
2033 	 */
2034 	receiver = CreateDestReceiver(dest);
2035 	if (dest == DestRemoteExecute)
2036 		SetRemoteDestReceiverParams(receiver, portal);
2037 
2038 	/*
2039 	 * Ensure we are in a transaction command (this should normally be the
2040 	 * case already due to prior BIND).
2041 	 */
2042 	start_xact_command();
2043 
2044 	/*
2045 	 * If we re-issue an Execute protocol request against an existing portal,
2046 	 * then we are only fetching more rows rather than completely re-executing
2047 	 * the query from the start. atStart is never reset for a v3 portal, so we
2048 	 * are safe to use this check.
2049 	 */
2050 	execute_is_fetch = !portal->atStart;
2051 
2052 	/* Log immediately if dictated by log_statement */
2053 	if (check_log_statement(portal->stmts))
2054 	{
2055 		ereport(LOG,
2056 				(errmsg("%s %s%s%s: %s",
2057 						execute_is_fetch ?
2058 						_("execute fetch from") :
2059 						_("execute"),
2060 						prepStmtName,
2061 						*portal_name ? "/" : "",
2062 						*portal_name ? portal_name : "",
2063 						sourceText),
2064 				 errhidestmt(true),
2065 				 errdetail_params(portalParams)));
2066 		was_logged = true;
2067 	}
2068 
2069 	/*
2070 	 * If we are in aborted transaction state, the only portals we can
2071 	 * actually run are those containing COMMIT or ROLLBACK commands.
2072 	 */
2073 	if (IsAbortedTransactionBlockState() &&
2074 		!IsTransactionExitStmtList(portal->stmts))
2075 		ereport(ERROR,
2076 				(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
2077 				 errmsg("current transaction is aborted, "
2078 						"commands ignored until end of transaction block"),
2079 				 errdetail_abort()));
2080 
2081 	/* Check for cancel signal before we start execution */
2082 	CHECK_FOR_INTERRUPTS();
2083 
2084 	/*
2085 	 * Okay to run the portal.
2086 	 */
2087 	if (max_rows <= 0)
2088 		max_rows = FETCH_ALL;
2089 
2090 	completed = PortalRun(portal,
2091 						  max_rows,
2092 						  true, /* always top level */
2093 						  !execute_is_fetch && max_rows == FETCH_ALL,
2094 						  receiver,
2095 						  receiver,
2096 						  completionTag);
2097 
2098 	receiver->rDestroy(receiver);
2099 
2100 	if (completed)
2101 	{
2102 		if (is_xact_command)
2103 		{
2104 			/*
2105 			 * If this was a transaction control statement, commit it.  We
2106 			 * will start a new xact command for the next command (if any).
2107 			 */
2108 			finish_xact_command();
2109 		}
2110 		else
2111 		{
2112 			/*
2113 			 * We need a CommandCounterIncrement after every query, except
2114 			 * those that start or end a transaction block.
2115 			 */
2116 			CommandCounterIncrement();
2117 
2118 			/* full command has been executed, reset timeout */
2119 			disable_statement_timeout();
2120 		}
2121 
2122 		/* Send appropriate CommandComplete to client */
2123 		EndCommand(completionTag, dest);
2124 	}
2125 	else
2126 	{
2127 		/* Portal run not complete, so send PortalSuspended */
2128 		if (whereToSendOutput == DestRemote)
2129 			pq_putemptymessage('s');
2130 	}
2131 
2132 	/*
2133 	 * Emit duration logging if appropriate.
2134 	 */
2135 	switch (check_log_duration(msec_str, was_logged))
2136 	{
2137 		case 1:
2138 			ereport(LOG,
2139 					(errmsg("duration: %s ms", msec_str),
2140 					 errhidestmt(true)));
2141 			break;
2142 		case 2:
2143 			ereport(LOG,
2144 					(errmsg("duration: %s ms  %s %s%s%s: %s",
2145 							msec_str,
2146 							execute_is_fetch ?
2147 							_("execute fetch from") :
2148 							_("execute"),
2149 							prepStmtName,
2150 							*portal_name ? "/" : "",
2151 							*portal_name ? portal_name : "",
2152 							sourceText),
2153 					 errhidestmt(true),
2154 					 errdetail_params(portalParams)));
2155 			break;
2156 	}
2157 
2158 	if (save_log_statement_stats)
2159 		ShowUsage("EXECUTE MESSAGE STATISTICS");
2160 
2161 	debug_query_string = NULL;
2162 }
2163 
2164 /*
2165  * check_log_statement
2166  *		Determine whether command should be logged because of log_statement
2167  *
2168  * stmt_list can be either raw grammar output or a list of planned
2169  * statements
2170  */
2171 static bool
check_log_statement(List * stmt_list)2172 check_log_statement(List *stmt_list)
2173 {
2174 	ListCell   *stmt_item;
2175 
2176 	if (log_statement == LOGSTMT_NONE)
2177 		return false;
2178 	if (log_statement == LOGSTMT_ALL)
2179 		return true;
2180 
2181 	/* Else we have to inspect the statement(s) to see whether to log */
2182 	foreach(stmt_item, stmt_list)
2183 	{
2184 		Node	   *stmt = (Node *) lfirst(stmt_item);
2185 
2186 		if (GetCommandLogLevel(stmt) <= log_statement)
2187 			return true;
2188 	}
2189 
2190 	return false;
2191 }
2192 
2193 /*
2194  * check_log_duration
2195  *		Determine whether current command's duration should be logged
2196  *		We also check if this statement in this transaction must be logged
2197  *		(regardless of its duration).
2198  *
2199  * Returns:
2200  *		0 if no logging is needed
2201  *		1 if just the duration should be logged
2202  *		2 if duration and query details should be logged
2203  *
2204  * If logging is needed, the duration in msec is formatted into msec_str[],
2205  * which must be a 32-byte buffer.
2206  *
2207  * was_logged should be true if caller already logged query details (this
2208  * essentially prevents 2 from being returned).
2209  */
2210 int
check_log_duration(char * msec_str,bool was_logged)2211 check_log_duration(char *msec_str, bool was_logged)
2212 {
2213 	if (log_duration || log_min_duration_statement >= 0 || xact_is_sampled)
2214 	{
2215 		long		secs;
2216 		int			usecs;
2217 		int			msecs;
2218 		bool		exceeded;
2219 
2220 		TimestampDifference(GetCurrentStatementStartTimestamp(),
2221 							GetCurrentTimestamp(),
2222 							&secs, &usecs);
2223 		msecs = usecs / 1000;
2224 
2225 		/*
2226 		 * This odd-looking test for log_min_duration_statement being exceeded
2227 		 * is designed to avoid integer overflow with very long durations:
2228 		 * don't compute secs * 1000 until we've verified it will fit in int.
2229 		 */
2230 		exceeded = (log_min_duration_statement == 0 ||
2231 					(log_min_duration_statement > 0 &&
2232 					 (secs > log_min_duration_statement / 1000 ||
2233 					  secs * 1000 + msecs >= log_min_duration_statement)));
2234 
2235 		if (exceeded || log_duration || xact_is_sampled)
2236 		{
2237 			snprintf(msec_str, 32, "%ld.%03d",
2238 					 secs * 1000 + msecs, usecs % 1000);
2239 			if ((exceeded || xact_is_sampled) && !was_logged)
2240 				return 2;
2241 			else
2242 				return 1;
2243 		}
2244 	}
2245 
2246 	return 0;
2247 }
2248 
2249 /*
2250  * errdetail_execute
2251  *
2252  * Add an errdetail() line showing the query referenced by an EXECUTE, if any.
2253  * The argument is the raw parsetree list.
2254  */
2255 static int
errdetail_execute(List * raw_parsetree_list)2256 errdetail_execute(List *raw_parsetree_list)
2257 {
2258 	ListCell   *parsetree_item;
2259 
2260 	foreach(parsetree_item, raw_parsetree_list)
2261 	{
2262 		RawStmt    *parsetree = lfirst_node(RawStmt, parsetree_item);
2263 
2264 		if (IsA(parsetree->stmt, ExecuteStmt))
2265 		{
2266 			ExecuteStmt *stmt = (ExecuteStmt *) parsetree->stmt;
2267 			PreparedStatement *pstmt;
2268 
2269 			pstmt = FetchPreparedStatement(stmt->name, false);
2270 			if (pstmt)
2271 			{
2272 				errdetail("prepare: %s", pstmt->plansource->query_string);
2273 				return 0;
2274 			}
2275 		}
2276 	}
2277 
2278 	return 0;
2279 }
2280 
2281 /*
2282  * errdetail_params
2283  *
2284  * Add an errdetail() line showing bind-parameter data, if available.
2285  */
2286 static int
errdetail_params(ParamListInfo params)2287 errdetail_params(ParamListInfo params)
2288 {
2289 	/* We mustn't call user-defined I/O functions when in an aborted xact */
2290 	if (params && params->numParams > 0 && !IsAbortedTransactionBlockState())
2291 	{
2292 		StringInfoData param_str;
2293 		MemoryContext oldcontext;
2294 
2295 		/* This code doesn't support dynamic param lists */
2296 		Assert(params->paramFetch == NULL);
2297 
2298 		/* Make sure any trash is generated in MessageContext */
2299 		oldcontext = MemoryContextSwitchTo(MessageContext);
2300 
2301 		initStringInfo(&param_str);
2302 
2303 		for (int paramno = 0; paramno < params->numParams; paramno++)
2304 		{
2305 			ParamExternData *prm = &params->params[paramno];
2306 			Oid			typoutput;
2307 			bool		typisvarlena;
2308 			char	   *pstring;
2309 			char	   *p;
2310 
2311 			appendStringInfo(&param_str, "%s$%d = ",
2312 							 paramno > 0 ? ", " : "",
2313 							 paramno + 1);
2314 
2315 			if (prm->isnull || !OidIsValid(prm->ptype))
2316 			{
2317 				appendStringInfoString(&param_str, "NULL");
2318 				continue;
2319 			}
2320 
2321 			getTypeOutputInfo(prm->ptype, &typoutput, &typisvarlena);
2322 
2323 			pstring = OidOutputFunctionCall(typoutput, prm->value);
2324 
2325 			appendStringInfoCharMacro(&param_str, '\'');
2326 			for (p = pstring; *p; p++)
2327 			{
2328 				if (*p == '\'') /* double single quotes */
2329 					appendStringInfoCharMacro(&param_str, *p);
2330 				appendStringInfoCharMacro(&param_str, *p);
2331 			}
2332 			appendStringInfoCharMacro(&param_str, '\'');
2333 
2334 			pfree(pstring);
2335 		}
2336 
2337 		errdetail("parameters: %s", param_str.data);
2338 
2339 		pfree(param_str.data);
2340 
2341 		MemoryContextSwitchTo(oldcontext);
2342 	}
2343 
2344 	return 0;
2345 }
2346 
2347 /*
2348  * errdetail_abort
2349  *
2350  * Add an errdetail() line showing abort reason, if any.
2351  */
2352 static int
errdetail_abort(void)2353 errdetail_abort(void)
2354 {
2355 	if (MyProc->recoveryConflictPending)
2356 		errdetail("abort reason: recovery conflict");
2357 
2358 	return 0;
2359 }
2360 
2361 /*
2362  * errdetail_recovery_conflict
2363  *
2364  * Add an errdetail() line showing conflict source.
2365  */
2366 static int
errdetail_recovery_conflict(void)2367 errdetail_recovery_conflict(void)
2368 {
2369 	switch (RecoveryConflictReason)
2370 	{
2371 		case PROCSIG_RECOVERY_CONFLICT_BUFFERPIN:
2372 			errdetail("User was holding shared buffer pin for too long.");
2373 			break;
2374 		case PROCSIG_RECOVERY_CONFLICT_LOCK:
2375 			errdetail("User was holding a relation lock for too long.");
2376 			break;
2377 		case PROCSIG_RECOVERY_CONFLICT_TABLESPACE:
2378 			errdetail("User was or might have been using tablespace that must be dropped.");
2379 			break;
2380 		case PROCSIG_RECOVERY_CONFLICT_SNAPSHOT:
2381 			errdetail("User query might have needed to see row versions that must be removed.");
2382 			break;
2383 		case PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK:
2384 			errdetail("User transaction caused buffer deadlock with recovery.");
2385 			break;
2386 		case PROCSIG_RECOVERY_CONFLICT_DATABASE:
2387 			errdetail("User was connected to a database that must be dropped.");
2388 			break;
2389 		default:
2390 			break;
2391 			/* no errdetail */
2392 	}
2393 
2394 	return 0;
2395 }
2396 
2397 /*
2398  * exec_describe_statement_message
2399  *
2400  * Process a "Describe" message for a prepared statement
2401  */
2402 static void
exec_describe_statement_message(const char * stmt_name)2403 exec_describe_statement_message(const char *stmt_name)
2404 {
2405 	CachedPlanSource *psrc;
2406 
2407 	/*
2408 	 * Start up a transaction command. (Note that this will normally change
2409 	 * current memory context.) Nothing happens if we are already in one.
2410 	 */
2411 	start_xact_command();
2412 
2413 	/* Switch back to message context */
2414 	MemoryContextSwitchTo(MessageContext);
2415 
2416 	/* Find prepared statement */
2417 	if (stmt_name[0] != '\0')
2418 	{
2419 		PreparedStatement *pstmt;
2420 
2421 		pstmt = FetchPreparedStatement(stmt_name, true);
2422 		psrc = pstmt->plansource;
2423 	}
2424 	else
2425 	{
2426 		/* special-case the unnamed statement */
2427 		psrc = unnamed_stmt_psrc;
2428 		if (!psrc)
2429 			ereport(ERROR,
2430 					(errcode(ERRCODE_UNDEFINED_PSTATEMENT),
2431 					 errmsg("unnamed prepared statement does not exist")));
2432 	}
2433 
2434 	/* Prepared statements shouldn't have changeable result descs */
2435 	Assert(psrc->fixed_result);
2436 
2437 	/*
2438 	 * If we are in aborted transaction state, we can't run
2439 	 * SendRowDescriptionMessage(), because that needs catalog accesses.
2440 	 * Hence, refuse to Describe statements that return data.  (We shouldn't
2441 	 * just refuse all Describes, since that might break the ability of some
2442 	 * clients to issue COMMIT or ROLLBACK commands, if they use code that
2443 	 * blindly Describes whatever it does.)  We can Describe parameters
2444 	 * without doing anything dangerous, so we don't restrict that.
2445 	 */
2446 	if (IsAbortedTransactionBlockState() &&
2447 		psrc->resultDesc)
2448 		ereport(ERROR,
2449 				(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
2450 				 errmsg("current transaction is aborted, "
2451 						"commands ignored until end of transaction block"),
2452 				 errdetail_abort()));
2453 
2454 	if (whereToSendOutput != DestRemote)
2455 		return;					/* can't actually do anything... */
2456 
2457 	/*
2458 	 * First describe the parameters...
2459 	 */
2460 	pq_beginmessage_reuse(&row_description_buf, 't');	/* parameter description
2461 														 * message type */
2462 	pq_sendint16(&row_description_buf, psrc->num_params);
2463 
2464 	for (int i = 0; i < psrc->num_params; i++)
2465 	{
2466 		Oid			ptype = psrc->param_types[i];
2467 
2468 		pq_sendint32(&row_description_buf, (int) ptype);
2469 	}
2470 	pq_endmessage_reuse(&row_description_buf);
2471 
2472 	/*
2473 	 * Next send RowDescription or NoData to describe the result...
2474 	 */
2475 	if (psrc->resultDesc)
2476 	{
2477 		List	   *tlist;
2478 
2479 		/* Get the plan's primary targetlist */
2480 		tlist = CachedPlanGetTargetList(psrc, NULL);
2481 
2482 		SendRowDescriptionMessage(&row_description_buf,
2483 								  psrc->resultDesc,
2484 								  tlist,
2485 								  NULL);
2486 	}
2487 	else
2488 		pq_putemptymessage('n');	/* NoData */
2489 
2490 }
2491 
2492 /*
2493  * exec_describe_portal_message
2494  *
2495  * Process a "Describe" message for a portal
2496  */
2497 static void
exec_describe_portal_message(const char * portal_name)2498 exec_describe_portal_message(const char *portal_name)
2499 {
2500 	Portal		portal;
2501 
2502 	/*
2503 	 * Start up a transaction command. (Note that this will normally change
2504 	 * current memory context.) Nothing happens if we are already in one.
2505 	 */
2506 	start_xact_command();
2507 
2508 	/* Switch back to message context */
2509 	MemoryContextSwitchTo(MessageContext);
2510 
2511 	portal = GetPortalByName(portal_name);
2512 	if (!PortalIsValid(portal))
2513 		ereport(ERROR,
2514 				(errcode(ERRCODE_UNDEFINED_CURSOR),
2515 				 errmsg("portal \"%s\" does not exist", portal_name)));
2516 
2517 	/*
2518 	 * If we are in aborted transaction state, we can't run
2519 	 * SendRowDescriptionMessage(), because that needs catalog accesses.
2520 	 * Hence, refuse to Describe portals that return data.  (We shouldn't just
2521 	 * refuse all Describes, since that might break the ability of some
2522 	 * clients to issue COMMIT or ROLLBACK commands, if they use code that
2523 	 * blindly Describes whatever it does.)
2524 	 */
2525 	if (IsAbortedTransactionBlockState() &&
2526 		portal->tupDesc)
2527 		ereport(ERROR,
2528 				(errcode(ERRCODE_IN_FAILED_SQL_TRANSACTION),
2529 				 errmsg("current transaction is aborted, "
2530 						"commands ignored until end of transaction block"),
2531 				 errdetail_abort()));
2532 
2533 	if (whereToSendOutput != DestRemote)
2534 		return;					/* can't actually do anything... */
2535 
2536 	if (portal->tupDesc)
2537 		SendRowDescriptionMessage(&row_description_buf,
2538 								  portal->tupDesc,
2539 								  FetchPortalTargetList(portal),
2540 								  portal->formats);
2541 	else
2542 		pq_putemptymessage('n');	/* NoData */
2543 }
2544 
2545 
2546 /*
2547  * Convenience routines for starting/committing a single command.
2548  */
2549 static void
start_xact_command(void)2550 start_xact_command(void)
2551 {
2552 	if (!xact_started)
2553 	{
2554 		StartTransactionCommand();
2555 
2556 		xact_started = true;
2557 	}
2558 
2559 	/*
2560 	 * Start statement timeout if necessary.  Note that this'll intentionally
2561 	 * not reset the clock on an already started timeout, to avoid the timing
2562 	 * overhead when start_xact_command() is invoked repeatedly, without an
2563 	 * interceding finish_xact_command() (e.g. parse/bind/execute).  If that's
2564 	 * not desired, the timeout has to be disabled explicitly.
2565 	 */
2566 	enable_statement_timeout();
2567 }
2568 
2569 static void
finish_xact_command(void)2570 finish_xact_command(void)
2571 {
2572 	/* cancel active statement timeout after each command */
2573 	disable_statement_timeout();
2574 
2575 	if (xact_started)
2576 	{
2577 		CommitTransactionCommand();
2578 
2579 #ifdef MEMORY_CONTEXT_CHECKING
2580 		/* Check all memory contexts that weren't freed during commit */
2581 		/* (those that were, were checked before being deleted) */
2582 		MemoryContextCheck(TopMemoryContext);
2583 #endif
2584 
2585 #ifdef SHOW_MEMORY_STATS
2586 		/* Print mem stats after each commit for leak tracking */
2587 		MemoryContextStats(TopMemoryContext);
2588 #endif
2589 
2590 		xact_started = false;
2591 	}
2592 }
2593 
2594 
2595 /*
2596  * Convenience routines for checking whether a statement is one of the
2597  * ones that we allow in transaction-aborted state.
2598  */
2599 
2600 /* Test a bare parsetree */
2601 static bool
IsTransactionExitStmt(Node * parsetree)2602 IsTransactionExitStmt(Node *parsetree)
2603 {
2604 	if (parsetree && IsA(parsetree, TransactionStmt))
2605 	{
2606 		TransactionStmt *stmt = (TransactionStmt *) parsetree;
2607 
2608 		if (stmt->kind == TRANS_STMT_COMMIT ||
2609 			stmt->kind == TRANS_STMT_PREPARE ||
2610 			stmt->kind == TRANS_STMT_ROLLBACK ||
2611 			stmt->kind == TRANS_STMT_ROLLBACK_TO)
2612 			return true;
2613 	}
2614 	return false;
2615 }
2616 
2617 /* Test a list that contains PlannedStmt nodes */
2618 static bool
IsTransactionExitStmtList(List * pstmts)2619 IsTransactionExitStmtList(List *pstmts)
2620 {
2621 	if (list_length(pstmts) == 1)
2622 	{
2623 		PlannedStmt *pstmt = linitial_node(PlannedStmt, pstmts);
2624 
2625 		if (pstmt->commandType == CMD_UTILITY &&
2626 			IsTransactionExitStmt(pstmt->utilityStmt))
2627 			return true;
2628 	}
2629 	return false;
2630 }
2631 
2632 /* Test a list that contains PlannedStmt nodes */
2633 static bool
IsTransactionStmtList(List * pstmts)2634 IsTransactionStmtList(List *pstmts)
2635 {
2636 	if (list_length(pstmts) == 1)
2637 	{
2638 		PlannedStmt *pstmt = linitial_node(PlannedStmt, pstmts);
2639 
2640 		if (pstmt->commandType == CMD_UTILITY &&
2641 			IsA(pstmt->utilityStmt, TransactionStmt))
2642 			return true;
2643 	}
2644 	return false;
2645 }
2646 
2647 /* Release any existing unnamed prepared statement */
2648 static void
drop_unnamed_stmt(void)2649 drop_unnamed_stmt(void)
2650 {
2651 	/* paranoia to avoid a dangling pointer in case of error */
2652 	if (unnamed_stmt_psrc)
2653 	{
2654 		CachedPlanSource *psrc = unnamed_stmt_psrc;
2655 
2656 		unnamed_stmt_psrc = NULL;
2657 		DropCachedPlan(psrc);
2658 	}
2659 }
2660 
2661 
2662 /* --------------------------------
2663  *		signal handler routines used in PostgresMain()
2664  * --------------------------------
2665  */
2666 
2667 /*
2668  * quickdie() occurs when signalled SIGQUIT by the postmaster.
2669  *
2670  * Some backend has bought the farm,
2671  * so we need to stop what we're doing and exit.
2672  */
2673 void
quickdie(SIGNAL_ARGS)2674 quickdie(SIGNAL_ARGS)
2675 {
2676 	sigaddset(&BlockSig, SIGQUIT);	/* prevent nested calls */
2677 	PG_SETMASK(&BlockSig);
2678 
2679 	/*
2680 	 * Prevent interrupts while exiting; though we just blocked signals that
2681 	 * would queue new interrupts, one may have been pending.  We don't want a
2682 	 * quickdie() downgraded to a mere query cancel.
2683 	 */
2684 	HOLD_INTERRUPTS();
2685 
2686 	/*
2687 	 * If we're aborting out of client auth, don't risk trying to send
2688 	 * anything to the client; we will likely violate the protocol, not to
2689 	 * mention that we may have interrupted the guts of OpenSSL or some
2690 	 * authentication library.
2691 	 */
2692 	if (ClientAuthInProgress && whereToSendOutput == DestRemote)
2693 		whereToSendOutput = DestNone;
2694 
2695 	/*
2696 	 * Notify the client before exiting, to give a clue on what happened.
2697 	 *
2698 	 * It's dubious to call ereport() from a signal handler.  It is certainly
2699 	 * not async-signal safe.  But it seems better to try, than to disconnect
2700 	 * abruptly and leave the client wondering what happened.  It's remotely
2701 	 * possible that we crash or hang while trying to send the message, but
2702 	 * receiving a SIGQUIT is a sign that something has already gone badly
2703 	 * wrong, so there's not much to lose.  Assuming the postmaster is still
2704 	 * running, it will SIGKILL us soon if we get stuck for some reason.
2705 	 *
2706 	 * Ideally this should be ereport(FATAL), but then we'd not get control
2707 	 * back...
2708 	 */
2709 	ereport(WARNING,
2710 			(errcode(ERRCODE_CRASH_SHUTDOWN),
2711 			 errmsg("terminating connection because of crash of another server process"),
2712 			 errdetail("The postmaster has commanded this server process to roll back"
2713 					   " the current transaction and exit, because another"
2714 					   " server process exited abnormally and possibly corrupted"
2715 					   " shared memory."),
2716 			 errhint("In a moment you should be able to reconnect to the"
2717 					 " database and repeat your command.")));
2718 
2719 	/*
2720 	 * We DO NOT want to run proc_exit() or atexit() callbacks -- we're here
2721 	 * because shared memory may be corrupted, so we don't want to try to
2722 	 * clean up our transaction.  Just nail the windows shut and get out of
2723 	 * town.  The callbacks wouldn't be safe to run from a signal handler,
2724 	 * anyway.
2725 	 *
2726 	 * Note we do _exit(2) not _exit(0).  This is to force the postmaster into
2727 	 * a system reset cycle if someone sends a manual SIGQUIT to a random
2728 	 * backend.  This is necessary precisely because we don't clean up our
2729 	 * shared memory state.  (The "dead man switch" mechanism in pmsignal.c
2730 	 * should ensure the postmaster sees this as a crash, too, but no harm in
2731 	 * being doubly sure.)
2732 	 */
2733 	_exit(2);
2734 }
2735 
2736 /*
2737  * Shutdown signal from postmaster: abort transaction and exit
2738  * at soonest convenient time
2739  */
2740 void
die(SIGNAL_ARGS)2741 die(SIGNAL_ARGS)
2742 {
2743 	int			save_errno = errno;
2744 
2745 	/* Don't joggle the elbow of proc_exit */
2746 	if (!proc_exit_inprogress)
2747 	{
2748 		InterruptPending = true;
2749 		ProcDiePending = true;
2750 	}
2751 
2752 	/* If we're still here, waken anything waiting on the process latch */
2753 	SetLatch(MyLatch);
2754 
2755 	/*
2756 	 * If we're in single user mode, we want to quit immediately - we can't
2757 	 * rely on latches as they wouldn't work when stdin/stdout is a file.
2758 	 * Rather ugly, but it's unlikely to be worthwhile to invest much more
2759 	 * effort just for the benefit of single user mode.
2760 	 */
2761 	if (DoingCommandRead && whereToSendOutput != DestRemote)
2762 		ProcessInterrupts();
2763 
2764 	errno = save_errno;
2765 }
2766 
2767 /*
2768  * Query-cancel signal from postmaster: abort current transaction
2769  * at soonest convenient time
2770  */
2771 void
StatementCancelHandler(SIGNAL_ARGS)2772 StatementCancelHandler(SIGNAL_ARGS)
2773 {
2774 	int			save_errno = errno;
2775 
2776 	/*
2777 	 * Don't joggle the elbow of proc_exit
2778 	 */
2779 	if (!proc_exit_inprogress)
2780 	{
2781 		InterruptPending = true;
2782 		QueryCancelPending = true;
2783 	}
2784 
2785 	/* If we're still here, waken anything waiting on the process latch */
2786 	SetLatch(MyLatch);
2787 
2788 	errno = save_errno;
2789 }
2790 
2791 /* signal handler for floating point exception */
2792 void
FloatExceptionHandler(SIGNAL_ARGS)2793 FloatExceptionHandler(SIGNAL_ARGS)
2794 {
2795 	/* We're not returning, so no need to save errno */
2796 	ereport(ERROR,
2797 			(errcode(ERRCODE_FLOATING_POINT_EXCEPTION),
2798 			 errmsg("floating-point exception"),
2799 			 errdetail("An invalid floating-point operation was signaled. "
2800 					   "This probably means an out-of-range result or an "
2801 					   "invalid operation, such as division by zero.")));
2802 }
2803 
2804 /*
2805  * SIGHUP: set flag to re-read config file at next convenient time.
2806  *
2807  * Sets the ConfigReloadPending flag, which should be checked at convenient
2808  * places inside main loops. (Better than doing the reading in the signal
2809  * handler, ey?)
2810  */
2811 void
PostgresSigHupHandler(SIGNAL_ARGS)2812 PostgresSigHupHandler(SIGNAL_ARGS)
2813 {
2814 	int			save_errno = errno;
2815 
2816 	ConfigReloadPending = true;
2817 	SetLatch(MyLatch);
2818 
2819 	errno = save_errno;
2820 }
2821 
2822 /*
2823  * RecoveryConflictInterrupt: out-of-line portion of recovery conflict
2824  * handling following receipt of SIGUSR1. Designed to be similar to die()
2825  * and StatementCancelHandler(). Called only by a normal user backend
2826  * that begins a transaction during recovery.
2827  */
2828 void
RecoveryConflictInterrupt(ProcSignalReason reason)2829 RecoveryConflictInterrupt(ProcSignalReason reason)
2830 {
2831 	int			save_errno = errno;
2832 
2833 	/*
2834 	 * Don't joggle the elbow of proc_exit
2835 	 */
2836 	if (!proc_exit_inprogress)
2837 	{
2838 		RecoveryConflictReason = reason;
2839 		switch (reason)
2840 		{
2841 			case PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK:
2842 
2843 				/*
2844 				 * If we aren't waiting for a lock we can never deadlock.
2845 				 */
2846 				if (!IsWaitingForLock())
2847 					return;
2848 
2849 				/* Intentional fall through to check wait for pin */
2850 				/* FALLTHROUGH */
2851 
2852 			case PROCSIG_RECOVERY_CONFLICT_BUFFERPIN:
2853 
2854 				/*
2855 				 * If PROCSIG_RECOVERY_CONFLICT_BUFFERPIN is requested but we
2856 				 * aren't blocking the Startup process there is nothing more
2857 				 * to do.
2858 				 *
2859 				 * When PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK is
2860 				 * requested, if we're waiting for locks and the startup
2861 				 * process is not waiting for buffer pin (i.e., also waiting
2862 				 * for locks), we set the flag so that ProcSleep() will check
2863 				 * for deadlocks.
2864 				 */
2865 				if (!HoldingBufferPinThatDelaysRecovery())
2866 				{
2867 					if (reason == PROCSIG_RECOVERY_CONFLICT_STARTUP_DEADLOCK &&
2868 						GetStartupBufferPinWaitBufId() < 0)
2869 						CheckDeadLockAlert();
2870 					return;
2871 				}
2872 
2873 				MyProc->recoveryConflictPending = true;
2874 
2875 				/* Intentional fall through to error handling */
2876 				/* FALLTHROUGH */
2877 
2878 			case PROCSIG_RECOVERY_CONFLICT_LOCK:
2879 			case PROCSIG_RECOVERY_CONFLICT_TABLESPACE:
2880 			case PROCSIG_RECOVERY_CONFLICT_SNAPSHOT:
2881 
2882 				/*
2883 				 * If we aren't in a transaction any longer then ignore.
2884 				 */
2885 				if (!IsTransactionOrTransactionBlock())
2886 					return;
2887 
2888 				/*
2889 				 * If we can abort just the current subtransaction then we are
2890 				 * OK to throw an ERROR to resolve the conflict. Otherwise
2891 				 * drop through to the FATAL case.
2892 				 *
2893 				 * XXX other times that we can throw just an ERROR *may* be
2894 				 * PROCSIG_RECOVERY_CONFLICT_LOCK if no locks are held in
2895 				 * parent transactions
2896 				 *
2897 				 * PROCSIG_RECOVERY_CONFLICT_SNAPSHOT if no snapshots are held
2898 				 * by parent transactions and the transaction is not
2899 				 * transaction-snapshot mode
2900 				 *
2901 				 * PROCSIG_RECOVERY_CONFLICT_TABLESPACE if no temp files or
2902 				 * cursors open in parent transactions
2903 				 */
2904 				if (!IsSubTransaction())
2905 				{
2906 					/*
2907 					 * If we already aborted then we no longer need to cancel.
2908 					 * We do this here since we do not wish to ignore aborted
2909 					 * subtransactions, which must cause FATAL, currently.
2910 					 */
2911 					if (IsAbortedTransactionBlockState())
2912 						return;
2913 
2914 					RecoveryConflictPending = true;
2915 					QueryCancelPending = true;
2916 					InterruptPending = true;
2917 					break;
2918 				}
2919 
2920 				/* Intentional fall through to session cancel */
2921 				/* FALLTHROUGH */
2922 
2923 			case PROCSIG_RECOVERY_CONFLICT_DATABASE:
2924 				RecoveryConflictPending = true;
2925 				ProcDiePending = true;
2926 				InterruptPending = true;
2927 				break;
2928 
2929 			default:
2930 				elog(FATAL, "unrecognized conflict mode: %d",
2931 					 (int) reason);
2932 		}
2933 
2934 		Assert(RecoveryConflictPending && (QueryCancelPending || ProcDiePending));
2935 
2936 		/*
2937 		 * All conflicts apart from database cause dynamic errors where the
2938 		 * command or transaction can be retried at a later point with some
2939 		 * potential for success. No need to reset this, since non-retryable
2940 		 * conflict errors are currently FATAL.
2941 		 */
2942 		if (reason == PROCSIG_RECOVERY_CONFLICT_DATABASE)
2943 			RecoveryConflictRetryable = false;
2944 	}
2945 
2946 	/*
2947 	 * Set the process latch. This function essentially emulates signal
2948 	 * handlers like die() and StatementCancelHandler() and it seems prudent
2949 	 * to behave similarly as they do.
2950 	 */
2951 	SetLatch(MyLatch);
2952 
2953 	errno = save_errno;
2954 }
2955 
2956 /*
2957  * ProcessInterrupts: out-of-line portion of CHECK_FOR_INTERRUPTS() macro
2958  *
2959  * If an interrupt condition is pending, and it's safe to service it,
2960  * then clear the flag and accept the interrupt.  Called only when
2961  * InterruptPending is true.
2962  *
2963  * Note: if INTERRUPTS_CAN_BE_PROCESSED() is true, then ProcessInterrupts
2964  * is guaranteed to clear the InterruptPending flag before returning.
2965  * (This is not the same as guaranteeing that it's still clear when we
2966  * return; another interrupt could have arrived.  But we promise that
2967  * any pre-existing one will have been serviced.)
2968  */
2969 void
ProcessInterrupts(void)2970 ProcessInterrupts(void)
2971 {
2972 	/* OK to accept any interrupts now? */
2973 	if (InterruptHoldoffCount != 0 || CritSectionCount != 0)
2974 		return;
2975 	InterruptPending = false;
2976 
2977 	if (ProcDiePending)
2978 	{
2979 		ProcDiePending = false;
2980 		QueryCancelPending = false; /* ProcDie trumps QueryCancel */
2981 		LockErrorCleanup();
2982 		/* As in quickdie, don't risk sending to client during auth */
2983 		if (ClientAuthInProgress && whereToSendOutput == DestRemote)
2984 			whereToSendOutput = DestNone;
2985 		if (ClientAuthInProgress)
2986 			ereport(FATAL,
2987 					(errcode(ERRCODE_QUERY_CANCELED),
2988 					 errmsg("canceling authentication due to timeout")));
2989 		else if (IsAutoVacuumWorkerProcess())
2990 			ereport(FATAL,
2991 					(errcode(ERRCODE_ADMIN_SHUTDOWN),
2992 					 errmsg("terminating autovacuum process due to administrator command")));
2993 		else if (IsLogicalWorker())
2994 			ereport(FATAL,
2995 					(errcode(ERRCODE_ADMIN_SHUTDOWN),
2996 					 errmsg("terminating logical replication worker due to administrator command")));
2997 		else if (IsLogicalLauncher())
2998 		{
2999 			ereport(DEBUG1,
3000 					(errmsg("logical replication launcher shutting down")));
3001 
3002 			/*
3003 			 * The logical replication launcher can be stopped at any time.
3004 			 * Use exit status 1 so the background worker is restarted.
3005 			 */
3006 			proc_exit(1);
3007 		}
3008 		else if (RecoveryConflictPending && RecoveryConflictRetryable)
3009 		{
3010 			pgstat_report_recovery_conflict(RecoveryConflictReason);
3011 			ereport(FATAL,
3012 					(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
3013 					 errmsg("terminating connection due to conflict with recovery"),
3014 					 errdetail_recovery_conflict()));
3015 		}
3016 		else if (RecoveryConflictPending)
3017 		{
3018 			/* Currently there is only one non-retryable recovery conflict */
3019 			Assert(RecoveryConflictReason == PROCSIG_RECOVERY_CONFLICT_DATABASE);
3020 			pgstat_report_recovery_conflict(RecoveryConflictReason);
3021 			ereport(FATAL,
3022 					(errcode(ERRCODE_DATABASE_DROPPED),
3023 					 errmsg("terminating connection due to conflict with recovery"),
3024 					 errdetail_recovery_conflict()));
3025 		}
3026 		else
3027 			ereport(FATAL,
3028 					(errcode(ERRCODE_ADMIN_SHUTDOWN),
3029 					 errmsg("terminating connection due to administrator command")));
3030 	}
3031 	if (ClientConnectionLost)
3032 	{
3033 		QueryCancelPending = false; /* lost connection trumps QueryCancel */
3034 		LockErrorCleanup();
3035 		/* don't send to client, we already know the connection to be dead. */
3036 		whereToSendOutput = DestNone;
3037 		ereport(FATAL,
3038 				(errcode(ERRCODE_CONNECTION_FAILURE),
3039 				 errmsg("connection to client lost")));
3040 	}
3041 
3042 	/*
3043 	 * If a recovery conflict happens while we are waiting for input from the
3044 	 * client, the client is presumably just sitting idle in a transaction,
3045 	 * preventing recovery from making progress.  Terminate the connection to
3046 	 * dislodge it.
3047 	 */
3048 	if (RecoveryConflictPending && DoingCommandRead)
3049 	{
3050 		QueryCancelPending = false; /* this trumps QueryCancel */
3051 		RecoveryConflictPending = false;
3052 		LockErrorCleanup();
3053 		pgstat_report_recovery_conflict(RecoveryConflictReason);
3054 		ereport(FATAL,
3055 				(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
3056 				 errmsg("terminating connection due to conflict with recovery"),
3057 				 errdetail_recovery_conflict(),
3058 				 errhint("In a moment you should be able to reconnect to the"
3059 						 " database and repeat your command.")));
3060 	}
3061 
3062 	/*
3063 	 * Don't allow query cancel interrupts while reading input from the
3064 	 * client, because we might lose sync in the FE/BE protocol.  (Die
3065 	 * interrupts are OK, because we won't read any further messages from the
3066 	 * client in that case.)
3067 	 */
3068 	if (QueryCancelPending && QueryCancelHoldoffCount != 0)
3069 	{
3070 		/*
3071 		 * Re-arm InterruptPending so that we process the cancel request as
3072 		 * soon as we're done reading the message.  (XXX this is seriously
3073 		 * ugly: it complicates INTERRUPTS_CAN_BE_PROCESSED(), and it means we
3074 		 * can't use that macro directly as the initial test in this function,
3075 		 * meaning that this code also creates opportunities for other bugs to
3076 		 * appear.)
3077 		 */
3078 		InterruptPending = true;
3079 	}
3080 	else if (QueryCancelPending)
3081 	{
3082 		bool		lock_timeout_occurred;
3083 		bool		stmt_timeout_occurred;
3084 
3085 		QueryCancelPending = false;
3086 
3087 		/*
3088 		 * If LOCK_TIMEOUT and STATEMENT_TIMEOUT indicators are both set, we
3089 		 * need to clear both, so always fetch both.
3090 		 */
3091 		lock_timeout_occurred = get_timeout_indicator(LOCK_TIMEOUT, true);
3092 		stmt_timeout_occurred = get_timeout_indicator(STATEMENT_TIMEOUT, true);
3093 
3094 		/*
3095 		 * If both were set, we want to report whichever timeout completed
3096 		 * earlier; this ensures consistent behavior if the machine is slow
3097 		 * enough that the second timeout triggers before we get here.  A tie
3098 		 * is arbitrarily broken in favor of reporting a lock timeout.
3099 		 */
3100 		if (lock_timeout_occurred && stmt_timeout_occurred &&
3101 			get_timeout_finish_time(STATEMENT_TIMEOUT) < get_timeout_finish_time(LOCK_TIMEOUT))
3102 			lock_timeout_occurred = false;	/* report stmt timeout */
3103 
3104 		if (lock_timeout_occurred)
3105 		{
3106 			LockErrorCleanup();
3107 			ereport(ERROR,
3108 					(errcode(ERRCODE_LOCK_NOT_AVAILABLE),
3109 					 errmsg("canceling statement due to lock timeout")));
3110 		}
3111 		if (stmt_timeout_occurred)
3112 		{
3113 			LockErrorCleanup();
3114 			ereport(ERROR,
3115 					(errcode(ERRCODE_QUERY_CANCELED),
3116 					 errmsg("canceling statement due to statement timeout")));
3117 		}
3118 		if (IsAutoVacuumWorkerProcess())
3119 		{
3120 			LockErrorCleanup();
3121 			ereport(ERROR,
3122 					(errcode(ERRCODE_QUERY_CANCELED),
3123 					 errmsg("canceling autovacuum task")));
3124 		}
3125 		if (RecoveryConflictPending)
3126 		{
3127 			RecoveryConflictPending = false;
3128 			LockErrorCleanup();
3129 			pgstat_report_recovery_conflict(RecoveryConflictReason);
3130 			ereport(ERROR,
3131 					(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
3132 					 errmsg("canceling statement due to conflict with recovery"),
3133 					 errdetail_recovery_conflict()));
3134 		}
3135 
3136 		/*
3137 		 * If we are reading a command from the client, just ignore the cancel
3138 		 * request --- sending an extra error message won't accomplish
3139 		 * anything.  Otherwise, go ahead and throw the error.
3140 		 */
3141 		if (!DoingCommandRead)
3142 		{
3143 			LockErrorCleanup();
3144 			ereport(ERROR,
3145 					(errcode(ERRCODE_QUERY_CANCELED),
3146 					 errmsg("canceling statement due to user request")));
3147 		}
3148 	}
3149 
3150 	if (IdleInTransactionSessionTimeoutPending)
3151 	{
3152 		/* Has the timeout setting changed since last we looked? */
3153 		if (IdleInTransactionSessionTimeout > 0)
3154 			ereport(FATAL,
3155 					(errcode(ERRCODE_IDLE_IN_TRANSACTION_SESSION_TIMEOUT),
3156 					 errmsg("terminating connection due to idle-in-transaction timeout")));
3157 		else
3158 			IdleInTransactionSessionTimeoutPending = false;
3159 
3160 	}
3161 
3162 	if (ParallelMessagePending)
3163 		HandleParallelMessages();
3164 }
3165 
3166 
3167 /*
3168  * IA64-specific code to fetch the AR.BSP register for stack depth checks.
3169  *
3170  * We currently support gcc, icc, and HP-UX's native compiler here.
3171  *
3172  * Note: while icc accepts gcc asm blocks on x86[_64], this is not true on
3173  * ia64 (at least not in icc versions before 12.x).  So we have to carry a
3174  * separate implementation for it.
3175  */
3176 #if defined(__ia64__) || defined(__ia64)
3177 
3178 #if defined(__hpux) && !defined(__GNUC__) && !defined(__INTEL_COMPILER)
3179 /* Assume it's HP-UX native compiler */
3180 #include <ia64/sys/inline.h>
3181 #define ia64_get_bsp() ((char *) (_Asm_mov_from_ar(_AREG_BSP, _NO_FENCE)))
3182 #elif defined(__INTEL_COMPILER)
3183 /* icc */
3184 #include <asm/ia64regs.h>
3185 #define ia64_get_bsp() ((char *) __getReg(_IA64_REG_AR_BSP))
3186 #else
3187 /* gcc */
3188 static __inline__ char *
ia64_get_bsp(void)3189 ia64_get_bsp(void)
3190 {
3191 	char	   *ret;
3192 
3193 	/* the ;; is a "stop", seems to be required before fetching BSP */
3194 	__asm__ __volatile__(
3195 						 ";;\n"
3196 						 "	mov	%0=ar.bsp	\n"
3197 :						 "=r"(ret));
3198 
3199 	return ret;
3200 }
3201 #endif
3202 #endif							/* IA64 */
3203 
3204 
3205 /*
3206  * set_stack_base: set up reference point for stack depth checking
3207  *
3208  * Returns the old reference point, if any.
3209  */
3210 pg_stack_base_t
set_stack_base(void)3211 set_stack_base(void)
3212 {
3213 	char		stack_base;
3214 	pg_stack_base_t old;
3215 
3216 #if defined(__ia64__) || defined(__ia64)
3217 	old.stack_base_ptr = stack_base_ptr;
3218 	old.register_stack_base_ptr = register_stack_base_ptr;
3219 #else
3220 	old = stack_base_ptr;
3221 #endif
3222 
3223 	/* Set up reference point for stack depth checking */
3224 	stack_base_ptr = &stack_base;
3225 #if defined(__ia64__) || defined(__ia64)
3226 	register_stack_base_ptr = ia64_get_bsp();
3227 #endif
3228 
3229 	return old;
3230 }
3231 
3232 /*
3233  * restore_stack_base: restore reference point for stack depth checking
3234  *
3235  * This can be used after set_stack_base() to restore the old value. This
3236  * is currently only used in PL/Java. When PL/Java calls a backend function
3237  * from different thread, the thread's stack is at a different location than
3238  * the main thread's stack, so it sets the base pointer before the call, and
3239  * restores it afterwards.
3240  */
3241 void
restore_stack_base(pg_stack_base_t base)3242 restore_stack_base(pg_stack_base_t base)
3243 {
3244 #if defined(__ia64__) || defined(__ia64)
3245 	stack_base_ptr = base.stack_base_ptr;
3246 	register_stack_base_ptr = base.register_stack_base_ptr;
3247 #else
3248 	stack_base_ptr = base;
3249 #endif
3250 }
3251 
3252 /*
3253  * check_stack_depth/stack_is_too_deep: check for excessively deep recursion
3254  *
3255  * This should be called someplace in any recursive routine that might possibly
3256  * recurse deep enough to overflow the stack.  Most Unixen treat stack
3257  * overflow as an unrecoverable SIGSEGV, so we want to error out ourselves
3258  * before hitting the hardware limit.
3259  *
3260  * check_stack_depth() just throws an error summarily.  stack_is_too_deep()
3261  * can be used by code that wants to handle the error condition itself.
3262  */
3263 void
check_stack_depth(void)3264 check_stack_depth(void)
3265 {
3266 	if (stack_is_too_deep())
3267 	{
3268 		ereport(ERROR,
3269 				(errcode(ERRCODE_STATEMENT_TOO_COMPLEX),
3270 				 errmsg("stack depth limit exceeded"),
3271 				 errhint("Increase the configuration parameter \"max_stack_depth\" (currently %dkB), "
3272 						 "after ensuring the platform's stack depth limit is adequate.",
3273 						 max_stack_depth)));
3274 	}
3275 }
3276 
3277 bool
stack_is_too_deep(void)3278 stack_is_too_deep(void)
3279 {
3280 	char		stack_top_loc;
3281 	long		stack_depth;
3282 
3283 	/*
3284 	 * Compute distance from reference point to my local variables
3285 	 */
3286 	stack_depth = (long) (stack_base_ptr - &stack_top_loc);
3287 
3288 	/*
3289 	 * Take abs value, since stacks grow up on some machines, down on others
3290 	 */
3291 	if (stack_depth < 0)
3292 		stack_depth = -stack_depth;
3293 
3294 	/*
3295 	 * Trouble?
3296 	 *
3297 	 * The test on stack_base_ptr prevents us from erroring out if called
3298 	 * during process setup or in a non-backend process.  Logically it should
3299 	 * be done first, but putting it here avoids wasting cycles during normal
3300 	 * cases.
3301 	 */
3302 	if (stack_depth > max_stack_depth_bytes &&
3303 		stack_base_ptr != NULL)
3304 		return true;
3305 
3306 	/*
3307 	 * On IA64 there is a separate "register" stack that requires its own
3308 	 * independent check.  For this, we have to measure the change in the
3309 	 * "BSP" pointer from PostgresMain to here.  Logic is just as above,
3310 	 * except that we know IA64's register stack grows up.
3311 	 *
3312 	 * Note we assume that the same max_stack_depth applies to both stacks.
3313 	 */
3314 #if defined(__ia64__) || defined(__ia64)
3315 	stack_depth = (long) (ia64_get_bsp() - register_stack_base_ptr);
3316 
3317 	if (stack_depth > max_stack_depth_bytes &&
3318 		register_stack_base_ptr != NULL)
3319 		return true;
3320 #endif							/* IA64 */
3321 
3322 	return false;
3323 }
3324 
3325 /* GUC check hook for max_stack_depth */
3326 bool
check_max_stack_depth(int * newval,void ** extra,GucSource source)3327 check_max_stack_depth(int *newval, void **extra, GucSource source)
3328 {
3329 	long		newval_bytes = *newval * 1024L;
3330 	long		stack_rlimit = get_stack_depth_rlimit();
3331 
3332 	if (stack_rlimit > 0 && newval_bytes > stack_rlimit - STACK_DEPTH_SLOP)
3333 	{
3334 		GUC_check_errdetail("\"max_stack_depth\" must not exceed %ldkB.",
3335 							(stack_rlimit - STACK_DEPTH_SLOP) / 1024L);
3336 		GUC_check_errhint("Increase the platform's stack depth limit via \"ulimit -s\" or local equivalent.");
3337 		return false;
3338 	}
3339 	return true;
3340 }
3341 
3342 /* GUC assign hook for max_stack_depth */
3343 void
assign_max_stack_depth(int newval,void * extra)3344 assign_max_stack_depth(int newval, void *extra)
3345 {
3346 	long		newval_bytes = newval * 1024L;
3347 
3348 	max_stack_depth_bytes = newval_bytes;
3349 }
3350 
3351 
3352 /*
3353  * set_debug_options --- apply "-d N" command line option
3354  *
3355  * -d is not quite the same as setting log_min_messages because it enables
3356  * other output options.
3357  */
3358 void
set_debug_options(int debug_flag,GucContext context,GucSource source)3359 set_debug_options(int debug_flag, GucContext context, GucSource source)
3360 {
3361 	if (debug_flag > 0)
3362 	{
3363 		char		debugstr[64];
3364 
3365 		sprintf(debugstr, "debug%d", debug_flag);
3366 		SetConfigOption("log_min_messages", debugstr, context, source);
3367 	}
3368 	else
3369 		SetConfigOption("log_min_messages", "notice", context, source);
3370 
3371 	if (debug_flag >= 1 && context == PGC_POSTMASTER)
3372 	{
3373 		SetConfigOption("log_connections", "true", context, source);
3374 		SetConfigOption("log_disconnections", "true", context, source);
3375 	}
3376 	if (debug_flag >= 2)
3377 		SetConfigOption("log_statement", "all", context, source);
3378 	if (debug_flag >= 3)
3379 		SetConfigOption("debug_print_parse", "true", context, source);
3380 	if (debug_flag >= 4)
3381 		SetConfigOption("debug_print_plan", "true", context, source);
3382 	if (debug_flag >= 5)
3383 		SetConfigOption("debug_print_rewritten", "true", context, source);
3384 }
3385 
3386 
3387 bool
set_plan_disabling_options(const char * arg,GucContext context,GucSource source)3388 set_plan_disabling_options(const char *arg, GucContext context, GucSource source)
3389 {
3390 	const char *tmp = NULL;
3391 
3392 	switch (arg[0])
3393 	{
3394 		case 's':				/* seqscan */
3395 			tmp = "enable_seqscan";
3396 			break;
3397 		case 'i':				/* indexscan */
3398 			tmp = "enable_indexscan";
3399 			break;
3400 		case 'o':				/* indexonlyscan */
3401 			tmp = "enable_indexonlyscan";
3402 			break;
3403 		case 'b':				/* bitmapscan */
3404 			tmp = "enable_bitmapscan";
3405 			break;
3406 		case 't':				/* tidscan */
3407 			tmp = "enable_tidscan";
3408 			break;
3409 		case 'n':				/* nestloop */
3410 			tmp = "enable_nestloop";
3411 			break;
3412 		case 'm':				/* mergejoin */
3413 			tmp = "enable_mergejoin";
3414 			break;
3415 		case 'h':				/* hashjoin */
3416 			tmp = "enable_hashjoin";
3417 			break;
3418 	}
3419 	if (tmp)
3420 	{
3421 		SetConfigOption(tmp, "false", context, source);
3422 		return true;
3423 	}
3424 	else
3425 		return false;
3426 }
3427 
3428 
3429 const char *
get_stats_option_name(const char * arg)3430 get_stats_option_name(const char *arg)
3431 {
3432 	switch (arg[0])
3433 	{
3434 		case 'p':
3435 			if (optarg[1] == 'a')	/* "parser" */
3436 				return "log_parser_stats";
3437 			else if (optarg[1] == 'l')	/* "planner" */
3438 				return "log_planner_stats";
3439 			break;
3440 
3441 		case 'e':				/* "executor" */
3442 			return "log_executor_stats";
3443 			break;
3444 	}
3445 
3446 	return NULL;
3447 }
3448 
3449 
3450 /* ----------------------------------------------------------------
3451  * process_postgres_switches
3452  *	   Parse command line arguments for PostgresMain
3453  *
3454  * This is called twice, once for the "secure" options coming from the
3455  * postmaster or command line, and once for the "insecure" options coming
3456  * from the client's startup packet.  The latter have the same syntax but
3457  * may be restricted in what they can do.
3458  *
3459  * argv[0] is ignored in either case (it's assumed to be the program name).
3460  *
3461  * ctx is PGC_POSTMASTER for secure options, PGC_BACKEND for insecure options
3462  * coming from the client, or PGC_SU_BACKEND for insecure options coming from
3463  * a superuser client.
3464  *
3465  * If a database name is present in the command line arguments, it's
3466  * returned into *dbname (this is allowed only if *dbname is initially NULL).
3467  * ----------------------------------------------------------------
3468  */
3469 void
process_postgres_switches(int argc,char * argv[],GucContext ctx,const char ** dbname)3470 process_postgres_switches(int argc, char *argv[], GucContext ctx,
3471 						  const char **dbname)
3472 {
3473 	bool		secure = (ctx == PGC_POSTMASTER);
3474 	int			errs = 0;
3475 	GucSource	gucsource;
3476 	int			flag;
3477 
3478 	if (secure)
3479 	{
3480 		gucsource = PGC_S_ARGV; /* switches came from command line */
3481 
3482 		/* Ignore the initial --single argument, if present */
3483 		if (argc > 1 && strcmp(argv[1], "--single") == 0)
3484 		{
3485 			argv++;
3486 			argc--;
3487 		}
3488 	}
3489 	else
3490 	{
3491 		gucsource = PGC_S_CLIENT;	/* switches came from client */
3492 	}
3493 
3494 #ifdef HAVE_INT_OPTERR
3495 
3496 	/*
3497 	 * Turn this off because it's either printed to stderr and not the log
3498 	 * where we'd want it, or argv[0] is now "--single", which would make for
3499 	 * a weird error message.  We print our own error message below.
3500 	 */
3501 	opterr = 0;
3502 #endif
3503 
3504 	/*
3505 	 * Parse command-line options.  CAUTION: keep this in sync with
3506 	 * postmaster/postmaster.c (the option sets should not conflict) and with
3507 	 * the common help() function in main/main.c.
3508 	 */
3509 	while ((flag = getopt(argc, argv, "B:bc:C:D:d:EeFf:h:ijk:lN:nOo:Pp:r:S:sTt:v:W:-:")) != -1)
3510 	{
3511 		switch (flag)
3512 		{
3513 			case 'B':
3514 				SetConfigOption("shared_buffers", optarg, ctx, gucsource);
3515 				break;
3516 
3517 			case 'b':
3518 				/* Undocumented flag used for binary upgrades */
3519 				if (secure)
3520 					IsBinaryUpgrade = true;
3521 				break;
3522 
3523 			case 'C':
3524 				/* ignored for consistency with the postmaster */
3525 				break;
3526 
3527 			case 'D':
3528 				if (secure)
3529 					userDoption = strdup(optarg);
3530 				break;
3531 
3532 			case 'd':
3533 				set_debug_options(atoi(optarg), ctx, gucsource);
3534 				break;
3535 
3536 			case 'E':
3537 				if (secure)
3538 					EchoQuery = true;
3539 				break;
3540 
3541 			case 'e':
3542 				SetConfigOption("datestyle", "euro", ctx, gucsource);
3543 				break;
3544 
3545 			case 'F':
3546 				SetConfigOption("fsync", "false", ctx, gucsource);
3547 				break;
3548 
3549 			case 'f':
3550 				if (!set_plan_disabling_options(optarg, ctx, gucsource))
3551 					errs++;
3552 				break;
3553 
3554 			case 'h':
3555 				SetConfigOption("listen_addresses", optarg, ctx, gucsource);
3556 				break;
3557 
3558 			case 'i':
3559 				SetConfigOption("listen_addresses", "*", ctx, gucsource);
3560 				break;
3561 
3562 			case 'j':
3563 				if (secure)
3564 					UseSemiNewlineNewline = true;
3565 				break;
3566 
3567 			case 'k':
3568 				SetConfigOption("unix_socket_directories", optarg, ctx, gucsource);
3569 				break;
3570 
3571 			case 'l':
3572 				SetConfigOption("ssl", "true", ctx, gucsource);
3573 				break;
3574 
3575 			case 'N':
3576 				SetConfigOption("max_connections", optarg, ctx, gucsource);
3577 				break;
3578 
3579 			case 'n':
3580 				/* ignored for consistency with postmaster */
3581 				break;
3582 
3583 			case 'O':
3584 				SetConfigOption("allow_system_table_mods", "true", ctx, gucsource);
3585 				break;
3586 
3587 			case 'o':
3588 				errs++;
3589 				break;
3590 
3591 			case 'P':
3592 				SetConfigOption("ignore_system_indexes", "true", ctx, gucsource);
3593 				break;
3594 
3595 			case 'p':
3596 				SetConfigOption("port", optarg, ctx, gucsource);
3597 				break;
3598 
3599 			case 'r':
3600 				/* send output (stdout and stderr) to the given file */
3601 				if (secure)
3602 					strlcpy(OutputFileName, optarg, MAXPGPATH);
3603 				break;
3604 
3605 			case 'S':
3606 				SetConfigOption("work_mem", optarg, ctx, gucsource);
3607 				break;
3608 
3609 			case 's':
3610 				SetConfigOption("log_statement_stats", "true", ctx, gucsource);
3611 				break;
3612 
3613 			case 'T':
3614 				/* ignored for consistency with the postmaster */
3615 				break;
3616 
3617 			case 't':
3618 				{
3619 					const char *tmp = get_stats_option_name(optarg);
3620 
3621 					if (tmp)
3622 						SetConfigOption(tmp, "true", ctx, gucsource);
3623 					else
3624 						errs++;
3625 					break;
3626 				}
3627 
3628 			case 'v':
3629 
3630 				/*
3631 				 * -v is no longer used in normal operation, since
3632 				 * FrontendProtocol is already set before we get here. We keep
3633 				 * the switch only for possible use in standalone operation,
3634 				 * in case we ever support using normal FE/BE protocol with a
3635 				 * standalone backend.
3636 				 */
3637 				if (secure)
3638 					FrontendProtocol = (ProtocolVersion) atoi(optarg);
3639 				break;
3640 
3641 			case 'W':
3642 				SetConfigOption("post_auth_delay", optarg, ctx, gucsource);
3643 				break;
3644 
3645 			case 'c':
3646 			case '-':
3647 				{
3648 					char	   *name,
3649 							   *value;
3650 
3651 					ParseLongOption(optarg, &name, &value);
3652 					if (!value)
3653 					{
3654 						if (flag == '-')
3655 							ereport(ERROR,
3656 									(errcode(ERRCODE_SYNTAX_ERROR),
3657 									 errmsg("--%s requires a value",
3658 											optarg)));
3659 						else
3660 							ereport(ERROR,
3661 									(errcode(ERRCODE_SYNTAX_ERROR),
3662 									 errmsg("-c %s requires a value",
3663 											optarg)));
3664 					}
3665 					SetConfigOption(name, value, ctx, gucsource);
3666 					free(name);
3667 					if (value)
3668 						free(value);
3669 					break;
3670 				}
3671 
3672 			default:
3673 				errs++;
3674 				break;
3675 		}
3676 
3677 		if (errs)
3678 			break;
3679 	}
3680 
3681 	/*
3682 	 * Optional database name should be there only if *dbname is NULL.
3683 	 */
3684 	if (!errs && dbname && *dbname == NULL && argc - optind >= 1)
3685 		*dbname = strdup(argv[optind++]);
3686 
3687 	if (errs || argc != optind)
3688 	{
3689 		if (errs)
3690 			optind--;			/* complain about the previous argument */
3691 
3692 		/* spell the error message a bit differently depending on context */
3693 		if (IsUnderPostmaster)
3694 			ereport(FATAL,
3695 					errcode(ERRCODE_SYNTAX_ERROR),
3696 					errmsg("invalid command-line argument for server process: %s", argv[optind]),
3697 					errhint("Try \"%s --help\" for more information.", progname));
3698 		else
3699 			ereport(FATAL,
3700 					errcode(ERRCODE_SYNTAX_ERROR),
3701 					errmsg("%s: invalid command-line argument: %s",
3702 						   progname, argv[optind]),
3703 					errhint("Try \"%s --help\" for more information.", progname));
3704 	}
3705 
3706 	/*
3707 	 * Reset getopt(3) library so that it will work correctly in subprocesses
3708 	 * or when this function is called a second time with another array.
3709 	 */
3710 	optind = 1;
3711 #ifdef HAVE_INT_OPTRESET
3712 	optreset = 1;				/* some systems need this too */
3713 #endif
3714 }
3715 
3716 
3717 /* ----------------------------------------------------------------
3718  * PostgresMain
3719  *	   postgres main loop -- all backends, interactive or otherwise start here
3720  *
3721  * argc/argv are the command line arguments to be used.  (When being forked
3722  * by the postmaster, these are not the original argv array of the process.)
3723  * dbname is the name of the database to connect to, or NULL if the database
3724  * name should be extracted from the command line arguments or defaulted.
3725  * username is the PostgreSQL user name to be used for the session.
3726  * ----------------------------------------------------------------
3727  */
3728 void
PostgresMain(int argc,char * argv[],const char * dbname,const char * username)3729 PostgresMain(int argc, char *argv[],
3730 			 const char *dbname,
3731 			 const char *username)
3732 {
3733 	int			firstchar;
3734 	StringInfoData input_message;
3735 	sigjmp_buf	local_sigjmp_buf;
3736 	volatile bool send_ready_for_query = true;
3737 	bool		disable_idle_in_transaction_timeout = false;
3738 
3739 	/* Initialize startup process environment if necessary. */
3740 	if (!IsUnderPostmaster)
3741 		InitStandaloneProcess(argv[0]);
3742 
3743 	SetProcessingMode(InitProcessing);
3744 
3745 	/*
3746 	 * Set default values for command-line options.
3747 	 */
3748 	if (!IsUnderPostmaster)
3749 		InitializeGUCOptions();
3750 
3751 	/*
3752 	 * Parse command-line options.
3753 	 */
3754 	process_postgres_switches(argc, argv, PGC_POSTMASTER, &dbname);
3755 
3756 	/* Must have gotten a database name, or have a default (the username) */
3757 	if (dbname == NULL)
3758 	{
3759 		dbname = username;
3760 		if (dbname == NULL)
3761 			ereport(FATAL,
3762 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
3763 					 errmsg("%s: no database nor user name specified",
3764 							progname)));
3765 	}
3766 
3767 	/* Acquire configuration parameters, unless inherited from postmaster */
3768 	if (!IsUnderPostmaster)
3769 	{
3770 		if (!SelectConfigFiles(userDoption, progname))
3771 			proc_exit(1);
3772 	}
3773 
3774 	/*
3775 	 * Set up signal handlers and masks.
3776 	 *
3777 	 * Note that postmaster blocked all signals before forking child process,
3778 	 * so there is no race condition whereby we might receive a signal before
3779 	 * we have set up the handler.
3780 	 *
3781 	 * Also note: it's best not to use any signals that are SIG_IGNored in the
3782 	 * postmaster.  If such a signal arrives before we are able to change the
3783 	 * handler to non-SIG_IGN, it'll get dropped.  Instead, make a dummy
3784 	 * handler in the postmaster to reserve the signal. (Of course, this isn't
3785 	 * an issue for signals that are locally generated, such as SIGALRM and
3786 	 * SIGPIPE.)
3787 	 */
3788 	if (am_walsender)
3789 		WalSndSignals();
3790 	else
3791 	{
3792 		pqsignal(SIGHUP, PostgresSigHupHandler);	/* set flag to read config
3793 													 * file */
3794 		pqsignal(SIGINT, StatementCancelHandler);	/* cancel current query */
3795 		pqsignal(SIGTERM, die); /* cancel current query and exit */
3796 
3797 		/*
3798 		 * In a standalone backend, SIGQUIT can be generated from the keyboard
3799 		 * easily, while SIGTERM cannot, so we make both signals do die()
3800 		 * rather than quickdie().
3801 		 */
3802 		if (IsUnderPostmaster)
3803 			pqsignal(SIGQUIT, quickdie);	/* hard crash time */
3804 		else
3805 			pqsignal(SIGQUIT, die); /* cancel current query and exit */
3806 		InitializeTimeouts();	/* establishes SIGALRM handler */
3807 
3808 		/*
3809 		 * Ignore failure to write to frontend. Note: if frontend closes
3810 		 * connection, we will notice it and exit cleanly when control next
3811 		 * returns to outer loop.  This seems safer than forcing exit in the
3812 		 * midst of output during who-knows-what operation...
3813 		 */
3814 		pqsignal(SIGPIPE, SIG_IGN);
3815 		pqsignal(SIGUSR1, procsignal_sigusr1_handler);
3816 		pqsignal(SIGUSR2, SIG_IGN);
3817 		pqsignal(SIGFPE, FloatExceptionHandler);
3818 
3819 		/*
3820 		 * Reset some signals that are accepted by postmaster but not by
3821 		 * backend
3822 		 */
3823 		pqsignal(SIGCHLD, SIG_DFL); /* system() requires this on some
3824 									 * platforms */
3825 	}
3826 
3827 	pqinitmask();
3828 
3829 	if (IsUnderPostmaster)
3830 	{
3831 		/* We allow SIGQUIT (quickdie) at all times */
3832 		sigdelset(&BlockSig, SIGQUIT);
3833 	}
3834 
3835 	PG_SETMASK(&BlockSig);		/* block everything except SIGQUIT */
3836 
3837 	if (!IsUnderPostmaster)
3838 	{
3839 		/*
3840 		 * Validate we have been given a reasonable-looking DataDir (if under
3841 		 * postmaster, assume postmaster did this already).
3842 		 */
3843 		checkDataDir();
3844 
3845 		/* Change into DataDir (if under postmaster, was done already) */
3846 		ChangeToDataDir();
3847 
3848 		/*
3849 		 * Create lockfile for data directory.
3850 		 */
3851 		CreateDataDirLockFile(false);
3852 
3853 		/* read control file (error checking and contains config ) */
3854 		LocalProcessControlFile(false);
3855 
3856 		/* Initialize MaxBackends (if under postmaster, was done already) */
3857 		InitializeMaxBackends();
3858 	}
3859 
3860 	/* Early initialization */
3861 	BaseInit();
3862 
3863 	/*
3864 	 * Create a per-backend PGPROC struct in shared memory, except in the
3865 	 * EXEC_BACKEND case where this was done in SubPostmasterMain. We must do
3866 	 * this before we can use LWLocks (and in the EXEC_BACKEND case we already
3867 	 * had to do some stuff with LWLocks).
3868 	 */
3869 #ifdef EXEC_BACKEND
3870 	if (!IsUnderPostmaster)
3871 		InitProcess();
3872 #else
3873 	InitProcess();
3874 #endif
3875 
3876 	/* We need to allow SIGINT, etc during the initial transaction */
3877 	PG_SETMASK(&UnBlockSig);
3878 
3879 	/*
3880 	 * General initialization.
3881 	 *
3882 	 * NOTE: if you are tempted to add code in this vicinity, consider putting
3883 	 * it inside InitPostgres() instead.  In particular, anything that
3884 	 * involves database access should be there, not here.
3885 	 */
3886 	InitPostgres(dbname, InvalidOid, username, InvalidOid, NULL, false);
3887 
3888 	/*
3889 	 * If the PostmasterContext is still around, recycle the space; we don't
3890 	 * need it anymore after InitPostgres completes.  Note this does not trash
3891 	 * *MyProcPort, because ConnCreate() allocated that space with malloc()
3892 	 * ... else we'd need to copy the Port data first.  Also, subsidiary data
3893 	 * such as the username isn't lost either; see ProcessStartupPacket().
3894 	 */
3895 	if (PostmasterContext)
3896 	{
3897 		MemoryContextDelete(PostmasterContext);
3898 		PostmasterContext = NULL;
3899 	}
3900 
3901 	SetProcessingMode(NormalProcessing);
3902 
3903 	/*
3904 	 * Now all GUC states are fully set up.  Report them to client if
3905 	 * appropriate.
3906 	 */
3907 	BeginReportingGUCOptions();
3908 
3909 	/*
3910 	 * Also set up handler to log session end; we have to wait till now to be
3911 	 * sure Log_disconnections has its final value.
3912 	 */
3913 	if (IsUnderPostmaster && Log_disconnections)
3914 		on_proc_exit(log_disconnections, 0);
3915 
3916 	/* Perform initialization specific to a WAL sender process. */
3917 	if (am_walsender)
3918 		InitWalSender();
3919 
3920 	/*
3921 	 * process any libraries that should be preloaded at backend start (this
3922 	 * likewise can't be done until GUC settings are complete)
3923 	 */
3924 	process_session_preload_libraries();
3925 
3926 	/*
3927 	 * Send this backend's cancellation info to the frontend.
3928 	 */
3929 	if (whereToSendOutput == DestRemote)
3930 	{
3931 		StringInfoData buf;
3932 
3933 		pq_beginmessage(&buf, 'K');
3934 		pq_sendint32(&buf, (int32) MyProcPid);
3935 		pq_sendint32(&buf, (int32) MyCancelKey);
3936 		pq_endmessage(&buf);
3937 		/* Need not flush since ReadyForQuery will do it. */
3938 	}
3939 
3940 	/* Welcome banner for standalone case */
3941 	if (whereToSendOutput == DestDebug)
3942 		printf("\nPostgreSQL stand-alone backend %s\n", PG_VERSION);
3943 
3944 	/*
3945 	 * Create the memory context we will use in the main loop.
3946 	 *
3947 	 * MessageContext is reset once per iteration of the main loop, ie, upon
3948 	 * completion of processing of each command message from the client.
3949 	 */
3950 	MessageContext = AllocSetContextCreate(TopMemoryContext,
3951 										   "MessageContext",
3952 										   ALLOCSET_DEFAULT_SIZES);
3953 
3954 	/*
3955 	 * Create memory context and buffer used for RowDescription messages. As
3956 	 * SendRowDescriptionMessage(), via exec_describe_statement_message(), is
3957 	 * frequently executed for ever single statement, we don't want to
3958 	 * allocate a separate buffer every time.
3959 	 */
3960 	row_description_context = AllocSetContextCreate(TopMemoryContext,
3961 													"RowDescriptionContext",
3962 													ALLOCSET_DEFAULT_SIZES);
3963 	MemoryContextSwitchTo(row_description_context);
3964 	initStringInfo(&row_description_buf);
3965 	MemoryContextSwitchTo(TopMemoryContext);
3966 
3967 	/*
3968 	 * Remember stand-alone backend startup time
3969 	 */
3970 	if (!IsUnderPostmaster)
3971 		PgStartTime = GetCurrentTimestamp();
3972 
3973 	/*
3974 	 * POSTGRES main processing loop begins here
3975 	 *
3976 	 * If an exception is encountered, processing resumes here so we abort the
3977 	 * current transaction and start a new one.
3978 	 *
3979 	 * You might wonder why this isn't coded as an infinite loop around a
3980 	 * PG_TRY construct.  The reason is that this is the bottom of the
3981 	 * exception stack, and so with PG_TRY there would be no exception handler
3982 	 * in force at all during the CATCH part.  By leaving the outermost setjmp
3983 	 * always active, we have at least some chance of recovering from an error
3984 	 * during error recovery.  (If we get into an infinite loop thereby, it
3985 	 * will soon be stopped by overflow of elog.c's internal state stack.)
3986 	 *
3987 	 * Note that we use sigsetjmp(..., 1), so that this function's signal mask
3988 	 * (to wit, UnBlockSig) will be restored when longjmp'ing to here.  This
3989 	 * is essential in case we longjmp'd out of a signal handler on a platform
3990 	 * where that leaves the signal blocked.  It's not redundant with the
3991 	 * unblock in AbortTransaction() because the latter is only called if we
3992 	 * were inside a transaction.
3993 	 */
3994 
3995 	if (sigsetjmp(local_sigjmp_buf, 1) != 0)
3996 	{
3997 		/*
3998 		 * NOTE: if you are tempted to add more code in this if-block,
3999 		 * consider the high probability that it should be in
4000 		 * AbortTransaction() instead.  The only stuff done directly here
4001 		 * should be stuff that is guaranteed to apply *only* for outer-level
4002 		 * error recovery, such as adjusting the FE/BE protocol status.
4003 		 */
4004 
4005 		/* Since not using PG_TRY, must reset error stack by hand */
4006 		error_context_stack = NULL;
4007 
4008 		/* Prevent interrupts while cleaning up */
4009 		HOLD_INTERRUPTS();
4010 
4011 		/*
4012 		 * Forget any pending QueryCancel request, since we're returning to
4013 		 * the idle loop anyway, and cancel any active timeout requests.  (In
4014 		 * future we might want to allow some timeout requests to survive, but
4015 		 * at minimum it'd be necessary to do reschedule_timeouts(), in case
4016 		 * we got here because of a query cancel interrupting the SIGALRM
4017 		 * interrupt handler.)	Note in particular that we must clear the
4018 		 * statement and lock timeout indicators, to prevent any future plain
4019 		 * query cancels from being misreported as timeouts in case we're
4020 		 * forgetting a timeout cancel.
4021 		 */
4022 		disable_all_timeouts(false);
4023 		QueryCancelPending = false; /* second to avoid race condition */
4024 		stmt_timeout_active = false;
4025 
4026 		/* Not reading from the client anymore. */
4027 		DoingCommandRead = false;
4028 
4029 		/* Make sure libpq is in a good state */
4030 		pq_comm_reset();
4031 
4032 		/* Report the error to the client and/or server log */
4033 		EmitErrorReport();
4034 
4035 		/*
4036 		 * Make sure debug_query_string gets reset before we possibly clobber
4037 		 * the storage it points at.
4038 		 */
4039 		debug_query_string = NULL;
4040 
4041 		/*
4042 		 * Abort the current transaction in order to recover.
4043 		 */
4044 		AbortCurrentTransaction();
4045 
4046 		if (am_walsender)
4047 			WalSndErrorCleanup();
4048 
4049 		PortalErrorCleanup();
4050 		SPICleanup();
4051 
4052 		/*
4053 		 * We can't release replication slots inside AbortTransaction() as we
4054 		 * need to be able to start and abort transactions while having a slot
4055 		 * acquired. But we never need to hold them across top level errors,
4056 		 * so releasing here is fine. There's another cleanup in ProcKill()
4057 		 * ensuring we'll correctly cleanup on FATAL errors as well.
4058 		 */
4059 		if (MyReplicationSlot != NULL)
4060 			ReplicationSlotRelease();
4061 
4062 		/* We also want to cleanup temporary slots on error. */
4063 		ReplicationSlotCleanup();
4064 
4065 		jit_reset_after_error();
4066 
4067 		/*
4068 		 * Now return to normal top-level context and clear ErrorContext for
4069 		 * next time.
4070 		 */
4071 		MemoryContextSwitchTo(TopMemoryContext);
4072 		FlushErrorState();
4073 
4074 		/*
4075 		 * If we were handling an extended-query-protocol message, initiate
4076 		 * skip till next Sync.  This also causes us not to issue
4077 		 * ReadyForQuery (until we get Sync).
4078 		 */
4079 		if (doing_extended_query_message)
4080 			ignore_till_sync = true;
4081 
4082 		/* We don't have a transaction command open anymore */
4083 		xact_started = false;
4084 
4085 		/*
4086 		 * If an error occurred while we were reading a message from the
4087 		 * client, we have potentially lost track of where the previous
4088 		 * message ends and the next one begins.  Even though we have
4089 		 * otherwise recovered from the error, we cannot safely read any more
4090 		 * messages from the client, so there isn't much we can do with the
4091 		 * connection anymore.
4092 		 */
4093 		if (pq_is_reading_msg())
4094 			ereport(FATAL,
4095 					(errcode(ERRCODE_PROTOCOL_VIOLATION),
4096 					 errmsg("terminating connection because protocol synchronization was lost")));
4097 
4098 		/* Now we can allow interrupts again */
4099 		RESUME_INTERRUPTS();
4100 	}
4101 
4102 	/* We can now handle ereport(ERROR) */
4103 	PG_exception_stack = &local_sigjmp_buf;
4104 
4105 	if (!ignore_till_sync)
4106 		send_ready_for_query = true;	/* initially, or after error */
4107 
4108 	/*
4109 	 * Non-error queries loop here.
4110 	 */
4111 
4112 	for (;;)
4113 	{
4114 		/*
4115 		 * At top of loop, reset extended-query-message flag, so that any
4116 		 * errors encountered in "idle" state don't provoke skip.
4117 		 */
4118 		doing_extended_query_message = false;
4119 
4120 		/*
4121 		 * Release storage left over from prior query cycle, and create a new
4122 		 * query input buffer in the cleared MessageContext.
4123 		 */
4124 		MemoryContextSwitchTo(MessageContext);
4125 		MemoryContextResetAndDeleteChildren(MessageContext);
4126 
4127 		initStringInfo(&input_message);
4128 
4129 		/*
4130 		 * Also consider releasing our catalog snapshot if any, so that it's
4131 		 * not preventing advance of global xmin while we wait for the client.
4132 		 */
4133 		InvalidateCatalogSnapshotConditionally();
4134 
4135 		/*
4136 		 * (1) If we've reached idle state, tell the frontend we're ready for
4137 		 * a new query.
4138 		 *
4139 		 * Note: this includes fflush()'ing the last of the prior output.
4140 		 *
4141 		 * This is also a good time to send collected statistics to the
4142 		 * collector, and to update the PS stats display.  We avoid doing
4143 		 * those every time through the message loop because it'd slow down
4144 		 * processing of batched messages, and because we don't want to report
4145 		 * uncommitted updates (that confuses autovacuum).  The notification
4146 		 * processor wants a call too, if we are not in a transaction block.
4147 		 */
4148 		if (send_ready_for_query)
4149 		{
4150 			if (IsAbortedTransactionBlockState())
4151 			{
4152 				set_ps_display("idle in transaction (aborted)", false);
4153 				pgstat_report_activity(STATE_IDLEINTRANSACTION_ABORTED, NULL);
4154 
4155 				/* Start the idle-in-transaction timer */
4156 				if (IdleInTransactionSessionTimeout > 0)
4157 				{
4158 					disable_idle_in_transaction_timeout = true;
4159 					enable_timeout_after(IDLE_IN_TRANSACTION_SESSION_TIMEOUT,
4160 										 IdleInTransactionSessionTimeout);
4161 				}
4162 			}
4163 			else if (IsTransactionOrTransactionBlock())
4164 			{
4165 				set_ps_display("idle in transaction", false);
4166 				pgstat_report_activity(STATE_IDLEINTRANSACTION, NULL);
4167 
4168 				/* Start the idle-in-transaction timer */
4169 				if (IdleInTransactionSessionTimeout > 0)
4170 				{
4171 					disable_idle_in_transaction_timeout = true;
4172 					enable_timeout_after(IDLE_IN_TRANSACTION_SESSION_TIMEOUT,
4173 										 IdleInTransactionSessionTimeout);
4174 				}
4175 			}
4176 			else
4177 			{
4178 				/* Send out notify signals and transmit self-notifies */
4179 				ProcessCompletedNotifies();
4180 
4181 				/*
4182 				 * Also process incoming notifies, if any.  This is mostly to
4183 				 * ensure stable behavior in tests: if any notifies were
4184 				 * received during the just-finished transaction, they'll be
4185 				 * seen by the client before ReadyForQuery is.
4186 				 */
4187 				if (notifyInterruptPending)
4188 					ProcessNotifyInterrupt();
4189 
4190 				pgstat_report_stat(false);
4191 
4192 				set_ps_display("idle", false);
4193 				pgstat_report_activity(STATE_IDLE, NULL);
4194 			}
4195 
4196 			ReadyForQuery(whereToSendOutput);
4197 			send_ready_for_query = false;
4198 		}
4199 
4200 		/*
4201 		 * (2) Allow asynchronous signals to be executed immediately if they
4202 		 * come in while we are waiting for client input. (This must be
4203 		 * conditional since we don't want, say, reads on behalf of COPY FROM
4204 		 * STDIN doing the same thing.)
4205 		 */
4206 		DoingCommandRead = true;
4207 
4208 		/*
4209 		 * (3) read a command (loop blocks here)
4210 		 */
4211 		firstchar = ReadCommand(&input_message);
4212 
4213 		/*
4214 		 * (4) turn off the idle-in-transaction timeout, if active.  We do
4215 		 * this before step (5) so that any last-moment timeout is certain to
4216 		 * be detected in step (5).
4217 		 */
4218 		if (disable_idle_in_transaction_timeout)
4219 		{
4220 			disable_timeout(IDLE_IN_TRANSACTION_SESSION_TIMEOUT, false);
4221 			disable_idle_in_transaction_timeout = false;
4222 		}
4223 
4224 		/*
4225 		 * (5) disable async signal conditions again.
4226 		 *
4227 		 * Query cancel is supposed to be a no-op when there is no query in
4228 		 * progress, so if a query cancel arrived while we were idle, just
4229 		 * reset QueryCancelPending. ProcessInterrupts() has that effect when
4230 		 * it's called when DoingCommandRead is set, so check for interrupts
4231 		 * before resetting DoingCommandRead.
4232 		 */
4233 		CHECK_FOR_INTERRUPTS();
4234 		DoingCommandRead = false;
4235 
4236 		/*
4237 		 * (6) check for any other interesting events that happened while we
4238 		 * slept.
4239 		 */
4240 		if (ConfigReloadPending)
4241 		{
4242 			ConfigReloadPending = false;
4243 			ProcessConfigFile(PGC_SIGHUP);
4244 		}
4245 
4246 		/*
4247 		 * (7) process the command.  But ignore it if we're skipping till
4248 		 * Sync.
4249 		 */
4250 		if (ignore_till_sync && firstchar != EOF)
4251 			continue;
4252 
4253 		switch (firstchar)
4254 		{
4255 			case 'Q':			/* simple query */
4256 				{
4257 					const char *query_string;
4258 
4259 					/* Set statement_timestamp() */
4260 					SetCurrentStatementStartTimestamp();
4261 
4262 					query_string = pq_getmsgstring(&input_message);
4263 					pq_getmsgend(&input_message);
4264 
4265 					if (am_walsender)
4266 					{
4267 						if (!exec_replication_command(query_string))
4268 							exec_simple_query(query_string);
4269 					}
4270 					else
4271 						exec_simple_query(query_string);
4272 
4273 					send_ready_for_query = true;
4274 				}
4275 				break;
4276 
4277 			case 'P':			/* parse */
4278 				{
4279 					const char *stmt_name;
4280 					const char *query_string;
4281 					int			numParams;
4282 					Oid		   *paramTypes = NULL;
4283 
4284 					forbidden_in_wal_sender(firstchar);
4285 
4286 					/* Set statement_timestamp() */
4287 					SetCurrentStatementStartTimestamp();
4288 
4289 					stmt_name = pq_getmsgstring(&input_message);
4290 					query_string = pq_getmsgstring(&input_message);
4291 					numParams = pq_getmsgint(&input_message, 2);
4292 					if (numParams > 0)
4293 					{
4294 						paramTypes = (Oid *) palloc(numParams * sizeof(Oid));
4295 						for (int i = 0; i < numParams; i++)
4296 							paramTypes[i] = pq_getmsgint(&input_message, 4);
4297 					}
4298 					pq_getmsgend(&input_message);
4299 
4300 					exec_parse_message(query_string, stmt_name,
4301 									   paramTypes, numParams);
4302 				}
4303 				break;
4304 
4305 			case 'B':			/* bind */
4306 				forbidden_in_wal_sender(firstchar);
4307 
4308 				/* Set statement_timestamp() */
4309 				SetCurrentStatementStartTimestamp();
4310 
4311 				/*
4312 				 * this message is complex enough that it seems best to put
4313 				 * the field extraction out-of-line
4314 				 */
4315 				exec_bind_message(&input_message);
4316 				break;
4317 
4318 			case 'E':			/* execute */
4319 				{
4320 					const char *portal_name;
4321 					int			max_rows;
4322 
4323 					forbidden_in_wal_sender(firstchar);
4324 
4325 					/* Set statement_timestamp() */
4326 					SetCurrentStatementStartTimestamp();
4327 
4328 					portal_name = pq_getmsgstring(&input_message);
4329 					max_rows = pq_getmsgint(&input_message, 4);
4330 					pq_getmsgend(&input_message);
4331 
4332 					exec_execute_message(portal_name, max_rows);
4333 				}
4334 				break;
4335 
4336 			case 'F':			/* fastpath function call */
4337 				forbidden_in_wal_sender(firstchar);
4338 
4339 				/* Set statement_timestamp() */
4340 				SetCurrentStatementStartTimestamp();
4341 
4342 				/* Report query to various monitoring facilities. */
4343 				pgstat_report_activity(STATE_FASTPATH, NULL);
4344 				set_ps_display("<FASTPATH>", false);
4345 
4346 				/* start an xact for this function invocation */
4347 				start_xact_command();
4348 
4349 				/*
4350 				 * Note: we may at this point be inside an aborted
4351 				 * transaction.  We can't throw error for that until we've
4352 				 * finished reading the function-call message, so
4353 				 * HandleFunctionRequest() must check for it after doing so.
4354 				 * Be careful not to do anything that assumes we're inside a
4355 				 * valid transaction here.
4356 				 */
4357 
4358 				/* switch back to message context */
4359 				MemoryContextSwitchTo(MessageContext);
4360 
4361 				HandleFunctionRequest(&input_message);
4362 
4363 				/* commit the function-invocation transaction */
4364 				finish_xact_command();
4365 
4366 				send_ready_for_query = true;
4367 				break;
4368 
4369 			case 'C':			/* close */
4370 				{
4371 					int			close_type;
4372 					const char *close_target;
4373 
4374 					forbidden_in_wal_sender(firstchar);
4375 
4376 					close_type = pq_getmsgbyte(&input_message);
4377 					close_target = pq_getmsgstring(&input_message);
4378 					pq_getmsgend(&input_message);
4379 
4380 					switch (close_type)
4381 					{
4382 						case 'S':
4383 							if (close_target[0] != '\0')
4384 								DropPreparedStatement(close_target, false);
4385 							else
4386 							{
4387 								/* special-case the unnamed statement */
4388 								drop_unnamed_stmt();
4389 							}
4390 							break;
4391 						case 'P':
4392 							{
4393 								Portal		portal;
4394 
4395 								portal = GetPortalByName(close_target);
4396 								if (PortalIsValid(portal))
4397 									PortalDrop(portal, false);
4398 							}
4399 							break;
4400 						default:
4401 							ereport(ERROR,
4402 									(errcode(ERRCODE_PROTOCOL_VIOLATION),
4403 									 errmsg("invalid CLOSE message subtype %d",
4404 											close_type)));
4405 							break;
4406 					}
4407 
4408 					if (whereToSendOutput == DestRemote)
4409 						pq_putemptymessage('3');	/* CloseComplete */
4410 				}
4411 				break;
4412 
4413 			case 'D':			/* describe */
4414 				{
4415 					int			describe_type;
4416 					const char *describe_target;
4417 
4418 					forbidden_in_wal_sender(firstchar);
4419 
4420 					/* Set statement_timestamp() (needed for xact) */
4421 					SetCurrentStatementStartTimestamp();
4422 
4423 					describe_type = pq_getmsgbyte(&input_message);
4424 					describe_target = pq_getmsgstring(&input_message);
4425 					pq_getmsgend(&input_message);
4426 
4427 					switch (describe_type)
4428 					{
4429 						case 'S':
4430 							exec_describe_statement_message(describe_target);
4431 							break;
4432 						case 'P':
4433 							exec_describe_portal_message(describe_target);
4434 							break;
4435 						default:
4436 							ereport(ERROR,
4437 									(errcode(ERRCODE_PROTOCOL_VIOLATION),
4438 									 errmsg("invalid DESCRIBE message subtype %d",
4439 											describe_type)));
4440 							break;
4441 					}
4442 				}
4443 				break;
4444 
4445 			case 'H':			/* flush */
4446 				pq_getmsgend(&input_message);
4447 				if (whereToSendOutput == DestRemote)
4448 					pq_flush();
4449 				break;
4450 
4451 			case 'S':			/* sync */
4452 				pq_getmsgend(&input_message);
4453 				finish_xact_command();
4454 				send_ready_for_query = true;
4455 				break;
4456 
4457 				/*
4458 				 * 'X' means that the frontend is closing down the socket. EOF
4459 				 * means unexpected loss of frontend connection. Either way,
4460 				 * perform normal shutdown.
4461 				 */
4462 			case 'X':
4463 			case EOF:
4464 
4465 				/*
4466 				 * Reset whereToSendOutput to prevent ereport from attempting
4467 				 * to send any more messages to client.
4468 				 */
4469 				if (whereToSendOutput == DestRemote)
4470 					whereToSendOutput = DestNone;
4471 
4472 				/*
4473 				 * NOTE: if you are tempted to add more code here, DON'T!
4474 				 * Whatever you had in mind to do should be set up as an
4475 				 * on_proc_exit or on_shmem_exit callback, instead. Otherwise
4476 				 * it will fail to be called during other backend-shutdown
4477 				 * scenarios.
4478 				 */
4479 				proc_exit(0);
4480 
4481 			case 'd':			/* copy data */
4482 			case 'c':			/* copy done */
4483 			case 'f':			/* copy fail */
4484 
4485 				/*
4486 				 * Accept but ignore these messages, per protocol spec; we
4487 				 * probably got here because a COPY failed, and the frontend
4488 				 * is still sending data.
4489 				 */
4490 				break;
4491 
4492 			default:
4493 				ereport(FATAL,
4494 						(errcode(ERRCODE_PROTOCOL_VIOLATION),
4495 						 errmsg("invalid frontend message type %d",
4496 								firstchar)));
4497 		}
4498 	}							/* end of input-reading loop */
4499 }
4500 
4501 /*
4502  * Throw an error if we're a WAL sender process.
4503  *
4504  * This is used to forbid anything else than simple query protocol messages
4505  * in a WAL sender process.  'firstchar' specifies what kind of a forbidden
4506  * message was received, and is used to construct the error message.
4507  */
4508 static void
forbidden_in_wal_sender(char firstchar)4509 forbidden_in_wal_sender(char firstchar)
4510 {
4511 	if (am_walsender)
4512 	{
4513 		if (firstchar == 'F')
4514 			ereport(ERROR,
4515 					(errcode(ERRCODE_PROTOCOL_VIOLATION),
4516 					 errmsg("fastpath function calls not supported in a replication connection")));
4517 		else
4518 			ereport(ERROR,
4519 					(errcode(ERRCODE_PROTOCOL_VIOLATION),
4520 					 errmsg("extended query protocol not supported in a replication connection")));
4521 	}
4522 }
4523 
4524 
4525 /*
4526  * Obtain platform stack depth limit (in bytes)
4527  *
4528  * Return -1 if unknown
4529  */
4530 long
get_stack_depth_rlimit(void)4531 get_stack_depth_rlimit(void)
4532 {
4533 #if defined(HAVE_GETRLIMIT) && defined(RLIMIT_STACK)
4534 	static long val = 0;
4535 
4536 	/* This won't change after process launch, so check just once */
4537 	if (val == 0)
4538 	{
4539 		struct rlimit rlim;
4540 
4541 		if (getrlimit(RLIMIT_STACK, &rlim) < 0)
4542 			val = -1;
4543 		else if (rlim.rlim_cur == RLIM_INFINITY)
4544 			val = LONG_MAX;
4545 		/* rlim_cur is probably of an unsigned type, so check for overflow */
4546 		else if (rlim.rlim_cur >= LONG_MAX)
4547 			val = LONG_MAX;
4548 		else
4549 			val = rlim.rlim_cur;
4550 	}
4551 	return val;
4552 #else							/* no getrlimit */
4553 #if defined(WIN32) || defined(__CYGWIN__)
4554 	/* On Windows we set the backend stack size in src/backend/Makefile */
4555 	return WIN32_STACK_RLIMIT;
4556 #else							/* not windows ... give up */
4557 	return -1;
4558 #endif
4559 #endif
4560 }
4561 
4562 
4563 static struct rusage Save_r;
4564 static struct timeval Save_t;
4565 
4566 void
ResetUsage(void)4567 ResetUsage(void)
4568 {
4569 	getrusage(RUSAGE_SELF, &Save_r);
4570 	gettimeofday(&Save_t, NULL);
4571 }
4572 
4573 void
ShowUsage(const char * title)4574 ShowUsage(const char *title)
4575 {
4576 	StringInfoData str;
4577 	struct timeval user,
4578 				sys;
4579 	struct timeval elapse_t;
4580 	struct rusage r;
4581 
4582 	getrusage(RUSAGE_SELF, &r);
4583 	gettimeofday(&elapse_t, NULL);
4584 	memcpy((char *) &user, (char *) &r.ru_utime, sizeof(user));
4585 	memcpy((char *) &sys, (char *) &r.ru_stime, sizeof(sys));
4586 	if (elapse_t.tv_usec < Save_t.tv_usec)
4587 	{
4588 		elapse_t.tv_sec--;
4589 		elapse_t.tv_usec += 1000000;
4590 	}
4591 	if (r.ru_utime.tv_usec < Save_r.ru_utime.tv_usec)
4592 	{
4593 		r.ru_utime.tv_sec--;
4594 		r.ru_utime.tv_usec += 1000000;
4595 	}
4596 	if (r.ru_stime.tv_usec < Save_r.ru_stime.tv_usec)
4597 	{
4598 		r.ru_stime.tv_sec--;
4599 		r.ru_stime.tv_usec += 1000000;
4600 	}
4601 
4602 	/*
4603 	 * The only stats we don't show here are ixrss, idrss, isrss.  It takes
4604 	 * some work to interpret them, and most platforms don't fill them in.
4605 	 */
4606 	initStringInfo(&str);
4607 
4608 	appendStringInfoString(&str, "! system usage stats:\n");
4609 	appendStringInfo(&str,
4610 					 "!\t%ld.%06ld s user, %ld.%06ld s system, %ld.%06ld s elapsed\n",
4611 					 (long) (r.ru_utime.tv_sec - Save_r.ru_utime.tv_sec),
4612 					 (long) (r.ru_utime.tv_usec - Save_r.ru_utime.tv_usec),
4613 					 (long) (r.ru_stime.tv_sec - Save_r.ru_stime.tv_sec),
4614 					 (long) (r.ru_stime.tv_usec - Save_r.ru_stime.tv_usec),
4615 					 (long) (elapse_t.tv_sec - Save_t.tv_sec),
4616 					 (long) (elapse_t.tv_usec - Save_t.tv_usec));
4617 	appendStringInfo(&str,
4618 					 "!\t[%ld.%06ld s user, %ld.%06ld s system total]\n",
4619 					 (long) user.tv_sec,
4620 					 (long) user.tv_usec,
4621 					 (long) sys.tv_sec,
4622 					 (long) sys.tv_usec);
4623 #if defined(HAVE_GETRUSAGE)
4624 	appendStringInfo(&str,
4625 					 "!\t%ld kB max resident size\n",
4626 #if defined(__darwin__)
4627 	/* in bytes on macOS */
4628 					 r.ru_maxrss / 1024
4629 #else
4630 	/* in kilobytes on most other platforms */
4631 					 r.ru_maxrss
4632 #endif
4633 		);
4634 	appendStringInfo(&str,
4635 					 "!\t%ld/%ld [%ld/%ld] filesystem blocks in/out\n",
4636 					 r.ru_inblock - Save_r.ru_inblock,
4637 	/* they only drink coffee at dec */
4638 					 r.ru_oublock - Save_r.ru_oublock,
4639 					 r.ru_inblock, r.ru_oublock);
4640 	appendStringInfo(&str,
4641 					 "!\t%ld/%ld [%ld/%ld] page faults/reclaims, %ld [%ld] swaps\n",
4642 					 r.ru_majflt - Save_r.ru_majflt,
4643 					 r.ru_minflt - Save_r.ru_minflt,
4644 					 r.ru_majflt, r.ru_minflt,
4645 					 r.ru_nswap - Save_r.ru_nswap,
4646 					 r.ru_nswap);
4647 	appendStringInfo(&str,
4648 					 "!\t%ld [%ld] signals rcvd, %ld/%ld [%ld/%ld] messages rcvd/sent\n",
4649 					 r.ru_nsignals - Save_r.ru_nsignals,
4650 					 r.ru_nsignals,
4651 					 r.ru_msgrcv - Save_r.ru_msgrcv,
4652 					 r.ru_msgsnd - Save_r.ru_msgsnd,
4653 					 r.ru_msgrcv, r.ru_msgsnd);
4654 	appendStringInfo(&str,
4655 					 "!\t%ld/%ld [%ld/%ld] voluntary/involuntary context switches\n",
4656 					 r.ru_nvcsw - Save_r.ru_nvcsw,
4657 					 r.ru_nivcsw - Save_r.ru_nivcsw,
4658 					 r.ru_nvcsw, r.ru_nivcsw);
4659 #endif							/* HAVE_GETRUSAGE */
4660 
4661 	/* remove trailing newline */
4662 	if (str.data[str.len - 1] == '\n')
4663 		str.data[--str.len] = '\0';
4664 
4665 	ereport(LOG,
4666 			(errmsg_internal("%s", title),
4667 			 errdetail_internal("%s", str.data)));
4668 
4669 	pfree(str.data);
4670 }
4671 
4672 /*
4673  * on_proc_exit handler to log end of session
4674  */
4675 static void
log_disconnections(int code,Datum arg)4676 log_disconnections(int code, Datum arg)
4677 {
4678 	Port	   *port = MyProcPort;
4679 	long		secs;
4680 	int			usecs;
4681 	int			msecs;
4682 	int			hours,
4683 				minutes,
4684 				seconds;
4685 
4686 	TimestampDifference(MyStartTimestamp,
4687 						GetCurrentTimestamp(),
4688 						&secs, &usecs);
4689 	msecs = usecs / 1000;
4690 
4691 	hours = secs / SECS_PER_HOUR;
4692 	secs %= SECS_PER_HOUR;
4693 	minutes = secs / SECS_PER_MINUTE;
4694 	seconds = secs % SECS_PER_MINUTE;
4695 
4696 	ereport(LOG,
4697 			(errmsg("disconnection: session time: %d:%02d:%02d.%03d "
4698 					"user=%s database=%s host=%s%s%s",
4699 					hours, minutes, seconds, msecs,
4700 					port->user_name, port->database_name, port->remote_host,
4701 					port->remote_port[0] ? " port=" : "", port->remote_port)));
4702 }
4703 
4704 /*
4705  * Start statement timeout timer, if enabled.
4706  *
4707  * If there's already a timeout running, don't restart the timer.  That
4708  * enables compromises between accuracy of timeouts and cost of starting a
4709  * timeout.
4710  */
4711 static void
enable_statement_timeout(void)4712 enable_statement_timeout(void)
4713 {
4714 	/* must be within an xact */
4715 	Assert(xact_started);
4716 
4717 	if (StatementTimeout > 0)
4718 	{
4719 		if (!stmt_timeout_active)
4720 		{
4721 			enable_timeout_after(STATEMENT_TIMEOUT, StatementTimeout);
4722 			stmt_timeout_active = true;
4723 		}
4724 	}
4725 	else
4726 		disable_timeout(STATEMENT_TIMEOUT, false);
4727 }
4728 
4729 /*
4730  * Disable statement timeout, if active.
4731  */
4732 static void
disable_statement_timeout(void)4733 disable_statement_timeout(void)
4734 {
4735 	if (stmt_timeout_active)
4736 	{
4737 		disable_timeout(STATEMENT_TIMEOUT, false);
4738 
4739 		stmt_timeout_active = false;
4740 	}
4741 }
4742