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