LCOV - code coverage report
Current view: top level - src/bin/pg_dump - pg_restore.c (source / functions) Hit Total Coverage
Test: PostgreSQL 19devel Lines: 277 353 78.5 %
Date: 2025-08-31 01:17:28 Functions: 3 3 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * pg_restore.c
       4             :  *  pg_restore is an utility extracting postgres database definitions
       5             :  *  from a backup archive created by pg_dump using the archiver
       6             :  *  interface.
       7             :  *
       8             :  *  pg_restore will read the backup archive and
       9             :  *  dump out a script that reproduces
      10             :  *  the schema of the database in terms of
      11             :  *        user-defined types
      12             :  *        user-defined functions
      13             :  *        tables
      14             :  *        indexes
      15             :  *        aggregates
      16             :  *        operators
      17             :  *        ACL - grant/revoke
      18             :  *
      19             :  * the output script is SQL that is understood by PostgreSQL
      20             :  *
      21             :  * Basic process in a restore operation is:
      22             :  *
      23             :  *  Open the Archive and read the TOC.
      24             :  *  Set flags in TOC entries, and *maybe* reorder them.
      25             :  *  Generate script to stdout
      26             :  *  Exit
      27             :  *
      28             :  * Copyright (c) 2000, Philip Warner
      29             :  *      Rights are granted to use this software in any way so long
      30             :  *      as this notice is not removed.
      31             :  *
      32             :  *  The author is not responsible for loss or damages that may
      33             :  *  result from its use.
      34             :  *
      35             :  *
      36             :  * IDENTIFICATION
      37             :  *      src/bin/pg_dump/pg_restore.c
      38             :  *
      39             :  *-------------------------------------------------------------------------
      40             :  */
      41             : #include "postgres_fe.h"
      42             : 
      43             : #include <ctype.h>
      44             : #ifdef HAVE_TERMIOS_H
      45             : #include <termios.h>
      46             : #endif
      47             : 
      48             : #include "dumputils.h"
      49             : #include "fe_utils/option_utils.h"
      50             : #include "filter.h"
      51             : #include "getopt_long.h"
      52             : #include "parallel.h"
      53             : #include "pg_backup_utils.h"
      54             : 
      55             : static void usage(const char *progname);
      56             : static void read_restore_filters(const char *filename, RestoreOptions *opts);
      57             : 
      58             : int
      59         180 : main(int argc, char **argv)
      60             : {
      61             :     RestoreOptions *opts;
      62             :     int         c;
      63             :     int         exit_code;
      64         180 :     int         numWorkers = 1;
      65             :     Archive    *AH;
      66             :     char       *inputFileSpec;
      67         180 :     bool        data_only = false;
      68         180 :     bool        schema_only = false;
      69             :     static int  disable_triggers = 0;
      70             :     static int  enable_row_security = 0;
      71             :     static int  if_exists = 0;
      72             :     static int  no_data_for_failed_tables = 0;
      73             :     static int  outputNoTableAm = 0;
      74             :     static int  outputNoTablespaces = 0;
      75             :     static int  use_setsessauth = 0;
      76             :     static int  no_comments = 0;
      77             :     static int  no_data = 0;
      78             :     static int  no_policies = 0;
      79             :     static int  no_publications = 0;
      80             :     static int  no_schema = 0;
      81             :     static int  no_security_labels = 0;
      82             :     static int  no_statistics = 0;
      83             :     static int  no_subscriptions = 0;
      84             :     static int  strict_names = 0;
      85             :     static int  statistics_only = 0;
      86             :     static int  with_statistics = 0;
      87             : 
      88         180 :     struct option cmdopts[] = {
      89             :         {"clean", 0, NULL, 'c'},
      90             :         {"create", 0, NULL, 'C'},
      91             :         {"data-only", 0, NULL, 'a'},
      92             :         {"dbname", 1, NULL, 'd'},
      93             :         {"exit-on-error", 0, NULL, 'e'},
      94             :         {"exclude-schema", 1, NULL, 'N'},
      95             :         {"file", 1, NULL, 'f'},
      96             :         {"format", 1, NULL, 'F'},
      97             :         {"function", 1, NULL, 'P'},
      98             :         {"host", 1, NULL, 'h'},
      99             :         {"index", 1, NULL, 'I'},
     100             :         {"jobs", 1, NULL, 'j'},
     101             :         {"list", 0, NULL, 'l'},
     102             :         {"no-privileges", 0, NULL, 'x'},
     103             :         {"no-acl", 0, NULL, 'x'},
     104             :         {"no-owner", 0, NULL, 'O'},
     105             :         {"no-reconnect", 0, NULL, 'R'},
     106             :         {"port", 1, NULL, 'p'},
     107             :         {"no-password", 0, NULL, 'w'},
     108             :         {"password", 0, NULL, 'W'},
     109             :         {"schema", 1, NULL, 'n'},
     110             :         {"schema-only", 0, NULL, 's'},
     111             :         {"superuser", 1, NULL, 'S'},
     112             :         {"table", 1, NULL, 't'},
     113             :         {"trigger", 1, NULL, 'T'},
     114             :         {"use-list", 1, NULL, 'L'},
     115             :         {"username", 1, NULL, 'U'},
     116             :         {"verbose", 0, NULL, 'v'},
     117             :         {"single-transaction", 0, NULL, '1'},
     118             : 
     119             :         /*
     120             :          * the following options don't have an equivalent short option letter
     121             :          */
     122             :         {"disable-triggers", no_argument, &disable_triggers, 1},
     123             :         {"enable-row-security", no_argument, &enable_row_security, 1},
     124             :         {"if-exists", no_argument, &if_exists, 1},
     125             :         {"no-data-for-failed-tables", no_argument, &no_data_for_failed_tables, 1},
     126             :         {"no-table-access-method", no_argument, &outputNoTableAm, 1},
     127             :         {"no-tablespaces", no_argument, &outputNoTablespaces, 1},
     128             :         {"role", required_argument, NULL, 2},
     129             :         {"section", required_argument, NULL, 3},
     130             :         {"strict-names", no_argument, &strict_names, 1},
     131             :         {"transaction-size", required_argument, NULL, 5},
     132             :         {"use-set-session-authorization", no_argument, &use_setsessauth, 1},
     133             :         {"no-comments", no_argument, &no_comments, 1},
     134             :         {"no-data", no_argument, &no_data, 1},
     135             :         {"no-policies", no_argument, &no_policies, 1},
     136             :         {"no-publications", no_argument, &no_publications, 1},
     137             :         {"no-schema", no_argument, &no_schema, 1},
     138             :         {"no-security-labels", no_argument, &no_security_labels, 1},
     139             :         {"no-subscriptions", no_argument, &no_subscriptions, 1},
     140             :         {"no-statistics", no_argument, &no_statistics, 1},
     141             :         {"statistics", no_argument, &with_statistics, 1},
     142             :         {"statistics-only", no_argument, &statistics_only, 1},
     143             :         {"filter", required_argument, NULL, 4},
     144             :         {"restrict-key", required_argument, NULL, 6},
     145             : 
     146             :         {NULL, 0, NULL, 0}
     147             :     };
     148             : 
     149         180 :     pg_logging_init(argv[0]);
     150         180 :     pg_logging_set_level(PG_LOG_WARNING);
     151         180 :     set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_dump"));
     152             : 
     153         180 :     init_parallel_dump_utils();
     154             : 
     155         180 :     opts = NewRestoreOptions();
     156             : 
     157         180 :     progname = get_progname(argv[0]);
     158             : 
     159         180 :     if (argc > 1)
     160             :     {
     161         178 :         if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
     162             :         {
     163           2 :             usage(progname);
     164           2 :             exit_nicely(0);
     165             :         }
     166         176 :         if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
     167             :         {
     168          36 :             puts("pg_restore (PostgreSQL) " PG_VERSION);
     169          36 :             exit_nicely(0);
     170             :         }
     171             :     }
     172             : 
     173         822 :     while ((c = getopt_long(argc, argv, "acCd:ef:F:h:I:j:lL:n:N:Op:P:RsS:t:T:U:vwWx1",
     174         822 :                             cmdopts, NULL)) != -1)
     175             :     {
     176         692 :         switch (c)
     177             :         {
     178           4 :             case 'a':           /* Dump data only */
     179           4 :                 data_only = true;
     180           4 :                 break;
     181          34 :             case 'c':           /* clean (i.e., drop) schema prior to create */
     182          34 :                 opts->dropSchema = 1;
     183          34 :                 break;
     184          60 :             case 'C':
     185          60 :                 opts->createDB = 1;
     186          60 :                 break;
     187          66 :             case 'd':
     188          66 :                 opts->cparams.dbname = pg_strdup(optarg);
     189          66 :                 break;
     190          56 :             case 'e':
     191          56 :                 opts->exit_on_error = true;
     192          56 :                 break;
     193          62 :             case 'f':           /* output file name */
     194          62 :                 opts->filename = pg_strdup(optarg);
     195          62 :                 break;
     196          22 :             case 'F':
     197          22 :                 if (strlen(optarg) != 0)
     198          22 :                     opts->formatName = pg_strdup(optarg);
     199          22 :                 break;
     200          56 :             case 'h':
     201          56 :                 if (strlen(optarg) != 0)
     202          56 :                     opts->cparams.pghost = pg_strdup(optarg);
     203          56 :                 break;
     204             : 
     205          16 :             case 'j':           /* number of restore jobs */
     206          16 :                 if (!option_parse_int(optarg, "-j/--jobs", 1,
     207             :                                       PG_MAX_JOBS,
     208             :                                       &numWorkers))
     209           2 :                     exit(1);
     210          14 :                 break;
     211             : 
     212           8 :             case 'l':           /* Dump the TOC summary */
     213           8 :                 opts->tocSummary = 1;
     214           8 :                 break;
     215             : 
     216           0 :             case 'L':           /* input TOC summary file name */
     217           0 :                 opts->tocFile = pg_strdup(optarg);
     218           0 :                 break;
     219             : 
     220           0 :             case 'n':           /* Dump data for this schema only */
     221           0 :                 simple_string_list_append(&opts->schemaNames, optarg);
     222           0 :                 break;
     223             : 
     224           0 :             case 'N':           /* Do not dump data for this schema */
     225           0 :                 simple_string_list_append(&opts->schemaExcludeNames, optarg);
     226           0 :                 break;
     227             : 
     228           0 :             case 'O':
     229           0 :                 opts->noOwner = 1;
     230           0 :                 break;
     231             : 
     232          76 :             case 'p':
     233          76 :                 if (strlen(optarg) != 0)
     234          76 :                     opts->cparams.pgport = pg_strdup(optarg);
     235          76 :                 break;
     236           0 :             case 'R':
     237             :                 /* no-op, still accepted for backwards compatibility */
     238           0 :                 break;
     239           0 :             case 'P':           /* Function */
     240           0 :                 opts->selTypes = 1;
     241           0 :                 opts->selFunction = 1;
     242           0 :                 simple_string_list_append(&opts->functionNames, optarg);
     243           0 :                 break;
     244           0 :             case 'I':           /* Index */
     245           0 :                 opts->selTypes = 1;
     246           0 :                 opts->selIndex = 1;
     247           0 :                 simple_string_list_append(&opts->indexNames, optarg);
     248           0 :                 break;
     249           0 :             case 'T':           /* Trigger */
     250           0 :                 opts->selTypes = 1;
     251           0 :                 opts->selTrigger = 1;
     252           0 :                 simple_string_list_append(&opts->triggerNames, optarg);
     253           0 :                 break;
     254           2 :             case 's':           /* dump schema only */
     255           2 :                 schema_only = true;
     256           2 :                 break;
     257           0 :             case 'S':           /* Superuser username */
     258           0 :                 if (strlen(optarg) != 0)
     259           0 :                     opts->superuser = pg_strdup(optarg);
     260           0 :                 break;
     261           0 :             case 't':           /* Dump specified table(s) only */
     262           0 :                 opts->selTypes = 1;
     263           0 :                 opts->selTable = 1;
     264           0 :                 simple_string_list_append(&opts->tableNames, optarg);
     265           0 :                 break;
     266             : 
     267          60 :             case 'U':
     268          60 :                 opts->cparams.username = pg_strdup(optarg);
     269          60 :                 break;
     270             : 
     271          66 :             case 'v':           /* verbose */
     272          66 :                 opts->verbose = 1;
     273          66 :                 pg_logging_increase_verbosity();
     274          66 :                 break;
     275             : 
     276           0 :             case 'w':
     277           0 :                 opts->cparams.promptPassword = TRI_NO;
     278           0 :                 break;
     279             : 
     280           0 :             case 'W':
     281           0 :                 opts->cparams.promptPassword = TRI_YES;
     282           0 :                 break;
     283             : 
     284           0 :             case 'x':           /* skip ACL dump */
     285           0 :                 opts->aclsSkip = 1;
     286           0 :                 break;
     287             : 
     288           4 :             case '1':           /* Restore data in a single transaction */
     289           4 :                 opts->single_txn = true;
     290           4 :                 opts->exit_on_error = true;
     291           4 :                 break;
     292             : 
     293          22 :             case 0:
     294             : 
     295             :                 /*
     296             :                  * This covers the long options without a short equivalent.
     297             :                  */
     298          22 :                 break;
     299             : 
     300           0 :             case 2:             /* SET ROLE */
     301           0 :                 opts->use_role = pg_strdup(optarg);
     302           0 :                 break;
     303             : 
     304           0 :             case 3:             /* section */
     305           0 :                 set_dump_section(optarg, &(opts->dumpSections));
     306           0 :                 break;
     307             : 
     308          20 :             case 4:             /* filter */
     309          20 :                 read_restore_filters(optarg, opts);
     310          12 :                 break;
     311             : 
     312          56 :             case 5:             /* transaction-size */
     313          56 :                 if (!option_parse_int(optarg, "--transaction-size",
     314             :                                       1, INT_MAX,
     315             :                                       &opts->txn_size))
     316           0 :                     exit(1);
     317          56 :                 opts->exit_on_error = true;
     318          56 :                 break;
     319             : 
     320           0 :             case 6:
     321           0 :                 opts->restrict_key = pg_strdup(optarg);
     322           0 :                 break;
     323             : 
     324           2 :             default:
     325             :                 /* getopt_long already emitted a complaint */
     326           2 :                 pg_log_error_hint("Try \"%s --help\" for more information.", progname);
     327           2 :                 exit_nicely(1);
     328             :         }
     329             :     }
     330             : 
     331             :     /* Get file name from command line */
     332         130 :     if (optind < argc)
     333         114 :         inputFileSpec = argv[optind++];
     334             :     else
     335          16 :         inputFileSpec = NULL;
     336             : 
     337             :     /* Complain if any arguments remain */
     338         130 :     if (optind < argc)
     339             :     {
     340           2 :         pg_log_error("too many command-line arguments (first is \"%s\")",
     341             :                      argv[optind]);
     342           2 :         pg_log_error_hint("Try \"%s --help\" for more information.", progname);
     343           2 :         exit_nicely(1);
     344             :     }
     345             : 
     346             :     /* Complain if neither -f nor -d was specified (except if dumping TOC) */
     347         128 :     if (!opts->cparams.dbname && !opts->filename && !opts->tocSummary)
     348           2 :         pg_fatal("one of -d/--dbname and -f/--file must be specified");
     349             : 
     350             :     /* Should get at most one of -d and -f, else user is confused */
     351         126 :     if (opts->cparams.dbname)
     352             :     {
     353          66 :         if (opts->filename)
     354             :         {
     355           2 :             pg_log_error("options -d/--dbname and -f/--file cannot be used together");
     356           2 :             pg_log_error_hint("Try \"%s --help\" for more information.", progname);
     357           2 :             exit_nicely(1);
     358             :         }
     359             : 
     360          64 :         if (opts->restrict_key)
     361           0 :             pg_fatal("options -d/--dbname and --restrict-key cannot be used together");
     362             : 
     363          64 :         opts->useDB = 1;
     364             :     }
     365             :     else
     366             :     {
     367             :         /*
     368             :          * If you don't provide a restrict key, one will be appointed for you.
     369             :          */
     370          60 :         if (!opts->restrict_key)
     371          60 :             opts->restrict_key = generate_restrict_key();
     372          60 :         if (!opts->restrict_key)
     373           0 :             pg_fatal("could not generate restrict key");
     374          60 :         if (!valid_restrict_key(opts->restrict_key))
     375           0 :             pg_fatal("invalid restrict key");
     376             :     }
     377             : 
     378             :     /* reject conflicting "-only" options */
     379         124 :     if (data_only && schema_only)
     380           2 :         pg_fatal("options -s/--schema-only and -a/--data-only cannot be used together");
     381         122 :     if (schema_only && statistics_only)
     382           0 :         pg_fatal("options -s/--schema-only and --statistics-only cannot be used together");
     383         122 :     if (data_only && statistics_only)
     384           0 :         pg_fatal("options -a/--data-only and --statistics-only cannot be used together");
     385             : 
     386             :     /* reject conflicting "-only" and "no-" options */
     387         122 :     if (data_only && no_data)
     388           0 :         pg_fatal("options -a/--data-only and --no-data cannot be used together");
     389         122 :     if (schema_only && no_schema)
     390           0 :         pg_fatal("options -s/--schema-only and --no-schema cannot be used together");
     391         122 :     if (statistics_only && no_statistics)
     392           0 :         pg_fatal("options --statistics-only and --no-statistics cannot be used together");
     393             : 
     394             :     /* reject conflicting "no-" options */
     395         122 :     if (with_statistics && no_statistics)
     396           0 :         pg_fatal("options --statistics and --no-statistics cannot be used together");
     397             : 
     398             :     /* reject conflicting "only-" options */
     399         122 :     if (data_only && with_statistics)
     400           0 :         pg_fatal("options %s and %s cannot be used together",
     401             :                  "-a/--data-only", "--statistics");
     402         122 :     if (schema_only && with_statistics)
     403           0 :         pg_fatal("options %s and %s cannot be used together",
     404             :                  "-s/--schema-only", "--statistics");
     405             : 
     406         122 :     if (data_only && opts->dropSchema)
     407           2 :         pg_fatal("options -c/--clean and -a/--data-only cannot be used together");
     408             : 
     409         120 :     if (opts->single_txn && opts->txn_size > 0)
     410           0 :         pg_fatal("options -1/--single-transaction and --transaction-size cannot be used together");
     411             : 
     412             :     /*
     413             :      * -C is not compatible with -1, because we can't create a database inside
     414             :      * a transaction block.
     415             :      */
     416         120 :     if (opts->createDB && opts->single_txn)
     417           2 :         pg_fatal("options -C/--create and -1/--single-transaction cannot be used together");
     418             : 
     419             :     /* Can't do single-txn mode with multiple connections */
     420         118 :     if (opts->single_txn && numWorkers > 1)
     421           2 :         pg_fatal("cannot specify both --single-transaction and multiple jobs");
     422             : 
     423             :     /*
     424             :      * Set derivative flags. Ambiguous or nonsensical combinations, e.g.
     425             :      * "--schema-only --no-schema", will have already caused an error in one
     426             :      * of the checks above.
     427             :      */
     428         116 :     opts->dumpData = ((opts->dumpData && !schema_only && !statistics_only) ||
     429         232 :                       data_only) && !no_data;
     430         116 :     opts->dumpSchema = ((opts->dumpSchema && !data_only && !statistics_only) ||
     431         232 :                         schema_only) && !no_schema;
     432         116 :     opts->dumpStatistics = ((opts->dumpStatistics && !schema_only && !data_only) ||
     433         232 :                             (statistics_only || with_statistics)) && !no_statistics;
     434             : 
     435         116 :     opts->disable_triggers = disable_triggers;
     436         116 :     opts->enable_row_security = enable_row_security;
     437         116 :     opts->noDataForFailedTables = no_data_for_failed_tables;
     438         116 :     opts->noTableAm = outputNoTableAm;
     439         116 :     opts->noTablespace = outputNoTablespaces;
     440         116 :     opts->use_setsessauth = use_setsessauth;
     441         116 :     opts->no_comments = no_comments;
     442         116 :     opts->no_policies = no_policies;
     443         116 :     opts->no_publications = no_publications;
     444         116 :     opts->no_security_labels = no_security_labels;
     445         116 :     opts->no_subscriptions = no_subscriptions;
     446             : 
     447         116 :     if (if_exists && !opts->dropSchema)
     448           2 :         pg_fatal("option --if-exists requires option -c/--clean");
     449         114 :     opts->if_exists = if_exists;
     450         114 :     opts->strict_names = strict_names;
     451             : 
     452         114 :     if (opts->formatName)
     453             :     {
     454          44 :         if (pg_strcasecmp(opts->formatName, "c") == 0 ||
     455          22 :             pg_strcasecmp(opts->formatName, "custom") == 0)
     456          16 :             opts->format = archCustom;
     457          12 :         else if (pg_strcasecmp(opts->formatName, "d") == 0 ||
     458           6 :                  pg_strcasecmp(opts->formatName, "directory") == 0)
     459           2 :             opts->format = archDirectory;
     460           8 :         else if (pg_strcasecmp(opts->formatName, "t") == 0 ||
     461           4 :                  pg_strcasecmp(opts->formatName, "tar") == 0)
     462           2 :             opts->format = archTar;
     463           4 :         else if (pg_strcasecmp(opts->formatName, "p") == 0 ||
     464           2 :                  pg_strcasecmp(opts->formatName, "plain") == 0)
     465             :         {
     466             :             /* recognize this for consistency with pg_dump */
     467           0 :             pg_fatal("archive format \"%s\" is not supported; please use psql",
     468             :                      opts->formatName);
     469             :         }
     470             :         else
     471           2 :             pg_fatal("unrecognized archive format \"%s\"; please specify \"c\", \"d\", or \"t\"",
     472             :                      opts->formatName);
     473             :     }
     474             : 
     475         112 :     AH = OpenArchive(inputFileSpec, opts->format);
     476             : 
     477         112 :     SetArchiveOptions(AH, NULL, opts);
     478             : 
     479             :     /*
     480             :      * We don't have a connection yet but that doesn't matter. The connection
     481             :      * is initialized to NULL and if we terminate through exit_nicely() while
     482             :      * it's still NULL, the cleanup function will just be a no-op.
     483             :      */
     484         112 :     on_exit_close_archive(AH);
     485             : 
     486             :     /* Let the archiver know how noisy to be */
     487         112 :     AH->verbose = opts->verbose;
     488             : 
     489             :     /*
     490             :      * Whether to keep submitting sql commands as "pg_restore ... | psql ... "
     491             :      */
     492         112 :     AH->exit_on_error = opts->exit_on_error;
     493             : 
     494         112 :     if (opts->tocFile)
     495           0 :         SortTocFromFile(AH);
     496             : 
     497         112 :     AH->numWorkers = numWorkers;
     498             : 
     499         112 :     if (opts->tocSummary)
     500           8 :         PrintTOCSummary(AH);
     501             :     else
     502             :     {
     503         104 :         ProcessArchiveRestoreOptions(AH);
     504         104 :         RestoreArchive(AH);
     505             :     }
     506             : 
     507             :     /* done, print a summary of ignored errors */
     508         112 :     if (AH->n_errors)
     509           0 :         pg_log_warning("errors ignored on restore: %d", AH->n_errors);
     510             : 
     511             :     /* AH may be freed in CloseArchive? */
     512         112 :     exit_code = AH->n_errors ? 1 : 0;
     513             : 
     514         112 :     CloseArchive(AH);
     515             : 
     516         112 :     return exit_code;
     517             : }
     518             : 
     519             : static void
     520           2 : usage(const char *progname)
     521             : {
     522           2 :     printf(_("%s restores a PostgreSQL database from an archive created by pg_dump.\n\n"), progname);
     523           2 :     printf(_("Usage:\n"));
     524           2 :     printf(_("  %s [OPTION]... [FILE]\n"), progname);
     525             : 
     526           2 :     printf(_("\nGeneral options:\n"));
     527           2 :     printf(_("  -d, --dbname=NAME        connect to database name\n"));
     528           2 :     printf(_("  -f, --file=FILENAME      output file name (- for stdout)\n"));
     529           2 :     printf(_("  -F, --format=c|d|t       backup file format (should be automatic)\n"));
     530           2 :     printf(_("  -l, --list               print summarized TOC of the archive\n"));
     531           2 :     printf(_("  -v, --verbose            verbose mode\n"));
     532           2 :     printf(_("  -V, --version            output version information, then exit\n"));
     533           2 :     printf(_("  -?, --help               show this help, then exit\n"));
     534             : 
     535           2 :     printf(_("\nOptions controlling the restore:\n"));
     536           2 :     printf(_("  -a, --data-only              restore only the data, no schema\n"));
     537           2 :     printf(_("  -c, --clean                  clean (drop) database objects before recreating\n"));
     538           2 :     printf(_("  -C, --create                 create the target database\n"));
     539           2 :     printf(_("  -e, --exit-on-error          exit on error, default is to continue\n"));
     540           2 :     printf(_("  -I, --index=NAME             restore named index\n"));
     541           2 :     printf(_("  -j, --jobs=NUM               use this many parallel jobs to restore\n"));
     542           2 :     printf(_("  -L, --use-list=FILENAME      use table of contents from this file for\n"
     543             :              "                               selecting/ordering output\n"));
     544           2 :     printf(_("  -n, --schema=NAME            restore only objects in this schema\n"));
     545           2 :     printf(_("  -N, --exclude-schema=NAME    do not restore objects in this schema\n"));
     546           2 :     printf(_("  -O, --no-owner               skip restoration of object ownership\n"));
     547           2 :     printf(_("  -P, --function=NAME(args)    restore named function\n"));
     548           2 :     printf(_("  -s, --schema-only            restore only the schema, no data\n"));
     549           2 :     printf(_("  -S, --superuser=NAME         superuser user name to use for disabling triggers\n"));
     550           2 :     printf(_("  -t, --table=NAME             restore named relation (table, view, etc.)\n"));
     551           2 :     printf(_("  -T, --trigger=NAME           restore named trigger\n"));
     552           2 :     printf(_("  -x, --no-privileges          skip restoration of access privileges (grant/revoke)\n"));
     553           2 :     printf(_("  -1, --single-transaction     restore as a single transaction\n"));
     554           2 :     printf(_("  --disable-triggers           disable triggers during data-only restore\n"));
     555           2 :     printf(_("  --enable-row-security        enable row security\n"));
     556           2 :     printf(_("  --filter=FILENAME            restore or skip objects based on expressions\n"
     557             :              "                               in FILENAME\n"));
     558           2 :     printf(_("  --if-exists                  use IF EXISTS when dropping objects\n"));
     559           2 :     printf(_("  --no-comments                do not restore comment commands\n"));
     560           2 :     printf(_("  --no-data                    do not restore data\n"));
     561           2 :     printf(_("  --no-data-for-failed-tables  do not restore data of tables that could not be\n"
     562             :              "                               created\n"));
     563           2 :     printf(_("  --no-policies                do not restore row security policies\n"));
     564           2 :     printf(_("  --no-publications            do not restore publications\n"));
     565           2 :     printf(_("  --no-schema                  do not restore schema\n"));
     566           2 :     printf(_("  --no-security-labels         do not restore security labels\n"));
     567           2 :     printf(_("  --no-statistics              do not restore statistics\n"));
     568           2 :     printf(_("  --no-subscriptions           do not restore subscriptions\n"));
     569           2 :     printf(_("  --no-table-access-method     do not restore table access methods\n"));
     570           2 :     printf(_("  --no-tablespaces             do not restore tablespace assignments\n"));
     571           2 :     printf(_("  --restrict-key=RESTRICT_KEY  use provided string as psql \\restrict key\n"));
     572           2 :     printf(_("  --section=SECTION            restore named section (pre-data, data, or post-data)\n"));
     573           2 :     printf(_("  --statistics                 restore the statistics\n"));
     574           2 :     printf(_("  --statistics-only            restore only the statistics, not schema or data\n"));
     575           2 :     printf(_("  --strict-names               require table and/or schema include patterns to\n"
     576             :              "                               match at least one entity each\n"));
     577           2 :     printf(_("  --transaction-size=N         commit after every N objects\n"));
     578           2 :     printf(_("  --use-set-session-authorization\n"
     579             :              "                               use SET SESSION AUTHORIZATION commands instead of\n"
     580             :              "                               ALTER OWNER commands to set ownership\n"));
     581             : 
     582           2 :     printf(_("\nConnection options:\n"));
     583           2 :     printf(_("  -h, --host=HOSTNAME      database server host or socket directory\n"));
     584           2 :     printf(_("  -p, --port=PORT          database server port number\n"));
     585           2 :     printf(_("  -U, --username=NAME      connect as specified database user\n"));
     586           2 :     printf(_("  -w, --no-password        never prompt for password\n"));
     587           2 :     printf(_("  -W, --password           force password prompt (should happen automatically)\n"));
     588           2 :     printf(_("  --role=ROLENAME          do SET ROLE before restore\n"));
     589             : 
     590           2 :     printf(_("\n"
     591             :              "The options -I, -n, -N, -P, -t, -T, and --section can be combined and specified\n"
     592             :              "multiple times to select multiple objects.\n"));
     593           2 :     printf(_("\nIf no input file name is supplied, then standard input is used.\n\n"));
     594           2 :     printf(_("Report bugs to <%s>.\n"), PACKAGE_BUGREPORT);
     595           2 :     printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
     596           2 : }
     597             : 
     598             : /*
     599             :  * read_restore_filters - retrieve object identifier patterns from file
     600             :  *
     601             :  * Parse the specified filter file for include and exclude patterns, and add
     602             :  * them to the relevant lists.  If the filename is "-" then filters will be
     603             :  * read from STDIN rather than a file.
     604             :  */
     605             : static void
     606          20 : read_restore_filters(const char *filename, RestoreOptions *opts)
     607             : {
     608             :     FilterStateData fstate;
     609             :     char       *objname;
     610             :     FilterCommandType comtype;
     611             :     FilterObjectType objtype;
     612             : 
     613          20 :     filter_init(&fstate, filename, exit_nicely);
     614             : 
     615          54 :     while (filter_read_item(&fstate, &objname, &comtype, &objtype))
     616             :     {
     617          22 :         if (comtype == FILTER_COMMAND_TYPE_INCLUDE)
     618             :         {
     619          16 :             switch (objtype)
     620             :             {
     621           0 :                 case FILTER_OBJECT_TYPE_NONE:
     622           0 :                     break;
     623           4 :                 case FILTER_OBJECT_TYPE_TABLE_DATA:
     624             :                 case FILTER_OBJECT_TYPE_TABLE_DATA_AND_CHILDREN:
     625             :                 case FILTER_OBJECT_TYPE_TABLE_AND_CHILDREN:
     626             :                 case FILTER_OBJECT_TYPE_DATABASE:
     627             :                 case FILTER_OBJECT_TYPE_EXTENSION:
     628             :                 case FILTER_OBJECT_TYPE_FOREIGN_DATA:
     629           4 :                     pg_log_filter_error(&fstate, _("%s filter for \"%s\" is not allowed"),
     630             :                                         "include",
     631             :                                         filter_object_type_name(objtype));
     632           4 :                     exit_nicely(1);
     633             : 
     634           4 :                 case FILTER_OBJECT_TYPE_FUNCTION:
     635           4 :                     opts->selTypes = 1;
     636           4 :                     opts->selFunction = 1;
     637           4 :                     simple_string_list_append(&opts->functionNames, objname);
     638           4 :                     break;
     639           2 :                 case FILTER_OBJECT_TYPE_INDEX:
     640           2 :                     opts->selTypes = 1;
     641           2 :                     opts->selIndex = 1;
     642           2 :                     simple_string_list_append(&opts->indexNames, objname);
     643           2 :                     break;
     644           2 :                 case FILTER_OBJECT_TYPE_SCHEMA:
     645           2 :                     simple_string_list_append(&opts->schemaNames, objname);
     646           2 :                     break;
     647           2 :                 case FILTER_OBJECT_TYPE_TABLE:
     648           2 :                     opts->selTypes = 1;
     649           2 :                     opts->selTable = 1;
     650           2 :                     simple_string_list_append(&opts->tableNames, objname);
     651           2 :                     break;
     652           2 :                 case FILTER_OBJECT_TYPE_TRIGGER:
     653           2 :                     opts->selTypes = 1;
     654           2 :                     opts->selTrigger = 1;
     655           2 :                     simple_string_list_append(&opts->triggerNames, objname);
     656           2 :                     break;
     657             :             }
     658             :         }
     659           6 :         else if (comtype == FILTER_COMMAND_TYPE_EXCLUDE)
     660             :         {
     661           6 :             switch (objtype)
     662             :             {
     663           0 :                 case FILTER_OBJECT_TYPE_NONE:
     664           0 :                     break;
     665           4 :                 case FILTER_OBJECT_TYPE_TABLE_DATA:
     666             :                 case FILTER_OBJECT_TYPE_TABLE_DATA_AND_CHILDREN:
     667             :                 case FILTER_OBJECT_TYPE_DATABASE:
     668             :                 case FILTER_OBJECT_TYPE_EXTENSION:
     669             :                 case FILTER_OBJECT_TYPE_FOREIGN_DATA:
     670             :                 case FILTER_OBJECT_TYPE_FUNCTION:
     671             :                 case FILTER_OBJECT_TYPE_INDEX:
     672             :                 case FILTER_OBJECT_TYPE_TABLE:
     673             :                 case FILTER_OBJECT_TYPE_TABLE_AND_CHILDREN:
     674             :                 case FILTER_OBJECT_TYPE_TRIGGER:
     675           4 :                     pg_log_filter_error(&fstate, _("%s filter for \"%s\" is not allowed"),
     676             :                                         "exclude",
     677             :                                         filter_object_type_name(objtype));
     678           4 :                     exit_nicely(1);
     679             : 
     680           2 :                 case FILTER_OBJECT_TYPE_SCHEMA:
     681           2 :                     simple_string_list_append(&opts->schemaExcludeNames, objname);
     682           2 :                     break;
     683             :             }
     684             :         }
     685             :         else
     686             :         {
     687             :             Assert(comtype == FILTER_COMMAND_TYPE_NONE);
     688             :             Assert(objtype == FILTER_OBJECT_TYPE_NONE);
     689             :         }
     690             : 
     691          14 :         if (objname)
     692          14 :             free(objname);
     693             :     }
     694             : 
     695          12 :     filter_free(&fstate);
     696          12 : }

Generated by: LCOV version 1.16