开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
postgres.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：43k
源码类别：

数据库系统

开发平台：

Unix_Linux

postgres.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * postgres.c
  4.  *   POSTGRES C Backend Interface
  5.  *
  6.  * Copyright (c) 1994, Regents of the University of California
  7.  *
  8.  *
  9.  * IDENTIFICATION
  10.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.119 1999/07/02 18:09:27 momjian Exp $
  11.  *
  12.  * NOTES
  13.  *   this is the "main" module of the postgres backend and
  14.  *   hence the main module of the "traffic cop".
  15.  *
  16.  *-------------------------------------------------------------------------
  17.  */
  19. #include <unistd.h>
  20. #include <stdio.h>
  21. #include <string.h>
  22. #include <signal.h>
  23. #include <time.h>
  24. #include <sys/time.h>
  25. #include <sys/types.h>
  26. #include <fcntl.h>
  27. #include <sys/param.h> /* for MAXHOSTNAMELEN on most */
  28. #ifndef MAXHOSTNAMELEN
  29. #include <netdb.h> /* for MAXHOSTNAMELEN on some */
  30. #endif
  31. #ifndef MAXHOSTNAMELEN /* for MAXHOSTNAMELEN under sco3.2v5.0.2 */
  32. #include <sys/socket.h>
  33. #endif
  34. #include <errno.h>
  35. #if HAVE_SYS_SELECT_H
  36. #include <sys/select.h>
  37. #endif  /* aix */
  38. #include <netinet/in.h>
  39. #include <arpa/inet.h>
  40. #include <netdb.h>
  41. #ifdef __CYGWIN32__
  42. #include <getopt.h>
  43. #endif
  45. #include "postgres.h"
  46. #include "miscadmin.h"
  47. #include "fmgr.h"
  49. #include "access/xact.h"
  50. #include "catalog/catname.h"
  51. #include "commands/async.h"
  52. #include "executor/execdebug.h"
  53. #include "executor/executor.h"
  54. #include "libpq/libpq.h"
  55. #include "libpq/pqformat.h"
  56. #include "libpq/libpq-be.h"
  57. #include "libpq/pqsignal.h"
  58. #include "nodes/pg_list.h"
  59. #include "nodes/print.h"
  60. #include "optimizer/cost.h"
  61. #include "optimizer/planner.h"
  62. #include "optimizer/prep.h"
  63. #include "parser/parser.h"
  64. #include "rewrite/rewriteHandler.h" /* for QueryRewrite() */
  65. #include "storage/bufmgr.h"
  66. #include "tcop/dest.h"
  67. #include "tcop/fastpath.h"
  68. #include "tcop/pquery.h"
  69. #include "tcop/tcopdebug.h"
  70. #include "tcop/tcopprot.h" /* where declarations for this file go */
  71. #include "tcop/utility.h"
  72. #include "utils/mcxt.h"
  73. #include "utils/rel.h"
  74. #include "utils/ps_status.h"
  75. #include "utils/temprel.h"
  76. #include "nodes/parsenodes.h"
  77. #include "../backend/parser/parse.h"
  79. #ifdef NOT_USED
  80. #include "nodes/relation.h"
  81. #endif
  83. #ifdef NOT_USED
  84. #include "optimizer/xfunc.h"
  85. #endif
  87. #ifdef NOT_USED
  88. #include "nodes/plannodes.h"
  89. #endif
  91. #ifdef NOT_USED
  92. #include "nodes/memnodes.h"
  93. #endif
  95. #include "utils/trace.h"
  97. #ifdef MULTIBYTE
  98. #include "mb/pg_wchar.h"
  99. #endif
  101. /*
  102.  * Trace flags, see backend/utils/misc/trace.c
  103.  */
  104. #define Verbose pg_options[TRACE_VERBOSE]
  105. #define DebugPrintQuery pg_options[TRACE_QUERY]
  106. #define DebugPrintPlan pg_options[TRACE_PLAN]
  107. #define DebugPrintParse pg_options[TRACE_PARSE]
  108. #define DebugPrintRewrittenParsetree 
  109. pg_options[TRACE_REWRITTEN]
  110. #define DebugPPrintPlan pg_options[TRACE_PRETTY_PLAN]
  111. #define DebugPPrintParse pg_options[TRACE_PRETTY_PARSE]
  112. #define DebugPPrintRewrittenParsetree 
  113. pg_options[TRACE_PRETTY_REWRITTEN]
  114. #define ShowParserStats pg_options[TRACE_PARSERSTATS]
  115. #define ShowPlannerStats pg_options[TRACE_PLANNERSTATS]
  116. #define ShowExecutorStats pg_options[TRACE_EXECUTORSTATS]
  117. #ifdef LOCK_MGR_DEBUG
  118. #define LockDebug pg_options[TRACE_LOCKS]
  119. #endif
  121. #define DeadlockCheckTimer pg_options[OPT_DEADLOCKTIMEOUT]
  122. #define HostnameLookup pg_options[OPT_HOSTLOOKUP]
  123. #define ShowPortNumber pg_options[OPT_SHOWPORTNUMBER]
  125. /* ----------------
  126.  * global variables
  127.  * ----------------
  128.  */
  130. /*static bool EnableRewrite = true; , never changes why have it*/
  131. CommandDest whereToSendOutput;
  133. /* Define status buffer needed by PS_SET_STATUS */
  134. PS_DEFINE_BUFFER;
  136. extern int lockingOff;
  137. extern int NBuffers;
  139. int dontExecute = 0;
  140. static int ShowStats;
  141. static bool IsEmptyQuery = false;
  143. char relname[80]; /* current relation name */
  145. /* note: these declarations had better match tcopprot.h */
  146. DLLIMPORT sigjmp_buf Warn_restart;
  147. bool InError;
  149. extern int NBuffers;
  151. static int EchoQuery = 0; /* default don't echo */
  152. time_t tim;
  153. char pg_pathname[256];
  154. FILE    *StatFp;
  156. /* ----------------
  157.  * people who want to use EOF should #define DONTUSENEWLINE in
  158.  * tcop/tcopdebug.h
  159.  * ----------------
  160.  */
  161. #ifndef TCOP_DONTUSENEWLINE
  162. int UseNewLine = 1; /* Use newlines query delimiters (the
  163.  * default) */
  165. #else
  166. int UseNewLine = 0; /* Use EOF as query delimiters */
  168. #endif  /* TCOP_DONTUSENEWLINE */
  170. /*
  171. ** Flags for expensive function optimization -- JMH 3/9/92
  172. */
  173. int XfuncMode = 0;
  175. /*
  176.  * ----------------
  177.  *  Note: _exec_repeat_ defaults to 1 but may be changed
  178.  *    by a DEBUG command.  If you set this to a large
  179.  *    number N, run a single query, and then set it
  180.  *    back to 1 and run N queries, you can get an idea
  181.  *    of how much time is being spent in the parser and
  182.  *    planner b/c in the first case this overhead only
  183.  *    happens once.  -cim 6/9/91
  184.  * ----------------
  185. */
  186. int _exec_repeat_ = 1;
  188. /* ----------------------------------------------------------------
  189.  * decls for routines only used in this file
  190.  * ----------------------------------------------------------------
  191.  */
  192. static char InteractiveBackend(char *inBuf);
  193. static char SocketBackend(char *inBuf);
  194. static char ReadCommand(char *inBuf);
  195. static void pg_exec_query(char *query_string);
  198. /* ----------------------------------------------------------------
  199.  * routines to obtain user input
  200.  * ----------------------------------------------------------------
  201.  */
  203. /* ----------------
  204.  * InteractiveBackend() is called for user interactive connections
  205.  * the string entered by the user is placed in its parameter inBuf.
  206.  * ----------------
  207.  */
  209. static char
  210. InteractiveBackend(char *inBuf)
  211. {
  212. char    *stuff = inBuf; /* current place in input buffer */
  213. int c; /* character read from getc() */
  214. bool end = false; /* end-of-input flag */
  215. bool backslashSeen = false; /* have we seen a  ? */
  217. /* ----------------
  218.  * display a prompt and obtain input from the user
  219.  * ----------------
  220.  */
  221. printf("backend> ");
  222. fflush(stdout);
  224. for (;;)
  225. {
  226. if (UseNewLine)
  227. {
  228. /* ----------------
  229.  * if we are using n as a delimiter, then read
  230.  * characters until the n.
  231.  * ----------------
  232.  */
  233. while ((c = getc(stdin)) != EOF)
  234. {
  235. if (c == 'n')
  236. {
  237. if (backslashSeen)
  238. {
  239. stuff--;
  240. continue;
  241. }
  242. else
  243. {
  244. /* keep the newline character */
  245. *stuff++ = 'n';
  246. *stuff++ = '';
  247. break;
  248. }
  249. }
  250. else if (c == '\')
  251. backslashSeen = true;
  252. else
  253. backslashSeen = false;
  255. *stuff++ = (char) c;
  256. }
  258. if (c == EOF)
  259. end = true;
  260. }
  261. else
  262. {
  263. /* ----------------
  264.  * otherwise read characters until EOF.
  265.  * ----------------
  266.  */
  267. while ((c = getc(stdin)) != EOF)
  268. *stuff++ = (char) c;
  270. if (stuff == inBuf)
  271. end = true;
  272. }
  274. if (end)
  275. {
  276. if (Verbose)
  277. puts("EOF");
  278. IsEmptyQuery = true;
  279. proc_exit(0);
  280. }
  282. /* ----------------
  283.  * otherwise we have a user query so process it.
  284.  * ----------------
  285.  */
  286. break;
  287. }
  289. /* ----------------
  290.  * if the query echo flag was given, print the query..
  291.  * ----------------
  292.  */
  293. if (EchoQuery)
  294. printf("query: %sn", inBuf);
  295. fflush(stdout);
  297. return 'Q';
  298. }
  300. /* ----------------
  301.  * SocketBackend() Is called for frontend-backend connections
  302.  *
  303.  * If the input is a query (case 'Q') then the string entered by
  304.  * the user is placed in its parameter inBuf.
  305.  *
  306.  * If the input is a fastpath function call (case 'F') then
  307.  * the function call is processed in HandleFunctionRequest().
  308.  * (now called from PostgresMain())
  309.  * ----------------
  310.  */
  312. static char
  313. SocketBackend(char *inBuf)
  314. {
  315. char qtype;
  316. char result = '';
  318. /* ----------------
  319.  * get input from the frontend
  320.  * ----------------
  321.  */
  322. qtype = '?';
  323. if (pq_getbytes(&qtype, 1) == EOF)
  324. {
  325. /* ------------
  326.  * when front-end applications quits/dies
  327.  * ------------
  328.  */
  329. proc_exit(0);
  330. }
  332. switch (qtype)
  333. {
  334. /* ----------------
  335.  * 'Q': user entered a query
  336.  * ----------------
  337.  */
  338. case 'Q':
  339. pq_getstr(inBuf, MAX_PARSE_BUFFER);
  340. result = 'Q';
  341. break;
  343. /* ----------------
  344.  * 'F':  calling user/system functions
  345.  * ----------------
  346.  */
  347. case 'F':
  348. pq_getstr(inBuf, MAX_PARSE_BUFFER); /* ignore the rest of the
  349.  * line */
  350. result = 'F';
  351. break;
  353. /* ----------------
  354.  * 'X':  frontend is exiting
  355.  * ----------------
  356.  */
  357. case 'X':
  358. result = 'X';
  359. break;
  361. /* ----------------
  362.  * otherwise we got garbage from the frontend.
  363.  *
  364.  * XXX are we certain that we want to do an elog(FATAL) here?
  365.  * -cim 1/24/90
  366.  * ----------------
  367.  */
  368. default:
  369. elog(FATAL, "Socket command type %c unknown", qtype);
  370. break;
  371. }
  372. return result;
  373. }
  375. /* ----------------
  376.  * ReadCommand reads a command from either the frontend or
  377.  * standard input, places it in inBuf, and returns a char
  378.  * representing whether the string is a 'Q'uery or a 'F'astpath
  379.  * call.
  380.  * ----------------
  381.  */
  382. static char
  383. ReadCommand(char *inBuf)
  384. {
  385. if (IsUnderPostmaster)
  386. return SocketBackend(inBuf);
  387. else
  388. return InteractiveBackend(inBuf);
  389. }
  391. List *
  392. pg_parse_and_plan(char *query_string, /* string to execute */
  393.   Oid *typev, /* argument types */
  394.   int nargs, /* number of arguments */
  395.   List **queryListP, /* returned pointer to the parse
  396.  * trees */
  397.   CommandDest dest, /* where results should go */
  398.   bool aclOverride)
  399. {
  400. List    *querytree_list = NIL;
  401. List    *plan_list = NIL;
  402. List    *querytree_list_item;
  403. Query    *querytree;
  404. Plan    *plan;
  405. List    *new_list;
  406. List    *rewritten;
  408. if (DebugPrintQuery)
  409. {
  410. if (DebugPrintQuery > 3)
  411. {
  412. /* Print the query string as is if query debug level > 3 */
  413. TPRINTF(TRACE_QUERY, "query: %s", query_string);
  414. }
  415. else
  416. {
  417. /* Print condensed query string to fit in one log line */
  418. char buff[MAX_QUERY_SIZE + 1];
  419. char c,
  420.    *s,
  421.    *d;
  422. int n,
  423. is_space = 1;
  425. for (s = query_string, d = buff, n = 0; (c = *s) && (n < MAX_QUERY_SIZE); s++)
  426. {
  427. switch (c)
  428. {
  429. case 'r':
  430. case 'n':
  431. case 't':
  432. c = ' ';
  433. /* fall through */
  434. case ' ':
  435. if (is_space)
  436. continue;
  437. is_space = 1;
  438. break;
  439. default:
  440. is_space = 0;
  441. break;
  442. }
  443. *d++ = c;
  444. n++;
  445. }
  446. *d = '';
  447. TPRINTF(TRACE_QUERY, "query: %s", buff);
  448. }
  449. }
  451. /* ----------------
  452.  * (1) parse the request string into a list of parse trees
  453.  * ----------------
  454.  */
  455. if (ShowParserStats)
  456. ResetUsage();
  458. querytree_list = parser(query_string, typev, nargs);
  460. if (ShowParserStats)
  461. {
  462. fprintf(stderr, "! Parser Stats:n");
  463. ShowUsage();
  464. }
  466. /* ----------------
  467.  * (2) rewrite the queries, as necessary
  468.  *
  469.  * rewritten queries are collected in new_list.  Note there may be
  470.  * more or fewer than in the original list.
  471.  * ----------------
  472.  */
  473. new_list = NIL;
  474. foreach(querytree_list_item, querytree_list)
  475. {
  476. querytree = (Query *) lfirst(querytree_list_item);
  478. if (DebugPrintParse || DebugPPrintParse)
  479. {
  480. if (DebugPPrintParse)
  481. {
  482. TPRINTF(TRACE_PRETTY_PARSE, "parser outputs:");
  483. nodeDisplay(querytree);
  484. }
  485. else
  486. {
  487. TPRINTF(TRACE_PARSE, "parser outputs:");
  488. printf("n%snn", nodeToString(querytree));
  489. }
  490. }
  492. if (querytree->commandType == CMD_UTILITY)
  493. {
  494. /* don't rewrite utilities, just dump 'em into new_list */
  495. new_list = lappend(new_list, querytree);
  496. }
  497. else
  498. {
  499. /* rewrite regular queries */
  500. rewritten = QueryRewrite(querytree);
  501. new_list = nconc(new_list, rewritten);
  502. }
  503. }
  505. querytree_list = new_list;
  507. /*
  508.  * Override ACL checking if requested
  509.  */
  510. if (aclOverride)
  511. {
  512. foreach(querytree_list_item, querytree_list)
  513. {
  514. List    *l;
  516. querytree = (Query *) lfirst(querytree_list_item);
  518. if (querytree->commandType == CMD_UTILITY)
  519. continue;
  521. foreach(l, querytree->rtable)
  522. {
  523. RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
  525. rte->skipAcl = TRUE;
  526. }
  527. }
  528. }
  530. if (DebugPrintRewrittenParsetree || DebugPPrintRewrittenParsetree)
  531. {
  532. if (DebugPPrintRewrittenParsetree)
  533. {
  534. TPRINTF(TRACE_PRETTY_REWRITTEN, "after rewriting:");
  536. foreach(querytree_list_item, querytree_list)
  537. {
  538. querytree = (Query *) lfirst(querytree_list_item);
  539. nodeDisplay(querytree);
  540. printf("n");
  541. }
  542. }
  543. else
  544. {
  545. TPRINTF(TRACE_REWRITTEN, "after rewriting:");
  547. foreach(querytree_list_item, querytree_list)
  548. {
  549. querytree = (Query *) lfirst(querytree_list_item);
  550. printf("n%snn", nodeToString(querytree));
  551. }
  552. }
  553. }
  555. foreach(querytree_list_item, querytree_list)
  556. {
  557. querytree = (Query *) lfirst(querytree_list_item);
  559. /*
  560.  * For each query that isn't a utility invocation, generate a
  561.  * plan.
  562.  */
  564. if (querytree->commandType != CMD_UTILITY)
  565. {
  567. if (IsAbortedTransactionBlockState())
  568. {
  569. /* ----------------
  570.  *  the EndCommand() stuff is to tell the frontend
  571.  *  that the command ended. -cim 6/1/90
  572.  * ----------------
  573.  */
  574. char    *tag = "*ABORT STATE*";
  576. EndCommand(tag, dest);
  578. elog(NOTICE, "(transaction aborted): %s",
  579.  "queries ignored until END");
  581. if (queryListP)
  582. *queryListP = NIL;
  583. return NIL;
  584. }
  586. if (ShowPlannerStats)
  587. ResetUsage();
  589. /* call that optimizer */
  590. plan = planner(querytree);
  592. if (ShowPlannerStats)
  593. {
  594. fprintf(stderr, "! Planner Stats:n");
  595. ShowUsage();
  596. }
  597. plan_list = lappend(plan_list, plan);
  598. #ifdef INDEXSCAN_PATCH
  599. /* ----------------
  600.  * Print plan if debugging.
  601.  * This has been moved here to get debugging output
  602.  * also for queries in functions. DZ - 27-8-1996
  603.  * ----------------
  604.  */
  605. if (DebugPrintPlan || DebugPPrintPlan)
  606. {
  607. if (DebugPPrintPlan)
  608. {
  609. TPRINTF(TRACE_PRETTY_PLAN, "plan:");
  610. nodeDisplay(plan);
  611. }
  612. else
  613. {
  614. TPRINTF(TRACE_PLAN, "plan:");
  615. printf("n%snn", nodeToString(plan));
  616. }
  617. }
  618. #endif
  619. }
  621. /*
  622.  * If the command is an utility append a null plan. This is needed
  623.  * to keep the plan_list aligned with the querytree_list or the
  624.  * function executor will crash.  DZ - 30-8-1996
  625.  */
  626. else
  627. plan_list = lappend(plan_list, NULL);
  628. }
  630. if (queryListP)
  631. *queryListP = querytree_list;
  633. return plan_list;
  634. }
  636. /* ----------------------------------------------------------------
  637.  * pg_exec_query()
  638.  *
  639.  * Takes a querystring, runs the parser/utilities or
  640.  * parser/planner/executor over it as necessary
  641.  * Begin Transaction Should have been called before this
  642.  * and CommitTransaction After this is called
  643.  * This is strictly because we do not allow for nested xactions.
  644.  *
  645.  * NON-OBVIOUS-RESTRICTIONS
  646.  * this function _MUST_ allocate a new "parsetree" each time,
  647.  * since it may be stored in a named portal and should not
  648.  * change its value.
  649.  *
  650.  * ----------------------------------------------------------------
  651.  */
  653. static void
  654. pg_exec_query(char *query_string)
  655. {
  656. pg_exec_query_dest(query_string, whereToSendOutput, FALSE);
  657. }
  659. void
  660. pg_exec_query_acl_override(char *query_string)
  661. {
  662. pg_exec_query_dest(query_string, whereToSendOutput, TRUE);
  663. }
  665. void
  666. pg_exec_query_dest(char *query_string, /* string to execute */
  667.    CommandDest dest, /* where results should go */
  668.    bool aclOverride) /* to give utility commands power
  669.  * of superusers */
  670. {
  671. List    *querytree_list;
  672. List    *plan_list;
  673. Query    *querytree;
  674. Plan    *plan;
  675. int j;
  677. /* plan the queries */
  678. plan_list = pg_parse_and_plan(query_string, NULL, 0,
  679.   &querytree_list, dest, aclOverride);
  681. /* if we got a cancel signal whilst planning, quit */
  682. if (QueryCancel)
  683. CancelQuery();
  685. /* OK, do it to it! */
  687. /*
  688.  * NOTE: we do not use "foreach" here because we want to be sure the
  689.  * list pointers have been advanced before the query is executed. We
  690.  * need to do that because VACUUM has a nasty little habit of doing
  691.  * CommitTransactionCommand at startup, and that will release the
  692.  * memory holding our parse/plan lists :-(.  This needs a better
  693.  * solution --- currently, the code will crash if someone submits
  694.  * "vacuum; something-else" in a single query string.  But memory
  695.  * allocation needs redesigned anyway, so this will have to do for
  696.  * now.
  697.  */
  699. while (querytree_list)
  700. {
  701. querytree = (Query *) lfirst(querytree_list);
  702. querytree_list = lnext(querytree_list);
  703. plan = (Plan *) lfirst(plan_list);
  704. plan_list = lnext(plan_list);
  706. if (querytree->commandType == CMD_UTILITY)
  707. {
  708. /* ----------------
  709.  *  process utility functions (create, destroy, etc..)
  710.  *
  711.  *  Note: we do not check for the transaction aborted state
  712.  *  because that is done in ProcessUtility.
  713.  * ----------------
  714.  */
  715. if (DebugPrintQuery)
  716. TPRINTF(TRACE_QUERY, "ProcessUtility: %s", query_string);
  717. else if (Verbose)
  718. TPRINTF(TRACE_VERBOSE, "ProcessUtility");
  720. /*
  721.  * We have to set query SnapShot in the case of FETCH or COPY TO.
  722.  */
  723. if (nodeTag(querytree->utilityStmt) == T_FetchStmt ||
  724. (nodeTag(querytree->utilityStmt) == T_CopyStmt && 
  725. ((CopyStmt *)(querytree->utilityStmt))->direction != FROM))
  726. SetQuerySnapshot();
  727. ProcessUtility(querytree->utilityStmt, dest);
  728. }
  729. else
  730. {
  731. #ifdef INDEXSCAN_PATCH
  733. /*
  734.  * Print moved in pg_parse_and_plan. DZ - 27-8-1996
  735.  */
  736. #else
  737. /* ----------------
  738.  * print plan if debugging
  739.  * ----------------
  740.  */
  741. if (DebugPrintPlan || DebugPPrintPlan)
  742. {
  743. if (DebugPPrintPlan)
  744. {
  745. TPRINTF(TRACE_PRETTY_PLAN, "plan:");
  746. nodeDisplay(plan);
  747. }
  748. else
  749. {
  750. TPRINTF(TRACE_PLAN, "plan:");
  751. printf("n%snn", nodeToString(plan));
  752. }
  753. }
  754. #endif
  756. SetQuerySnapshot();
  758. /*
  759.  * execute the plan
  760.  */
  761. if (ShowExecutorStats)
  762. ResetUsage();
  764. for (j = 0; j < _exec_repeat_; j++)
  765. {
  766. if (Verbose)
  767. TPRINTF(TRACE_VERBOSE, "ProcessQuery");
  768. ProcessQuery(querytree, plan, dest);
  769. }
  771. if (ShowExecutorStats)
  772. {
  773. fprintf(stderr, "! Executor Stats:n");
  774. ShowUsage();
  775. }
  776. }
  778. /*
  779.  * In a query block, we want to increment the command counter
  780.  * between queries so that the effects of early queries are
  781.  * visible to subsequent ones.
  782.  */
  784. CommandCounterIncrement();
  785. }
  786. }
  788. /* --------------------------------
  789.  * signal handler routines used in PostgresMain()
  790.  *
  791.  * handle_warn() catches SIGQUIT. It forces control back to the main
  792.  * loop, just as if an internal error (elog(ERROR,...)) had occurred.
  793.  * elog() used to actually use kill(2) to induce a SIGQUIT to get here!
  794.  * But that's not 100% reliable on some systems, so now it does its own
  795.  * siglongjmp() instead.
  796.  * We still provide the signal catcher so that an error quit can be
  797.  * forced externally. This should be done only with great caution,
  798.  * however, since an asynchronous signal could leave the system in
  799.  * who-knows-what inconsistent state.
  800.  *
  801.  * quickdie() occurs when signalled by the postmaster.
  802.  * Some backend has bought the farm,
  803.  * so we need to stop what we're doing and exit.
  804.  *
  805.  * die() performs an orderly cleanup via ExitPostgres()
  806.  * --------------------------------
  807.  */
  809. void
  810. handle_warn(SIGNAL_ARGS)
  811. {
  812. siglongjmp(Warn_restart, 1);
  813. }
  815. void
  816. quickdie(SIGNAL_ARGS)
  817. {
  818. elog(NOTICE, "Message from PostgreSQL backend:"
  819.  "ntThe Postmaster has informed me that some other backend"
  820.  " died abnormally and possibly corrupted shared memory."
  821.  "ntI have rolled back the current transaction and am"
  822.  " going to terminate your database system connection and exit."
  823. "ntPlease reconnect to the database system and repeat your query.");
  826. /*
  827.  * DO NOT ExitPostgres(0) -- we're here because shared memory may be
  828.  * corrupted, so we don't want to flush any shared state to stable
  829.  * storage.  Just nail the windows shut and get out of town.
  830.  */
  832. exit(0);
  833. }
  835. void
  836. die(SIGNAL_ARGS)
  837. {
  838. ExitPostgres(0);
  839. }
  841. /* signal handler for floating point exception */
  842. void
  843. FloatExceptionHandler(SIGNAL_ARGS)
  844. {
  845. elog(ERROR, "floating point exception!"
  846.  " The last floating point operation either exceeded legal ranges"
  847.  " or was a divide by zero");
  848. }
  851. /* signal handler for query cancel signal from postmaster */
  852. static void
  853. QueryCancelHandler(SIGNAL_ARGS)
  854. {
  855. QueryCancel = true;
  856. }
  858. void
  859. CancelQuery(void)
  860. {
  862. /*
  863.  * QueryCancel flag will be reset in main loop, which we reach by
  864.  * longjmp from elog().
  865.  */
  866. elog(ERROR, "Query was cancelled.");
  867. }
  870. static void
  871. usage(char *progname)
  872. {
  873. fprintf(stderr,
  874. "Usage: %s [options] [dbname]n", progname);
  875. #ifdef USE_ASSERT_CHECKING
  876. fprintf(stderr, "t-A onttenable/disable assert checkingn");
  877. #endif
  878. fprintf(stderr, "t-B bufferstset number of buffers in buffer pooln");
  879. fprintf(stderr, "t-C ttsuppress version infon");
  880. fprintf(stderr, "t-D dirttdata directoryn");
  881. fprintf(stderr, "t-E ttecho query before executionn");
  882. fprintf(stderr, "t-F ttturn off fsyncn");
  883. #ifdef LOCK_MGR_DEBUG
  884. fprintf(stderr, "t-K levttset locking debug level [0|1|2]n");
  885. #endif
  886. fprintf(stderr, "t-L ttturn off lockingn");
  887. fprintf(stderr, "t-N ttdon't use newline as interactive query delimitern");
  888. fprintf(stderr, "t-O ttallow system table structure changesn");
  889. fprintf(stderr, "t-Q ttsuppress informational messagesn");
  890. fprintf(stderr, "t-S kbytestset amount of memory for sorts (in kbytes)n");
  891. fprintf(stderr, "t-T optionstspecify pg_optionsn");
  892. fprintf(stderr, "t-W secttwait N seconds to allow attach from a debuggern");
  893. fprintf(stderr, "t-d [1|2|3]tset debug leveln");
  894. fprintf(stderr, "t-e ttturn on European date formatn");
  895. fprintf(stderr, "t-f [s|i|n|m|h]tforbid use of some plan typesn");
  896. fprintf(stderr, "t-i ttdon't execute queriesn");
  897. fprintf(stderr, "t-o filettsend stdout and stderr to given filenamen");
  898. fprintf(stderr, "t-p databasetbackend is started under a postmastern");
  899. fprintf(stderr, "t-s ttshow stats after each queryn");
  900. fprintf(stderr, "t-t [pa|pl|ex]tshow timings after each queryn");
  901. fprintf(stderr, "t-v versiontset protocol version being used by frontendn");
  902. }
  904. /* ----------------------------------------------------------------
  905.  * PostgresMain
  906.  * postgres main loop
  907.  * all backends, interactive or otherwise start here
  908.  *
  909.  * argc/argv are the command line arguments to be used.  When being forked
  910.  * by the postmaster, these are not the original argv array of the process.
  911.  * real_argc/real_argv point to the original argv array, which is needed by
  912.  * PS_INIT_STATUS on some platforms.
  913.  * ----------------------------------------------------------------
  914.  */
  915. int
  916. PostgresMain(int argc, char *argv[], int real_argc, char *real_argv[])
  917. {
  918. int flag;
  920. char    *DBName = NULL;
  921. bool secure = true;
  922. int errs = 0;
  924. char firstchar;
  925. char parser_input[MAX_PARSE_BUFFER];
  926. char    *userName;
  928. /* Used if verbose is set, must be initialized */
  929. char    *remote_info = "interactive";
  930. char    *remote_host = "";
  931. unsigned short remote_port = 0;
  933. char    *DBDate = NULL;
  934. extern int optind;
  935. extern char *optarg;
  936. extern short DebugLvl;
  938. /*
  939.  * Set default values for command-line options.
  940.  */
  941. IsUnderPostmaster = false;
  942. ShowStats = 0;
  943. ShowParserStats = ShowPlannerStats = ShowExecutorStats = 0;
  944. DeadlockCheckTimer = DEADLOCK_CHECK_TIMER;
  945. Noversion = false;
  946. EchoQuery = false;
  947. #ifdef LOCK_MGR_DEBUG
  948. LockDebug = 0;
  949. #endif
  950. DataDir = getenv("PGDATA");
  952. /*
  953.  * Try to get initial values for date styles and formats. Does not do
  954.  * a complete job, but should be good enough for backend. Cannot call
  955.  * parse_date() since palloc/pfree memory is not set up yet.
  956.  */
  957. DBDate = getenv("PGDATESTYLE");
  958. if (DBDate != NULL)
  959. {
  960. if (strcasecmp(DBDate, "ISO") == 0)
  961. DateStyle = USE_ISO_DATES;
  962. else if (strcasecmp(DBDate, "SQL") == 0)
  963. DateStyle = USE_SQL_DATES;
  964. else if (strcasecmp(DBDate, "POSTGRES") == 0)
  965. DateStyle = USE_POSTGRES_DATES;
  966. else if (strcasecmp(DBDate, "GERMAN") == 0)
  967. {
  968. DateStyle = USE_GERMAN_DATES;
  969. EuroDates = TRUE;
  970. }
  971. else if (strcasecmp(DBDate, "NONEURO") == 0)
  972. EuroDates = FALSE;
  973. else if (strcasecmp(DBDate, "EURO") == 0)
  974. EuroDates = TRUE;
  975. }
  977. /*
  978.  * Read default pg_options from file $DATADIR/pg_options.
  979.  */
  980. if (DataDir)
  981. read_pg_options(0);
  983. /* ----------------
  984.  * parse command line arguments
  985.  *
  986.  * There are now two styles of command line layout for the backend:
  987.  *
  988.  * For interactive use (not started from postmaster) the format is
  989.  * postgres [switches] [databasename]
  990.  * If the databasename is omitted it is taken to be the user name.
  991.  *
  992.  * When started from the postmaster, the format is
  993.  * postgres [secure switches] -p databasename [insecure switches]
  994.  * Switches appearing after -p came from the client (via "options"
  995.  * field of connection request).  For security reasons we restrict
  996.  * what these switches can do.
  997.  * ----------------
  998.  */
  1000. optind = 1; /* reset after postmaster's usage */
  1002. while ((flag = getopt(argc, argv,
  1003.   "A:B:CD:d:EeFf:iK:LNOo:p:QS:sT:t:v:W:x:"))
  1004.    != EOF)
  1005. switch (flag)
  1006. {
  1007. case 'A':
  1008. /* ----------------
  1009.  * enable/disable assert checking.
  1010.  * ----------------
  1011.  */
  1012. #ifdef USE_ASSERT_CHECKING
  1013. assert_enabled = atoi(optarg);
  1014. #else
  1015. fprintf(stderr, "Assert checking is not enabledn");
  1016. #endif
  1017. break;
  1019. case 'B':
  1020. /* ----------------
  1021.  * specify the size of buffer pool
  1022.  * ----------------
  1023.  */
  1024. if (secure)
  1025. NBuffers = atoi(optarg);
  1026. break;
  1028. case 'C':
  1029. /* ----------------
  1030.  * don't print version string
  1031.  * ----------------
  1032.  */
  1033. Noversion = true;
  1034. break;
  1036. case 'D': /* PGDATA directory */
  1037. if (secure)
  1038. {
  1039. if (!DataDir)
  1040. {
  1041. DataDir = optarg;
  1042. /* must be done after DataDir is defined */
  1043. read_pg_options(0);
  1044. }
  1045. DataDir = optarg;
  1046. }
  1047. break;
  1049. case 'd': /* debug level */
  1050. DebugLvl = (short) atoi(optarg);
  1051. if (DebugLvl >= 1)
  1052. Verbose = DebugLvl;
  1053. if (DebugLvl >= 2)
  1054. DebugPrintQuery = true;
  1055. if (DebugLvl >= 3)
  1056. DebugPrintQuery = DebugLvl;
  1057. if (DebugLvl >= 4)
  1058. {
  1059. DebugPrintParse = true;
  1060. DebugPrintPlan = true;
  1061. DebugPrintRewrittenParsetree = true;
  1062. }
  1063. if (DebugLvl >= 5)
  1064. {
  1065. DebugPPrintParse = true;
  1066. DebugPPrintPlan = true;
  1067. DebugPPrintRewrittenParsetree = true;
  1068. }
  1069. break;
  1071. case 'E':
  1072. /* ----------------
  1073.  * E - echo the query the user entered
  1074.  * ----------------
  1075.  */
  1076. EchoQuery = true;
  1077. break;
  1079. case 'e':
  1080. /* --------------------------
  1081.  * Use european date formats.
  1082.  * --------------------------
  1083.  */
  1084. EuroDates = true;
  1085. break;
  1087. case 'F':
  1088. /* --------------------
  1089.  * turn off fsync
  1090.  * --------------------
  1091.  */
  1092. if (secure)
  1093. disableFsync = true;
  1094. break;
  1096. case 'f':
  1097. /* -----------------
  1098.  *   f - forbid generation of certain plans
  1099.  * -----------------
  1100.  */
  1101. switch (optarg[0])
  1102. {
  1103. case 's': /* seqscan */
  1104. _enable_seqscan_ = false;
  1105. break;
  1106. case 'i': /* indexscan */
  1107. _enable_indexscan_ = false;
  1108. break;
  1109. case 'n': /* nestloop */
  1110. _enable_nestloop_ = false;
  1111. break;
  1112. case 'm': /* mergejoin */
  1113. _enable_mergejoin_ = false;
  1114. break;
  1115. case 'h': /* hashjoin */
  1116. _enable_hashjoin_ = false;
  1117. break;
  1118. default:
  1119. errs++;
  1120. }
  1121. break;
  1123. case 'i':
  1124. dontExecute = 1;
  1125. break;
  1127. case 'K':
  1128. #ifdef LOCK_MGR_DEBUG
  1129. LockDebug = atoi(optarg);
  1130. #else
  1131. fprintf(stderr, "Lock debug not compiled inn");
  1132. #endif
  1133. break;
  1135. case 'L':
  1136. /* --------------------
  1137.  * turn off locking
  1138.  * --------------------
  1139.  */
  1140. if (secure)
  1141. lockingOff = 1;
  1142. break;
  1144. case 'N':
  1145. /* ----------------
  1146.  * N - Don't use newline as a query delimiter
  1147.  * ----------------
  1148.  */
  1149. UseNewLine = 0;
  1150. break;
  1152. case 'O':
  1153. /* --------------------
  1154.  * allow system table structure modifications
  1155.  * --------------------
  1156.  */
  1157. if (secure) /* XXX safe to allow from client??? */
  1158. allowSystemTableMods = true;
  1159. break;
  1161. case 'o':
  1162. /* ----------------
  1163.  * o - send output (stdout and stderr) to the given file
  1164.  * ----------------
  1165.  */
  1166. if (secure)
  1167. StrNCpy(OutputFileName, optarg, MAXPGPATH);
  1168. break;
  1170. case 'p':
  1171. /* ----------------
  1172.  * p - special flag passed if backend was forked
  1173.  * by a postmaster.
  1174.  * ----------------
  1175.  */
  1176. if (secure)
  1177. {
  1178. IsUnderPostmaster = true;
  1179. DBName = optarg;
  1180. secure = false; /* subsequent switches are NOT
  1181.  * secure */
  1182. }
  1183. break;
  1185. case 'Q':
  1186. /* ----------------
  1187.  * Q - set Quiet mode (reduce debugging output)
  1188.  * ----------------
  1189.  */
  1190. Verbose = 0;
  1191. break;
  1193. case 'S':
  1194. /* ----------------
  1195.  * S - amount of sort memory to use in 1k bytes
  1196.  * ----------------
  1197.  */
  1198. {
  1199. int S;
  1201. S = atoi(optarg);
  1202. if (S >= 4 * BLCKSZ / 1024)
  1203. SortMem = S;
  1204. }
  1205. break;
  1207. case 's':
  1208. /* ----------------
  1209.  *   s - report usage statistics (timings) after each query
  1210.  * ----------------
  1211.  */
  1212. ShowStats = 1;
  1213. StatFp = stderr;
  1214. break;
  1216. case 'T':
  1217. /* ----------------
  1218.  * T - tracing options
  1219.  * ----------------
  1220.  */
  1221. parse_options(optarg, secure);
  1222. break;
  1224. case 't':
  1225. /* ----------------
  1226.  * tell postgres to report usage statistics (timings) for
  1227.  * each query
  1228.  *
  1229.  * -tpa[rser] = print stats for parser time of each query
  1230.  * -tpl[anner] = print stats for planner time of each query
  1231.  * -te[xecutor] = print stats for executor time of each query
  1232.  * caution: -s can not be used together with -t.
  1233.  * ----------------
  1234.  */
  1235. StatFp = stderr;
  1236. switch (optarg[0])
  1237. {
  1238. case 'p':
  1239. if (optarg[1] == 'a')
  1240. ShowParserStats = 1;
  1241. else if (optarg[1] == 'l')
  1242. ShowPlannerStats = 1;
  1243. else
  1244. errs++;
  1245. break;
  1246. case 'e':
  1247. ShowExecutorStats = 1;
  1248. break;
  1249. default:
  1250. errs++;
  1251. break;
  1252. }
  1253. break;
  1255. case 'v':
  1256. if (secure)
  1257. FrontendProtocol = (ProtocolVersion) atoi(optarg);
  1258. break;
  1260. case 'W':
  1261. /* ----------------
  1262.  * wait N seconds to allow attach from a debugger
  1263.  * ----------------
  1264.  */
  1265. sleep(atoi(optarg));
  1266. break;
  1268. case 'x':
  1269. #ifdef NOT_USED /* planner/xfunc.h */
  1271. /*
  1272.  * control joey hellerstein's expensive function
  1273.  * optimization
  1274.  */
  1275. if (XfuncMode != 0)
  1276. {
  1277. fprintf(stderr, "only one -x flag is allowedn");
  1278. errs++;
  1279. break;
  1280. }
  1281. if (strcmp(optarg, "off") == 0)
  1282. XfuncMode = XFUNC_OFF;
  1283. else if (strcmp(optarg, "nor") == 0)
  1284. XfuncMode = XFUNC_NOR;
  1285. else if (strcmp(optarg, "nopull") == 0)
  1286. XfuncMode = XFUNC_NOPULL;
  1287. else if (strcmp(optarg, "nopm") == 0)
  1288. XfuncMode = XFUNC_NOPM;
  1289. else if (strcmp(optarg, "pullall") == 0)
  1290. XfuncMode = XFUNC_PULLALL;
  1291. else if (strcmp(optarg, "wait") == 0)
  1292. XfuncMode = XFUNC_WAIT;
  1293. else
  1294. {
  1295. fprintf(stderr, "use -x {off,nor,nopull,nopm,pullall,wait}n");
  1296. errs++;
  1297. }
  1298. #endif
  1299. break;
  1301. default:
  1302. /* ----------------
  1303.  * default: bad command line option
  1304.  * ----------------
  1305.  */
  1306. errs++;
  1307. break;
  1308. }
  1310. /* ----------------
  1311.  * get user name (needed now in case it is the default database name)
  1312.  * and check command line validity
  1313.  * ----------------
  1314.  */
  1315. SetPgUserName();
  1316. userName = GetPgUserName();
  1318. if (IsUnderPostmaster)
  1319. {
  1320. /* noninteractive case: nothing should be left after switches */
  1321. if (errs || argc != optind || DBName == NULL)
  1322. {
  1323. usage(argv[0]);
  1324. proc_exit(1);
  1325. }
  1326. }
  1327. else
  1328. {
  1329. /* interactive case: database name can be last arg on command line */
  1330. if (errs || argc - optind > 1)
  1331. {
  1332. usage(argv[0]);
  1333. proc_exit(1);
  1334. }
  1335. else if (argc - optind == 1)
  1336. DBName = argv[optind];
  1337. else if ((DBName = userName) == NULL)
  1338. {
  1339. fprintf(stderr, "%s: USER undefined and no database specifiedn",
  1340. argv[0]);
  1341. proc_exit(1);
  1342. }
  1343. }
  1345. if (ShowStats &&
  1346. (ShowParserStats || ShowPlannerStats || ShowExecutorStats))
  1347. {
  1348. fprintf(stderr, "-s can not be used together with -t.n");
  1349. proc_exit(1);
  1350. }
  1352. if (!DataDir)
  1353. {
  1354. fprintf(stderr, "%s does not know where to find the database system "
  1355. "data.  You must specify the directory that contains the "
  1356. "database system either by specifying the -D invocation "
  1357.  "option or by setting the PGDATA environment variable.nn",
  1358. argv[0]);
  1359. proc_exit(1);
  1360. }
  1362. /*
  1363.  * Set up additional info.
  1364.  */
  1366. #ifdef CYR_RECODE
  1367. SetCharSet();
  1368. #endif
  1370. if (FindExec(pg_pathname, argv[0], "postgres") < 0)
  1371. elog(FATAL, "%s: could not locate executable, bailing out...",
  1372.  argv[0]);
  1374. /*
  1375.  * Find remote host name or address.
  1376.  */
  1377. if (IsUnderPostmaster)
  1378. {
  1379. switch (MyProcPort->raddr.sa.sa_family)
  1380. {
  1381. struct hostent *host_ent;
  1383. case AF_INET:
  1384. remote_info = remote_host = malloc(48);
  1385. remote_port = ntohs(MyProcPort->raddr.in.sin_port);
  1386. strcpy(remote_host, inet_ntoa(MyProcPort->raddr.in.sin_addr));
  1387. if (HostnameLookup)
  1388. {
  1389. host_ent = 
  1390. gethostbyaddr((char *) &MyProcPort->raddr.in.sin_addr,
  1391.    sizeof(MyProcPort->raddr.in.sin_addr),
  1392.   AF_INET);
  1393. if (host_ent)
  1394. {
  1395. strncpy(remote_host, host_ent->h_name, 48);
  1396. *(remote_host + 47) = '';
  1397. }
  1398. }
  1399. if (ShowPortNumber)
  1400. {
  1401. remote_info = malloc(strlen(remote_host) + 6);
  1402. sprintf(remote_info, "%s:%d", remote_host, remote_port);
  1403. }
  1404. break;
  1405. case AF_UNIX:
  1406. remote_info = remote_host = "localhost";
  1407. break;
  1408. default:
  1409. remote_info = remote_host = "unknown";
  1410. break;
  1411. }
  1412. }
  1414. /* ----------------
  1415.  * set process params for ps
  1416.  * ----------------
  1417.  */
  1418. if (IsUnderPostmaster)
  1419. {
  1420. PS_INIT_STATUS(real_argc, real_argv, argv[0],
  1421.    remote_info, userName, DBName);
  1422. PS_SET_STATUS("startup");
  1423. }
  1425. /* ----------------
  1426.  * print flags
  1427.  * ----------------
  1428.  */
  1429. if (Verbose)
  1430. {
  1431. if (Verbose == 1)
  1432. {
  1433. TPRINTF(TRACE_VERBOSE, "started: host=%s user=%s database=%s",
  1434. remote_host, userName, DBName);
  1435. }
  1436. else
  1437. {
  1438. TPRINTF(TRACE_VERBOSE, "debug info:");
  1439. TPRINTF(TRACE_VERBOSE, "tUser         = %s", userName);
  1440. TPRINTF(TRACE_VERBOSE, "tRemoteHost   = %s", remote_host);
  1441. TPRINTF(TRACE_VERBOSE, "tRemotePort   = %d", remote_port);
  1442. TPRINTF(TRACE_VERBOSE, "tDatabaseName = %s", DBName);
  1443. TPRINTF(TRACE_VERBOSE, "tVerbose      = %d", Verbose);
  1444. TPRINTF(TRACE_VERBOSE, "tNoversion    = %c", Noversion ? 't' : 'f');
  1445. TPRINTF(TRACE_VERBOSE, "ttimings      = %c", ShowStats ? 't' : 'f');
  1446. TPRINTF(TRACE_VERBOSE, "tdates        = %s",
  1447. EuroDates ? "European" : "Normal");
  1448. TPRINTF(TRACE_VERBOSE, "tbufsize      = %d", NBuffers);
  1449. TPRINTF(TRACE_VERBOSE, "tsortmem      = %d", SortMem);
  1450. TPRINTF(TRACE_VERBOSE, "tquery echo   = %c", EchoQuery ? 't' : 'f');
  1451. }
  1452. }
  1454. /* ----------------
  1455.  * initialize I/O
  1456.  * ----------------
  1457.  */
  1458. if (IsUnderPostmaster)
  1459. {
  1460. pq_init(); /* initialize libpq at backend startup */
  1461. whereToSendOutput = Remote;
  1462. }
  1463. else
  1464. whereToSendOutput = Debug;
  1466. /* ----------------
  1467.  * general initialization
  1468.  * ----------------
  1469.  */
  1470. SetProcessingMode(InitProcessing);
  1472. if (Verbose)
  1473. TPRINTF(TRACE_VERBOSE, "InitPostgres");
  1475. InitPostgres(DBName);
  1477. #ifdef MULTIBYTE
  1478. /* set default client encoding */
  1479. if (Verbose)
  1480. puts("treset_client_encoding()..");
  1481. reset_client_encoding();
  1482. if (Verbose)
  1483. puts("treset_client_encoding() done.");
  1484. #endif
  1486. on_shmem_exit(remove_all_temp_relations, NULL);
  1488. /* ----------------
  1489.  * Set up handler for cancel-request signal, and
  1490.  * send this backend's cancellation info to the frontend.
  1491.  * This should not be done until we are sure startup is successful.
  1492.  * ----------------
  1493.  */
  1495. pqsignal(SIGHUP, read_pg_options); /* update pg_options from file */
  1496. pqsignal(SIGINT, QueryCancelHandler); /* cancel current query */
  1497. pqsignal(SIGQUIT, handle_warn); /* handle error */
  1498. pqsignal(SIGTERM, die);
  1499. pqsignal(SIGPIPE, SIG_IGN); /* ignore failure to write to frontend */
  1501. /*
  1502.  * Note: if frontend closes connection, we will notice it and exit
  1503.  * cleanly when control next returns to outer loop.  This seems safer
  1504.  * than forcing exit in the midst of output during who-knows-what
  1505.  * operation...
  1506.  */
  1507. pqsignal(SIGUSR1, quickdie);
  1508. pqsignal(SIGUSR2, Async_NotifyHandler); /* flush also sinval cache */
  1509. pqsignal(SIGCHLD, SIG_IGN); /* ignored, sent by LockOwners */
  1510. pqsignal(SIGFPE, FloatExceptionHandler);
  1512. if (whereToSendOutput == Remote &&
  1513. PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
  1514. {
  1515. StringInfoData buf;
  1517. pq_beginmessage(&buf);
  1518. pq_sendbyte(&buf, 'K');
  1519. pq_sendint(&buf, (int32) MyProcPid, sizeof(int32));
  1520. pq_sendint(&buf, (int32) MyCancelKey, sizeof(int32));
  1521. pq_endmessage(&buf);
  1522. /* Need not flush since ReadyForQuery will do it. */
  1523. }
  1525. if (!IsUnderPostmaster)
  1526. {
  1527. puts("nPOSTGRES backend interactive interface ");
  1528. puts("$Revision: 1.119 $ $Date: 1999/07/02 18:09:27 $n");
  1529. }
  1531. /* ----------------
  1532.  * POSTGRES main processing loop begins here
  1533.  *
  1534.  * if an exception is encountered, processing resumes here
  1535.  * so we abort the current transaction and start a new one.
  1536.  *
  1537.  * Note:  elog(ERROR) does a siglongjmp() to transfer control here.
  1538.  * ----------------
  1539.  */
  1541. if (sigsetjmp(Warn_restart, 1) != 0)
  1542. {
  1543. InError = true;
  1545. time(&tim);
  1547. if (Verbose)
  1548. TPRINTF(TRACE_VERBOSE, "AbortCurrentTransaction");
  1550. AbortCurrentTransaction();
  1551. }
  1553. InError = false;
  1555. /*
  1556.  * Non-error queries loop here.
  1557.  */
  1559. for (;;)
  1560. {
  1561. PS_SET_STATUS("idle");
  1563. /* ----------------
  1564.  *  (1) tell the frontend we're ready for a new query.
  1565.  *
  1566.  *  Note: this includes fflush()'ing the last of the prior output.
  1567.  * ----------------
  1568.  */
  1569. ReadyForQuery(whereToSendOutput);
  1571. /* ----------------
  1572.  *  (2) deal with pending asynchronous NOTIFY from other backends,
  1573.  *  and enable async.c's signal handler to execute NOTIFY directly.
  1574.  * ----------------
  1575.  */
  1576. QueryCancel = false; /* forget any earlier CANCEL signal */
  1578. EnableNotifyInterrupt();
  1580. /* ----------------
  1581.  *  (3) read a command.
  1582.  * ----------------
  1583.  */
  1584. MemSet(parser_input, 0, MAX_PARSE_BUFFER);
  1586. firstchar = ReadCommand(parser_input);
  1588. QueryCancel = false; /* forget any earlier CANCEL signal */
  1590. /* ----------------
  1591.  *  (4) disable async.c's signal handler.
  1592.  * ----------------
  1593.  */
  1594. DisableNotifyInterrupt();
  1596. /* ----------------
  1597.  *  (5) process the command.
  1598.  * ----------------
  1599.  */
  1600. switch (firstchar)
  1601. {
  1602. /* ----------------
  1603.  * 'F' indicates a fastpath call.
  1604.  * XXX HandleFunctionRequest
  1605.  * ----------------
  1606.  */
  1607. case 'F':
  1608. IsEmptyQuery = false;
  1610. /* start an xact for this function invocation */
  1611. if (Verbose)
  1612. TPRINTF(TRACE_VERBOSE, "StartTransactionCommand");
  1613. StartTransactionCommand();
  1615. HandleFunctionRequest();
  1616. break;
  1618. /* ----------------
  1619.  * 'Q' indicates a user query
  1620.  * ----------------
  1621.  */
  1622. case 'Q':
  1623. if (strspn(parser_input, " tn") == strlen(parser_input))
  1624. {
  1625. /* ----------------
  1626.  * if there is nothing in the input buffer, don't bother
  1627.  * trying to parse and execute anything..
  1628.  * ----------------
  1629.  */
  1630. IsEmptyQuery = true;
  1631. }
  1632. else
  1633. {
  1634. /* ----------------
  1635.  * otherwise, process the input string.
  1636.  * ----------------
  1637.  */
  1638. IsEmptyQuery = false;
  1639. if (ShowStats)
  1640. ResetUsage();
  1642. /* start an xact for this query */
  1643. if (Verbose)
  1644. TPRINTF(TRACE_VERBOSE, "StartTransactionCommand");
  1645. StartTransactionCommand();
  1647. pg_exec_query(parser_input);
  1649. if (ShowStats)
  1650. ShowUsage();
  1651. }
  1652. break;
  1654. /* ----------------
  1655.  * 'X' means that the frontend is closing down the socket
  1656.  * ----------------
  1657.  */
  1658. case 'X':
  1659. pq_close();
  1660. proc_exit(0);
  1661. break;
  1663. default:
  1664. elog(ERROR, "unknown frontend message was received");
  1665. }
  1667. /* ----------------
  1668.  *  (6) commit the current transaction
  1669.  *
  1670.  *  Note: if we had an empty input buffer, then we didn't
  1671.  *  call pg_exec_query, so we don't bother to commit this transaction.
  1672.  * ----------------
  1673.  */
  1674. if (!IsEmptyQuery)
  1675. {
  1676. if (Verbose)
  1677. TPRINTF(TRACE_VERBOSE, "CommitTransactionCommand");
  1678. PS_SET_STATUS("commit");
  1679. CommitTransactionCommand();
  1680. }
  1681. else
  1682. {
  1683. if (IsUnderPostmaster)
  1684. NullCommand(Remote);
  1685. }
  1686. } /* infinite for-loop */
  1688. proc_exit(0); /* shouldn't get here... */
  1689. return 1;
  1690. }
  1692. #ifndef HAVE_GETRUSAGE
  1693. #include "rusagestub.h"
  1694. #else /* HAVE_GETRUSAGE */
  1695. #include <sys/resource.h>
  1696. #endif  /* HAVE_GETRUSAGE */
  1698. struct rusage Save_r;
  1699. struct timeval Save_t;
  1701. void
  1702. ResetUsage(void)
  1703. {
  1704. struct timezone tz;
  1706. getrusage(RUSAGE_SELF, &Save_r);
  1707. gettimeofday(&Save_t, &tz);
  1708. ResetBufferUsage();
  1709. /*   ResetTupleCount(); */
  1710. }
  1712. void
  1713. ShowUsage(void)
  1714. {
  1715. struct timeval user,
  1716. sys;
  1717. struct timeval elapse_t;
  1718. struct timezone tz;
  1719. struct rusage r;
  1721. getrusage(RUSAGE_SELF, &r);
  1722. gettimeofday(&elapse_t, &tz);
  1723. memmove((char *) &user, (char *) &r.ru_utime, sizeof(user));
  1724. memmove((char *) &sys, (char *) &r.ru_stime, sizeof(sys));
  1725. if (elapse_t.tv_usec < Save_t.tv_usec)
  1726. {
  1727. elapse_t.tv_sec--;
  1728. elapse_t.tv_usec += 1000000;
  1729. }
  1730. if (r.ru_utime.tv_usec < Save_r.ru_utime.tv_usec)
  1731. {
  1732. r.ru_utime.tv_sec--;
  1733. r.ru_utime.tv_usec += 1000000;
  1734. }
  1735. if (r.ru_stime.tv_usec < Save_r.ru_stime.tv_usec)
  1736. {
  1737. r.ru_stime.tv_sec--;
  1738. r.ru_stime.tv_usec += 1000000;
  1739. }
  1741. /*
  1742.  * the only stats we don't show here are for memory usage -- i can't
  1743.  * figure out how to interpret the relevant fields in the rusage
  1744.  * struct, and they change names across o/s platforms, anyway. if you
  1745.  * can figure out what the entries mean, you can somehow extract
  1746.  * resident set size, shared text size, and unshared data and stack
  1747.  * sizes.
  1748.  */
  1750. fprintf(StatFp, "! system usage stats:n");
  1751. fprintf(StatFp,
  1752. "!t%ld.%06ld elapsed %ld.%06ld user %ld.%06ld system secn",
  1753. (long int) elapse_t.tv_sec - Save_t.tv_sec,
  1754. (long int) elapse_t.tv_usec - Save_t.tv_usec,
  1755. (long int) r.ru_utime.tv_sec - Save_r.ru_utime.tv_sec,
  1756. (long int) r.ru_utime.tv_usec - Save_r.ru_utime.tv_usec,
  1757. (long int) r.ru_stime.tv_sec - Save_r.ru_stime.tv_sec,
  1758. (long int) r.ru_stime.tv_usec - Save_r.ru_stime.tv_usec);
  1759. fprintf(StatFp,
  1760. "!t[%ld.%06ld user %ld.%06ld sys total]n",
  1761. (long int) user.tv_sec,
  1762. (long int) user.tv_usec,
  1763. (long int) sys.tv_sec,
  1764. (long int) sys.tv_usec);
  1765. #ifdef HAVE_GETRUSAGE
  1766. fprintf(StatFp,
  1767. "!t%ld/%ld [%ld/%ld] filesystem blocks in/outn",
  1768. r.ru_inblock - Save_r.ru_inblock,
  1769. /* they only drink coffee at dec */
  1770. r.ru_oublock - Save_r.ru_oublock,
  1771. r.ru_inblock, r.ru_oublock);
  1772. fprintf(StatFp,
  1773.   "!t%ld/%ld [%ld/%ld] page faults/reclaims, %ld [%ld] swapsn",
  1774. r.ru_majflt - Save_r.ru_majflt,
  1775. r.ru_minflt - Save_r.ru_minflt,
  1776. r.ru_majflt, r.ru_minflt,
  1777. r.ru_nswap - Save_r.ru_nswap,
  1778. r.ru_nswap);
  1779. fprintf(StatFp,
  1780.  "!t%ld [%ld] signals rcvd, %ld/%ld [%ld/%ld] messages rcvd/sentn",
  1781. r.ru_nsignals - Save_r.ru_nsignals,
  1782. r.ru_nsignals,
  1783. r.ru_msgrcv - Save_r.ru_msgrcv,
  1784. r.ru_msgsnd - Save_r.ru_msgsnd,
  1785. r.ru_msgrcv, r.ru_msgsnd);
  1786. fprintf(StatFp,
  1787.  "!t%ld/%ld [%ld/%ld] voluntary/involuntary context switchesn",
  1788. r.ru_nvcsw - Save_r.ru_nvcsw,
  1789. r.ru_nivcsw - Save_r.ru_nivcsw,
  1790. r.ru_nvcsw, r.ru_nivcsw);
  1791. #endif  /* HAVE_GETRUSAGE */
  1792. fprintf(StatFp, "! postgres usage stats:n");
  1793. PrintBufferUsage(StatFp);
  1794. /*    DisplayTupleCount(StatFp); */
  1795. }
  1797. #ifdef USE_ASSERT_CHECKING
  1798. int
  1799. assertEnable(int val)
  1800. {
  1801. assert_enabled = val;
  1802. return val;
  1803. }
  1805. #ifdef ASSERT_CHECKING_TEST
  1806. int
  1807. assertTest(int val)
  1808. {
  1809. Assert(val == 0);
  1811. if (assert_enabled)
  1812. {
  1813. /* val != 0 should be trapped by previous Assert */
  1814. elog(NOTICE, "Assert test successfull (val = %d)", val);
  1815. }
  1816. else
  1817. elog(NOTICE, "Assert checking is disabled (val = %d)", val);
  1819. return val;
  1820. }
  1822. #endif
  1823. #endif