[フレーム]

startup.c

Go to the documentation of this file.

1/*

2 * psql - the PostgreSQL interactive terminal

3 *

5 *

6 * src/bin/psql/startup.c

7 */

8#include "postgres_fe.h"

9

10#ifndef WIN32

11#include <unistd.h>

12#else /* WIN32 */

13#include <io.h>

14#include <win32.h>

15#endif /* WIN32 */

16

17#include "command.h"

18#include "common.h"

19#include "common/logging.h"

20#include "common/string.h"

21#include "describe.h"

22#include "fe_utils/print.h"

23#include "getopt_long.h"

24#include "help.h"

25#include "input.h"

26#include "mainloop.h"

27#include "settings.h"

28

29/*

30 * Global psql options

31 */

32 PsqlSettings pset;

33

34#ifndef WIN32

35 #define SYSPSQLRC "psqlrc"

36 #define PSQLRC ".psqlrc"

37#else

38#define SYSPSQLRC "psqlrc"

39#define PSQLRC "psqlrc.conf"

40#endif

41

42/*

43 * Structures to pass information between the option parsing routine

44 * and the main function

45 */

46 enum _actions

47{

48 ACT_SINGLE_QUERY,

49 ACT_SINGLE_SLASH,

50 ACT_FILE,

51};

52

53 typedef struct SimpleActionListCell

54{

55 struct SimpleActionListCell *next;

56 enum _actions action;

57 char *val;

58 } SimpleActionListCell;

59

60 typedef struct SimpleActionList

61{

62 SimpleActionListCell *head;

63 SimpleActionListCell *tail;

64 } SimpleActionList;

65

66 struct adhoc_opts

67{

68 char *dbname;

69 char *host;

70 char *port;

71 char *username;

72 char *logfilename;

73 bool no_readline;

74 bool no_psqlrc;

75 bool single_txn;

76 bool list_dbs;

77 SimpleActionList actions;

78};

79

80static void parse_psql_options(int argc, char *argv[],

81 struct adhoc_opts *options);

82static void simple_action_list_append(SimpleActionList *list,

83 enum _actions action, const char *val);

84static void process_psqlrc(char *argv0);

85static void process_psqlrc_file(char *filename);

86static void showVersion(void);

87static void EstablishVariableSpace(void);

88

89 #define NOPAGER 0

90

91static void

92 log_pre_callback(void)

93{

94 if (pset.queryFout && pset.queryFout != stdout)

95 fflush(pset.queryFout);

96}

97

98static void

99 log_locus_callback(const char **filename, uint64 *lineno)

100{

101 if (pset.inputfile)

102 {

103 *filename = pset.inputfile;

104 *lineno = pset.lineno;

105 }

106 else

107 {

108 *filename = NULL;

109 *lineno = 0;

110 }

111}

112

113#ifndef WIN32

114static void

115 empty_signal_handler(SIGNAL_ARGS)

116{

117}

118#endif

119

120/*

121 *

122 * main

123 *

124 */

125int

126 main(int argc, char *argv[])

127{

128 struct adhoc_opts options;

129 int successResult;

130 char *password = NULL;

131 bool new_pass;

132

133 pg_logging_init(argv[0]);

134 pg_logging_set_pre_callback(log_pre_callback);

135 pg_logging_set_locus_callback(log_locus_callback);

136 set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("psql"));

137

138 if (argc > 1)

139 {

140 if ((strcmp(argv[1], "-?") == 0) || (argc == 2 && (strcmp(argv[1], "--help") == 0)))

141 {

142 usage(NOPAGER);

143 exit(EXIT_SUCCESS);

144 }

145 if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)

146 {

147 showVersion();

148 exit(EXIT_SUCCESS);

149 }

150 }

151

152 pset.progname = get_progname(argv[0]);

153

154 pset.db = NULL;

155 pset.dead_conn = NULL;

156 setDecimalLocale();

157 pset.encoding = PQenv2encoding();

158 pset.queryFout = stdout;

159 pset.queryFoutPipe = false;

160 pset.copyStream = NULL;

161 pset.last_error_result = NULL;

162 pset.cur_cmd_source = stdin;

163 pset.cur_cmd_interactive = false;

164

165 /* We rely on unmentioned fields of pset.popt to start out 0/false/NULL */

166 pset.popt.topt.format = PRINT_ALIGNED;

167 pset.popt.topt.border = 1;

168 pset.popt.topt.pager = 1;

169 pset.popt.topt.pager_min_lines = 0;

170 pset.popt.topt.start_table = true;

171 pset.popt.topt.stop_table = true;

172 pset.popt.topt.default_footer = true;

173

174 pset.popt.topt.csvFieldSep[0] = DEFAULT_CSV_FIELD_SEP;

175 pset.popt.topt.csvFieldSep[1] = '0円';

176

177 pset.popt.topt.unicode_border_linestyle = UNICODE_LINESTYLE_SINGLE;

178 pset.popt.topt.unicode_column_linestyle = UNICODE_LINESTYLE_SINGLE;

179 pset.popt.topt.unicode_header_linestyle = UNICODE_LINESTYLE_SINGLE;

180

181 refresh_utf8format(&(pset.popt.topt));

182

183 /* We must get COLUMNS here before readline() sets it */

184 pset.popt.topt.env_columns = getenv("COLUMNS") ? atoi(getenv("COLUMNS")) : 0;

185

186 pset.notty = (!isatty(fileno(stdin)) || !isatty(fileno(stdout)));

187

188 pset.getPassword = TRI_DEFAULT;

189

190 EstablishVariableSpace();

191

192 /* Create variables showing psql version number */

193 SetVariable(pset.vars, "VERSION", PG_VERSION_STR);

194 SetVariable(pset.vars, "VERSION_NAME", PG_VERSION);

195 SetVariable(pset.vars, "VERSION_NUM", CppAsString2(PG_VERSION_NUM));

196

197 /* Initialize variables for last error */

198 SetVariable(pset.vars, "LAST_ERROR_MESSAGE", "");

199 SetVariable(pset.vars, "LAST_ERROR_SQLSTATE", "00000");

200

201 /* Default values for variables (that don't match the result of \unset) */

202 SetVariableBool(pset.vars, "AUTOCOMMIT");

203 SetVariable(pset.vars, "PROMPT1", DEFAULT_PROMPT1);

204 SetVariable(pset.vars, "PROMPT2", DEFAULT_PROMPT2);

205 SetVariable(pset.vars, "PROMPT3", DEFAULT_PROMPT3);

206 SetVariableBool(pset.vars, "SHOW_ALL_RESULTS");

207

208 /* Initialize pipeline variables */

209 SetVariable(pset.vars, "PIPELINE_SYNC_COUNT", "0");

210 SetVariable(pset.vars, "PIPELINE_COMMAND_COUNT", "0");

211 SetVariable(pset.vars, "PIPELINE_RESULT_COUNT", "0");

212

213 parse_psql_options(argc, argv, &options);

214

215 /*

216 * If no action was specified and we're in non-interactive mode, treat it

217 * as if the user had specified "-f -". This lets single-transaction mode

218 * work in this case.

219 */

220 if (options.actions.head == NULL && pset.notty)

221 simple_action_list_append(&options.actions, ACT_FILE, NULL);

222

223 /* Bail out if -1 was specified but will be ignored. */

224 if (options.single_txn && options.actions.head == NULL)

225 pg_fatal("-1 can only be used in non-interactive mode");

226

227 if (!pset.popt.topt.fieldSep.separator &&

228 !pset.popt.topt.fieldSep.separator_zero)

229 {

230 pset.popt.topt.fieldSep.separator = pg_strdup(DEFAULT_FIELD_SEP);

231 pset.popt.topt.fieldSep.separator_zero = false;

232 }

233 if (!pset.popt.topt.recordSep.separator &&

234 !pset.popt.topt.recordSep.separator_zero)

235 {

236 pset.popt.topt.recordSep.separator = pg_strdup(DEFAULT_RECORD_SEP);

237 pset.popt.topt.recordSep.separator_zero = false;

238 }

239

240 if (pset.getPassword == TRI_YES)

241 {

242 /*

243 * We can't be sure yet of the username that will be used, so don't

244 * offer a potentially wrong one. Typical uses of this option are

245 * noninteractive anyway. (Note: since we've not yet set up our

246 * cancel handler, there's no need to use simple_prompt_extended.)

247 */

248 password = simple_prompt("Password: ", false);

249 }

250

251 /* loop until we have a password if requested by backend */

252 do

253 {

254#define PARAMS_ARRAY_SIZE 8

255 const char **keywords = pg_malloc_array(const char *, PARAMS_ARRAY_SIZE);

256 const char **values = pg_malloc_array(const char *, PARAMS_ARRAY_SIZE);

257

258 keywords[0] = "host";

259 values[0] = options.host;

260 keywords[1] = "port";

261 values[1] = options.port;

262 keywords[2] = "user";

263 values[2] = options.username;

264 keywords[3] = "password";

265 values[3] = password;

266 keywords[4] = "dbname"; /* see do_connect() */

267 values[4] = (options.list_dbs && options.dbname == NULL) ?

268 "postgres" : options.dbname;

269 keywords[5] = "fallback_application_name";

270 values[5] = pset.progname;

271 keywords[6] = "client_encoding";

272 values[6] = (pset.notty || getenv("PGCLIENTENCODING")) ? NULL : "auto";

273 keywords[7] = NULL;

274 values[7] = NULL;

275

276 new_pass = false;

277 pset.db = PQconnectdbParams(keywords, values, true);

278 free(keywords);

279 free(values);

280

281 if (PQstatus(pset.db) == CONNECTION_BAD &&

282 PQconnectionNeedsPassword(pset.db) &&

283 !password &&

284 pset.getPassword != TRI_NO)

285 {

286 /*

287 * Before closing the old PGconn, extract the user name that was

288 * actually connected with --- it might've come out of a URI or

289 * connstring "database name" rather than options.username.

290 */

291 const char *realusername = PQuser(pset.db);

292 char *password_prompt;

293

294 if (realusername && realusername[0])

295 password_prompt = psprintf(_("Password for user %s: "),

296 realusername);

297 else

298 password_prompt = pg_strdup(_("Password: "));

299 PQfinish(pset.db);

300

301 password = simple_prompt(password_prompt, false);

302 free(password_prompt);

303 new_pass = true;

304 }

305 } while (new_pass);

306

307 if (PQstatus(pset.db) == CONNECTION_BAD)

308 {

309 pg_log_error("%s", PQerrorMessage(pset.db));

310 PQfinish(pset.db);

311 exit(EXIT_BADCONN);

312 }

313

314 psql_setup_cancel_handler();

315

316#ifndef WIN32

317

318 /*

319 * do_watch() needs signal handlers installed (otherwise sigwait() will

320 * filter them out on some platforms), but doesn't need them to do

321 * anything, and they shouldn't ever run (unless perhaps a stray SIGALRM

322 * arrives due to a race when do_watch() cancels an itimer).

323 */

324 pqsignal(SIGCHLD, empty_signal_handler);

325 pqsignal(SIGALRM, empty_signal_handler);

326#endif

327

328 PQsetNoticeProcessor(pset.db, NoticeProcessor, NULL);

329

330 SyncVariables();

331

332 if (options.list_dbs)

333 {

334 int success;

335

336 if (!options.no_psqlrc)

337 process_psqlrc(argv[0]);

338

339 success = listAllDbs(NULL, false);

340 PQfinish(pset.db);

341 exit(success ? EXIT_SUCCESS : EXIT_FAILURE);

342 }

343

344 if (options.logfilename)

345 {

346 pset.logfile = fopen(options.logfilename, "a");

347 if (!pset.logfile)

348 pg_fatal("could not open log file \"%s\": %m",

349 options.logfilename);

350 }

351

352 if (!options.no_psqlrc)

353 process_psqlrc(argv[0]);

354

355 /*

356 * If any actions were given by user, process them in the order in which

357 * they were specified. Note single_txn is only effective in this mode.

358 */

359 if (options.actions.head != NULL)

360 {

361 PGresult *res;

362 SimpleActionListCell *cell;

363

364 successResult = EXIT_SUCCESS; /* silence compiler */

365

366 if (options.single_txn)

367 {

368 if ((res = PSQLexec("BEGIN")) == NULL)

369 {

370 if (pset.on_error_stop)

371 {

372 successResult = EXIT_USER;

373 goto error;

374 }

375 }

376 else

377 PQclear(res);

378 }

379

380 for (cell = options.actions.head; cell; cell = cell->next)

381 {

382 if (cell->action == ACT_SINGLE_QUERY)

383 {

384 pg_logging_config(PG_LOG_FLAG_TERSE);

385

386 if (pset.echo == PSQL_ECHO_ALL)

387 puts(cell->val);

388

389 successResult = SendQuery(cell->val)

390 ? EXIT_SUCCESS : EXIT_FAILURE;

391 }

392 else if (cell->action == ACT_SINGLE_SLASH)

393 {

394 PsqlScanState scan_state;

395 ConditionalStack cond_stack;

396

397 pg_logging_config(PG_LOG_FLAG_TERSE);

398

399 if (pset.echo == PSQL_ECHO_ALL)

400 puts(cell->val);

401

402 scan_state = psql_scan_create(&psqlscan_callbacks);

403 psql_scan_setup(scan_state,

404 cell->val, strlen(cell->val),

405 pset.encoding, standard_strings());

406 cond_stack = conditional_stack_create();

407 psql_scan_set_passthrough(scan_state, cond_stack);

408

409 successResult = HandleSlashCmds(scan_state,

410 cond_stack,

411 NULL,

412 NULL) != PSQL_CMD_ERROR

413 ? EXIT_SUCCESS : EXIT_FAILURE;

414

415 psql_scan_destroy(scan_state);

416 conditional_stack_destroy(cond_stack);

417 }

418 else if (cell->action == ACT_FILE)

419 {

420 successResult = process_file(cell->val, false);

421 }

422 else

423 {

424 /* should never come here */

425 Assert(false);

426 }

427

428 if (successResult != EXIT_SUCCESS && pset.on_error_stop)

429 break;

430 }

431

432 if (options.single_txn)

433 {

434 /*

435 * Rollback the contents of the single transaction if the caller

436 * has set ON_ERROR_STOP and one of the steps has failed. This

437 * check needs to match the one done a couple of lines above.

438 */

439 res = PSQLexec((successResult != EXIT_SUCCESS && pset.on_error_stop) ?

440 "ROLLBACK" : "COMMIT");

441 if (res == NULL)

442 {

443 if (pset.on_error_stop)

444 {

445 successResult = EXIT_USER;

446 goto error;

447 }

448 }

449 else

450 PQclear(res);

451 }

452

453error:

454 ;

455 }

456

457 /*

458 * or otherwise enter interactive main loop

459 */

460 else

461 {

462 pg_logging_config(PG_LOG_FLAG_TERSE);

463 connection_warnings(true);

464 if (!pset.quiet)

465 printf(_("Type \"help\" for help.\n\n"));

466 initializeInput(options.no_readline ? 0 : 1);

467 successResult = MainLoop(stdin);

468 }

469

470 /* clean up */

471 if (pset.logfile)

472 fclose(pset.logfile);

473 if (pset.db)

474 PQfinish(pset.db);

475 if (pset.dead_conn)

476 PQfinish(pset.dead_conn);

477 setQFout(NULL);

478

479 return successResult;

480}

481

482

483/*

484 * Parse command line options

485 */

486

487static void

488 parse_psql_options(int argc, char *argv[], struct adhoc_opts *options)

489{

490 static struct option long_options[] =

491 {

492 {"echo-all", no_argument, NULL, 'a'},

493 {"no-align", no_argument, NULL, 'A'},

494 {"command", required_argument, NULL, 'c'},

495 {"dbname", required_argument, NULL, 'd'},

496 {"echo-queries", no_argument, NULL, 'e'},

497 {"echo-errors", no_argument, NULL, 'b'},

498 {"echo-hidden", no_argument, NULL, 'E'},

499 {"file", required_argument, NULL, 'f'},

500 {"field-separator", required_argument, NULL, 'F'},

501 {"field-separator-zero", no_argument, NULL, 'z'},

502 {"host", required_argument, NULL, 'h'},

503 {"html", no_argument, NULL, 'H'},

504 {"list", no_argument, NULL, 'l'},

505 {"log-file", required_argument, NULL, 'L'},

506 {"no-readline", no_argument, NULL, 'n'},

507 {"single-transaction", no_argument, NULL, '1'},

508 {"output", required_argument, NULL, 'o'},

509 {"port", required_argument, NULL, 'p'},

510 {"pset", required_argument, NULL, 'P'},

511 {"quiet", no_argument, NULL, 'q'},

512 {"record-separator", required_argument, NULL, 'R'},

513 {"record-separator-zero", no_argument, NULL, '0'},

514 {"single-step", no_argument, NULL, 's'},

515 {"single-line", no_argument, NULL, 'S'},

516 {"tuples-only", no_argument, NULL, 't'},

517 {"table-attr", required_argument, NULL, 'T'},

518 {"username", required_argument, NULL, 'U'},

519 {"set", required_argument, NULL, 'v'},

520 {"variable", required_argument, NULL, 'v'},

521 {"version", no_argument, NULL, 'V'},

522 {"no-password", no_argument, NULL, 'w'},

523 {"password", no_argument, NULL, 'W'},

524 {"expanded", no_argument, NULL, 'x'},

525 {"no-psqlrc", no_argument, NULL, 'X'},

526 {"help", optional_argument, NULL, 1},

527 {"csv", no_argument, NULL, 2},

528 {NULL, 0, NULL, 0}

529 };

530

531 int optindex;

532 int c;

533

534 memset(options, 0, sizeof *options);

535

536 while ((c = getopt_long(argc, argv, "aAbc:d:eEf:F:h:HlL:no:p:P:qR:sStT:U:v:VwWxXz?01",

537 long_options, &optindex)) != -1)

538 {

539 switch (c)

540 {

541 case 'a':

542 SetVariable(pset.vars, "ECHO", "all");

543 break;

544 case 'A':

545 pset.popt.topt.format = PRINT_UNALIGNED;

546 break;

547 case 'b':

548 SetVariable(pset.vars, "ECHO", "errors");

549 break;

550 case 'c':

551 if (optarg[0] == '\\')

552 simple_action_list_append(&options->actions,

553 ACT_SINGLE_SLASH,

554 optarg + 1);

555 else

556 simple_action_list_append(&options->actions,

557 ACT_SINGLE_QUERY,

558 optarg);

559 break;

560 case 'd':

561 options->dbname = pg_strdup(optarg);

562 break;

563 case 'e':

564 SetVariable(pset.vars, "ECHO", "queries");

565 break;

566 case 'E':

567 SetVariableBool(pset.vars, "ECHO_HIDDEN");

568 break;

569 case 'f':

570 simple_action_list_append(&options->actions,

571 ACT_FILE,

572 optarg);

573 break;

574 case 'F':

575 pset.popt.topt.fieldSep.separator = pg_strdup(optarg);

576 pset.popt.topt.fieldSep.separator_zero = false;

577 break;

578 case 'h':

579 options->host = pg_strdup(optarg);

580 break;

581 case 'H':

582 pset.popt.topt.format = PRINT_HTML;

583 break;

584 case 'l':

585 options->list_dbs = true;

586 break;

587 case 'L':

588 options->logfilename = pg_strdup(optarg);

589 break;

590 case 'n':

591 options->no_readline = true;

592 break;

593 case 'o':

594 if (!setQFout(optarg))

595 exit(EXIT_FAILURE);

596 break;

597 case 'p':

598 options->port = pg_strdup(optarg);

599 break;

600 case 'P':

601 {

602 char *value;

603 char *equal_loc;

604 bool result;

605

606 value = pg_strdup(optarg);

607 equal_loc = strchr(value, '=');

608 if (!equal_loc)

609 result = do_pset(value, NULL, &pset.popt, true);

610 else

611 {

612 *equal_loc = '0円';

613 result = do_pset(value, equal_loc + 1, &pset.popt, true);

614 }

615

616 if (!result)

617 pg_fatal("could not set printing parameter \"%s\"", value);

618

619 free(value);

620 break;

621 }

622 case 'q':

623 SetVariableBool(pset.vars, "QUIET");

624 break;

625 case 'R':

626 pset.popt.topt.recordSep.separator = pg_strdup(optarg);

627 pset.popt.topt.recordSep.separator_zero = false;

628 break;

629 case 's':

630 SetVariableBool(pset.vars, "SINGLESTEP");

631 break;

632 case 'S':

633 SetVariableBool(pset.vars, "SINGLELINE");

634 break;

635 case 't':

636 pset.popt.topt.tuples_only = true;

637 break;

638 case 'T':

639 pset.popt.topt.tableAttr = pg_strdup(optarg);

640 break;

641 case 'U':

642 options->username = pg_strdup(optarg);

643 break;

644 case 'v':

645 {

646 char *value;

647 char *equal_loc;

648

649 value = pg_strdup(optarg);

650 equal_loc = strchr(value, '=');

651 if (!equal_loc)

652 {

653 if (!DeleteVariable(pset.vars, value))

654 exit(EXIT_FAILURE); /* error already printed */

655 }

656 else

657 {

658 *equal_loc = '0円';

659 if (!SetVariable(pset.vars, value, equal_loc + 1))

660 exit(EXIT_FAILURE); /* error already printed */

661 }

662

663 free(value);

664 break;

665 }

666 case 'V':

667 showVersion();

668 exit(EXIT_SUCCESS);

669 case 'w':

670 pset.getPassword = TRI_NO;

671 break;

672 case 'W':

673 pset.getPassword = TRI_YES;

674 break;

675 case 'x':

676 pset.popt.topt.expanded = true;

677 break;

678 case 'X':

679 options->no_psqlrc = true;

680 break;

681 case 'z':

682 pset.popt.topt.fieldSep.separator_zero = true;

683 break;

684 case '0':

685 pset.popt.topt.recordSep.separator_zero = true;

686 break;

687 case '1':

688 options->single_txn = true;

689 break;

690 case '?':

691 if (optind <= argc &&

692 strcmp(argv[optind - 1], "-?") == 0)

693 {

694 /* actual help option given */

695 usage(NOPAGER);

696 exit(EXIT_SUCCESS);

697 }

698 else

699 {

700 /* getopt error (unknown option or missing argument) */

701 goto unknown_option;

702 }

703 break;

704 case 1:

705 {

706 if (!optarg || strcmp(optarg, "options") == 0)

707 usage(NOPAGER);

708 else if (optarg && strcmp(optarg, "commands") == 0)

709 slashUsage(NOPAGER);

710 else if (optarg && strcmp(optarg, "variables") == 0)

711 helpVariables(NOPAGER);

712 else

713 goto unknown_option;

714

715 exit(EXIT_SUCCESS);

716 }

717 break;

718 case 2:

719 pset.popt.topt.format = PRINT_CSV;

720 break;

721 default:

722 unknown_option:

723 /* getopt_long already emitted a complaint */

724 pg_log_error_hint("Try \"%s --help\" for more information.",

725 pset.progname);

726 exit(EXIT_FAILURE);

727 }

728 }

729

730 /*

731 * if we still have arguments, use it as the database name and username

732 */

733 while (argc - optind >= 1)

734 {

735 if (!options->dbname)

736 options->dbname = argv[optind];

737 else if (!options->username)

738 options->username = argv[optind];

739 else if (!pset.quiet)

740 pg_log_warning("extra command-line argument \"%s\" ignored",

741 argv[optind]);

742

743 optind++;

744 }

745}

746

747

748/*

749 * Append a new item to the end of the SimpleActionList.

750 * Note that "val" is copied if it's not NULL.

751 */

752static void

753 simple_action_list_append(SimpleActionList *list,

754 enum _actions action, const char *val)

755{

756 SimpleActionListCell *cell;

757

758 cell = pg_malloc_object(SimpleActionListCell);

759

760 cell->next = NULL;

761 cell->action = action;

762 if (val)

763 cell->val = pg_strdup(val);

764 else

765 cell->val = NULL;

766

767 if (list->tail)

768 list->tail->next = cell;

769 else

770 list->head = cell;

771 list->tail = cell;

772}

773

774

775/*

776 * Load .psqlrc file, if found.

777 */

778static void

779 process_psqlrc(char *argv0)

780{

781 char home[MAXPGPATH];

782 char rc_file[MAXPGPATH];

783 char my_exec_path[MAXPGPATH];

784 char etc_path[MAXPGPATH];

785 char *envrc = getenv("PSQLRC");

786

787 if (find_my_exec(argv0, my_exec_path) < 0)

788 pg_fatal("could not find own program executable");

789

790 get_etc_path(my_exec_path, etc_path);

791

792 snprintf(rc_file, MAXPGPATH, "%s/%s", etc_path, SYSPSQLRC);

793 process_psqlrc_file(rc_file);

794

795 if (envrc != NULL && strlen(envrc) > 0)

796 {

797 /* might need to free() this */

798 char *envrc_alloc = pstrdup(envrc);

799

800 expand_tilde(&envrc_alloc);

801 process_psqlrc_file(envrc_alloc);

802 }

803 else if (get_home_path(home))

804 {

805 snprintf(rc_file, MAXPGPATH, "%s/%s", home, PSQLRC);

806 process_psqlrc_file(rc_file);

807 }

808}

809

810

811

812static void

813 process_psqlrc_file(char *filename)

814{

815 char *psqlrc_minor,

816 *psqlrc_major;

817

818#if defined(WIN32) && (!defined(__MINGW32__))

819#define R_OK 4

820#endif

821

822 psqlrc_minor = psprintf("%s-%s", filename, PG_VERSION);

823 psqlrc_major = psprintf("%s-%s", filename, PG_MAJORVERSION);

824

825 /* check for minor version first, then major, then no version */

826 if (access(psqlrc_minor, R_OK) == 0)

827 (void) process_file(psqlrc_minor, false);

828 else if (access(psqlrc_major, R_OK) == 0)

829 (void) process_file(psqlrc_major, false);

830 else if (access(filename, R_OK) == 0)

831 (void) process_file(filename, false);

832

833 free(psqlrc_minor);

834 free(psqlrc_major);

835}

836

837

838

839/* showVersion

840 *

841 * This output format is intended to match GNU standards.

842 */

843static void

844 showVersion(void)

845{

846 puts("psql (PostgreSQL) " PG_VERSION);

847}

848

849

850

851/*

852 * Substitute hooks and assign hooks for psql variables.

853 *

854 * This isn't an amazingly good place for them, but neither is anywhere else.

855 *

856 * By policy, every special variable that controls any psql behavior should

857 * have one or both hooks, even if they're just no-ops. This ensures that

858 * the variable will remain present in variables.c's list even when unset,

859 * which ensures that it's known to tab completion.

860 */

861

862static char *

863 bool_substitute_hook(char *newval)

864{

865 if (newval == NULL)

866 {

867 /* "\unset FOO" becomes "\set FOO off" */

868 newval = pg_strdup("off");

869 }

870 else if (newval[0] == '0円')

871 {

872 /* "\set FOO" becomes "\set FOO on" */

873 pg_free(newval);

874 newval = pg_strdup("on");

875 }

876 return newval;

877}

878

879static bool

880 autocommit_hook(const char *newval)

881{

882 return ParseVariableBool(newval, "AUTOCOMMIT", &pset.autocommit);

883}

884

885static bool

886 on_error_stop_hook(const char *newval)

887{

888 return ParseVariableBool(newval, "ON_ERROR_STOP", &pset.on_error_stop);

889}

890

891static bool

892 quiet_hook(const char *newval)

893{

894 return ParseVariableBool(newval, "QUIET", &pset.quiet);

895}

896

897static bool

898 singleline_hook(const char *newval)

899{

900 return ParseVariableBool(newval, "SINGLELINE", &pset.singleline);

901}

902

903static bool

904 singlestep_hook(const char *newval)

905{

906 return ParseVariableBool(newval, "SINGLESTEP", &pset.singlestep);

907}

908

909static char *

910 fetch_count_substitute_hook(char *newval)

911{

912 if (newval == NULL)

913 newval = pg_strdup("0");

914 return newval;

915}

916

917static bool

918 fetch_count_hook(const char *newval)

919{

920 return ParseVariableNum(newval, "FETCH_COUNT", &pset.fetch_count);

921}

922

923static bool

924 histfile_hook(const char *newval)

925{

926 /*

927 * Someday we might try to validate the filename, but for now, this is

928 * just a placeholder to ensure HISTFILE is known to tab completion.

929 */

930 return true;

931}

932

933static char *

934 histsize_substitute_hook(char *newval)

935{

936 if (newval == NULL)

937 newval = pg_strdup("500");

938 return newval;

939}

940

941static bool

942 histsize_hook(const char *newval)

943{

944 return ParseVariableNum(newval, "HISTSIZE", &pset.histsize);

945}

946

947static char *

948 watch_interval_substitute_hook(char *newval)

949{

950 if (newval == NULL)

951 newval = pg_strdup(DEFAULT_WATCH_INTERVAL);

952 return newval;

953}

954

955static bool

956 watch_interval_hook(const char *newval)

957{

958 return ParseVariableDouble(newval, "WATCH_INTERVAL", &pset.watch_interval,

959 0, DEFAULT_WATCH_INTERVAL_MAX);

960}

961

962static char *

963 ignoreeof_substitute_hook(char *newval)

964{

965 int dummy;

966

967 /*

968 * This tries to mimic the behavior of bash, to wit "If set, the value is

969 * the number of consecutive EOF characters which must be typed as the

970 * first characters on an input line before bash exits. If the variable

971 * exists but does not have a numeric value, or has no value, the default

972 * value is 10. If it does not exist, EOF signifies the end of input to

973 * the shell." Unlike bash, however, we insist on the stored value

974 * actually being a valid integer.

975 */

976 if (newval == NULL)

977 newval = pg_strdup("0");

978 else if (!ParseVariableNum(newval, NULL, &dummy))

979 newval = pg_strdup("10");

980 return newval;

981}

982

983static bool

984 ignoreeof_hook(const char *newval)

985{

986 return ParseVariableNum(newval, "IGNOREEOF", &pset.ignoreeof);

987}

988

989static char *

990 echo_substitute_hook(char *newval)

991{

992 if (newval == NULL)

993 newval = pg_strdup("none");

994 return newval;

995}

996

997static bool

998 echo_hook(const char *newval)

999{

1000 Assert(newval != NULL); /* else substitute hook messed up */

1001 if (pg_strcasecmp(newval, "queries") == 0)

1002 pset.echo = PSQL_ECHO_QUERIES;

1003 else if (pg_strcasecmp(newval, "errors") == 0)

1004 pset.echo = PSQL_ECHO_ERRORS;

1005 else if (pg_strcasecmp(newval, "all") == 0)

1006 pset.echo = PSQL_ECHO_ALL;

1007 else if (pg_strcasecmp(newval, "none") == 0)

1008 pset.echo = PSQL_ECHO_NONE;

1009 else

1010 {

1011 PsqlVarEnumError("ECHO", newval, "none, errors, queries, all");

1012 return false;

1013 }

1014 return true;

1015}

1016

1017static bool

1018 echo_hidden_hook(const char *newval)

1019{

1020 Assert(newval != NULL); /* else substitute hook messed up */

1021 if (pg_strcasecmp(newval, "noexec") == 0)

1022 pset.echo_hidden = PSQL_ECHO_HIDDEN_NOEXEC;

1023 else

1024 {

1025 bool on_off;

1026

1027 if (ParseVariableBool(newval, NULL, &on_off))

1028 pset.echo_hidden = on_off ? PSQL_ECHO_HIDDEN_ON : PSQL_ECHO_HIDDEN_OFF;

1029 else

1030 {

1031 PsqlVarEnumError("ECHO_HIDDEN", newval, "on, off, noexec");

1032 return false;

1033 }

1034 }

1035 return true;

1036}

1037

1038static bool

1039 on_error_rollback_hook(const char *newval)

1040{

1041 Assert(newval != NULL); /* else substitute hook messed up */

1042 if (pg_strcasecmp(newval, "interactive") == 0)

1043 pset.on_error_rollback = PSQL_ERROR_ROLLBACK_INTERACTIVE;

1044 else

1045 {

1046 bool on_off;

1047

1048 if (ParseVariableBool(newval, NULL, &on_off))

1049 pset.on_error_rollback = on_off ? PSQL_ERROR_ROLLBACK_ON : PSQL_ERROR_ROLLBACK_OFF;

1050 else

1051 {

1052 PsqlVarEnumError("ON_ERROR_ROLLBACK", newval, "on, off, interactive");

1053 return false;

1054 }

1055 }

1056 return true;

1057}

1058

1059static char *

1060 comp_keyword_case_substitute_hook(char *newval)

1061{

1062 if (newval == NULL)

1063 newval = pg_strdup("preserve-upper");

1064 return newval;

1065}

1066

1067static bool

1068 comp_keyword_case_hook(const char *newval)

1069{

1070 Assert(newval != NULL); /* else substitute hook messed up */

1071 if (pg_strcasecmp(newval, "preserve-upper") == 0)

1072 pset.comp_case = PSQL_COMP_CASE_PRESERVE_UPPER;

1073 else if (pg_strcasecmp(newval, "preserve-lower") == 0)

1074 pset.comp_case = PSQL_COMP_CASE_PRESERVE_LOWER;

1075 else if (pg_strcasecmp(newval, "upper") == 0)

1076 pset.comp_case = PSQL_COMP_CASE_UPPER;

1077 else if (pg_strcasecmp(newval, "lower") == 0)

1078 pset.comp_case = PSQL_COMP_CASE_LOWER;

1079 else

1080 {

1081 PsqlVarEnumError("COMP_KEYWORD_CASE", newval,

1082 "lower, upper, preserve-lower, preserve-upper");

1083 return false;

1084 }

1085 return true;

1086}

1087

1088static char *

1089 histcontrol_substitute_hook(char *newval)

1090{

1091 if (newval == NULL)

1092 newval = pg_strdup("none");

1093 return newval;

1094}

1095

1096static bool

1097 histcontrol_hook(const char *newval)

1098{

1099 Assert(newval != NULL); /* else substitute hook messed up */

1100 if (pg_strcasecmp(newval, "ignorespace") == 0)

1101 pset.histcontrol = hctl_ignorespace;

1102 else if (pg_strcasecmp(newval, "ignoredups") == 0)

1103 pset.histcontrol = hctl_ignoredups;

1104 else if (pg_strcasecmp(newval, "ignoreboth") == 0)

1105 pset.histcontrol = hctl_ignoreboth;

1106 else if (pg_strcasecmp(newval, "none") == 0)

1107 pset.histcontrol = hctl_none;

1108 else

1109 {

1110 PsqlVarEnumError("HISTCONTROL", newval,

1111 "none, ignorespace, ignoredups, ignoreboth");

1112 return false;

1113 }

1114 return true;

1115}

1116

1117static bool

1118 prompt1_hook(const char *newval)

1119{

1120 pset.prompt1 = newval ? newval : "";

1121 return true;

1122}

1123

1124static bool

1125 prompt2_hook(const char *newval)

1126{

1127 pset.prompt2 = newval ? newval : "";

1128 return true;

1129}

1130

1131static bool

1132 prompt3_hook(const char *newval)

1133{

1134 pset.prompt3 = newval ? newval : "";

1135 return true;

1136}

1137

1138static char *

1139 verbosity_substitute_hook(char *newval)

1140{

1141 if (newval == NULL)

1142 newval = pg_strdup("default");

1143 return newval;

1144}

1145

1146static bool

1147 verbosity_hook(const char *newval)

1148{

1149 Assert(newval != NULL); /* else substitute hook messed up */

1150 if (pg_strcasecmp(newval, "default") == 0)

1151 pset.verbosity = PQERRORS_DEFAULT;

1152 else if (pg_strcasecmp(newval, "verbose") == 0)

1153 pset.verbosity = PQERRORS_VERBOSE;

1154 else if (pg_strcasecmp(newval, "terse") == 0)

1155 pset.verbosity = PQERRORS_TERSE;

1156 else if (pg_strcasecmp(newval, "sqlstate") == 0)

1157 pset.verbosity = PQERRORS_SQLSTATE;

1158 else

1159 {

1160 PsqlVarEnumError("VERBOSITY", newval, "default, verbose, terse, sqlstate");

1161 return false;

1162 }

1163

1164 if (pset.db)

1165 PQsetErrorVerbosity(pset.db, pset.verbosity);

1166 return true;

1167}

1168

1169static bool

1170 show_all_results_hook(const char *newval)

1171{

1172 return ParseVariableBool(newval, "SHOW_ALL_RESULTS", &pset.show_all_results);

1173}

1174

1175static char *

1176 show_context_substitute_hook(char *newval)

1177{

1178 if (newval == NULL)

1179 newval = pg_strdup("errors");

1180 return newval;

1181}

1182

1183static bool

1184 show_context_hook(const char *newval)

1185{

1186 Assert(newval != NULL); /* else substitute hook messed up */

1187 if (pg_strcasecmp(newval, "never") == 0)

1188 pset.show_context = PQSHOW_CONTEXT_NEVER;

1189 else if (pg_strcasecmp(newval, "errors") == 0)

1190 pset.show_context = PQSHOW_CONTEXT_ERRORS;

1191 else if (pg_strcasecmp(newval, "always") == 0)

1192 pset.show_context = PQSHOW_CONTEXT_ALWAYS;

1193 else

1194 {

1195 PsqlVarEnumError("SHOW_CONTEXT", newval, "never, errors, always");

1196 return false;

1197 }

1198

1199 if (pset.db)

1200 PQsetErrorContextVisibility(pset.db, pset.show_context);

1201 return true;

1202}

1203

1204static bool

1205 hide_compression_hook(const char *newval)

1206{

1207 return ParseVariableBool(newval, "HIDE_TOAST_COMPRESSION",

1208 &pset.hide_compression);

1209}

1210

1211static bool

1212 hide_tableam_hook(const char *newval)

1213{

1214 return ParseVariableBool(newval, "HIDE_TABLEAM", &pset.hide_tableam);

1215}

1216

1217static void

1218 EstablishVariableSpace(void)

1219{

1220 pset.vars = CreateVariableSpace();

1221

1222 SetVariableHooks(pset.vars, "AUTOCOMMIT",

1223 bool_substitute_hook,

1224 autocommit_hook);

1225 SetVariableHooks(pset.vars, "ON_ERROR_STOP",

1226 bool_substitute_hook,

1227 on_error_stop_hook);

1228 SetVariableHooks(pset.vars, "QUIET",

1229 bool_substitute_hook,

1230 quiet_hook);

1231 SetVariableHooks(pset.vars, "SINGLELINE",

1232 bool_substitute_hook,

1233 singleline_hook);

1234 SetVariableHooks(pset.vars, "SINGLESTEP",

1235 bool_substitute_hook,

1236 singlestep_hook);

1237 SetVariableHooks(pset.vars, "FETCH_COUNT",

1238 fetch_count_substitute_hook,

1239 fetch_count_hook);

1240 SetVariableHooks(pset.vars, "HISTFILE",

1241 NULL,

1242 histfile_hook);

1243 SetVariableHooks(pset.vars, "HISTSIZE",

1244 histsize_substitute_hook,

1245 histsize_hook);

1246 SetVariableHooks(pset.vars, "IGNOREEOF",

1247 ignoreeof_substitute_hook,

1248 ignoreeof_hook);

1249 SetVariableHooks(pset.vars, "ECHO",

1250 echo_substitute_hook,

1251 echo_hook);

1252 SetVariableHooks(pset.vars, "ECHO_HIDDEN",

1253 bool_substitute_hook,

1254 echo_hidden_hook);

1255 SetVariableHooks(pset.vars, "ON_ERROR_ROLLBACK",

1256 bool_substitute_hook,

1257 on_error_rollback_hook);

1258 SetVariableHooks(pset.vars, "COMP_KEYWORD_CASE",

1259 comp_keyword_case_substitute_hook,

1260 comp_keyword_case_hook);

1261 SetVariableHooks(pset.vars, "HISTCONTROL",

1262 histcontrol_substitute_hook,

1263 histcontrol_hook);

1264 SetVariableHooks(pset.vars, "PROMPT1",

1265 NULL,

1266 prompt1_hook);

1267 SetVariableHooks(pset.vars, "PROMPT2",

1268 NULL,

1269 prompt2_hook);

1270 SetVariableHooks(pset.vars, "PROMPT3",

1271 NULL,

1272 prompt3_hook);

1273 SetVariableHooks(pset.vars, "VERBOSITY",

1274 verbosity_substitute_hook,

1275 verbosity_hook);

1276 SetVariableHooks(pset.vars, "SHOW_ALL_RESULTS",

1277 bool_substitute_hook,

1278 show_all_results_hook);

1279 SetVariableHooks(pset.vars, "SHOW_CONTEXT",

1280 show_context_substitute_hook,

1281 show_context_hook);

1282 SetVariableHooks(pset.vars, "HIDE_TOAST_COMPRESSION",

1283 bool_substitute_hook,

1284 hide_compression_hook);

1285 SetVariableHooks(pset.vars, "HIDE_TABLEAM",

1286 bool_substitute_hook,

1287 hide_tableam_hook);

1288 SetVariableHooks(pset.vars, "WATCH_INTERVAL",

1289 watch_interval_substitute_hook,

1290 watch_interval_hook);

1291}

expand_tilde

void expand_tilde(char **filename)

Definition: common.c:2576

PSQLexec

PGresult * PSQLexec(const char *query)

Definition: common.c:655

psql_setup_cancel_handler

void psql_setup_cancel_handler(void)

Definition: common.c:325

NoticeProcessor

void NoticeProcessor(void *arg, const char *message)

Definition: common.c:279

standard_strings

bool standard_strings(void)

Definition: common.c:2500

setQFout

bool setQFout(const char *fname)

Definition: common.c:144

SendQuery

bool SendQuery(const char *query)

Definition: common.c:1118

verbosity_substitute_hook

static char * verbosity_substitute_hook(char *newval)

Definition: startup.c:1139

show_context_hook

static bool show_context_hook(const char *newval)

Definition: startup.c:1184

main

int main(int argc, char *argv[])

Definition: startup.c:126

hide_tableam_hook

static bool hide_tableam_hook(const char *newval)

Definition: startup.c:1212

quiet_hook

static bool quiet_hook(const char *newval)

Definition: startup.c:892

singleline_hook

static bool singleline_hook(const char *newval)

Definition: startup.c:898

prompt2_hook

static bool prompt2_hook(const char *newval)

Definition: startup.c:1125

comp_keyword_case_hook

static bool comp_keyword_case_hook(const char *newval)

Definition: startup.c:1068

SYSPSQLRC

#define SYSPSQLRC

Definition: startup.c:35

histcontrol_hook

static bool histcontrol_hook(const char *newval)

Definition: startup.c:1097

prompt1_hook

static bool prompt1_hook(const char *newval)

Definition: startup.c:1118

PSQLRC

#define PSQLRC

Definition: startup.c:36

verbosity_hook

static bool verbosity_hook(const char *newval)

Definition: startup.c:1147

empty_signal_handler

static void empty_signal_handler(SIGNAL_ARGS)

Definition: startup.c:115

ignoreeof_substitute_hook

static char * ignoreeof_substitute_hook(char *newval)

Definition: startup.c:963

show_all_results_hook

static bool show_all_results_hook(const char *newval)

Definition: startup.c:1170

SimpleActionListCell

struct SimpleActionListCell SimpleActionListCell

fetch_count_hook

static bool fetch_count_hook(const char *newval)

Definition: startup.c:918

process_psqlrc

static void process_psqlrc(char *argv0)

Definition: startup.c:779

fetch_count_substitute_hook

static char * fetch_count_substitute_hook(char *newval)

Definition: startup.c:910

EstablishVariableSpace

static void EstablishVariableSpace(void)

Definition: startup.c:1218

histsize_hook

static bool histsize_hook(const char *newval)

Definition: startup.c:942

log_pre_callback

static void log_pre_callback(void)

Definition: startup.c:92

SimpleActionList

struct SimpleActionList SimpleActionList

NOPAGER

#define NOPAGER

Definition: startup.c:89

echo_substitute_hook

static char * echo_substitute_hook(char *newval)

Definition: startup.c:990

watch_interval_substitute_hook

static char * watch_interval_substitute_hook(char *newval)

Definition: startup.c:948

hide_compression_hook

static bool hide_compression_hook(const char *newval)

Definition: startup.c:1205

bool_substitute_hook

static char * bool_substitute_hook(char *newval)

Definition: startup.c:863

PARAMS_ARRAY_SIZE

#define PARAMS_ARRAY_SIZE

log_locus_callback

static void log_locus_callback(const char **filename, uint64 *lineno)

Definition: startup.c:99

singlestep_hook

static bool singlestep_hook(const char *newval)

Definition: startup.c:904

histfile_hook

static bool histfile_hook(const char *newval)

Definition: startup.c:924

prompt3_hook

static bool prompt3_hook(const char *newval)

Definition: startup.c:1132

on_error_rollback_hook

static bool on_error_rollback_hook(const char *newval)

Definition: startup.c:1039

histsize_substitute_hook

static char * histsize_substitute_hook(char *newval)

Definition: startup.c:934

on_error_stop_hook

static bool on_error_stop_hook(const char *newval)

Definition: startup.c:886

autocommit_hook

static bool autocommit_hook(const char *newval)

Definition: startup.c:880

show_context_substitute_hook

static char * show_context_substitute_hook(char *newval)

Definition: startup.c:1176

watch_interval_hook

static bool watch_interval_hook(const char *newval)

Definition: startup.c:956

ignoreeof_hook

static bool ignoreeof_hook(const char *newval)

Definition: startup.c:984

pset

PsqlSettings pset

Definition: startup.c:32

echo_hidden_hook

static bool echo_hidden_hook(const char *newval)

Definition: startup.c:1018

process_psqlrc_file

static void process_psqlrc_file(char *filename)

Definition: startup.c:813

echo_hook

static bool echo_hook(const char *newval)

Definition: startup.c:998

simple_action_list_append

static void simple_action_list_append(SimpleActionList *list, enum _actions action, const char *val)

Definition: startup.c:753

parse_psql_options

static void parse_psql_options(int argc, char *argv[], struct adhoc_opts *options)

Definition: startup.c:488

_actions

Definition: startup.c:47

ACT_SINGLE_SLASH

@ ACT_SINGLE_SLASH

Definition: startup.c:49

ACT_FILE

@ ACT_FILE

Definition: startup.c:50

ACT_SINGLE_QUERY

@ ACT_SINGLE_QUERY

Definition: startup.c:48

showVersion

static void showVersion(void)

Definition: startup.c:844

histcontrol_substitute_hook

static char * histcontrol_substitute_hook(char *newval)

Definition: startup.c:1089

comp_keyword_case_substitute_hook

static char * comp_keyword_case_substitute_hook(char *newval)

Definition: startup.c:1060

values

static Datum values[MAXATTR]

Definition: bootstrap.c:153

SIGNAL_ARGS

#define SIGNAL_ARGS

Definition: c.h:1348

PG_TEXTDOMAIN

#define PG_TEXTDOMAIN(domain)

Definition: c.h:1213

CppAsString2

#define CppAsString2(x)

Definition: c.h:418

uint64

uint64_t uint64

Definition: c.h:539

do_pset

bool do_pset(const char *param, const char *value, printQueryOpt *popt, bool quiet)

Definition: command.c:5076

HandleSlashCmds

backslashResult HandleSlashCmds(PsqlScanState scan_state, ConditionalStack cstack, PQExpBuffer query_buf, PQExpBuffer previous_buf)

Definition: command.c:231

SyncVariables

void SyncVariables(void)

Definition: command.c:4569

connection_warnings

void connection_warnings(bool in_startup)

Definition: command.c:4441

command.h

PSQL_CMD_ERROR

@ PSQL_CMD_ERROR

Definition: command.h:22

find_my_exec

int find_my_exec(const char *argv0, char *retpath)

Definition: exec.c:161

set_pglocale_pgservice

void set_pglocale_pgservice(const char *argv0, const char *app)

Definition: exec.c:430

conditional_stack_create

ConditionalStack conditional_stack_create(void)

Definition: conditional.c:18

conditional_stack_destroy

void conditional_stack_destroy(ConditionalStack cstack)

Definition: conditional.c:43

listAllDbs

bool listAllDbs(const char *pattern, bool verbose)

Definition: describe.c:946

describe.h

_

#define _(x)

Definition: elog.c:91

PQconnectionNeedsPassword

int PQconnectionNeedsPassword(const PGconn *conn)

Definition: fe-connect.c:7732

PQstatus

ConnStatusType PQstatus(const PGconn *conn)

Definition: fe-connect.c:7616

PQfinish

void PQfinish(PGconn *conn)

Definition: fe-connect.c:5305

PQsetErrorContextVisibility

PGContextVisibility PQsetErrorContextVisibility(PGconn *conn, PGContextVisibility show_context)

Definition: fe-connect.c:7831

PQuser

char * PQuser(const PGconn *conn)

Definition: fe-connect.c:7521

PQsetErrorVerbosity

PGVerbosity PQsetErrorVerbosity(PGconn *conn, PGVerbosity verbosity)

Definition: fe-connect.c:7819

PQsetNoticeProcessor

PQnoticeProcessor PQsetNoticeProcessor(PGconn *conn, PQnoticeProcessor proc, void *arg)

Definition: fe-connect.c:7860

PQerrorMessage

char * PQerrorMessage(const PGconn *conn)

Definition: fe-connect.c:7679

PQconnectdbParams

PGconn * PQconnectdbParams(const char *const *keywords, const char *const *values, int expand_dbname)

Definition: fe-connect.c:768

PQenv2encoding

int PQenv2encoding(void)

Definition: fe-misc.c:1285

pg_strdup

char * pg_strdup(const char *in)

Definition: fe_memutils.c:85

pg_free

void pg_free(void *ptr)

Definition: fe_memutils.c:105

pg_malloc_array

#define pg_malloc_array(type, count)

Definition: fe_memutils.h:56

pg_malloc_object

#define pg_malloc_object(type)

Definition: fe_memutils.h:50

refresh_utf8format

void refresh_utf8format(const printTableOpt *opt)

Definition: print.c:3691

setDecimalLocale

void setDecimalLocale(void)

Definition: print.c:3641

print.h

UNICODE_LINESTYLE_SINGLE

@ UNICODE_LINESTYLE_SINGLE

Definition: print.h:101

PRINT_CSV

@ PRINT_CSV

Definition: print.h:33

PRINT_UNALIGNED

@ PRINT_UNALIGNED

Definition: print.h:38

PRINT_ALIGNED

@ PRINT_ALIGNED

Definition: print.h:31

PRINT_HTML

@ PRINT_HTML

Definition: print.h:34

getopt_long.h

getopt_long

int getopt_long(int argc, char *const argv[], const char *optstring, const struct option *longopts, int *longindex)

Definition: getopt_long.c:60

no_argument

#define no_argument

Definition: getopt_long.h:25

required_argument

#define required_argument

Definition: getopt_long.h:26

optional_argument

#define optional_argument

Definition: getopt_long.h:27

my_exec_path

char my_exec_path[MAXPGPATH]

Definition: globals.c:81

newval

#define newval

Assert

Assert(PointerIsAligned(start, uint64))

free

#define free(a)

Definition: header.h:65

helpVariables

void helpVariables(unsigned short int pager)

Definition: help.c:374

slashUsage

void slashUsage(unsigned short int pager)

Definition: help.c:148

help.h

value

static struct @169 value

val

long val

Definition: informix.c:689

success

static bool success

Definition: initdb.c:187

initializeInput

void initializeInput(int flags)

Definition: input.c:344

input.h

keywords

static const JsonPathKeyword keywords[]

Definition: jsonpath_scan.l:402

PQclear

#define PQclear

Definition: libpq-be-fe.h:245

CONNECTION_BAD

@ CONNECTION_BAD

Definition: libpq-fe.h:85

PQSHOW_CONTEXT_NEVER

@ PQSHOW_CONTEXT_NEVER

Definition: libpq-fe.h:164

PQSHOW_CONTEXT_ALWAYS

@ PQSHOW_CONTEXT_ALWAYS

Definition: libpq-fe.h:166

PQSHOW_CONTEXT_ERRORS

@ PQSHOW_CONTEXT_ERRORS

Definition: libpq-fe.h:165

PQERRORS_VERBOSE

@ PQERRORS_VERBOSE

Definition: libpq-fe.h:158

PQERRORS_DEFAULT

@ PQERRORS_DEFAULT

Definition: libpq-fe.h:157

PQERRORS_TERSE

@ PQERRORS_TERSE

Definition: libpq-fe.h:156

PQERRORS_SQLSTATE

@ PQERRORS_SQLSTATE

Definition: libpq-fe.h:159

pg_logging_init

void pg_logging_init(const char *argv0)

Definition: logging.c:83

pg_logging_set_locus_callback

void pg_logging_set_locus_callback(void(*cb)(const char **filename, uint64 *lineno))

Definition: logging.c:202

pg_logging_config

void pg_logging_config(int new_flags)

Definition: logging.c:166

pg_logging_set_pre_callback

void pg_logging_set_pre_callback(void(*cb)(void))

Definition: logging.c:196

logging.h

pg_log_error

#define pg_log_error(...)

Definition: logging.h:106

pg_log_error_hint

#define pg_log_error_hint(...)

Definition: logging.h:112

PG_LOG_FLAG_TERSE

#define PG_LOG_FLAG_TERSE

Definition: logging.h:86

psqlscan_callbacks

const PsqlScanCallbacks psqlscan_callbacks

Definition: mainloop.c:20

MainLoop

int MainLoop(FILE *source)

Definition: mainloop.c:33

mainloop.h

pstrdup

char * pstrdup(const char *in)

Definition: mcxt.c:1759

generate_unaccent_rules.stdout

stdout

Definition: generate_unaccent_rules.py:35

generate_unaccent_rules.action

action

Definition: generate_unaccent_rules.py:287

sort-test.list

list

Definition: sort-test.py:13

pg_fatal

#define pg_fatal(...)

Definition: pg_backup_utils.h:36

MAXPGPATH

#define MAXPGPATH

Definition: pg_config_manual.h:95

argv0

static char * argv0

Definition: pg_ctl.c:93

filename

static char * filename

Definition: pg_dumpall.c:120

optind

PGDLLIMPORT int optind

Definition: getopt.c:51

optarg

PGDLLIMPORT char * optarg

Definition: getopt.c:53

process_file

static void process_file(const char *filename, int weight)

Definition: pgbench.c:6143

pg_log_warning

#define pg_log_warning(...)

Definition: pgfnames.c:24

pqsignal

#define pqsignal

Definition: port.h:531

get_home_path

bool get_home_path(char *ret_path)

Definition: path.c:1005

pg_strcasecmp

int pg_strcasecmp(const char *s1, const char *s2)

Definition: pgstrcasecmp.c:36

get_etc_path

void get_etc_path(const char *my_exec_path, char *ret_path)

Definition: path.c:911

snprintf

#define snprintf

Definition: port.h:239

get_progname

const char * get_progname(const char *argv0)

Definition: path.c:652

printf

#define printf(...)

Definition: port.h:245

postgres_fe.h

c

char * c

Definition: preproc-cursor.c:31

access

short access

Definition: preproc-type.c:36

psprintf

char * psprintf(const char *fmt,...)

Definition: psprintf.c:43

psql_scan_destroy

void psql_scan_destroy(PsqlScanState state)

Definition: psqlscan.l:1022

psql_scan_create

PsqlScanState psql_scan_create(const PsqlScanCallbacks *callbacks)

Definition: psqlscan.l:1001

psql_scan_set_passthrough

void psql_scan_set_passthrough(PsqlScanState state, void *passthrough)

Definition: psqlscan.l:1041

psql_scan_setup

void psql_scan_setup(PsqlScanState state, const char *line, int line_len, int encoding, bool std_strings)

Definition: psqlscan.l:1059

common.h

settings.h

DEFAULT_PROMPT1

#define DEFAULT_PROMPT1

Definition: settings.h:26

DEFAULT_PROMPT3

#define DEFAULT_PROMPT3

Definition: settings.h:28

PSQL_ERROR_ROLLBACK_INTERACTIVE

@ PSQL_ERROR_ROLLBACK_INTERACTIVE

Definition: settings.h:59

PSQL_ERROR_ROLLBACK_ON

@ PSQL_ERROR_ROLLBACK_ON

Definition: settings.h:60

PSQL_ERROR_ROLLBACK_OFF

@ PSQL_ERROR_ROLLBACK_OFF

Definition: settings.h:58

DEFAULT_RECORD_SEP

#define DEFAULT_RECORD_SEP

Definition: settings.h:16

hctl_ignoredups

@ hctl_ignoredups

Definition: settings.h:90

hctl_ignoreboth

@ hctl_ignoreboth

Definition: settings.h:91

hctl_none

@ hctl_none

Definition: settings.h:88

hctl_ignorespace

@ hctl_ignorespace

Definition: settings.h:89

DEFAULT_WATCH_INTERVAL_MAX

#define DEFAULT_WATCH_INTERVAL_MAX

Definition: settings.h:35

PSQL_ECHO_ALL

@ PSQL_ECHO_ALL

Definition: settings.h:46

PSQL_ECHO_ERRORS

@ PSQL_ECHO_ERRORS

Definition: settings.h:45

PSQL_ECHO_NONE

@ PSQL_ECHO_NONE

Definition: settings.h:43

PSQL_ECHO_QUERIES

@ PSQL_ECHO_QUERIES

Definition: settings.h:44

DEFAULT_FIELD_SEP

#define DEFAULT_FIELD_SEP

Definition: settings.h:15

EXIT_SUCCESS

#define EXIT_SUCCESS

Definition: settings.h:193

EXIT_FAILURE

#define EXIT_FAILURE

Definition: settings.h:197

PSQL_ECHO_HIDDEN_NOEXEC

@ PSQL_ECHO_HIDDEN_NOEXEC

Definition: settings.h:53

PSQL_ECHO_HIDDEN_OFF

@ PSQL_ECHO_HIDDEN_OFF

Definition: settings.h:51

PSQL_ECHO_HIDDEN_ON

@ PSQL_ECHO_HIDDEN_ON

Definition: settings.h:52

EXIT_BADCONN

#define EXIT_BADCONN

Definition: settings.h:200

DEFAULT_WATCH_INTERVAL

#define DEFAULT_WATCH_INTERVAL

Definition: settings.h:30

DEFAULT_PROMPT2

#define DEFAULT_PROMPT2

Definition: settings.h:27

EXIT_USER

#define EXIT_USER

Definition: settings.h:202

PSQL_COMP_CASE_PRESERVE_LOWER

@ PSQL_COMP_CASE_PRESERVE_LOWER

Definition: settings.h:66

PSQL_COMP_CASE_LOWER

@ PSQL_COMP_CASE_LOWER

Definition: settings.h:68

PSQL_COMP_CASE_PRESERVE_UPPER

@ PSQL_COMP_CASE_PRESERVE_UPPER

Definition: settings.h:65

PSQL_COMP_CASE_UPPER

@ PSQL_COMP_CASE_UPPER

Definition: settings.h:67

DEFAULT_CSV_FIELD_SEP

#define DEFAULT_CSV_FIELD_SEP

Definition: settings.h:14

simple_prompt

char * simple_prompt(const char *prompt, bool echo)

Definition: sprompt.c:38

error

static void error(void)

Definition: sql-dyntest.c:147

password

static char * password

Definition: streamutil.c:51

string.h

ConditionalStackData

Definition: conditional.h:67

PsqlScanStateData

Definition: psqlscan_int.h:79

SimpleActionListCell

Definition: startup.c:54

SimpleActionListCell::next

struct SimpleActionListCell * next

Definition: startup.c:55

SimpleActionListCell::action

enum _actions action

Definition: startup.c:56

SimpleActionListCell::val

char * val

Definition: startup.c:57

SimpleActionList

Definition: startup.c:61

SimpleActionList::head

SimpleActionListCell * head

Definition: startup.c:62

SimpleActionList::tail

SimpleActionListCell * tail

Definition: startup.c:63

_psqlSettings

Definition: settings.h:102

_psqlSettings::lineno

uint64 lineno

Definition: settings.h:144

_psqlSettings::popt

printQueryOpt popt

Definition: settings.h:112

_psqlSettings::watch_interval

double watch_interval

Definition: settings.h:175

_psqlSettings::on_error_rollback

PSQL_ERROR_ROLLBACK on_error_rollback

Definition: settings.h:178

_psqlSettings::hide_tableam

bool hide_tableam

Definition: settings.h:171

_psqlSettings::vars

VariableSpace vars

Definition: settings.h:151

_psqlSettings::quiet

bool quiet

Definition: settings.h:167

_psqlSettings::comp_case

PSQL_COMP_CASE comp_case

Definition: settings.h:179

_psqlSettings::encoding

int encoding

Definition: settings.h:104

_psqlSettings::inputfile

char * inputfile

Definition: settings.h:143

_psqlSettings::verbosity

PGVerbosity verbosity

Definition: settings.h:184

_psqlSettings::hide_compression

bool hide_compression

Definition: settings.h:170

_psqlSettings::logfile

FILE * logfile

Definition: settings.h:149

_psqlSettings::on_error_stop

bool on_error_stop

Definition: settings.h:166

_psqlSettings::dead_conn

PGconn * dead_conn

Definition: settings.h:158

_psqlSettings::autocommit

bool autocommit

Definition: settings.h:165

_psqlSettings::ignoreeof

int ignoreeof

Definition: settings.h:174

_psqlSettings::last_error_result

PGresult * last_error_result

Definition: settings.h:110

_psqlSettings::show_all_results

bool show_all_results

Definition: settings.h:185

_psqlSettings::prompt2

const char * prompt2

Definition: settings.h:182

_psqlSettings::prompt3

const char * prompt3

Definition: settings.h:183

_psqlSettings::copyStream

FILE * copyStream

Definition: settings.h:108

_psqlSettings::histsize

int histsize

Definition: settings.h:173

_psqlSettings::db

PGconn * db

Definition: settings.h:103

_psqlSettings::queryFout

FILE * queryFout

Definition: settings.h:105

_psqlSettings::queryFoutPipe

bool queryFoutPipe

Definition: settings.h:106

_psqlSettings::echo

PSQL_ECHO echo

Definition: settings.h:176

_psqlSettings::singlestep

bool singlestep

Definition: settings.h:169

_psqlSettings::getPassword

enum trivalue getPassword

Definition: settings.h:137

_psqlSettings::singleline

bool singleline

Definition: settings.h:168

_psqlSettings::show_context

PGContextVisibility show_context

Definition: settings.h:186

_psqlSettings::notty

bool notty

Definition: settings.h:135

_psqlSettings::prompt1

const char * prompt1

Definition: settings.h:181

_psqlSettings::echo_hidden

PSQL_ECHO_HIDDEN echo_hidden

Definition: settings.h:177

_psqlSettings::fetch_count

int fetch_count

Definition: settings.h:172

_psqlSettings::cur_cmd_interactive

bool cur_cmd_interactive

Definition: settings.h:140

_psqlSettings::cur_cmd_source

FILE * cur_cmd_source

Definition: settings.h:138

_psqlSettings::histcontrol

HistControl histcontrol

Definition: settings.h:180

_psqlSettings::progname

const char * progname

Definition: settings.h:142

adhoc_opts

Definition: startup.c:67

adhoc_opts::username

char * username

Definition: startup.c:71

adhoc_opts::no_readline

bool no_readline

Definition: startup.c:73

adhoc_opts::port

char * port

Definition: startup.c:70

adhoc_opts::list_dbs

bool list_dbs

Definition: startup.c:76

adhoc_opts::single_txn

bool single_txn

Definition: startup.c:75

adhoc_opts::no_psqlrc

bool no_psqlrc

Definition: startup.c:74

adhoc_opts::logfilename

char * logfilename

Definition: startup.c:72

adhoc_opts::actions

SimpleActionList actions

Definition: startup.c:77

adhoc_opts::dbname

char * dbname

Definition: startup.c:68

adhoc_opts::host

char * host

Definition: startup.c:69

option

Definition: getopt_long.h:18

options

Definition: oid2name.c:30

options::username

char * username

Definition: oid2name.c:45

options::dbname

char * dbname

Definition: oid2name.c:42

options::port

char * port

Definition: oid2name.c:44

pg_result

Definition: libpq-int.h:165

printQueryOpt::topt

printTableOpt topt

Definition: print.h:185

printTableOpt::start_table

bool start_table

Definition: print.h:127

printTableOpt::expanded

unsigned short int expanded

Definition: print.h:114

printTableOpt::unicode_border_linestyle

unicode_linestyle unicode_border_linestyle

Definition: print.h:141

printTableOpt::tuples_only

bool tuples_only

Definition: print.h:126

printTableOpt::format

enum printFormat format

Definition: print.h:113

printTableOpt::fieldSep

struct separator fieldSep

Definition: print.h:132

printTableOpt::recordSep

struct separator recordSep

Definition: print.h:133

printTableOpt::csvFieldSep

char csvFieldSep[2]

Definition: print.h:134

printTableOpt::default_footer

bool default_footer

Definition: print.h:129

printTableOpt::pager_min_lines

int pager_min_lines

Definition: print.h:124

printTableOpt::pager

unsigned short int pager

Definition: print.h:122

printTableOpt::tableAttr

char * tableAttr

Definition: print.h:137

printTableOpt::border

unsigned short int border

Definition: print.h:120

printTableOpt::unicode_header_linestyle

unicode_linestyle unicode_header_linestyle

Definition: print.h:143

printTableOpt::env_columns

int env_columns

Definition: print.h:139

printTableOpt::unicode_column_linestyle

unicode_linestyle unicode_column_linestyle

Definition: print.h:142

printTableOpt::stop_table

bool stop_table

Definition: print.h:128

separator::separator_zero

bool separator_zero

Definition: print.h:108

separator::separator

char * separator

Definition: print.h:107

unistd.h

usage

static void usage(const char *progname)

Definition: vacuumlo.c:414

TRI_YES

@ TRI_YES

Definition: vacuumlo.c:38

TRI_DEFAULT

@ TRI_DEFAULT

Definition: vacuumlo.c:36

TRI_NO

@ TRI_NO

Definition: vacuumlo.c:37

DeleteVariable

bool DeleteVariable(VariableSpace space, const char *name)

Definition: variables.c:474

SetVariableHooks

void SetVariableHooks(VariableSpace space, const char *name, VariableSubstituteHook shook, VariableAssignHook ahook)

Definition: variables.c:384

PsqlVarEnumError

void PsqlVarEnumError(const char *name, const char *value, const char *suggestions)

Definition: variables.c:486

ParseVariableBool

bool ParseVariableBool(const char *value, const char *name, bool *result)

Definition: variables.c:109

ParseVariableDouble

bool ParseVariableDouble(const char *value, const char *name, double *result, double min, double max)

Definition: variables.c:195

SetVariableBool

bool SetVariableBool(VariableSpace space, const char *name)

Definition: variables.c:462

ParseVariableNum

bool ParseVariableNum(const char *value, const char *name, int *result)

Definition: variables.c:158

SetVariable

bool SetVariable(VariableSpace space, const char *name, const char *value)

Definition: variables.c:281

CreateVariableSpace

VariableSpace CreateVariableSpace(void)

Definition: variables.c:53

SIGCHLD

#define SIGCHLD

Definition: win32_port.h:168

SIGALRM

#define SIGALRM

Definition: win32_port.h:164

PostgreSQL Source Code: src/bin/psql/startup.c Source File