LCOV - code coverage report
Current view: top level - src/backend/access/common - reloptions.c (source / functions) Hit Total Coverage
Test: PostgreSQL 16devel Lines: 490 543 90.2 %
Date: 2022-08-17 05:10:35 Functions: 37 41 90.2 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * reloptions.c
       4             :  *    Core support for relation options (pg_class.reloptions)
       5             :  *
       6             :  * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/access/common/reloptions.c
      12             :  *
      13             :  *-------------------------------------------------------------------------
      14             :  */
      15             : 
      16             : #include "postgres.h"
      17             : 
      18             : #include <float.h>
      19             : 
      20             : #include "access/gist_private.h"
      21             : #include "access/hash.h"
      22             : #include "access/heaptoast.h"
      23             : #include "access/htup_details.h"
      24             : #include "access/nbtree.h"
      25             : #include "access/reloptions.h"
      26             : #include "access/spgist_private.h"
      27             : #include "catalog/pg_type.h"
      28             : #include "commands/defrem.h"
      29             : #include "commands/tablespace.h"
      30             : #include "commands/view.h"
      31             : #include "nodes/makefuncs.h"
      32             : #include "postmaster/postmaster.h"
      33             : #include "utils/array.h"
      34             : #include "utils/attoptcache.h"
      35             : #include "utils/builtins.h"
      36             : #include "utils/guc.h"
      37             : #include "utils/memutils.h"
      38             : #include "utils/rel.h"
      39             : 
      40             : /*
      41             :  * Contents of pg_class.reloptions
      42             :  *
      43             :  * To add an option:
      44             :  *
      45             :  * (i) decide on a type (integer, real, bool, string), name, default value,
      46             :  * upper and lower bounds (if applicable); for strings, consider a validation
      47             :  * routine.
      48             :  * (ii) add a record below (or use add_<type>_reloption).
      49             :  * (iii) add it to the appropriate options struct (perhaps StdRdOptions)
      50             :  * (iv) add it to the appropriate handling routine (perhaps
      51             :  * default_reloptions)
      52             :  * (v) make sure the lock level is set correctly for that operation
      53             :  * (vi) don't forget to document the option
      54             :  *
      55             :  * The default choice for any new option should be AccessExclusiveLock.
      56             :  * In some cases the lock level can be reduced from there, but the lock
      57             :  * level chosen should always conflict with itself to ensure that multiple
      58             :  * changes aren't lost when we attempt concurrent changes.
      59             :  * The choice of lock level depends completely upon how that parameter
      60             :  * is used within the server, not upon how and when you'd like to change it.
      61             :  * Safety first. Existing choices are documented here, and elsewhere in
      62             :  * backend code where the parameters are used.
      63             :  *
      64             :  * In general, anything that affects the results obtained from a SELECT must be
      65             :  * protected by AccessExclusiveLock.
      66             :  *
      67             :  * Autovacuum related parameters can be set at ShareUpdateExclusiveLock
      68             :  * since they are only used by the AV procs and don't change anything
      69             :  * currently executing.
      70             :  *
      71             :  * Fillfactor can be set because it applies only to subsequent changes made to
      72             :  * data blocks, as documented in hio.c
      73             :  *
      74             :  * n_distinct options can be set at ShareUpdateExclusiveLock because they
      75             :  * are only used during ANALYZE, which uses a ShareUpdateExclusiveLock,
      76             :  * so the ANALYZE will not be affected by in-flight changes. Changing those
      77             :  * values has no effect until the next ANALYZE, so no need for stronger lock.
      78             :  *
      79             :  * Planner-related parameters can be set with ShareUpdateExclusiveLock because
      80             :  * they only affect planning and not the correctness of the execution. Plans
      81             :  * cannot be changed in mid-flight, so changes here could not easily result in
      82             :  * new improved plans in any case. So we allow existing queries to continue
      83             :  * and existing plans to survive, a small price to pay for allowing better
      84             :  * plans to be introduced concurrently without interfering with users.
      85             :  *
      86             :  * Setting parallel_workers is safe, since it acts the same as
      87             :  * max_parallel_workers_per_gather which is a USERSET parameter that doesn't
      88             :  * affect existing plans or queries.
      89             :  *
      90             :  * vacuum_truncate can be set at ShareUpdateExclusiveLock because it
      91             :  * is only used during VACUUM, which uses a ShareUpdateExclusiveLock,
      92             :  * so the VACUUM will not be affected by in-flight changes. Changing its
      93             :  * value has no effect until the next VACUUM, so no need for stronger lock.
      94             :  */
      95             : 
      96             : static relopt_bool boolRelOpts[] =
      97             : {
      98             :     {
      99             :         {
     100             :             "autosummarize",
     101             :             "Enables automatic summarization on this BRIN index",
     102             :             RELOPT_KIND_BRIN,
     103             :             AccessExclusiveLock
     104             :         },
     105             :         false
     106             :     },
     107             :     {
     108             :         {
     109             :             "autovacuum_enabled",
     110             :             "Enables autovacuum in this relation",
     111             :             RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
     112             :             ShareUpdateExclusiveLock
     113             :         },
     114             :         true
     115             :     },
     116             :     {
     117             :         {
     118             :             "user_catalog_table",
     119             :             "Declare a table as an additional catalog table, e.g. for the purpose of logical replication",
     120             :             RELOPT_KIND_HEAP,
     121             :             AccessExclusiveLock
     122             :         },
     123             :         false
     124             :     },
     125             :     {
     126             :         {
     127             :             "fastupdate",
     128             :             "Enables \"fast update\" feature for this GIN index",
     129             :             RELOPT_KIND_GIN,
     130             :             AccessExclusiveLock
     131             :         },
     132             :         true
     133             :     },
     134             :     {
     135             :         {
     136             :             "security_barrier",
     137             :             "View acts as a row security barrier",
     138             :             RELOPT_KIND_VIEW,
     139             :             AccessExclusiveLock
     140             :         },
     141             :         false
     142             :     },
     143             :     {
     144             :         {
     145             :             "security_invoker",
     146             :             "Privileges on underlying relations are checked as the invoking user, not the view owner",
     147             :             RELOPT_KIND_VIEW,
     148             :             AccessExclusiveLock
     149             :         },
     150             :         false
     151             :     },
     152             :     {
     153             :         {
     154             :             "vacuum_truncate",
     155             :             "Enables vacuum to truncate empty pages at the end of this table",
     156             :             RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
     157             :             ShareUpdateExclusiveLock
     158             :         },
     159             :         true
     160             :     },
     161             :     {
     162             :         {
     163             :             "deduplicate_items",
     164             :             "Enables \"deduplicate items\" feature for this btree index",
     165             :             RELOPT_KIND_BTREE,
     166             :             ShareUpdateExclusiveLock    /* since it applies only to later
     167             :                                          * inserts */
     168             :         },
     169             :         true
     170             :     },
     171             :     /* list terminator */
     172             :     {{NULL}}
     173             : };
     174             : 
     175             : static relopt_int intRelOpts[] =
     176             : {
     177             :     {
     178             :         {
     179             :             "fillfactor",
     180             :             "Packs table pages only to this percentage",
     181             :             RELOPT_KIND_HEAP,
     182             :             ShareUpdateExclusiveLock    /* since it applies only to later
     183             :                                          * inserts */
     184             :         },
     185             :         HEAP_DEFAULT_FILLFACTOR, HEAP_MIN_FILLFACTOR, 100
     186             :     },
     187             :     {
     188             :         {
     189             :             "fillfactor",
     190             :             "Packs btree index pages only to this percentage",
     191             :             RELOPT_KIND_BTREE,
     192             :             ShareUpdateExclusiveLock    /* since it applies only to later
     193             :                                          * inserts */
     194             :         },
     195             :         BTREE_DEFAULT_FILLFACTOR, BTREE_MIN_FILLFACTOR, 100
     196             :     },
     197             :     {
     198             :         {
     199             :             "fillfactor",
     200             :             "Packs hash index pages only to this percentage",
     201             :             RELOPT_KIND_HASH,
     202             :             ShareUpdateExclusiveLock    /* since it applies only to later
     203             :                                          * inserts */
     204             :         },
     205             :         HASH_DEFAULT_FILLFACTOR, HASH_MIN_FILLFACTOR, 100
     206             :     },
     207             :     {
     208             :         {
     209             :             "fillfactor",
     210             :             "Packs gist index pages only to this percentage",
     211             :             RELOPT_KIND_GIST,
     212             :             ShareUpdateExclusiveLock    /* since it applies only to later
     213             :                                          * inserts */
     214             :         },
     215             :         GIST_DEFAULT_FILLFACTOR, GIST_MIN_FILLFACTOR, 100
     216             :     },
     217             :     {
     218             :         {
     219             :             "fillfactor",
     220             :             "Packs spgist index pages only to this percentage",
     221             :             RELOPT_KIND_SPGIST,
     222             :             ShareUpdateExclusiveLock    /* since it applies only to later
     223             :                                          * inserts */
     224             :         },
     225             :         SPGIST_DEFAULT_FILLFACTOR, SPGIST_MIN_FILLFACTOR, 100
     226             :     },
     227             :     {
     228             :         {
     229             :             "autovacuum_vacuum_threshold",
     230             :             "Minimum number of tuple updates or deletes prior to vacuum",
     231             :             RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
     232             :             ShareUpdateExclusiveLock
     233             :         },
     234             :         -1, 0, INT_MAX
     235             :     },
     236             :     {
     237             :         {
     238             :             "autovacuum_vacuum_insert_threshold",
     239             :             "Minimum number of tuple inserts prior to vacuum, or -1 to disable insert vacuums",
     240             :             RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
     241             :             ShareUpdateExclusiveLock
     242             :         },
     243             :         -2, -1, INT_MAX
     244             :     },
     245             :     {
     246             :         {
     247             :             "autovacuum_analyze_threshold",
     248             :             "Minimum number of tuple inserts, updates or deletes prior to analyze",
     249             :             RELOPT_KIND_HEAP,
     250             :             ShareUpdateExclusiveLock
     251             :         },
     252             :         -1, 0, INT_MAX
     253             :     },
     254             :     {
     255             :         {
     256             :             "autovacuum_vacuum_cost_limit",
     257             :             "Vacuum cost amount available before napping, for autovacuum",
     258             :             RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
     259             :             ShareUpdateExclusiveLock
     260             :         },
     261             :         -1, 1, 10000
     262             :     },
     263             :     {
     264             :         {
     265             :             "autovacuum_freeze_min_age",
     266             :             "Minimum age at which VACUUM should freeze a table row, for autovacuum",
     267             :             RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
     268             :             ShareUpdateExclusiveLock
     269             :         },
     270             :         -1, 0, 1000000000
     271             :     },
     272             :     {
     273             :         {
     274             :             "autovacuum_multixact_freeze_min_age",
     275             :             "Minimum multixact age at which VACUUM should freeze a row multixact's, for autovacuum",
     276             :             RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
     277             :             ShareUpdateExclusiveLock
     278             :         },
     279             :         -1, 0, 1000000000
     280             :     },
     281             :     {
     282             :         {
     283             :             "autovacuum_freeze_max_age",
     284             :             "Age at which to autovacuum a table to prevent transaction ID wraparound",
     285             :             RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
     286             :             ShareUpdateExclusiveLock
     287             :         },
     288             :         -1, 100000, 2000000000
     289             :     },
     290             :     {
     291             :         {
     292             :             "autovacuum_multixact_freeze_max_age",
     293             :             "Multixact age at which to autovacuum a table to prevent multixact wraparound",
     294             :             RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
     295             :             ShareUpdateExclusiveLock
     296             :         },
     297             :         -1, 10000, 2000000000
     298             :     },
     299             :     {
     300             :         {
     301             :             "autovacuum_freeze_table_age",
     302             :             "Age at which VACUUM should perform a full table sweep to freeze row versions",
     303             :             RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
     304             :             ShareUpdateExclusiveLock
     305             :         }, -1, 0, 2000000000
     306             :     },
     307             :     {
     308             :         {
     309             :             "autovacuum_multixact_freeze_table_age",
     310             :             "Age of multixact at which VACUUM should perform a full table sweep to freeze row versions",
     311             :             RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
     312             :             ShareUpdateExclusiveLock
     313             :         }, -1, 0, 2000000000
     314             :     },
     315             :     {
     316             :         {
     317             :             "log_autovacuum_min_duration",
     318             :             "Sets the minimum execution time above which autovacuum actions will be logged",
     319             :             RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
     320             :             ShareUpdateExclusiveLock
     321             :         },
     322             :         -1, -1, INT_MAX
     323             :     },
     324             :     {
     325             :         {
     326             :             "toast_tuple_target",
     327             :             "Sets the target tuple length at which external columns will be toasted",
     328             :             RELOPT_KIND_HEAP,
     329             :             ShareUpdateExclusiveLock
     330             :         },
     331             :         TOAST_TUPLE_TARGET, 128, TOAST_TUPLE_TARGET_MAIN
     332             :     },
     333             :     {
     334             :         {
     335             :             "pages_per_range",
     336             :             "Number of pages that each page range covers in a BRIN index",
     337             :             RELOPT_KIND_BRIN,
     338             :             AccessExclusiveLock
     339             :         }, 128, 1, 131072
     340             :     },
     341             :     {
     342             :         {
     343             :             "gin_pending_list_limit",
     344             :             "Maximum size of the pending list for this GIN index, in kilobytes.",
     345             :             RELOPT_KIND_GIN,
     346             :             AccessExclusiveLock
     347             :         },
     348             :         -1, 64, MAX_KILOBYTES
     349             :     },
     350             :     {
     351             :         {
     352             :             "effective_io_concurrency",
     353             :             "Number of simultaneous requests that can be handled efficiently by the disk subsystem.",
     354             :             RELOPT_KIND_TABLESPACE,
     355             :             ShareUpdateExclusiveLock
     356             :         },
     357             : #ifdef USE_PREFETCH
     358             :         -1, 0, MAX_IO_CONCURRENCY
     359             : #else
     360             :         0, 0, 0
     361             : #endif
     362             :     },
     363             :     {
     364             :         {
     365             :             "maintenance_io_concurrency",
     366             :             "Number of simultaneous requests that can be handled efficiently by the disk subsystem for maintenance work.",
     367             :             RELOPT_KIND_TABLESPACE,
     368             :             ShareUpdateExclusiveLock
     369             :         },
     370             : #ifdef USE_PREFETCH
     371             :         -1, 0, MAX_IO_CONCURRENCY
     372             : #else
     373             :         0, 0, 0
     374             : #endif
     375             :     },
     376             :     {
     377             :         {
     378             :             "parallel_workers",
     379             :             "Number of parallel processes that can be used per executor node for this relation.",
     380             :             RELOPT_KIND_HEAP,
     381             :             ShareUpdateExclusiveLock
     382             :         },
     383             :         -1, 0, 1024
     384             :     },
     385             : 
     386             :     /* list terminator */
     387             :     {{NULL}}
     388             : };
     389             : 
     390             : static relopt_real realRelOpts[] =
     391             : {
     392             :     {
     393             :         {
     394             :             "autovacuum_vacuum_cost_delay",
     395             :             "Vacuum cost delay in milliseconds, for autovacuum",
     396             :             RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
     397             :             ShareUpdateExclusiveLock
     398             :         },
     399             :         -1, 0.0, 100.0
     400             :     },
     401             :     {
     402             :         {
     403             :             "autovacuum_vacuum_scale_factor",
     404             :             "Number of tuple updates or deletes prior to vacuum as a fraction of reltuples",
     405             :             RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
     406             :             ShareUpdateExclusiveLock
     407             :         },
     408             :         -1, 0.0, 100.0
     409             :     },
     410             :     {
     411             :         {
     412             :             "autovacuum_vacuum_insert_scale_factor",
     413             :             "Number of tuple inserts prior to vacuum as a fraction of reltuples",
     414             :             RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
     415             :             ShareUpdateExclusiveLock
     416             :         },
     417             :         -1, 0.0, 100.0
     418             :     },
     419             :     {
     420             :         {
     421             :             "autovacuum_analyze_scale_factor",
     422             :             "Number of tuple inserts, updates or deletes prior to analyze as a fraction of reltuples",
     423             :             RELOPT_KIND_HEAP,
     424             :             ShareUpdateExclusiveLock
     425             :         },
     426             :         -1, 0.0, 100.0
     427             :     },
     428             :     {
     429             :         {
     430             :             "seq_page_cost",
     431             :             "Sets the planner's estimate of the cost of a sequentially fetched disk page.",
     432             :             RELOPT_KIND_TABLESPACE,
     433             :             ShareUpdateExclusiveLock
     434             :         },
     435             :         -1, 0.0, DBL_MAX
     436             :     },
     437             :     {
     438             :         {
     439             :             "random_page_cost",
     440             :             "Sets the planner's estimate of the cost of a nonsequentially fetched disk page.",
     441             :             RELOPT_KIND_TABLESPACE,
     442             :             ShareUpdateExclusiveLock
     443             :         },
     444             :         -1, 0.0, DBL_MAX
     445             :     },
     446             :     {
     447             :         {
     448             :             "n_distinct",
     449             :             "Sets the planner's estimate of the number of distinct values appearing in a column (excluding child relations).",
     450             :             RELOPT_KIND_ATTRIBUTE,
     451             :             ShareUpdateExclusiveLock
     452             :         },
     453             :         0, -1.0, DBL_MAX
     454             :     },
     455             :     {
     456             :         {
     457             :             "n_distinct_inherited",
     458             :             "Sets the planner's estimate of the number of distinct values appearing in a column (including child relations).",
     459             :             RELOPT_KIND_ATTRIBUTE,
     460             :             ShareUpdateExclusiveLock
     461             :         },
     462             :         0, -1.0, DBL_MAX
     463             :     },
     464             :     {
     465             :         {
     466             :             "vacuum_cleanup_index_scale_factor",
     467             :             "Deprecated B-Tree parameter.",
     468             :             RELOPT_KIND_BTREE,
     469             :             ShareUpdateExclusiveLock
     470             :         },
     471             :         -1, 0.0, 1e10
     472             :     },
     473             :     /* list terminator */
     474             :     {{NULL}}
     475             : };
     476             : 
     477             : /* values from StdRdOptIndexCleanup */
     478             : static relopt_enum_elt_def StdRdOptIndexCleanupValues[] =
     479             : {
     480             :     {"auto", STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO},
     481             :     {"on", STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON},
     482             :     {"off", STDRD_OPTION_VACUUM_INDEX_CLEANUP_OFF},
     483             :     {"true", STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON},
     484             :     {"false", STDRD_OPTION_VACUUM_INDEX_CLEANUP_OFF},
     485             :     {"yes", STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON},
     486             :     {"no", STDRD_OPTION_VACUUM_INDEX_CLEANUP_OFF},
     487             :     {"1", STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON},
     488             :     {"0", STDRD_OPTION_VACUUM_INDEX_CLEANUP_OFF},
     489             :     {(const char *) NULL}       /* list terminator */
     490             : };
     491             : 
     492             : /* values from GistOptBufferingMode */
     493             : static relopt_enum_elt_def gistBufferingOptValues[] =
     494             : {
     495             :     {"auto", GIST_OPTION_BUFFERING_AUTO},
     496             :     {"on", GIST_OPTION_BUFFERING_ON},
     497             :     {"off", GIST_OPTION_BUFFERING_OFF},
     498             :     {(const char *) NULL}       /* list terminator */
     499             : };
     500             : 
     501             : /* values from ViewOptCheckOption */
     502             : static relopt_enum_elt_def viewCheckOptValues[] =
     503             : {
     504             :     /* no value for NOT_SET */
     505             :     {"local", VIEW_OPTION_CHECK_OPTION_LOCAL},
     506             :     {"cascaded", VIEW_OPTION_CHECK_OPTION_CASCADED},
     507             :     {(const char *) NULL}       /* list terminator */
     508             : };
     509             : 
     510             : static relopt_enum enumRelOpts[] =
     511             : {
     512             :     {
     513             :         {
     514             :             "vacuum_index_cleanup",
     515             :             "Controls index vacuuming and index cleanup",
     516             :             RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
     517             :             ShareUpdateExclusiveLock
     518             :         },
     519             :         StdRdOptIndexCleanupValues,
     520             :         STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO,
     521             :         gettext_noop("Valid values are \"on\", \"off\", and \"auto\".")
     522             :     },
     523             :     {
     524             :         {
     525             :             "buffering",
     526             :             "Enables buffering build for this GiST index",
     527             :             RELOPT_KIND_GIST,
     528             :             AccessExclusiveLock
     529             :         },
     530             :         gistBufferingOptValues,
     531             :         GIST_OPTION_BUFFERING_AUTO,
     532             :         gettext_noop("Valid values are \"on\", \"off\", and \"auto\".")
     533             :     },
     534             :     {
     535             :         {
     536             :             "check_option",
     537             :             "View has WITH CHECK OPTION defined (local or cascaded).",
     538             :             RELOPT_KIND_VIEW,
     539             :             AccessExclusiveLock
     540             :         },
     541             :         viewCheckOptValues,
     542             :         VIEW_OPTION_CHECK_OPTION_NOT_SET,
     543             :         gettext_noop("Valid values are \"local\" and \"cascaded\".")
     544             :     },
     545             :     /* list terminator */
     546             :     {{NULL}}
     547             : };
     548             : 
     549             : static relopt_string stringRelOpts[] =
     550             : {
     551             :     /* list terminator */
     552             :     {{NULL}}
     553             : };
     554             : 
     555             : static relopt_gen **relOpts = NULL;
     556             : static bits32 last_assigned_kind = RELOPT_KIND_LAST_DEFAULT;
     557             : 
     558             : static int  num_custom_options = 0;
     559             : static relopt_gen **custom_options = NULL;
     560             : static bool need_initialization = true;
     561             : 
     562             : static void initialize_reloptions(void);
     563             : static void parse_one_reloption(relopt_value *option, char *text_str,
     564             :                                 int text_len, bool validate);
     565             : 
     566             : /*
     567             :  * Get the length of a string reloption (either default or the user-defined
     568             :  * value).  This is used for allocation purposes when building a set of
     569             :  * relation options.
     570             :  */
     571             : #define GET_STRING_RELOPTION_LEN(option) \
     572             :     ((option).isset ? strlen((option).values.string_val) : \
     573             :      ((relopt_string *) (option).gen)->default_len)
     574             : 
     575             : /*
     576             :  * initialize_reloptions
     577             :  *      initialization routine, must be called before parsing
     578             :  *
     579             :  * Initialize the relOpts array and fill each variable's type and name length.
     580             :  */
     581             : static void
     582        6118 : initialize_reloptions(void)
     583             : {
     584             :     int         i;
     585             :     int         j;
     586             : 
     587        6118 :     j = 0;
     588       55062 :     for (i = 0; boolRelOpts[i].gen.name; i++)
     589             :     {
     590             :         Assert(DoLockModesConflict(boolRelOpts[i].gen.lockmode,
     591             :                                    boolRelOpts[i].gen.lockmode));
     592       48944 :         j++;
     593             :     }
     594      140714 :     for (i = 0; intRelOpts[i].gen.name; i++)
     595             :     {
     596             :         Assert(DoLockModesConflict(intRelOpts[i].gen.lockmode,
     597             :                                    intRelOpts[i].gen.lockmode));
     598      134596 :         j++;
     599             :     }
     600       61180 :     for (i = 0; realRelOpts[i].gen.name; i++)
     601             :     {
     602             :         Assert(DoLockModesConflict(realRelOpts[i].gen.lockmode,
     603             :                                    realRelOpts[i].gen.lockmode));
     604       55062 :         j++;
     605             :     }
     606       24472 :     for (i = 0; enumRelOpts[i].gen.name; i++)
     607             :     {
     608             :         Assert(DoLockModesConflict(enumRelOpts[i].gen.lockmode,
     609             :                                    enumRelOpts[i].gen.lockmode));
     610       18354 :         j++;
     611             :     }
     612        6118 :     for (i = 0; stringRelOpts[i].gen.name; i++)
     613             :     {
     614             :         Assert(DoLockModesConflict(stringRelOpts[i].gen.lockmode,
     615             :                                    stringRelOpts[i].gen.lockmode));
     616           0 :         j++;
     617             :     }
     618        6118 :     j += num_custom_options;
     619             : 
     620        6118 :     if (relOpts)
     621           0 :         pfree(relOpts);
     622       12236 :     relOpts = MemoryContextAlloc(TopMemoryContext,
     623        6118 :                                  (j + 1) * sizeof(relopt_gen *));
     624             : 
     625        6118 :     j = 0;
     626       55062 :     for (i = 0; boolRelOpts[i].gen.name; i++)
     627             :     {
     628       48944 :         relOpts[j] = &boolRelOpts[i].gen;
     629       48944 :         relOpts[j]->type = RELOPT_TYPE_BOOL;
     630       48944 :         relOpts[j]->namelen = strlen(relOpts[j]->name);
     631       48944 :         j++;
     632             :     }
     633             : 
     634      140714 :     for (i = 0; intRelOpts[i].gen.name; i++)
     635             :     {
     636      134596 :         relOpts[j] = &intRelOpts[i].gen;
     637      134596 :         relOpts[j]->type = RELOPT_TYPE_INT;
     638      134596 :         relOpts[j]->namelen = strlen(relOpts[j]->name);
     639      134596 :         j++;
     640             :     }
     641             : 
     642       61180 :     for (i = 0; realRelOpts[i].gen.name; i++)
     643             :     {
     644       55062 :         relOpts[j] = &realRelOpts[i].gen;
     645       55062 :         relOpts[j]->type = RELOPT_TYPE_REAL;
     646       55062 :         relOpts[j]->namelen = strlen(relOpts[j]->name);
     647       55062 :         j++;
     648             :     }
     649             : 
     650       24472 :     for (i = 0; enumRelOpts[i].gen.name; i++)
     651             :     {
     652       18354 :         relOpts[j] = &enumRelOpts[i].gen;
     653       18354 :         relOpts[j]->type = RELOPT_TYPE_ENUM;
     654       18354 :         relOpts[j]->namelen = strlen(relOpts[j]->name);
     655       18354 :         j++;
     656             :     }
     657             : 
     658        6118 :     for (i = 0; stringRelOpts[i].gen.name; i++)
     659             :     {
     660           0 :         relOpts[j] = &stringRelOpts[i].gen;
     661           0 :         relOpts[j]->type = RELOPT_TYPE_STRING;
     662           0 :         relOpts[j]->namelen = strlen(relOpts[j]->name);
     663           0 :         j++;
     664             :     }
     665             : 
     666       12334 :     for (i = 0; i < num_custom_options; i++)
     667             :     {
     668        6216 :         relOpts[j] = custom_options[i];
     669        6216 :         j++;
     670             :     }
     671             : 
     672             :     /* add a list terminator */
     673        6118 :     relOpts[j] = NULL;
     674             : 
     675             :     /* flag the work is complete */
     676        6118 :     need_initialization = false;
     677        6118 : }
     678             : 
     679             : /*
     680             :  * add_reloption_kind
     681             :  *      Create a new relopt_kind value, to be used in custom reloptions by
     682             :  *      user-defined AMs.
     683             :  */
     684             : relopt_kind
     685         192 : add_reloption_kind(void)
     686             : {
     687             :     /* don't hand out the last bit so that the enum's behavior is portable */
     688         192 :     if (last_assigned_kind >= RELOPT_KIND_MAX)
     689           0 :         ereport(ERROR,
     690             :                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
     691             :                  errmsg("user-defined relation parameter types limit exceeded")));
     692         192 :     last_assigned_kind <<= 1;
     693         192 :     return (relopt_kind) last_assigned_kind;
     694             : }
     695             : 
     696             : /*
     697             :  * add_reloption
     698             :  *      Add an already-created custom reloption to the list, and recompute the
     699             :  *      main parser table.
     700             :  */
     701             : static void
     702        6282 : add_reloption(relopt_gen *newoption)
     703             : {
     704             :     static int  max_custom_options = 0;
     705             : 
     706        6282 :     if (num_custom_options >= max_custom_options)
     707             :     {
     708             :         MemoryContext oldcxt;
     709             : 
     710         762 :         oldcxt = MemoryContextSwitchTo(TopMemoryContext);
     711             : 
     712         762 :         if (max_custom_options == 0)
     713             :         {
     714         192 :             max_custom_options = 8;
     715         192 :             custom_options = palloc(max_custom_options * sizeof(relopt_gen *));
     716             :         }
     717             :         else
     718             :         {
     719         570 :             max_custom_options *= 2;
     720         570 :             custom_options = repalloc(custom_options,
     721             :                                       max_custom_options * sizeof(relopt_gen *));
     722             :         }
     723         762 :         MemoryContextSwitchTo(oldcxt);
     724             :     }
     725        6282 :     custom_options[num_custom_options++] = newoption;
     726             : 
     727        6282 :     need_initialization = true;
     728        6282 : }
     729             : 
     730             : /*
     731             :  * init_local_reloptions
     732             :  *      Initialize local reloptions that will parsed into bytea structure of
     733             :  *      'relopt_struct_size'.
     734             :  */
     735             : void
     736        3816 : init_local_reloptions(local_relopts *opts, Size relopt_struct_size)
     737             : {
     738        3816 :     opts->options = NIL;
     739        3816 :     opts->validators = NIL;
     740        3816 :     opts->relopt_struct_size = relopt_struct_size;
     741        3816 : }
     742             : 
     743             : /*
     744             :  * register_reloptions_validator
     745             :  *      Register custom validation callback that will be called at the end of
     746             :  *      build_local_reloptions().
     747             :  */
     748             : void
     749           0 : register_reloptions_validator(local_relopts *opts, relopts_validator validator)
     750             : {
     751           0 :     opts->validators = lappend(opts->validators, validator);
     752           0 : }
     753             : 
     754             : /*
     755             :  * add_local_reloption
     756             :  *      Add an already-created custom reloption to the local list.
     757             :  */
     758             : static void
     759        2496 : add_local_reloption(local_relopts *relopts, relopt_gen *newoption, int offset)
     760             : {
     761        2496 :     local_relopt *opt = palloc(sizeof(*opt));
     762             : 
     763             :     Assert(offset < relopts->relopt_struct_size);
     764             : 
     765        2496 :     opt->option = newoption;
     766        2496 :     opt->offset = offset;
     767             : 
     768        2496 :     relopts->options = lappend(relopts->options, opt);
     769        2496 : }
     770             : 
     771             : /*
     772             :  * allocate_reloption
     773             :  *      Allocate a new reloption and initialize the type-agnostic fields
     774             :  *      (for types other than string)
     775             :  */
     776             : static relopt_gen *
     777        8778 : allocate_reloption(bits32 kinds, int type, const char *name, const char *desc,
     778             :                    LOCKMODE lockmode)
     779             : {
     780             :     MemoryContext oldcxt;
     781             :     size_t      size;
     782             :     relopt_gen *newoption;
     783             : 
     784        8778 :     if (kinds != RELOPT_KIND_LOCAL)
     785        6282 :         oldcxt = MemoryContextSwitchTo(TopMemoryContext);
     786             :     else
     787        2496 :         oldcxt = NULL;
     788             : 
     789        8778 :     switch (type)
     790             :     {
     791           2 :         case RELOPT_TYPE_BOOL:
     792           2 :             size = sizeof(relopt_bool);
     793           2 :             break;
     794        7592 :         case RELOPT_TYPE_INT:
     795        7592 :             size = sizeof(relopt_int);
     796        7592 :             break;
     797        1178 :         case RELOPT_TYPE_REAL:
     798        1178 :             size = sizeof(relopt_real);
     799        1178 :             break;
     800           2 :         case RELOPT_TYPE_ENUM:
     801           2 :             size = sizeof(relopt_enum);
     802           2 :             break;
     803           4 :         case RELOPT_TYPE_STRING:
     804           4 :             size = sizeof(relopt_string);
     805           4 :             break;
     806           0 :         default:
     807           0 :             elog(ERROR, "unsupported reloption type %d", type);
     808             :             return NULL;        /* keep compiler quiet */
     809             :     }
     810             : 
     811        8778 :     newoption = palloc(size);
     812             : 
     813        8778 :     newoption->name = pstrdup(name);
     814        8778 :     if (desc)
     815        8776 :         newoption->desc = pstrdup(desc);
     816             :     else
     817           2 :         newoption->desc = NULL;
     818        8778 :     newoption->kinds = kinds;
     819        8778 :     newoption->namelen = strlen(name);
     820        8778 :     newoption->type = type;
     821        8778 :     newoption->lockmode = lockmode;
     822             : 
     823        8778 :     if (oldcxt != NULL)
     824        6282 :         MemoryContextSwitchTo(oldcxt);
     825             : 
     826        8778 :     return newoption;
     827             : }
     828             : 
     829             : /*
     830             :  * init_bool_reloption
     831             :  *      Allocate and initialize a new boolean reloption
     832             :  */
     833             : static relopt_bool *
     834           2 : init_bool_reloption(bits32 kinds, const char *name, const char *desc,
     835             :                     bool default_val, LOCKMODE lockmode)
     836             : {
     837             :     relopt_bool *newoption;
     838             : 
     839           2 :     newoption = (relopt_bool *) allocate_reloption(kinds, RELOPT_TYPE_BOOL,
     840             :                                                    name, desc, lockmode);
     841           2 :     newoption->default_val = default_val;
     842             : 
     843           2 :     return newoption;
     844             : }
     845             : 
     846             : /*
     847             :  * add_bool_reloption
     848             :  *      Add a new boolean reloption
     849             :  */
     850             : void
     851           2 : add_bool_reloption(bits32 kinds, const char *name, const char *desc,
     852             :                    bool default_val, LOCKMODE lockmode)
     853             : {
     854           2 :     relopt_bool *newoption = init_bool_reloption(kinds, name, desc,
     855             :                                                  default_val, lockmode);
     856             : 
     857           2 :     add_reloption((relopt_gen *) newoption);
     858           2 : }
     859             : 
     860             : /*
     861             :  * add_local_bool_reloption
     862             :  *      Add a new boolean local reloption
     863             :  *
     864             :  * 'offset' is offset of bool-typed field.
     865             :  */
     866             : void
     867           0 : add_local_bool_reloption(local_relopts *relopts, const char *name,
     868             :                          const char *desc, bool default_val, int offset)
     869             : {
     870           0 :     relopt_bool *newoption = init_bool_reloption(RELOPT_KIND_LOCAL,
     871             :                                                  name, desc,
     872             :                                                  default_val, 0);
     873             : 
     874           0 :     add_local_reloption(relopts, (relopt_gen *) newoption, offset);
     875           0 : }
     876             : 
     877             : 
     878             : /*
     879             :  * init_real_reloption
     880             :  *      Allocate and initialize a new integer reloption
     881             :  */
     882             : static relopt_int *
     883        7592 : init_int_reloption(bits32 kinds, const char *name, const char *desc,
     884             :                    int default_val, int min_val, int max_val,
     885             :                    LOCKMODE lockmode)
     886             : {
     887             :     relopt_int *newoption;
     888             : 
     889        7592 :     newoption = (relopt_int *) allocate_reloption(kinds, RELOPT_TYPE_INT,
     890             :                                                   name, desc, lockmode);
     891        7592 :     newoption->default_val = default_val;
     892        7592 :     newoption->min = min_val;
     893        7592 :     newoption->max = max_val;
     894             : 
     895        7592 :     return newoption;
     896             : }
     897             : 
     898             : /*
     899             :  * add_int_reloption
     900             :  *      Add a new integer reloption
     901             :  */
     902             : void
     903        6272 : add_int_reloption(bits32 kinds, const char *name, const char *desc, int default_val,
     904             :                   int min_val, int max_val, LOCKMODE lockmode)
     905             : {
     906        6272 :     relopt_int *newoption = init_int_reloption(kinds, name, desc,
     907             :                                                default_val, min_val,
     908             :                                                max_val, lockmode);
     909             : 
     910        6272 :     add_reloption((relopt_gen *) newoption);
     911        6272 : }
     912             : 
     913             : /*
     914             :  * add_local_int_reloption
     915             :  *      Add a new local integer reloption
     916             :  *
     917             :  * 'offset' is offset of int-typed field.
     918             :  */
     919             : void
     920        1320 : add_local_int_reloption(local_relopts *relopts, const char *name,
     921             :                         const char *desc, int default_val, int min_val,
     922             :                         int max_val, int offset)
     923             : {
     924        1320 :     relopt_int *newoption = init_int_reloption(RELOPT_KIND_LOCAL,
     925             :                                                name, desc, default_val,
     926             :                                                min_val, max_val, 0);
     927             : 
     928        1320 :     add_local_reloption(relopts, (relopt_gen *) newoption, offset);
     929        1320 : }
     930             : 
     931             : /*
     932             :  * init_real_reloption
     933             :  *      Allocate and initialize a new real reloption
     934             :  */
     935             : static relopt_real *
     936        1178 : init_real_reloption(bits32 kinds, const char *name, const char *desc,
     937             :                     double default_val, double min_val, double max_val,
     938             :                     LOCKMODE lockmode)
     939             : {
     940             :     relopt_real *newoption;
     941             : 
     942        1178 :     newoption = (relopt_real *) allocate_reloption(kinds, RELOPT_TYPE_REAL,
     943             :                                                    name, desc, lockmode);
     944        1178 :     newoption->default_val = default_val;
     945        1178 :     newoption->min = min_val;
     946        1178 :     newoption->max = max_val;
     947             : 
     948        1178 :     return newoption;
     949             : }
     950             : 
     951             : /*
     952             :  * add_real_reloption
     953             :  *      Add a new float reloption
     954             :  */
     955             : void
     956           2 : add_real_reloption(bits32 kinds, const char *name, const char *desc,
     957             :                    double default_val, double min_val, double max_val,
     958             :                    LOCKMODE lockmode)
     959             : {
     960           2 :     relopt_real *newoption = init_real_reloption(kinds, name, desc,
     961             :                                                  default_val, min_val,
     962             :                                                  max_val, lockmode);
     963             : 
     964           2 :     add_reloption((relopt_gen *) newoption);
     965           2 : }
     966             : 
     967             : /*
     968             :  * add_local_real_reloption
     969             :  *      Add a new local float reloption
     970             :  *
     971             :  * 'offset' is offset of double-typed field.
     972             :  */
     973             : void
     974        1176 : add_local_real_reloption(local_relopts *relopts, const char *name,
     975             :                          const char *desc, double default_val,
     976             :                          double min_val, double max_val, int offset)
     977             : {
     978        1176 :     relopt_real *newoption = init_real_reloption(RELOPT_KIND_LOCAL,
     979             :                                                  name, desc,
     980             :                                                  default_val, min_val,
     981             :                                                  max_val, 0);
     982             : 
     983        1176 :     add_local_reloption(relopts, (relopt_gen *) newoption, offset);
     984        1176 : }
     985             : 
     986             : /*
     987             :  * init_enum_reloption
     988             :  *      Allocate and initialize a new enum reloption
     989             :  */
     990             : static relopt_enum *
     991           2 : init_enum_reloption(bits32 kinds, const char *name, const char *desc,
     992             :                     relopt_enum_elt_def *members, int default_val,
     993             :                     const char *detailmsg, LOCKMODE lockmode)
     994             : {
     995             :     relopt_enum *newoption;
     996             : 
     997           2 :     newoption = (relopt_enum *) allocate_reloption(kinds, RELOPT_TYPE_ENUM,
     998             :                                                    name, desc, lockmode);
     999           2 :     newoption->members = members;
    1000           2 :     newoption->default_val = default_val;
    1001           2 :     newoption->detailmsg = detailmsg;
    1002             : 
    1003           2 :     return newoption;
    1004             : }
    1005             : 
    1006             : 
    1007             : /*
    1008             :  * add_enum_reloption
    1009             :  *      Add a new enum reloption
    1010             :  *
    1011             :  * The members array must have a terminating NULL entry.
    1012             :  *
    1013             :  * The detailmsg is shown when unsupported values are passed, and has this
    1014             :  * form:   "Valid values are \"foo\", \"bar\", and \"bar\"."
    1015             :  *
    1016             :  * The members array and detailmsg are not copied -- caller must ensure that
    1017             :  * they are valid throughout the life of the process.
    1018             :  */
    1019             : void
    1020           2 : add_enum_reloption(bits32 kinds, const char *name, const char *desc,
    1021             :                    relopt_enum_elt_def *members, int default_val,
    1022             :                    const char *detailmsg, LOCKMODE lockmode)
    1023             : {
    1024           2 :     relopt_enum *newoption = init_enum_reloption(kinds, name, desc,
    1025             :                                                  members, default_val,
    1026             :                                                  detailmsg, lockmode);
    1027             : 
    1028           2 :     add_reloption((relopt_gen *) newoption);
    1029           2 : }
    1030             : 
    1031             : /*
    1032             :  * add_local_enum_reloption
    1033             :  *      Add a new local enum reloption
    1034             :  *
    1035             :  * 'offset' is offset of int-typed field.
    1036             :  */
    1037             : void
    1038           0 : add_local_enum_reloption(local_relopts *relopts, const char *name,
    1039             :                          const char *desc, relopt_enum_elt_def *members,
    1040             :                          int default_val, const char *detailmsg, int offset)
    1041             : {
    1042           0 :     relopt_enum *newoption = init_enum_reloption(RELOPT_KIND_LOCAL,
    1043             :                                                  name, desc,
    1044             :                                                  members, default_val,
    1045             :                                                  detailmsg, 0);
    1046             : 
    1047           0 :     add_local_reloption(relopts, (relopt_gen *) newoption, offset);
    1048           0 : }
    1049             : 
    1050             : /*
    1051             :  * init_string_reloption
    1052             :  *      Allocate and initialize a new string reloption
    1053             :  */
    1054             : static relopt_string *
    1055           4 : init_string_reloption(bits32 kinds, const char *name, const char *desc,
    1056             :                       const char *default_val,
    1057             :                       validate_string_relopt validator,
    1058             :                       fill_string_relopt filler,
    1059             :                       LOCKMODE lockmode)
    1060             : {
    1061             :     relopt_string *newoption;
    1062             : 
    1063             :     /* make sure the validator/default combination is sane */
    1064           4 :     if (validator)
    1065           4 :         (validator) (default_val);
    1066             : 
    1067           4 :     newoption = (relopt_string *) allocate_reloption(kinds, RELOPT_TYPE_STRING,
    1068             :                                                      name, desc, lockmode);
    1069           4 :     newoption->validate_cb = validator;
    1070           4 :     newoption->fill_cb = filler;
    1071           4 :     if (default_val)
    1072             :     {
    1073           2 :         if (kinds == RELOPT_KIND_LOCAL)
    1074           0 :             newoption->default_val = strdup(default_val);
    1075             :         else
    1076           2 :             newoption->default_val = MemoryContextStrdup(TopMemoryContext, default_val);
    1077           2 :         newoption->default_len = strlen(default_val);
    1078           2 :         newoption->default_isnull = false;
    1079             :     }
    1080             :     else
    1081             :     {
    1082           2 :         newoption->default_val = "";
    1083           2 :         newoption->default_len = 0;
    1084           2 :         newoption->default_isnull = true;
    1085             :     }
    1086             : 
    1087           4 :     return newoption;
    1088             : }
    1089             : 
    1090             : /*
    1091             :  * add_string_reloption
    1092             :  *      Add a new string reloption
    1093             :  *
    1094             :  * "validator" is an optional function pointer that can be used to test the
    1095             :  * validity of the values.  It must elog(ERROR) when the argument string is
    1096             :  * not acceptable for the variable.  Note that the default value must pass
    1097             :  * the validation.
    1098             :  */
    1099             : void
    1100           4 : add_string_reloption(bits32 kinds, const char *name, const char *desc,
    1101             :                      const char *default_val, validate_string_relopt validator,
    1102             :                      LOCKMODE lockmode)
    1103             : {
    1104           4 :     relopt_string *newoption = init_string_reloption(kinds, name, desc,
    1105             :                                                      default_val,
    1106             :                                                      validator, NULL,
    1107             :                                                      lockmode);
    1108             : 
    1109           4 :     add_reloption((relopt_gen *) newoption);
    1110           4 : }
    1111             : 
    1112             : /*
    1113             :  * add_local_string_reloption
    1114             :  *      Add a new local string reloption
    1115             :  *
    1116             :  * 'offset' is offset of int-typed field that will store offset of string value
    1117             :  * in the resulting bytea structure.
    1118             :  */
    1119             : void
    1120           0 : add_local_string_reloption(local_relopts *relopts, const char *name,
    1121             :                            const char *desc, const char *default_val,
    1122             :                            validate_string_relopt validator,
    1123             :                            fill_string_relopt filler, int offset)
    1124             : {
    1125           0 :     relopt_string *newoption = init_string_reloption(RELOPT_KIND_LOCAL,
    1126             :                                                      name, desc,
    1127             :                                                      default_val,
    1128             :                                                      validator, filler,
    1129             :                                                      0);
    1130             : 
    1131           0 :     add_local_reloption(relopts, (relopt_gen *) newoption, offset);
    1132           0 : }
    1133             : 
    1134             : /*
    1135             :  * Transform a relation options list (list of DefElem) into the text array
    1136             :  * format that is kept in pg_class.reloptions, including only those options
    1137             :  * that are in the passed namespace.  The output values do not include the
    1138             :  * namespace.
    1139             :  *
    1140             :  * This is used for three cases: CREATE TABLE/INDEX, ALTER TABLE SET, and
    1141             :  * ALTER TABLE RESET.  In the ALTER cases, oldOptions is the existing
    1142             :  * reloptions value (possibly NULL), and we replace or remove entries
    1143             :  * as needed.
    1144             :  *
    1145             :  * If acceptOidsOff is true, then we allow oids = false, but throw error when
    1146             :  * on. This is solely needed for backwards compatibility.
    1147             :  *
    1148             :  * Note that this is not responsible for determining whether the options
    1149             :  * are valid, but it does check that namespaces for all the options given are
    1150             :  * listed in validnsps.  The NULL namespace is always valid and need not be
    1151             :  * explicitly listed.  Passing a NULL pointer means that only the NULL
    1152             :  * namespace is valid.
    1153             :  *
    1154             :  * Both oldOptions and the result are text arrays (or NULL for "default"),
    1155             :  * but we declare them as Datums to avoid including array.h in reloptions.h.
    1156             :  */
    1157             : Datum
    1158      232178 : transformRelOptions(Datum oldOptions, List *defList, const char *namspace,
    1159             :                     char *validnsps[], bool acceptOidsOff, bool isReset)
    1160             : {
    1161             :     Datum       result;
    1162             :     ArrayBuildState *astate;
    1163             :     ListCell   *cell;
    1164             : 
    1165             :     /* no change if empty list */
    1166      232178 :     if (defList == NIL)
    1167      228044 :         return oldOptions;
    1168             : 
    1169             :     /* We build new array using accumArrayResult */
    1170        4134 :     astate = NULL;
    1171             : 
    1172             :     /* Copy any oldOptions that aren't to be replaced */
    1173        4134 :     if (PointerIsValid(DatumGetPointer(oldOptions)))
    1174             :     {
    1175         330 :         ArrayType  *array = DatumGetArrayTypeP(oldOptions);
    1176             :         Datum      *oldoptions;
    1177             :         int         noldoptions;
    1178             :         int         i;
    1179             : 
    1180         330 :         deconstruct_array_builtin(array, TEXTOID, &oldoptions, NULL, &noldoptions);
    1181             : 
    1182         838 :         for (i = 0; i < noldoptions; i++)
    1183             :         {
    1184         508 :             char       *text_str = VARDATA(oldoptions[i]);
    1185         508 :             int         text_len = VARSIZE(oldoptions[i]) - VARHDRSZ;
    1186             : 
    1187             :             /* Search for a match in defList */
    1188         754 :             foreach(cell, defList)
    1189             :             {
    1190         556 :                 DefElem    *def = (DefElem *) lfirst(cell);
    1191             :                 int         kw_len;
    1192             : 
    1193             :                 /* ignore if not in the same namespace */
    1194         556 :                 if (namspace == NULL)
    1195             :                 {
    1196         508 :                     if (def->defnamespace != NULL)
    1197           0 :                         continue;
    1198             :                 }
    1199          48 :                 else if (def->defnamespace == NULL)
    1200          30 :                     continue;
    1201          18 :                 else if (strcmp(def->defnamespace, namspace) != 0)
    1202           0 :                     continue;
    1203             : 
    1204         526 :                 kw_len = strlen(def->defname);
    1205         526 :                 if (text_len > kw_len && text_str[kw_len] == '=' &&
    1206         332 :                     strncmp(text_str, def->defname, kw_len) == 0)
    1207         310 :                     break;
    1208             :             }
    1209         508 :             if (!cell)
    1210             :             {
    1211             :                 /* No match, so keep old option */
    1212         198 :                 astate = accumArrayResult(astate, oldoptions[i],
    1213             :                                           false, TEXTOID,
    1214             :                                           CurrentMemoryContext);
    1215             :             }
    1216             :         }
    1217             :     }
    1218             : 
    1219             :     /*
    1220             :      * If CREATE/SET, add new options to array; if RESET, just check that the
    1221             :      * user didn't say RESET (option=val).  (Must do this because the grammar
    1222             :      * doesn't enforce it.)
    1223             :      */
    1224        8562 :     foreach(cell, defList)
    1225             :     {
    1226        4464 :         DefElem    *def = (DefElem *) lfirst(cell);
    1227             : 
    1228        4464 :         if (isReset)
    1229             :         {
    1230         238 :             if (def->arg != NULL)
    1231          12 :                 ereport(ERROR,
    1232             :                         (errcode(ERRCODE_SYNTAX_ERROR),
    1233             :                          errmsg("RESET must not include values for parameters")));
    1234             :         }
    1235             :         else
    1236             :         {
    1237             :             text       *t;
    1238             :             const char *value;
    1239             :             Size        len;
    1240             : 
    1241             :             /*
    1242             :              * Error out if the namespace is not valid.  A NULL namespace is
    1243             :              * always valid.
    1244             :              */
    1245        4226 :             if (def->defnamespace != NULL)
    1246             :             {
    1247         112 :                 bool        valid = false;
    1248             :                 int         i;
    1249             : 
    1250         112 :                 if (validnsps)
    1251             :                 {
    1252         112 :                     for (i = 0; validnsps[i]; i++)
    1253             :                     {
    1254         106 :                         if (strcmp(def->defnamespace, validnsps[i]) == 0)
    1255             :                         {
    1256         100 :                             valid = true;
    1257         100 :                             break;
    1258             :                         }
    1259             :                     }
    1260             :                 }
    1261             : 
    1262         112 :                 if (!valid)
    1263          12 :                     ereport(ERROR,
    1264             :                             (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    1265             :                              errmsg("unrecognized parameter namespace \"%s\"",
    1266             :                                     def->defnamespace)));
    1267             :             }
    1268             : 
    1269             :             /* ignore if not in the same namespace */
    1270        4214 :             if (namspace == NULL)
    1271             :             {
    1272        3656 :                 if (def->defnamespace != NULL)
    1273          50 :                     continue;
    1274             :             }
    1275         558 :             else if (def->defnamespace == NULL)
    1276         508 :                 continue;
    1277          50 :             else if (strcmp(def->defnamespace, namspace) != 0)
    1278           0 :                 continue;
    1279             : 
    1280             :             /*
    1281             :              * Flatten the DefElem into a text string like "name=arg". If we
    1282             :              * have just "name", assume "name=true" is meant.  Note: the
    1283             :              * namespace is not output.
    1284             :              */
    1285        3656 :             if (def->arg != NULL)
    1286        1886 :                 value = defGetString(def);
    1287             :             else
    1288        1770 :                 value = "true";
    1289             : 
    1290             :             /*
    1291             :              * This is not a great place for this test, but there's no other
    1292             :              * convenient place to filter the option out. As WITH (oids =
    1293             :              * false) will be removed someday, this seems like an acceptable
    1294             :              * amount of ugly.
    1295             :              */
    1296        3656 :             if (acceptOidsOff && def->defnamespace == NULL &&
    1297        2388 :                 strcmp(def->defname, "oids") == 0)
    1298             :             {
    1299          18 :                 if (defGetBoolean(def))
    1300          12 :                     ereport(ERROR,
    1301             :                             (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    1302             :                              errmsg("tables declared WITH OIDS are not supported")));
    1303             :                 /* skip over option, reloptions machinery doesn't know it */
    1304           6 :                 continue;
    1305             :             }
    1306             : 
    1307        3638 :             len = VARHDRSZ + strlen(def->defname) + 1 + strlen(value);
    1308             :             /* +1 leaves room for sprintf's trailing null */
    1309        3638 :             t = (text *) palloc(len + 1);
    1310        3638 :             SET_VARSIZE(t, len);
    1311        3638 :             sprintf(VARDATA(t), "%s=%s", def->defname, value);
    1312             : 
    1313        3638 :             astate = accumArrayResult(astate, PointerGetDatum(t),
    1314             :                                       false, TEXTOID,
    1315             :                                       CurrentMemoryContext);
    1316             :         }
    1317             :     }
    1318             : 
    1319        4098 :     if (astate)
    1320        3498 :         result = makeArrayResult(astate, CurrentMemoryContext);
    1321             :     else
    1322         600 :         result = (Datum) 0;
    1323             : 
    1324        4098 :     return result;
    1325             : }
    1326             : 
    1327             : 
    1328             : /*
    1329             :  * Convert the text-array format of reloptions into a List of DefElem.
    1330             :  * This is the inverse of transformRelOptions().
    1331             :  */
    1332             : List *
    1333       23808 : untransformRelOptions(Datum options)
    1334             : {
    1335       23808 :     List       *result = NIL;
    1336             :     ArrayType  *array;
    1337             :     Datum      *optiondatums;
    1338             :     int         noptions;
    1339             :     int         i;
    1340             : 
    1341             :     /* Nothing to do if no options */
    1342       23808 :     if (!PointerIsValid(DatumGetPointer(options)))
    1343        2874 :         return result;
    1344             : 
    1345       20934 :     array = DatumGetArrayTypeP(options);
    1346             : 
    1347       20934 :     deconstruct_array_builtin(array, TEXTOID, &optiondatums, NULL, &noptions);
    1348             : 
    1349       61848 :     for (i = 0; i < noptions; i++)
    1350             :     {
    1351             :         char       *s;
    1352             :         char       *p;
    1353       40914 :         Node       *val = NULL;
    1354             : 
    1355       40914 :         s = TextDatumGetCString(optiondatums[i]);
    1356       40914 :         p = strchr(s, '=');
    1357       40914 :         if (p)
    1358             :         {
    1359       40914 :             *p++ = '\0';
    1360       40914 :             val = (Node *) makeString(pstrdup(p));
    1361             :         }
    1362       40914 :         result = lappend(result, makeDefElem(pstrdup(s), val, -1));
    1363             :     }
    1364             : 
    1365       20934 :     return result;
    1366             : }
    1367             : 
    1368             : /*
    1369             :  * Extract and parse reloptions from a pg_class tuple.
    1370             :  *
    1371             :  * This is a low-level routine, expected to be used by relcache code and
    1372             :  * callers that do not have a table's relcache entry (e.g. autovacuum).  For
    1373             :  * other uses, consider grabbing the rd_options pointer from the relcache entry
    1374             :  * instead.
    1375             :  *
    1376             :  * tupdesc is pg_class' tuple descriptor.  amoptions is a pointer to the index
    1377             :  * AM's options parser function in the case of a tuple corresponding to an
    1378             :  * index, or NULL otherwise.
    1379             :  */
    1380             : bytea *
    1381     1457216 : extractRelOptions(HeapTuple tuple, TupleDesc tupdesc,
    1382             :                   amoptions_function amoptions)
    1383             : {
    1384             :     bytea      *options;
    1385             :     bool        isnull;
    1386             :     Datum       datum;
    1387             :     Form_pg_class classForm;
    1388             : 
    1389     1457216 :     datum = fastgetattr(tuple,
    1390             :                         Anum_pg_class_reloptions,
    1391             :                         tupdesc,
    1392             :                         &isnull);
    1393     1457216 :     if (isnull)
    1394     1443362 :         return NULL;
    1395             : 
    1396       13854 :     classForm = (Form_pg_class) GETSTRUCT(tuple);
    1397             : 
    1398             :     /* Parse into appropriate format; don't error out here */
    1399       13854 :     switch (classForm->relkind)
    1400             :     {
    1401        7548 :         case RELKIND_RELATION:
    1402             :         case RELKIND_TOASTVALUE:
    1403             :         case RELKIND_MATVIEW:
    1404        7548 :             options = heap_reloptions(classForm->relkind, datum, false);
    1405        7548 :             break;
    1406           0 :         case RELKIND_PARTITIONED_TABLE:
    1407           0 :             options = partitioned_table_reloptions(datum, false);
    1408           0 :             break;
    1409        4722 :         case RELKIND_VIEW:
    1410        4722 :             options = view_reloptions(datum, false);
    1411        4722 :             break;
    1412        1584 :         case RELKIND_INDEX:
    1413             :         case RELKIND_PARTITIONED_INDEX:
    1414        1584 :             options = index_reloptions(amoptions, datum, false);
    1415        1584 :             break;
    1416           0 :         case RELKIND_FOREIGN_TABLE:
    1417           0 :             options = NULL;
    1418           0 :             break;
    1419           0 :         default:
    1420             :             Assert(false);      /* can't get here */
    1421           0 :             options = NULL;     /* keep compiler quiet */
    1422           0 :             break;
    1423             :     }
    1424             : 
    1425       13854 :     return options;
    1426             : }
    1427             : 
    1428             : static void
    1429       17652 : parseRelOptionsInternal(Datum options, bool validate,
    1430             :                         relopt_value *reloptions, int numoptions)
    1431             : {
    1432       17652 :     ArrayType  *array = DatumGetArrayTypeP(options);
    1433             :     Datum      *optiondatums;
    1434             :     int         noptions;
    1435             :     int         i;
    1436             : 
    1437       17652 :     deconstruct_array_builtin(array, TEXTOID, &optiondatums, NULL, &noptions);
    1438             : 
    1439       36688 :     for (i = 0; i < noptions; i++)
    1440             :     {
    1441       19356 :         char       *text_str = VARDATA(optiondatums[i]);
    1442       19356 :         int         text_len = VARSIZE(optiondatums[i]) - VARHDRSZ;
    1443             :         int         j;
    1444             : 
    1445             :         /* Search for a match in reloptions */
    1446       78756 :         for (j = 0; j < numoptions; j++)
    1447             :         {
    1448       78678 :             int         kw_len = reloptions[j].gen->namelen;
    1449             : 
    1450       78678 :             if (text_len > kw_len && text_str[kw_len] == '=' &&
    1451       20186 :                 strncmp(text_str, reloptions[j].gen->name, kw_len) == 0)
    1452             :             {
    1453       19278 :                 parse_one_reloption(&reloptions[j], text_str, text_len,
    1454             :                                     validate);
    1455       19024 :                 break;
    1456             :             }
    1457             :         }
    1458             : 
    1459       19102 :         if (j >= numoptions && validate)
    1460             :         {
    1461             :             char       *s;
    1462             :             char       *p;
    1463             : 
    1464          66 :             s = TextDatumGetCString(optiondatums[i]);
    1465          66 :             p = strchr(s, '=');
    1466          66 :             if (p)
    1467          66 :                 *p = '\0';
    1468          66 :             ereport(ERROR,
    1469             :                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    1470             :                      errmsg("unrecognized parameter \"%s\"", s)));
    1471             :         }
    1472             :     }
    1473             : 
    1474             :     /* It's worth avoiding memory leaks in this function */
    1475       17332 :     pfree(optiondatums);
    1476             : 
    1477       17332 :     if (((void *) array) != DatumGetPointer(options))
    1478       14126 :         pfree(array);
    1479       17332 : }
    1480             : 
    1481             : /*
    1482             :  * Interpret reloptions that are given in text-array format.
    1483             :  *
    1484             :  * options is a reloption text array as constructed by transformRelOptions.
    1485             :  * kind specifies the family of options to be processed.
    1486             :  *
    1487             :  * The return value is a relopt_value * array on which the options actually
    1488             :  * set in the options array are marked with isset=true.  The length of this
    1489             :  * array is returned in *numrelopts.  Options not set are also present in the
    1490             :  * array; this is so that the caller can easily locate the default values.
    1491             :  *
    1492             :  * If there are no options of the given kind, numrelopts is set to 0 and NULL
    1493             :  * is returned (unless options are illegally supplied despite none being
    1494             :  * defined, in which case an error occurs).
    1495             :  *
    1496             :  * Note: values of type int, bool and real are allocated as part of the
    1497             :  * returned array.  Values of type string are allocated separately and must
    1498             :  * be freed by the caller.
    1499             :  */
    1500             : static relopt_value *
    1501      161704 : parseRelOptions(Datum options, bool validate, relopt_kind kind,
    1502             :                 int *numrelopts)
    1503             : {
    1504      161704 :     relopt_value *reloptions = NULL;
    1505      161704 :     int         numoptions = 0;
    1506             :     int         i;
    1507             :     int         j;
    1508             : 
    1509      161704 :     if (need_initialization)
    1510        6110 :         initialize_reloptions();
    1511             : 
    1512             :     /* Build a list of expected options, based on kind */
    1513             : 
    1514     6962044 :     for (i = 0; relOpts[i]; i++)
    1515     6800340 :         if (relOpts[i]->kinds & kind)
    1516     1619710 :             numoptions++;
    1517             : 
    1518      161704 :     if (numoptions > 0)
    1519             :     {
    1520      157598 :         reloptions = palloc(numoptions * sizeof(relopt_value));
    1521             : 
    1522     6785486 :         for (i = 0, j = 0; relOpts[i]; i++)
    1523             :         {
    1524     6627888 :             if (relOpts[i]->kinds & kind)
    1525             :             {
    1526     1619710 :                 reloptions[j].gen = relOpts[i];
    1527     1619710 :                 reloptions[j].isset = false;
    1528     1619710 :                 j++;
    1529             :             }
    1530             :         }
    1531             :     }
    1532             : 
    1533             :     /* Done if no options */
    1534      161704 :     if (PointerIsValid(DatumGetPointer(options)))
    1535       17232 :         parseRelOptionsInternal(options, validate, reloptions, numoptions);
    1536             : 
    1537      161468 :     *numrelopts = numoptions;
    1538      161468 :     return reloptions;
    1539             : }
    1540             : 
    1541             : /* Parse local unregistered options. */
    1542             : static relopt_value *
    1543        1908 : parseLocalRelOptions(local_relopts *relopts, Datum options, bool validate)
    1544             : {
    1545        1908 :     int         nopts = list_length(relopts->options);
    1546        1908 :     relopt_value *values = palloc(sizeof(*values) * nopts);
    1547             :     ListCell   *lc;
    1548        1908 :     int         i = 0;
    1549             : 
    1550        4404 :     foreach(lc, relopts->options)
    1551             :     {
    1552        2496 :         local_relopt *opt = lfirst(lc);
    1553             : 
    1554        2496 :         values[i].gen = opt->option;
    1555        2496 :         values[i].isset = false;
    1556             : 
    1557        2496 :         i++;
    1558             :     }
    1559             : 
    1560        1908 :     if (options != (Datum) 0)
    1561         420 :         parseRelOptionsInternal(options, validate, values, nopts);
    1562             : 
    1563        1824 :     return values;
    1564             : }
    1565             : 
    1566             : /*
    1567             :  * Subroutine for parseRelOptions, to parse and validate a single option's
    1568             :  * value
    1569             :  */
    1570             : static void
    1571       19278 : parse_one_reloption(relopt_value *option, char *text_str, int text_len,
    1572             :                     bool validate)
    1573             : {
    1574             :     char       *value;
    1575             :     int         value_len;
    1576             :     bool        parsed;
    1577       19278 :     bool        nofree = false;
    1578             : 
    1579       19278 :     if (option->isset && validate)
    1580          12 :         ereport(ERROR,
    1581             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    1582             :                  errmsg("parameter \"%s\" specified more than once",
    1583             :                         option->gen->name)));
    1584             : 
    1585       19266 :     value_len = text_len - option->gen->namelen - 1;
    1586       19266 :     value = (char *) palloc(value_len + 1);
    1587       19266 :     memcpy(value, text_str + option->gen->namelen + 1, value_len);
    1588       19266 :     value[value_len] = '\0';
    1589             : 
    1590       19266 :     switch (option->gen->type)
    1591             :     {
    1592       10978 :         case RELOPT_TYPE_BOOL:
    1593             :             {
    1594       10978 :                 parsed = parse_bool(value, &option->values.bool_val);
    1595       10978 :                 if (validate && !parsed)
    1596          36 :                     ereport(ERROR,
    1597             :                             (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    1598             :                              errmsg("invalid value for boolean option \"%s\": %s",
    1599             :                                     option->gen->name, value)));
    1600             :             }
    1601       10942 :             break;
    1602        6660 :         case RELOPT_TYPE_INT:
    1603             :             {
    1604        6660 :                 relopt_int *optint = (relopt_int *) option->gen;
    1605             : 
    1606        6660 :                 parsed = parse_int(value, &option->values.int_val, 0, NULL);
    1607        6660 :                 if (validate && !parsed)
    1608          22 :                     ereport(ERROR,
    1609             :                             (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    1610             :                              errmsg("invalid value for integer option \"%s\": %s",
    1611             :                                     option->gen->name, value)));
    1612        6638 :                 if (validate && (option->values.int_val < optint->min ||
    1613         686 :                                  option->values.int_val > optint->max))
    1614         118 :                     ereport(ERROR,
    1615             :                             (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    1616             :                              errmsg("value %s out of bounds for option \"%s\"",
    1617             :                                     value, option->gen->name),
    1618             :                              errdetail("Valid values are between \"%d\" and \"%d\".",
    1619             :                                        optint->min, optint->max)));
    1620             :             }
    1621        6520 :             break;
    1622         444 :         case RELOPT_TYPE_REAL:
    1623             :             {
    1624         444 :                 relopt_real *optreal = (relopt_real *) option->gen;
    1625             : 
    1626         444 :                 parsed = parse_real(value, &option->values.real_val, 0, NULL);
    1627         444 :                 if (validate && !parsed)
    1628          16 :                     ereport(ERROR,
    1629             :                             (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    1630             :                              errmsg("invalid value for floating point option \"%s\": %s",
    1631             :                                     option->gen->name, value)));
    1632         428 :                 if (validate && (option->values.real_val < optreal->min ||
    1633         160 :                                  option->values.real_val > optreal->max))
    1634          30 :                     ereport(ERROR,
    1635             :                             (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    1636             :                              errmsg("value %s out of bounds for option \"%s\"",
    1637             :                                     value, option->gen->name),
    1638             :                              errdetail("Valid values are between \"%f\" and \"%f\".",
    1639             :                                        optreal->min, optreal->max)));
    1640             :             }
    1641         398 :             break;
    1642        1020 :         case RELOPT_TYPE_ENUM:
    1643             :             {
    1644        1020 :                 relopt_enum *optenum = (relopt_enum *) option->gen;
    1645             :                 relopt_enum_elt_def *elt;
    1646             : 
    1647        1020 :                 parsed = false;
    1648        2156 :                 for (elt = optenum->members; elt->string_val; elt++)
    1649             :                 {
    1650        2136 :                     if (pg_strcasecmp(value, elt->string_val) == 0)
    1651             :                     {
    1652        1000 :                         option->values.enum_val = elt->symbol_val;
    1653        1000 :                         parsed = true;
    1654        1000 :                         break;
    1655             :                     }
    1656             :                 }
    1657        1020 :                 if (validate && !parsed)
    1658          20 :                     ereport(ERROR,
    1659             :                             (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
    1660             :                              errmsg("invalid value for enum option \"%s\": %s",
    1661             :                                     option->gen->name, value),
    1662             :                              optenum->detailmsg ?
    1663             :                              errdetail_internal("%s", _(optenum->detailmsg)) : 0));
    1664             : 
    1665             :                 /*
    1666             :                  * If value is not among the allowed string values, but we are
    1667             :                  * not asked to validate, just use the default numeric value.
    1668             :                  */
    1669        1000 :                 if (!parsed)
    1670           0 :                     option->values.enum_val = optenum->default_val;
    1671             :             }
    1672        1000 :             break;
    1673         164 :         case RELOPT_TYPE_STRING:
    1674             :             {
    1675         164 :                 relopt_string *optstring = (relopt_string *) option->gen;
    1676             : 
    1677         164 :                 option->values.string_val = value;
    1678         164 :                 nofree = true;
    1679         164 :                 if (validate && optstring->validate_cb)
    1680          56 :                     (optstring->validate_cb) (value);
    1681         164 :                 parsed = true;
    1682             :             }
    1683         164 :             break;
    1684           0 :         default:
    1685           0 :             elog(ERROR, "unsupported reloption type %d", option->gen->type);
    1686             :             parsed = true;      /* quiet compiler */
    1687             :             break;
    1688             :     }
    1689             : 
    1690       19024 :     if (parsed)
    1691       19024 :         option->isset = true;
    1692       19024 :     if (!nofree)
    1693       18860 :         pfree(value);
    1694       19024 : }
    1695             : 
    1696             : /*
    1697             :  * Given the result from parseRelOptions, allocate a struct that's of the
    1698             :  * specified base size plus any extra space that's needed for string variables.
    1699             :  *
    1700             :  * "base" should be sizeof(struct) of the reloptions struct (StdRdOptions or
    1701             :  * equivalent).
    1702             :  */
    1703             : static void *
    1704      159186 : allocateReloptStruct(Size base, relopt_value *options, int numoptions)
    1705             : {
    1706      159186 :     Size        size = base;
    1707             :     int         i;
    1708             : 
    1709     1778548 :     for (i = 0; i < numoptions; i++)
    1710             :     {
    1711     1619362 :         relopt_value *optval = &options[i];
    1712             : 
    1713     1619362 :         if (optval->gen->type == RELOPT_TYPE_STRING)
    1714             :         {
    1715         232 :             relopt_string *optstr = (relopt_string *) optval->gen;
    1716             : 
    1717         232 :             if (optstr->fill_cb)
    1718             :             {
    1719           0 :                 const char *val = optval->isset ? optval->values.string_val :
    1720           0 :                 optstr->default_isnull ? NULL : optstr->default_val;
    1721             : 
    1722           0 :                 size += optstr->fill_cb(val, NULL);
    1723             :             }
    1724             :             else
    1725         232 :                 size += GET_STRING_RELOPTION_LEN(*optval) + 1;
    1726             :         }
    1727             :     }
    1728             : 
    1729      159186 :     return palloc0(size);
    1730             : }
    1731             : 
    1732             : /*
    1733             :  * Given the result of parseRelOptions and a parsing table, fill in the
    1734             :  * struct (previously allocated with allocateReloptStruct) with the parsed
    1735             :  * values.
    1736             :  *
    1737             :  * rdopts is the pointer to the allocated struct to be filled.
    1738             :  * basesize is the sizeof(struct) that was passed to allocateReloptStruct.
    1739             :  * options, of length numoptions, is parseRelOptions' output.
    1740             :  * elems, of length numelems, is the table describing the allowed options.
    1741             :  * When validate is true, it is expected that all options appear in elems.
    1742             :  */
    1743             : static void
    1744      159186 : fillRelOptions(void *rdopts, Size basesize,
    1745             :                relopt_value *options, int numoptions,
    1746             :                bool validate,
    1747             :                const relopt_parse_elt *elems, int numelems)
    1748             : {
    1749             :     int         i;
    1750      159186 :     int         offset = basesize;
    1751             : 
    1752     1778548 :     for (i = 0; i < numoptions; i++)
    1753             :     {
    1754             :         int         j;
    1755     1619362 :         bool        found = false;
    1756             : 
    1757    15914006 :         for (j = 0; j < numelems; j++)
    1758             :         {
    1759    15914006 :             if (strcmp(options[i].gen->name, elems[j].optname) == 0)
    1760             :             {
    1761             :                 relopt_string *optstring;
    1762     1619362 :                 char       *itempos = ((char *) rdopts) + elems[j].offset;
    1763             :                 char       *string_val;
    1764             : 
    1765     1619362 :                 switch (options[i].gen->type)
    1766             :                 {
    1767      349286 :                     case RELOPT_TYPE_BOOL:
    1768      698572 :                         *(bool *) itempos = options[i].isset ?
    1769      349286 :                             options[i].values.bool_val :
    1770      338346 :                             ((relopt_bool *) options[i].gen)->default_val;
    1771      349286 :                         break;
    1772      864032 :                     case RELOPT_TYPE_INT:
    1773     1728064 :                         *(int *) itempos = options[i].isset ?
    1774      864032 :                             options[i].values.int_val :
    1775      857538 :                             ((relopt_int *) options[i].gen)->default_val;
    1776      864032 :                         break;
    1777      250268 :                     case RELOPT_TYPE_REAL:
    1778      500536 :                         *(double *) itempos = options[i].isset ?
    1779      250268 :                             options[i].values.real_val :
    1780      249884 :                             ((relopt_real *) options[i].gen)->default_val;
    1781      250268 :                         break;
    1782      155544 :                     case RELOPT_TYPE_ENUM:
    1783      311088 :                         *(int *) itempos = options[i].isset ?
    1784      155544 :                             options[i].values.enum_val :
    1785      154544 :                             ((relopt_enum *) options[i].gen)->default_val;
    1786      155544 :                         break;
    1787         232 :                     case RELOPT_TYPE_STRING:
    1788         232 :                         optstring = (relopt_string *) options[i].gen;
    1789         232 :                         if (options[i].isset)
    1790         160 :                             string_val = options[i].values.string_val;
    1791          72 :                         else if (!optstring->default_isnull)
    1792          30 :                             string_val = optstring->default_val;
    1793             :                         else
    1794          42 :                             string_val = NULL;
    1795             : 
    1796         232 :                         if (optstring->fill_cb)
    1797             :                         {
    1798             :                             Size        size =
    1799           0 :                             optstring->fill_cb(string_val,
    1800             :                                                (char *) rdopts + offset);
    1801             : 
    1802           0 :                             if (size)
    1803             :                             {
    1804           0 :                                 *(int *) itempos = offset;
    1805           0 :                                 offset += size;
    1806             :                             }
    1807             :                             else
    1808           0 :                                 *(int *) itempos = 0;
    1809             :                         }
    1810         232 :                         else if (string_val == NULL)
    1811          42 :                             *(int *) itempos = 0;
    1812             :                         else
    1813             :                         {
    1814         190 :                             strcpy((char *) rdopts + offset, string_val);
    1815         190 :                             *(int *) itempos = offset;
    1816         190 :                             offset += strlen(string_val) + 1;
    1817             :                         }
    1818         232 :                         break;
    1819           0 :                     default:
    1820           0 :                         elog(ERROR, "unsupported reloption type %d",
    1821             :                              options[i].gen->type);
    1822             :                         break;
    1823             :                 }
    1824     1619362 :                 found = true;
    1825     1619362 :                 break;
    1826             :             }
    1827             :         }
    1828     1619362 :         if (validate && !found)
    1829           0 :             elog(ERROR, "reloption \"%s\" not found in parse table",
    1830             :                  options[i].gen->name);
    1831             :     }
    1832      159186 :     SET_VARSIZE(rdopts, offset);
    1833      159186 : }
    1834             : 
    1835             : 
    1836             : /*
    1837             :  * Option parser for anything that uses StdRdOptions.
    1838             :  */
    1839             : bytea *
    1840       70512 : default_reloptions(Datum reloptions, bool validate, relopt_kind kind)
    1841             : {
    1842             :     static const relopt_parse_elt tab[] = {
    1843             :         {"fillfactor", RELOPT_TYPE_INT, offsetof(StdRdOptions, fillfactor)},
    1844             :         {"autovacuum_enabled", RELOPT_TYPE_BOOL,
    1845             :         offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, enabled)},
    1846             :         {"autovacuum_vacuum_threshold", RELOPT_TYPE_INT,
    1847             :         offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_threshold)},
    1848             :         {"autovacuum_vacuum_insert_threshold", RELOPT_TYPE_INT,
    1849             :         offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_ins_threshold)},
    1850             :         {"autovacuum_analyze_threshold", RELOPT_TYPE_INT,
    1851             :         offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_threshold)},
    1852             :         {"autovacuum_vacuum_cost_limit", RELOPT_TYPE_INT,
    1853             :         offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_limit)},
    1854             :         {"autovacuum_freeze_min_age", RELOPT_TYPE_INT,
    1855             :         offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_min_age)},
    1856             :         {"autovacuum_freeze_max_age", RELOPT_TYPE_INT,
    1857             :         offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_max_age)},
    1858             :         {"autovacuum_freeze_table_age", RELOPT_TYPE_INT,
    1859             :         offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_table_age)},
    1860             :         {"autovacuum_multixact_freeze_min_age", RELOPT_TYPE_INT,
    1861             :         offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_min_age)},
    1862             :         {"autovacuum_multixact_freeze_max_age", RELOPT_TYPE_INT,
    1863             :         offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_max_age)},
    1864             :         {"autovacuum_multixact_freeze_table_age", RELOPT_TYPE_INT,
    1865             :         offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_table_age)},
    1866             :         {"log_autovacuum_min_duration", RELOPT_TYPE_INT,
    1867             :         offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, log_min_duration)},
    1868             :         {"toast_tuple_target", RELOPT_TYPE_INT,
    1869             :         offsetof(StdRdOptions, toast_tuple_target)},
    1870             :         {"autovacuum_vacuum_cost_delay", RELOPT_TYPE_REAL,
    1871             :         offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_delay)},
    1872             :         {"autovacuum_vacuum_scale_factor", RELOPT_TYPE_REAL,
    1873             :         offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_scale_factor)},
    1874             :         {"autovacuum_vacuum_insert_scale_factor", RELOPT_TYPE_REAL,
    1875             :         offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_ins_scale_factor)},
    1876             :         {"autovacuum_analyze_scale_factor", RELOPT_TYPE_REAL,
    1877             :         offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_scale_factor)},
    1878             :         {"user_catalog_table", RELOPT_TYPE_BOOL,
    1879             :         offsetof(StdRdOptions, user_catalog_table)},
    1880             :         {"parallel_workers", RELOPT_TYPE_INT,
    1881             :         offsetof(StdRdOptions, parallel_workers)},
    1882             :         {"vacuum_index_cleanup", RELOPT_TYPE_ENUM,
    1883             :         offsetof(StdRdOptions, vacuum_index_cleanup)},
    1884             :         {"vacuum_truncate", RELOPT_TYPE_BOOL,
    1885             :         offsetof(StdRdOptions, vacuum_truncate)}
    1886             :     };
    1887             : 
    1888       70512 :     return (bytea *) build_reloptions(reloptions, validate, kind,
    1889             :                                       sizeof(StdRdOptions),
    1890             :                                       tab, lengthof(tab));
    1891             : }
    1892             : 
    1893             : /*
    1894             :  * build_reloptions
    1895             :  *
    1896             :  * Parses "reloptions" provided by the caller, returning them in a
    1897             :  * structure containing the parsed options.  The parsing is done with
    1898             :  * the help of a parsing table describing the allowed options, defined
    1899             :  * by "relopt_elems" of length "num_relopt_elems".
    1900             :  *
    1901             :  * "validate" must be true if reloptions value is freshly built by
    1902             :  * transformRelOptions(), as opposed to being read from the catalog, in which
    1903             :  * case the values contained in it must already be valid.
    1904             :  *
    1905             :  * NULL is returned if the passed-in options did not match any of the options
    1906             :  * in the parsing table, unless validate is true in which case an error would
    1907             :  * be reported.
    1908             :  */
    1909             : void *
    1910      161704 : build_reloptions(Datum reloptions, bool validate,
    1911             :                  relopt_kind kind,
    1912             :                  Size relopt_struct_size,
    1913             :                  const relopt_parse_elt *relopt_elems,
    1914             :                  int num_relopt_elems)
    1915             : {
    1916             :     int         numoptions;
    1917             :     relopt_value *options;
    1918             :     void       *rdopts;
    1919             : 
    1920             :     /* parse options specific to given relation option kind */
    1921      161704 :     options = parseRelOptions(reloptions, validate, kind, &numoptions);
    1922             :     Assert(numoptions <= num_relopt_elems);
    1923             : 
    1924             :     /* if none set, we're done */
    1925      161468 :     if (numoptions == 0)
    1926             :     {
    1927             :         Assert(options == NULL);
    1928        4106 :         return NULL;
    1929             :     }
    1930             : 
    1931             :     /* allocate and fill the structure */
    1932      157362 :     rdopts = allocateReloptStruct(relopt_struct_size, options, numoptions);
    1933      157362 :     fillRelOptions(rdopts, relopt_struct_size, options, numoptions,
    1934             :                    validate, relopt_elems, num_relopt_elems);
    1935             : 
    1936      157362 :     pfree(options);
    1937             : 
    1938      157362 :     return rdopts;
    1939             : }
    1940             : 
    1941             : /*
    1942             :  * Parse local options, allocate a bytea struct that's of the specified
    1943             :  * 'base_size' plus any extra space that's needed for string variables,
    1944             :  * fill its option's fields located at the given offsets and return it.
    1945             :  */
    1946             : void *
    1947        1908 : build_local_reloptions(local_relopts *relopts, Datum options, bool validate)
    1948             : {
    1949        1908 :     int         noptions = list_length(relopts->options);
    1950        1908 :     relopt_parse_elt *elems = palloc(sizeof(*elems) * noptions);
    1951             :     relopt_value *vals;
    1952             :     void       *opts;
    1953        1908 :     int         i = 0;
    1954             :     ListCell   *lc;
    1955             : 
    1956        4404 :     foreach(lc, relopts->options)
    1957             :     {
    1958        2496 :         local_relopt *opt = lfirst(lc);
    1959             : 
    1960        2496 :         elems[i].optname = opt->option->name;
    1961        2496 :         elems[i].opttype = opt->option->type;
    1962        2496 :         elems[i].offset = opt->offset;
    1963             : 
    1964        2496 :         i++;
    1965             :     }
    1966             : 
    1967        1908 :     vals = parseLocalRelOptions(relopts, options, validate);
    1968        1824 :     opts = allocateReloptStruct(relopts->relopt_struct_size, vals, noptions);
    1969        1824 :     fillRelOptions(opts, relopts->relopt_struct_size, vals, noptions, validate,
    1970             :                    elems, noptions);
    1971             : 
    1972        1824 :     foreach(lc, relopts->validators)
    1973           0 :         ((relopts_validator) lfirst(lc)) (opts, vals, noptions);
    1974             : 
    1975        1824 :     if (elems)
    1976        1824 :         pfree(elems);
    1977             : 
    1978        1824 :     return opts;
    1979             : }
    1980             : 
    1981             : /*
    1982             :  * Option parser for partitioned tables
    1983             :  */
    1984             : bytea *
    1985        4106 : partitioned_table_reloptions(Datum reloptions, bool validate)
    1986             : {
    1987             :     /*
    1988             :      * There are no options for partitioned tables yet, but this is able to do
    1989             :      * some validation.
    1990             :      */
    1991        4106 :     return (bytea *) build_reloptions(reloptions, validate,
    1992             :                                       RELOPT_KIND_PARTITIONED,
    1993             :                                       0, NULL, 0);
    1994             : }
    1995             : 
    1996             : /*
    1997             :  * Option parser for views
    1998             :  */
    1999             : bytea *
    2000       84914 : view_reloptions(Datum reloptions, bool validate)
    2001             : {
    2002             :     static const relopt_parse_elt tab[] = {
    2003             :         {"security_barrier", RELOPT_TYPE_BOOL,
    2004             :         offsetof(ViewOptions, security_barrier)},
    2005             :         {"security_invoker", RELOPT_TYPE_BOOL,
    2006             :         offsetof(ViewOptions, security_invoker)},
    2007             :         {"check_option", RELOPT_TYPE_ENUM,
    2008             :         offsetof(ViewOptions, check_option)}
    2009             :     };
    2010             : 
    2011       84914 :     return (bytea *) build_reloptions(reloptions, validate,
    2012             :                                       RELOPT_KIND_VIEW,
    2013             :                                       sizeof(ViewOptions),
    2014             :                                       tab, lengthof(tab));
    2015             : }
    2016             : 
    2017             : /*
    2018             :  * Parse options for heaps, views and toast tables.
    2019             :  */
    2020             : bytea *
    2021       73018 : heap_reloptions(char relkind, Datum reloptions, bool validate)
    2022             : {
    2023             :     StdRdOptions *rdopts;
    2024             : 
    2025       73018 :     switch (relkind)
    2026             :     {
    2027       33102 :         case RELKIND_TOASTVALUE:
    2028             :             rdopts = (StdRdOptions *)
    2029       33102 :                 default_reloptions(reloptions, validate, RELOPT_KIND_TOAST);
    2030       33096 :             if (rdopts != NULL)
    2031             :             {
    2032             :                 /* adjust default-only parameters for TOAST relations */
    2033       33096 :                 rdopts->fillfactor = 100;
    2034       33096 :                 rdopts->autovacuum.analyze_threshold = -1;
    2035       33096 :                 rdopts->autovacuum.analyze_scale_factor = -1;
    2036             :             }
    2037       33096 :             return (bytea *) rdopts;
    2038       37410 :         case RELKIND_RELATION:
    2039             :         case RELKIND_MATVIEW:
    2040       37410 :             return default_reloptions(reloptions, validate, RELOPT_KIND_HEAP);
    2041        2506 :         default:
    2042             :             /* other relkinds are not supported */
    2043        2506 :             return NULL;
    2044             :     }
    2045             : }
    2046             : 
    2047             : 
    2048             : /*
    2049             :  * Parse options for indexes.
    2050             :  *
    2051             :  *  amoptions   index AM's option parser function
    2052             :  *  reloptions  options as text[] datum
    2053             :  *  validate    error flag
    2054             :  */
    2055             : bytea *
    2056       83698 : index_reloptions(amoptions_function amoptions, Datum reloptions, bool validate)
    2057             : {
    2058             :     Assert(amoptions != NULL);
    2059             : 
    2060             :     /* Assume function is strict */
    2061       83698 :     if (!PointerIsValid(DatumGetPointer(reloptions)))
    2062       81666 :         return NULL;
    2063             : 
    2064        2032 :     return amoptions(reloptions, validate);
    2065             : }
    2066             : 
    2067             : /*
    2068             :  * Option parser for attribute reloptions
    2069             :  */
    2070             : bytea *
    2071          38 : attribute_reloptions(Datum reloptions, bool validate)
    2072             : {
    2073             :     static const relopt_parse_elt tab[] = {
    2074             :         {"n_distinct", RELOPT_TYPE_REAL, offsetof(AttributeOpts, n_distinct)},
    2075             :         {"n_distinct_inherited", RELOPT_TYPE_REAL, offsetof(AttributeOpts, n_distinct_inherited)}
    2076             :     };
    2077             : 
    2078          38 :     return (bytea *) build_reloptions(reloptions, validate,
    2079             :                                       RELOPT_KIND_ATTRIBUTE,
    2080             :                                       sizeof(AttributeOpts),
    2081             :                                       tab, lengthof(tab));
    2082             : }
    2083             : 
    2084             : /*
    2085             :  * Option parser for tablespace reloptions
    2086             :  */
    2087             : bytea *
    2088         102 : tablespace_reloptions(Datum reloptions, bool validate)
    2089             : {
    2090             :     static const relopt_parse_elt tab[] = {
    2091             :         {"random_page_cost", RELOPT_TYPE_REAL, offsetof(TableSpaceOpts, random_page_cost)},
    2092             :         {"seq_page_cost", RELOPT_TYPE_REAL, offsetof(TableSpaceOpts, seq_page_cost)},
    2093             :         {"effective_io_concurrency", RELOPT_TYPE_INT, offsetof(TableSpaceOpts, effective_io_concurrency)},
    2094             :         {"maintenance_io_concurrency", RELOPT_TYPE_INT, offsetof(TableSpaceOpts, maintenance_io_concurrency)}
    2095             :     };
    2096             : 
    2097         102 :     return (bytea *) build_reloptions(reloptions, validate,
    2098             :                                       RELOPT_KIND_TABLESPACE,
    2099             :                                       sizeof(TableSpaceOpts),
    2100             :                                       tab, lengthof(tab));
    2101             : }
    2102             : 
    2103             : /*
    2104             :  * Determine the required LOCKMODE from an option list.
    2105             :  *
    2106             :  * Called from AlterTableGetLockLevel(), see that function
    2107             :  * for a longer explanation of how this works.
    2108             :  */
    2109             : LOCKMODE
    2110         726 : AlterTableGetRelOptionsLockLevel(List *defList)
    2111             : {
    2112         726 :     LOCKMODE    lockmode = NoLock;
    2113             :     ListCell   *cell;
    2114             : 
    2115         726 :     if (defList == NIL)
    2116           0 :         return AccessExclusiveLock;
    2117             : 
    2118         726 :     if (need_initialization)
    2119           8 :         initialize_reloptions();
    2120             : 
    2121        1488 :     foreach(cell, defList)
    2122             :     {
    2123         762 :         DefElem    *def = (DefElem *) lfirst(cell);
    2124             :         int         i;
    2125             : 
    2126       33252 :         for (i = 0; relOpts[i]; i++)
    2127             :         {
    2128       32490 :             if (strncmp(relOpts[i]->name,
    2129       32490 :                         def->defname,
    2130       32490 :                         relOpts[i]->namelen + 1) == 0)
    2131             :             {
    2132        1066 :                 if (lockmode < relOpts[i]->lockmode)
    2133         726 :                     lockmode = relOpts[i]->lockmode;
    2134             :             }
    2135             :         }
    2136             :     }
    2137             : 
    2138         726 :     return lockmode;
    2139             : }

Generated by: LCOV version 1.14