Thanks to visit codestin.com
Credit goes to doxygen.postgresql.org

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