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

Generated by: LCOV version 1.16