PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
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"
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{
496 {(const char *) NULL} /* list terminator */
497};
498
499/* values from ViewOptCheckOption */
501{
502 /* no value for NOT_SET */
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
553static relopt_gen **relOpts = NULL;
555
556static int num_custom_options = 0;
558static bool need_initialization = true;
559
560static void initialize_reloptions(void);
561static 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 */
579static void
581{
582 int i;
583 int j;
584
585 j = 0;
586 for (i = 0; boolRelOpts[i].gen.name; i++)
587 {
590 j++;
591 }
592 for (i = 0; intRelOpts[i].gen.name; i++)
593 {
596 j++;
597 }
598 for (i = 0; realRelOpts[i].gen.name; i++)
599 {
602 j++;
603 }
604 for (i = 0; enumRelOpts[i].gen.name; i++)
605 {
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 {
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 {
644 relOpts[j]->namelen = strlen(relOpts[j]->name);
645 j++;
646 }
647
648 for (i = 0; enumRelOpts[i].gen.name; i++)
649 {
652 relOpts[j]->namelen = strlen(relOpts[j]->name);
653 j++;
654 }
655
656 for (i = 0; stringRelOpts[i].gen.name; i++)
657 {
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 */
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 */
699static 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 */
733void
734init_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 */
746void
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 */
756static void
757add_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 */
774static relopt_gen *
775allocate_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;
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 */
831static relopt_bool *
832init_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 */
848void
849add_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 */
864void
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 */
880static relopt_int *
881init_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 */
900void
901add_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 */
917void
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 */
933static relopt_real *
934init_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 */
953void
954add_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 */
971void
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 */
988static relopt_enum *
989init_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 */
1017void
1018add_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 */
1035void
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 */
1052static relopt_string *
1053init_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
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 */
1097void
1098add_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 */
1117void
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 */
1155Datum
1156transformRelOptions(Datum oldOptions, List *defList, const char *namspace,
1157 const char *const 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 */
1330List *
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 */
1378bytea *
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
1426static 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 */
1498static relopt_value *
1500 int *numrelopts)
1501{
1502 relopt_value *reloptions = NULL;
1503 int numoptions = 0;
1504 int i;
1505 int j;
1506
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. */
1540static 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 */
1568static void
1569parse_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;
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 */
1701static 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 */
1741static void
1742fillRelOptions(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 */
1837bytea *
1838default_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 */
1907void *
1908build_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 */
1944void *
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 */
1983bytea *
1984partitioned_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 */
1997bytea *
1998view_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 */
2018bytea *
2019heap_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 */
2053bytea *
2054index_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 */
2068bytea *
2069attribute_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 */
2085bytea *
2086tablespace_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 */
2109{
2110 LOCKMODE lockmode = NoLock;
2111 ListCell *cell;
2112
2113 if (defList == NIL)
2114 return AccessExclusiveLock;
2115
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:155
#define DatumGetArrayTypeP(X)
Definition: array.h:261
ArrayBuildState * accumArrayResult(ArrayBuildState *astate, Datum dvalue, bool disnull, Oid element_type, MemoryContext rcontext)
Definition: arrayfuncs.c:5350
void deconstruct_array_builtin(ArrayType *array, Oid elmtype, Datum **elemsp, bool **nullsp, int *nelemsp)
Definition: arrayfuncs.c:3697
Datum makeArrayResult(ArrayBuildState *astate, MemoryContext rcontext)
Definition: arrayfuncs.c:5420
bool parse_bool(const char *value, bool *result)
Definition: bool.c:31
static Datum values[MAXATTR]
Definition: bootstrap.c:151
int maintenance_io_concurrency
Definition: bufmgr.c:158
int effective_io_concurrency
Definition: bufmgr.c:151
#define MAX_IO_CONCURRENCY
Definition: bufmgr.h:181
#define TextDatumGetCString(d)
Definition: builtins.h:98
#define gettext_noop(x)
Definition: c.h:1150
#define VARHDRSZ
Definition: c.h:646
#define Assert(condition)
Definition: c.h:812
#define PointerIsValid(pointer)
Definition: c.h:717
uint32 bits32
Definition: c.h:494
#define lengthof(array)
Definition: c.h:742
size_t Size
Definition: c.h:559
double random_page_cost
Definition: costsize.c:131
double seq_page_cost
Definition: costsize.c:130
char * defGetString(DefElem *def)
Definition: define.c:35
bool defGetBoolean(DefElem *def)
Definition: define.c:94
int errdetail_internal(const char *fmt,...)
Definition: elog.c:1230
int errdetail(const char *fmt,...)
Definition: elog.c:1203
int errhint(const char *fmt,...)
Definition: elog.c:1317
int errcode(int sqlerrcode)
Definition: elog.c:853
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define _(x)
Definition: elog.c:90
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:225
#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:2871
bool parse_real(const char *value, double *result, int flags, const char **hintmsg)
Definition: guc.c:2961
#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
static struct @161 value
long val
Definition: informix.c:689
int j
Definition: isn.c:73
int i
Definition: isn.c:72
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:76
List * lappend(List *list, void *datum)
Definition: list.c:339
bool DoLockModesConflict(LOCKMODE mode1, LOCKMODE mode2)
Definition: lock.c:617
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:587
char * MemoryContextStrdup(MemoryContext context, const char *string)
Definition: mcxt.c:1683
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1181
char * pstrdup(const char *in)
Definition: mcxt.c:1696
void * repalloc(void *pointer, Size size)
Definition: mcxt.c:1541
void pfree(void *pointer)
Definition: mcxt.c:1521
void * palloc0(Size size)
Definition: mcxt.c:1347
MemoryContext TopMemoryContext
Definition: mcxt.c:149
void * palloc(Size size)
Definition: mcxt.c:1317
MemoryContext CurrentMemoryContext
Definition: mcxt.c:143
#define BTREE_MIN_FILLFACTOR
Definition: nbtree.h:199
#define BTREE_DEFAULT_FILLFACTOR
Definition: nbtree.h:200
static AmcheckOptions opts
Definition: pg_amcheck.c:112
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
static 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:1890
#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 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 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
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 * default_reloptions(Datum reloptions, bool validate, relopt_kind kind)
Definition: reloptions.c:1838
static relopt_value * parseLocalRelOptions(local_relopts *relopts, Datum options, bool validate)
Definition: reloptions.c:1541
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
Datum transformRelOptions(Datum oldOptions, List *defList, const char *namspace, const char *const validnsps[], bool acceptOidsOff, bool isReset)
Definition: reloptions.c:1156
List * untransformRelOptions(Datum options)
Definition: reloptions.c:1331
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
static relopt_string stringRelOpts[]
Definition: reloptions.c:547
bytea * view_reloptions(Datum reloptions, bool validate)
Definition: reloptions.c:1998
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
bytea * index_reloptions(amoptions_function amoptions, Datum reloptions, bool validate)
Definition: reloptions.c:2054
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
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 * partitioned_table_reloptions(Datum reloptions, bool validate)
Definition: reloptions.c:1984
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
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 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
bytea * extractRelOptions(HeapTuple tuple, TupleDesc tupdesc, amoptions_function amoptions)
Definition: reloptions.c:1379
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_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
static void initialize_reloptions(void)
Definition: reloptions.c:580
relopt_kind add_reloption_kind(void)
Definition: reloptions.c:683
void * build_local_reloptions(local_relopts *relopts, Datum options, bool validate)
Definition: reloptions.c:1945
void register_reloptions_validator(local_relopts *relopts, relopts_validator validator)
Definition: reloptions.c:747
static bool need_initialization
Definition: reloptions.c:558
static relopt_value * parseRelOptions(Datum options, bool validate, relopt_kind kind, int *numrelopts)
Definition: reloptions.c:1499
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
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
bytea * attribute_reloptions(Datum reloptions, bool validate)
Definition: reloptions.c:2069
static relopt_gen * allocate_reloption(bits32 kinds, int type, const char *name, const char *desc, LOCKMODE lockmode)
Definition: reloptions.c:775
static relopt_bool boolRelOpts[]
Definition: reloptions.c:94
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 void * allocateReloptStruct(Size base, relopt_value *options, int numoptions)
Definition: reloptions.c:1702
static bits32 last_assigned_kind
Definition: reloptions.c:554
bytea * heap_reloptions(char relkind, Datum reloptions, bool validate)
Definition: reloptions.c:2019
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:816
char * defname
Definition: parsenodes.h:817
Node * arg
Definition: parsenodes.h:818
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
char * string_val
Definition: reloptions.h:86
union relopt_value::@48 values
Definition: c.h:641
double vacuum_cost_delay
Definition: vacuum.c:79
int vacuum_cost_limit
Definition: vacuum.c:80
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