Thread: Suggestion: Unified options API. Need help from core team
Hi!
I am still hoping to finish my work on reloptions I've started some years ago.
I've renewed my patch and I think I need help from core team to finish it.
General idea of the patch: Now we have three ways to define options for
different objects, with more or less different code used for it. It wold be
better to have unified context independent API for processing options, instead.
Long story short:
There is Option Specification object, that has all information about single
option, how it should be parsed and validated.
There is Option Specification Set object, an array of Option Specs, that defines
all options available for certain object (am of some index for example).
When some object (relation, opclass, etc) wants to have an options, it
creates an Option Spec Set for there options, and uses it for converting
options between different representations (to get is from SQL, to store it in
pg_class, to pass it to the core code as bytea etc)
For indexes Option Spec Set is available via Access Method API.
For non-index relations all Option Spec Sets are left in reloption.c file, and
should be moved to heap AM later. (They are not in AM now so will not change
it now)
Main problem:
There are LockModes. LockModes for options is also stored in Option Spec Set.
For indexes Option Spec Sec is accessable via AM. So to get LockMode for
option of an index you need to have access for it's relation object (so you
can call proper AM method to fetch spec set). So you need "Relation rel" in
AlterTableGetRelOptionsLockLevel where Lock Level is determinated (src/
backend/access/common/reloptions.c)
AlterTableGetRelOptionsLockLevel is called from AlterTableGetLockLevel (src/
backend/commands/tablecmds.c) so we need "Relation rel" there too.
AlterTableGetLockLevel is called from AlterTableInternal (/src/backend/
commands/tablecmds.c) There we have "Oid relid" so we can try to open relation
like this
Relation rel = relation_open(relid, NoLock);
cmd_lockmode = AlterTableGetRelOptionsLockLevel(rel,
castNode(List, cmd->def));
relation_close(rel,NoLock);
break;
but this will trigger the assertion
Assert(lockmode != NoLock ||
IsBootstrapProcessingMode() ||
CheckRelationLockedByMe(r, c, true));
in relation_open (b/src/backend/access/common/relation.c)
For now I've commented this assertion out. I've tried to open relation with
AccessShareLock but this caused one test to fail, and I am not sure this
solution is better.
What I have done here I consider a hack, so I need a help of core-team here to
do it in right way.
General problems:
I guess I need a coauthor, or supervisor from core team, to finish this patch.
The amount of code is big, and I guess there are parts that can be made more
in postgres way, then I did them. And I would need an advice there, and I
guess it would be better to do if before sending it to commitfest.
Current patch status:
1. It is Beta. Some minor issues and FIXMEs are not solved. Some code comments
needs revising, but in general it do what it is intended to do.
2. This patch does not intend to change postgres behavior at all, all should
work as before, all changes are internal only.
The only exception is error message for unexciting option name in toast
namespace
CREATE TABLE reloptions_test2 (i int) WITH (toast.not_existing_option = 42);
-ERROR: unrecognized parameter "not_existing_option"
+ERROR: unrecognized parameter "toast.not_existing_option"
New message is better I guess, though I can change it back if needed.
3. I am doing my development in this blanch https://gitlab.com/dhyannataraj/
postgres/-/tree/new_options_take_two I am making changes every day, so last
version will be available there
Would be glad to hear from coreteam before I finish with this patch and made it
ready for commit-fest.
Attachment
Uh, the core team does not get involved in development issues, unless there is a issue that clearly cannot be resolved by discussion on the hackers list. --------------------------------------------------------------------------- On Mon, Oct 18, 2021 at 04:24:23PM +0300, Nikolay Shaplov wrote: > Hi! > > I am still hoping to finish my work on reloptions I've started some years ago. > > I've renewed my patch and I think I need help from core team to finish it. > > General idea of the patch: Now we have three ways to define options for > different objects, with more or less different code used for it. It wold be > better to have unified context independent API for processing options, instead. > > Long story short: > > There is Option Specification object, that has all information about single > option, how it should be parsed and validated. > > There is Option Specification Set object, an array of Option Specs, that defines > all options available for certain object (am of some index for example). > > When some object (relation, opclass, etc) wants to have an options, it > creates an Option Spec Set for there options, and uses it for converting > options between different representations (to get is from SQL, to store it in > pg_class, to pass it to the core code as bytea etc) > > For indexes Option Spec Set is available via Access Method API. > > For non-index relations all Option Spec Sets are left in reloption.c file, and > should be moved to heap AM later. (They are not in AM now so will not change > it now) > > Main problem: > > There are LockModes. LockModes for options is also stored in Option Spec Set. > For indexes Option Spec Sec is accessable via AM. So to get LockMode for > option of an index you need to have access for it's relation object (so you > can call proper AM method to fetch spec set). So you need "Relation rel" in > AlterTableGetRelOptionsLockLevel where Lock Level is determinated (src/ > backend/access/common/reloptions.c) > AlterTableGetRelOptionsLockLevel is called from AlterTableGetLockLevel (src/ > backend/commands/tablecmds.c) so we need "Relation rel" there too. > AlterTableGetLockLevel is called from AlterTableInternal (/src/backend/ > commands/tablecmds.c) There we have "Oid relid" so we can try to open relation > like this > > Relation rel = relation_open(relid, NoLock); > cmd_lockmode = AlterTableGetRelOptionsLockLevel(rel, > castNode(List, cmd->def)); > relation_close(rel,NoLock); > break; > > but this will trigger the assertion > > Assert(lockmode != NoLock || > IsBootstrapProcessingMode() || > CheckRelationLockedByMe(r, c, true)); > > in relation_open (b/src/backend/access/common/relation.c) > > For now I've commented this assertion out. I've tried to open relation with > AccessShareLock but this caused one test to fail, and I am not sure this > solution is better. > > What I have done here I consider a hack, so I need a help of core-team here to > do it in right way. > > General problems: > > I guess I need a coauthor, or supervisor from core team, to finish this patch. > The amount of code is big, and I guess there are parts that can be made more > in postgres way, then I did them. And I would need an advice there, and I > guess it would be better to do if before sending it to commitfest. > > > Current patch status: > > 1. It is Beta. Some minor issues and FIXMEs are not solved. Some code comments > needs revising, but in general it do what it is intended to do. > > 2. This patch does not intend to change postgres behavior at all, all should > work as before, all changes are internal only. > > The only exception is error message for unexciting option name in toast > namespace > > CREATE TABLE reloptions_test2 (i int) WITH (toast.not_existing_option = 42); > -ERROR: unrecognized parameter "not_existing_option" > +ERROR: unrecognized parameter "toast.not_existing_option" > > New message is better I guess, though I can change it back if needed. > > 3. I am doing my development in this blanch https://gitlab.com/dhyannataraj/ > postgres/-/tree/new_options_take_two I am making changes every day, so last > version will be available there > > Would be glad to hear from coreteam before I finish with this patch and made it > ready for commit-fest. > > > diff --git a/contrib/bloom/bloom.h b/contrib/bloom/bloom.h > index a22a6df..8f2d5e7 100644 > --- a/contrib/bloom/bloom.h > +++ b/contrib/bloom/bloom.h > @@ -17,6 +17,7 @@ > #include "access/generic_xlog.h" > #include "access/itup.h" > #include "access/xlog.h" > +#include "access/options.h" > #include "fmgr.h" > #include "nodes/pathnodes.h" > > @@ -207,7 +208,8 @@ extern IndexBulkDeleteResult *blbulkdelete(IndexVacuumInfo *info, > void *callback_state); > extern IndexBulkDeleteResult *blvacuumcleanup(IndexVacuumInfo *info, > IndexBulkDeleteResult *stats); > -extern bytea *bloptions(Datum reloptions, bool validate); > +extern void *blrelopt_specset(void); > +extern void blReloptionPostprocess(void *, bool validate); > extern void blcostestimate(PlannerInfo *root, IndexPath *path, > double loop_count, Cost *indexStartupCost, > Cost *indexTotalCost, Selectivity *indexSelectivity, > diff --git a/contrib/bloom/blutils.c b/contrib/bloom/blutils.c > index 754de00..54dad16 100644 > --- a/contrib/bloom/blutils.c > +++ b/contrib/bloom/blutils.c > @@ -15,7 +15,7 @@ > > #include "access/amapi.h" > #include "access/generic_xlog.h" > -#include "access/reloptions.h" > +#include "access/options.h" > #include "bloom.h" > #include "catalog/index.h" > #include "commands/vacuum.h" > @@ -34,53 +34,13 @@ > > PG_FUNCTION_INFO_V1(blhandler); > > -/* Kind of relation options for bloom index */ > -static relopt_kind bl_relopt_kind; > - > -/* parse table for fillRelOptions */ > -static relopt_parse_elt bl_relopt_tab[INDEX_MAX_KEYS + 1]; > +/* Catalog of relation options for bloom index */ > +static options_spec_set *bl_relopt_specset; > > static int32 myRand(void); > static void mySrand(uint32 seed); > > /* > - * Module initialize function: initialize info about Bloom relation options. > - * > - * Note: keep this in sync with makeDefaultBloomOptions(). > - */ > -void > -_PG_init(void) > -{ > - int i; > - char buf[16]; > - > - bl_relopt_kind = add_reloption_kind(); > - > - /* Option for length of signature */ > - add_int_reloption(bl_relopt_kind, "length", > - "Length of signature in bits", > - DEFAULT_BLOOM_LENGTH, 1, MAX_BLOOM_LENGTH, > - AccessExclusiveLock); > - bl_relopt_tab[0].optname = "length"; > - bl_relopt_tab[0].opttype = RELOPT_TYPE_INT; > - bl_relopt_tab[0].offset = offsetof(BloomOptions, bloomLength); > - > - /* Number of bits for each possible index column: col1, col2, ... */ > - for (i = 0; i < INDEX_MAX_KEYS; i++) > - { > - snprintf(buf, sizeof(buf), "col%d", i + 1); > - add_int_reloption(bl_relopt_kind, buf, > - "Number of bits generated for each index column", > - DEFAULT_BLOOM_BITS, 1, MAX_BLOOM_BITS, > - AccessExclusiveLock); > - bl_relopt_tab[i + 1].optname = MemoryContextStrdup(TopMemoryContext, > - buf); > - bl_relopt_tab[i + 1].opttype = RELOPT_TYPE_INT; > - bl_relopt_tab[i + 1].offset = offsetof(BloomOptions, bitSize[0]) + sizeof(int) * i; > - } > -} > - > -/* > * Construct a default set of Bloom options. > */ > static BloomOptions * > @@ -135,7 +95,7 @@ blhandler(PG_FUNCTION_ARGS) > amroutine->amvacuumcleanup = blvacuumcleanup; > amroutine->amcanreturn = NULL; > amroutine->amcostestimate = blcostestimate; > - amroutine->amoptions = bloptions; > + amroutine->amreloptspecset = blrelopt_specset; > amroutine->amproperty = NULL; > amroutine->ambuildphasename = NULL; > amroutine->amvalidate = blvalidate; > @@ -154,6 +114,28 @@ blhandler(PG_FUNCTION_ARGS) > PG_RETURN_POINTER(amroutine); > } > > +void > +blReloptionPostprocess(void *data, bool validate) > +{ > + BloomOptions *opts = (BloomOptions *) data; > + int i; > + > + if (validate) > + for (i = 0; i < INDEX_MAX_KEYS; i++) > + { > + if (opts->bitSize[i] >= opts->bloomLength) > + { > + ereport(ERROR, > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > + errmsg("col%i should not be grater than length", i))); > + } > + } > + > + /* Convert signature length from # of bits to # to words, rounding up */ > + opts->bloomLength = (opts->bloomLength + SIGNWORDBITS - 1) / SIGNWORDBITS; > +} > + > + > /* > * Fill BloomState structure for particular index. > */ > @@ -474,24 +456,39 @@ BloomInitMetapage(Relation index) > UnlockReleaseBuffer(metaBuffer); > } > > -/* > - * Parse reloptions for bloom index, producing a BloomOptions struct. > - */ > -bytea * > -bloptions(Datum reloptions, bool validate) > +void * > +blrelopt_specset(void) > { > - BloomOptions *rdopts; > + int i; > + char buf[16]; > > - /* Parse the user-given reloptions */ > - rdopts = (BloomOptions *) build_reloptions(reloptions, validate, > - bl_relopt_kind, > - sizeof(BloomOptions), > - bl_relopt_tab, > - lengthof(bl_relopt_tab)); > + if (bl_relopt_specset) > + return bl_relopt_specset; > > - /* Convert signature length from # of bits to # to words, rounding up */ > - if (rdopts) > - rdopts->bloomLength = (rdopts->bloomLength + SIGNWORDBITS - 1) / SIGNWORDBITS; > > - return (bytea *) rdopts; > + bl_relopt_specset = allocateOptionsSpecSet(NULL, > + sizeof(BloomOptions), INDEX_MAX_KEYS + 1); > + bl_relopt_specset->postprocess_fun = blReloptionPostprocess; > + > + optionsSpecSetAddInt(bl_relopt_specset, "length", > + "Length of signature in bits", > + NoLock, /* No lock as far as ALTER is > + * forbidden */ > + 0, > + offsetof(BloomOptions, bloomLength), > + DEFAULT_BLOOM_LENGTH, 1, MAX_BLOOM_LENGTH); > + > + /* Number of bits for each possible index column: col1, col2, ... */ > + for (i = 0; i < INDEX_MAX_KEYS; i++) > + { > + snprintf(buf, 16, "col%d", i + 1); > + optionsSpecSetAddInt(bl_relopt_specset, buf, > + "Number of bits for corresponding column", > + NoLock, /* No lock as far as ALTER is > + * forbidden */ > + 0, > + offsetof(BloomOptions, bitSize[i]), > + DEFAULT_BLOOM_BITS, 1, MAX_BLOOM_BITS); > + } > + return bl_relopt_specset; > } > diff --git a/contrib/bloom/expected/bloom.out b/contrib/bloom/expected/bloom.out > index dae12a7..e79456d 100644 > --- a/contrib/bloom/expected/bloom.out > +++ b/contrib/bloom/expected/bloom.out > @@ -228,3 +228,6 @@ CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH (length=0); > ERROR: value 0 out of bounds for option "length" > CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH (col1=0); > ERROR: value 0 out of bounds for option "col1" > +-- check post_validate for colN<lengh > +CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH (length=10,col1=11); > +ERROR: col0 should not be grater than length > diff --git a/contrib/bloom/sql/bloom.sql b/contrib/bloom/sql/bloom.sql > index 4733e1e..0bfc767 100644 > --- a/contrib/bloom/sql/bloom.sql > +++ b/contrib/bloom/sql/bloom.sql > @@ -93,3 +93,6 @@ SELECT reloptions FROM pg_class WHERE oid = 'bloomidx'::regclass; > \set VERBOSITY terse > CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH (length=0); > CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH (col1=0); > + > +-- check post_validate for colN<lengh > +CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH (length=10,col1=11); > diff --git a/contrib/dblink/dblink.c b/contrib/dblink/dblink.c > index 3a0beaa..a15a10b 100644 > --- a/contrib/dblink/dblink.c > +++ b/contrib/dblink/dblink.c > @@ -2005,7 +2005,7 @@ PG_FUNCTION_INFO_V1(dblink_fdw_validator); > Datum > dblink_fdw_validator(PG_FUNCTION_ARGS) > { > - List *options_list = untransformRelOptions(PG_GETARG_DATUM(0)); > + List *options_list = optionsTextArrayToDefList(PG_GETARG_DATUM(0)); > Oid context = PG_GETARG_OID(1); > ListCell *cell; > > diff --git a/contrib/file_fdw/file_fdw.c b/contrib/file_fdw/file_fdw.c > index 2c2f149..1194747 100644 > --- a/contrib/file_fdw/file_fdw.c > +++ b/contrib/file_fdw/file_fdw.c > @@ -195,7 +195,7 @@ file_fdw_handler(PG_FUNCTION_ARGS) > Datum > file_fdw_validator(PG_FUNCTION_ARGS) > { > - List *options_list = untransformRelOptions(PG_GETARG_DATUM(0)); > + List *options_list = optionsTextArrayToDefList(PG_GETARG_DATUM(0)); > Oid catalog = PG_GETARG_OID(1); > char *filename = NULL; > DefElem *force_not_null = NULL; > diff --git a/contrib/postgres_fdw/option.c b/contrib/postgres_fdw/option.c > index 5bb1af4..bbd4167 100644 > --- a/contrib/postgres_fdw/option.c > +++ b/contrib/postgres_fdw/option.c > @@ -72,7 +72,7 @@ PG_FUNCTION_INFO_V1(postgres_fdw_validator); > Datum > postgres_fdw_validator(PG_FUNCTION_ARGS) > { > - List *options_list = untransformRelOptions(PG_GETARG_DATUM(0)); > + List *options_list = optionsTextArrayToDefList(PG_GETARG_DATUM(0)); > Oid catalog = PG_GETARG_OID(1); > ListCell *cell; > > diff --git a/src/backend/access/brin/brin.c b/src/backend/access/brin/brin.c > index ccc9fa0..5dd52a4 100644 > --- a/src/backend/access/brin/brin.c > +++ b/src/backend/access/brin/brin.c > @@ -20,7 +20,6 @@ > #include "access/brin_pageops.h" > #include "access/brin_xlog.h" > #include "access/relation.h" > -#include "access/reloptions.h" > #include "access/relscan.h" > #include "access/table.h" > #include "access/tableam.h" > @@ -40,7 +39,6 @@ > #include "utils/memutils.h" > #include "utils/rel.h" > > - > /* > * We use a BrinBuildState during initial construction of a BRIN index. > * The running state is kept in a BrinMemTuple. > @@ -119,7 +117,6 @@ brinhandler(PG_FUNCTION_ARGS) > amroutine->amvacuumcleanup = brinvacuumcleanup; > amroutine->amcanreturn = NULL; > amroutine->amcostestimate = brincostestimate; > - amroutine->amoptions = brinoptions; > amroutine->amproperty = NULL; > amroutine->ambuildphasename = NULL; > amroutine->amvalidate = brinvalidate; > @@ -134,6 +131,7 @@ brinhandler(PG_FUNCTION_ARGS) > amroutine->amestimateparallelscan = NULL; > amroutine->aminitparallelscan = NULL; > amroutine->amparallelrescan = NULL; > + amroutine->amreloptspecset = bringetreloptspecset; > > PG_RETURN_POINTER(amroutine); > } > @@ -963,23 +961,6 @@ brinvacuumcleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *stats) > } > > /* > - * reloptions processor for BRIN indexes > - */ > -bytea * > -brinoptions(Datum reloptions, bool validate) > -{ > - static const relopt_parse_elt tab[] = { > - {"pages_per_range", RELOPT_TYPE_INT, offsetof(BrinOptions, pagesPerRange)}, > - {"autosummarize", RELOPT_TYPE_BOOL, offsetof(BrinOptions, autosummarize)} > - }; > - > - return (bytea *) build_reloptions(reloptions, validate, > - RELOPT_KIND_BRIN, > - sizeof(BrinOptions), > - tab, lengthof(tab)); > -} > - > -/* > * SQL-callable function to scan through an index and summarize all ranges > * that are not currently summarized. > */ > @@ -1765,3 +1746,32 @@ check_null_keys(BrinValues *bval, ScanKey *nullkeys, int nnullkeys) > > return true; > } > + > +static options_spec_set *brin_relopt_specset = NULL; > + > +void * > +bringetreloptspecset(void) > +{ > + if (brin_relopt_specset) > + return brin_relopt_specset; > + brin_relopt_specset = allocateOptionsSpecSet(NULL, > + sizeof(BrinOptions), 2); > + > + optionsSpecSetAddInt(brin_relopt_specset, "pages_per_range", > + "Number of pages that each page range covers in a BRIN index", > + NoLock, /* since ALTER is not allowed > + * no lock needed */ > + 0, > + offsetof(BrinOptions, pagesPerRange), > + BRIN_DEFAULT_PAGES_PER_RANGE, > + BRIN_MIN_PAGES_PER_RANGE, > + BRIN_MAX_PAGES_PER_RANGE); > + optionsSpecSetAddBool(brin_relopt_specset, "autosummarize", > + "Enables automatic summarization on this BRIN index", > + AccessExclusiveLock, > + 0, > + offsetof(BrinOptions, autosummarize), > + false); > + return brin_relopt_specset; > +} > + > diff --git a/src/backend/access/brin/brin_pageops.c b/src/backend/access/brin/brin_pageops.c > index df9ffc2..1940b3d 100644 > --- a/src/backend/access/brin/brin_pageops.c > +++ b/src/backend/access/brin/brin_pageops.c > @@ -420,6 +420,9 @@ brin_doinsert(Relation idxrel, BlockNumber pagesPerRange, > freespace = br_page_get_freespace(page); > > ItemPointerSet(&tid, blk, off); > + > +//elog(WARNING, "pages_per_range = %i", pagesPerRange); > + > brinSetHeapBlockItemptr(revmapbuf, pagesPerRange, heapBlk, tid); > MarkBufferDirty(revmapbuf); > > diff --git a/src/backend/access/common/Makefile b/src/backend/access/common/Makefile > index b9aff0c..78c9c5a 100644 > --- a/src/backend/access/common/Makefile > +++ b/src/backend/access/common/Makefile > @@ -18,6 +18,7 @@ OBJS = \ > detoast.o \ > heaptuple.o \ > indextuple.o \ > + options.o \ > printsimple.o \ > printtup.o \ > relation.o \ > diff --git a/src/backend/access/common/options.c b/src/backend/access/common/options.c > new file mode 100644 > index 0000000..752cddc > --- /dev/null > +++ b/src/backend/access/common/options.c > @@ -0,0 +1,1468 @@ > +/*------------------------------------------------------------------------- > + * > + * options.c > + * An unifom, context-free API for processing name=value options. Used > + * to process relation optons (reloptions), attribute options, opclass > + * options, etc. > + * > + * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group > + * Portions Copyright (c) 1994, Regents of the University of California > + * > + * > + * IDENTIFICATION > + * src/backend/access/common/options.c > + * > + *------------------------------------------------------------------------- > + */ > + > +#include "postgres.h" > + > +#include "access/options.h" > +#include "catalog/pg_type.h" > +#include "commands/defrem.h" > +#include "nodes/makefuncs.h" > +#include "utils/builtins.h" > +#include "utils/guc.h" > +#include "utils/memutils.h" > +#include "mb/pg_wchar.h" > + > + > +/* > + * OPTIONS SPECIFICATION and OPTION SPECIFICATION SET > + * > + * Each option is defined via Option Specification object (Option Spec). > + * Option Spec should have all information that is needed for processing > + * (parsing, validating, converting) of a single option. Implemented via set of > + * option_spec_* structures. > + * > + * A set of Option Specs (Options Spec Set), defines all options available for > + * certain object (certain relation kind for example). It is a list of > + * Options Specs, plus validation functions that can be used to validate whole > + * option set, if needed. Implemenred via options_spec_set structure and set of > + * optionsSpecSetAdd* functions that are used for adding Option Specs items to > + * a Set. > + * > + * NOTE: we choose therm "sepcification" instead of "definition" because therm > + * "definition" is used for objects that came from lexer. So to avoud confusion > + * here we have Option Specifications, and all "definitions" are from lexer. > + */ > + > +/* > + * OPTION VALUES REPRESENTATIONS > + * > + * Option values usually came from lexer in form of defList obect, stored in > + * pg_catalog as text array, and used when they are stored in memory as > + * C-structure. These are different option values representations. Here goes > + * brief description of all representations used in the code. > + * > + * Values > + * > + * Values are an internal representation that is used while converting > + * Values between other representation. Value is called "parsed", > + * when Value's value is converted to a proper type and validated, or is called > + * "unparsed", when Value's value is stored as raw string that was obtained > + * from the source without any cheks. In convertation funcion names first case > + * is refered as Values, second case is refered as RawValues. Values is > + * implemented as List of option_value C-structures. > + * > + * defList > + * > + * Options in form of definition List that comes from lexer. (For reloptions it > + * is a part of SQL query that goes after WITH, SET or RESET keywords). Can be > + * converted to and from Values using optionsDefListToRawValues and > + * optionsTextArrayToRawValues functions. > + * > + * TEXT[] > + * > + * Options in form suitable for storig in TEXT[] field in DB. (E.g. reloptions > + * are stores in pg_catalog.pg_class table in reloptions field). Can be converted > + * to and from Values using optionsValuesToTextArray and optionsTextArrayToRawValues > + * functions. > + * > + * Bytea > + * > + * Option data stored in C-structure with varlena header in the beginning of the > + * structure. This representation is used to pass option values to the core > + * postgres. It is fast to read, it can be cached and so on. Bytea rpresentation > + * can be obtained from Vales using optionsValuesToBytea function, and can't be > + * converted back. > + */ > + > +static option_spec_basic *allocateOptionSpec(int type, const char *name, > + const char *desc, LOCKMODE lockmode, > + option_spec_flags flags, int struct_offset); > + > +static void parse_one_option(option_value * option, const char *text_str, > + int text_len, bool validate); > +static void *optionsAllocateBytea(options_spec_set * spec_set, List *options); > + > + > +static List * > +optionsDefListToRawValues(List *defList, options_parse_mode > + parse_mode); > +static Datum optionsValuesToTextArray(List *options_values); > +static List *optionsMergeOptionValues(List *old_options, List *new_options); > +static bytea *optionsValuesToBytea(List *options, options_spec_set * spec_set); > +List *optionsTextArrayToRawValues(Datum array_datum); > +List *optionsParseRawValues(List *raw_values, options_spec_set * spec_set, > + options_parse_mode mode); > + > + > +/* > + * Options spec_set functions > + */ > + > +/* > + * Options catalog describes options available for certain object. Catalog has > + * all necessary information for parsing transforming and validating options > + * for an object. All parsing/validation/transformation functions should not > + * know any details of option implementation for certain object, all this > + * information should be stored in catalog instead and interpreted by > + * pars/valid/transf functions blindly. > + * > + * The heart of the option catalog is an array of option definitions. Options > + * definition specifies name of option, type, range of acceptable values, and > + * default value. > + * > + * Options values can be one of the following types: bool, int, real, enum, > + * string. For more info see "option_type" and "optionsCatalogAddItemYyyy" > + * functions. > + * > + * Option definition flags allows to define parser behavior for special (or not > + * so special) cases. See option_spec_flags for more info. > + * > + * Options and Lock levels: > + * > + * The default choice for any new option should be AccessExclusiveLock. > + * In some cases the lock level can be reduced from there, but the lock > + * level chosen should always conflict with itself to ensure that multiple > + * changes aren't lost when we attempt concurrent changes. > + * The choice of lock level depends completely upon how that parameter > + * is used within the server, not upon how and when you'd like to change it. > + * Safety first. Existing choices are documented here, and elsewhere in > + * backend code where the parameters are used. > + * > + * In general, anything that affects the results obtained from a SELECT must be > + * protected by AccessExclusiveLock. > + * > + * Autovacuum related parameters can be set at ShareUpdateExclusiveLock > + * since they are only used by the AV procs and don't change anything > + * currently executing. > + * > + * Fillfactor can be set because it applies only to subsequent changes made to > + * data blocks, as documented in heapio.c > + * > + * n_distinct options can be set at ShareUpdateExclusiveLock because they > + * are only used during ANALYZE, which uses a ShareUpdateExclusiveLock, > + * so the ANALYZE will not be affected by in-flight changes. Changing those > + * values has no affect until the next ANALYZE, so no need for stronger lock. > + * > + * Planner-related parameters can be set with ShareUpdateExclusiveLock because > + * they only affect planning and not the correctness of the execution. Plans > + * cannot be changed in mid-flight, so changes here could not easily result in > + * new improved plans in any case. So we allow existing queries to continue > + * and existing plans to survive, a small price to pay for allowing better > + * plans to be introduced concurrently without interfering with users. > + * > + * Setting parallel_workers is safe, since it acts the same as > + * max_parallel_workers_per_gather which is a USERSET parameter that doesn't > + * affect existing plans or queries. > +*/ > + > +/* > + * allocateOptionsSpecSet > + * Creates new Option Spec Set object: Allocates memory and initializes > + * structure members. > + * > + * Spec Set items can be add via allocateOptionSpec and optionSpecSetAddItem functions > + * or by calling directly any of optionsSpecSetAdd* function (preferable way) > + * > + * namespace - Spec Set can be bind to certain namespace (E.g. > + * namespace.option=value). Options from other namespaces will be ignored while > + * processing. If set to NULL, no namespace will be used at all. > + * > + * size_of_bytea - size of target structure of Bytea options represenation > + * > + * num_items_expected - if you know expected number of Spec Set items set it here. > + * Set to -1 in other cases. num_items_expected will be used for preallocating memory > + * and will trigger error, if you try to add more items than you expected. > + */ > + > +options_spec_set * > +allocateOptionsSpecSet(const char *namespace, int size_of_bytea, int num_items_expected) > +{ > + MemoryContext oldcxt; > + options_spec_set *spec_set; > + > + oldcxt = MemoryContextSwitchTo(TopMemoryContext); > + spec_set = palloc(sizeof(options_spec_set)); > + if (namespace) > + { > + spec_set->namespace = palloc(strlen(namespace) + 1); > + strcpy(spec_set->namespace, namespace); > + } > + else > + spec_set->namespace = NULL; > + if (num_items_expected > 0) > + { > + spec_set->num_allocated = num_items_expected; > + spec_set->forbid_realloc = true; > + spec_set->definitions = palloc( > + spec_set->num_allocated * sizeof(option_spec_basic *)); > + } > + else > + { > + spec_set->num_allocated = 0; > + spec_set->forbid_realloc = false; > + spec_set->definitions = NULL; > + } > + spec_set->num = 0; > + spec_set->struct_size = size_of_bytea; > + spec_set->postprocess_fun = NULL; > + MemoryContextSwitchTo(oldcxt); > + return spec_set; > +} > + > +/* > + * allocateOptionSpec > + * Allocates a new Option Specifiation object of desired type and > + * initialize the type-independent fields > + */ > +static option_spec_basic * > +allocateOptionSpec(int type, const char *name, const char *desc, LOCKMODE lockmode, > + option_spec_flags flags, int struct_offset) > +{ > + MemoryContext oldcxt; > + size_t size; > + option_spec_basic *newoption; > + > + oldcxt = MemoryContextSwitchTo(TopMemoryContext); > + > + switch (type) > + { > + case OPTION_TYPE_BOOL: > + size = sizeof(option_spec_bool); > + break; > + case OPTION_TYPE_INT: > + size = sizeof(option_spec_int); > + break; > + case OPTION_TYPE_REAL: > + size = sizeof(option_spec_real); > + break; > + case OPTION_TYPE_ENUM: > + size = sizeof(option_spec_enum); > + break; > + case OPTION_TYPE_STRING: > + size = sizeof(option_spec_string); > + break; > + default: > + elog(ERROR, "unsupported reloption type %d", type); > + return NULL; /* keep compiler quiet */ > + } > + > + newoption = palloc(size); > + > + newoption->name = pstrdup(name); > + if (desc) > + newoption->desc = pstrdup(desc); > + else > + newoption->desc = NULL; > + newoption->type = type; > + newoption->lockmode = lockmode; > + newoption->flags = flags; > + newoption->struct_offset = struct_offset; > + > + MemoryContextSwitchTo(oldcxt); > + > + return newoption; > +} > + > +/* > + * optionSpecSetAddItem > + * Adds pre-created Option Specification objec to the Spec Set > + */ > +static void > +optionSpecSetAddItem(option_spec_basic * newoption, > + options_spec_set * spec_set) > +{ > + if (spec_set->num >= spec_set->num_allocated) > + { > + MemoryContext oldcxt; > + > + Assert(!spec_set->forbid_realloc); > + oldcxt = MemoryContextSwitchTo(TopMemoryContext); > + > + if (spec_set->num_allocated == 0) > + { > + spec_set->num_allocated = 8; > + spec_set->definitions = palloc( > + spec_set->num_allocated * sizeof(option_spec_basic *)); > + } > + else > + { > + spec_set->num_allocated *= 2; > + spec_set->definitions = repalloc(spec_set->definitions, > + spec_set->num_allocated * sizeof(option_spec_basic *)); > + } > + MemoryContextSwitchTo(oldcxt); > + } > + spec_set->definitions[spec_set->num] = newoption; > + spec_set->num++; > +} > + > + > +/* > + * optionsSpecSetAddBool > + * Adds boolean Option Specification entry to the Spec Set > + */ > +void > +optionsSpecSetAddBool(options_spec_set * spec_set, const char *name, const char *desc, > + LOCKMODE lockmode, option_spec_flags flags, > + int struct_offset, bool default_val) > +{ > + option_spec_bool *spec_set_item; > + > + spec_set_item = (option_spec_bool *) > + allocateOptionSpec(OPTION_TYPE_BOOL, name, desc, lockmode, > + flags, struct_offset); > + > + spec_set_item->default_val = default_val; > + > + optionSpecSetAddItem((option_spec_basic *) spec_set_item, spec_set); > +} > + > +/* > + * optionsSpecSetAddInt > + * Adds integer Option Specification entry to the Spec Set > + */ > +void > +optionsSpecSetAddInt(options_spec_set * spec_set, const char *name, > + const char *desc, LOCKMODE lockmode, option_spec_flags flags, > + int struct_offset, int default_val, int min_val, int max_val) > +{ > + option_spec_int *spec_set_item; > + > + spec_set_item = (option_spec_int *) > + allocateOptionSpec(OPTION_TYPE_INT, name, desc, lockmode, > + flags, struct_offset); > + > + spec_set_item->default_val = default_val; > + spec_set_item->min = min_val; > + spec_set_item->max = max_val; > + > + optionSpecSetAddItem((option_spec_basic *) spec_set_item, spec_set); > +} > + > +/* > + * optionsSpecSetAddReal > + * Adds float Option Specification entry to the Spec Set > + */ > +void > +optionsSpecSetAddReal(options_spec_set * spec_set, const char *name, const char *desc, > + LOCKMODE lockmode, option_spec_flags flags, int struct_offset, > + double default_val, double min_val, double max_val) > +{ > + option_spec_real *spec_set_item; > + > + spec_set_item = (option_spec_real *) > + allocateOptionSpec(OPTION_TYPE_REAL, name, desc, lockmode, > + flags, struct_offset); > + > + spec_set_item->default_val = default_val; > + spec_set_item->min = min_val; > + spec_set_item->max = max_val; > + > + optionSpecSetAddItem((option_spec_basic *) spec_set_item, spec_set); > +} > + > +/* > + * optionsSpecSetAddEnum > + * Adds enum Option Specification entry to the Spec Set > + * > + * The members array must have a terminating NULL entry. > + * > + * The detailmsg is shown when unsupported values are passed, and has this > + * form: "Valid values are \"foo\", \"bar\", and \"bar\"." > + * > + * The members array and detailmsg are not copied -- caller must ensure that > + * they are valid throughout the life of the process. > + */ > + > +void > +optionsSpecSetAddEnum(options_spec_set * spec_set, const char *name, const char *desc, > + LOCKMODE lockmode, option_spec_flags flags, int struct_offset, > + opt_enum_elt_def * members, int default_val, const char *detailmsg) > +{ > + option_spec_enum *spec_set_item; > + > + spec_set_item = (option_spec_enum *) > + allocateOptionSpec(OPTION_TYPE_ENUM, name, desc, lockmode, > + flags, struct_offset); > + > + spec_set_item->default_val = default_val; > + spec_set_item->members = members; > + spec_set_item->detailmsg = detailmsg; > + > + optionSpecSetAddItem((option_spec_basic *) spec_set_item, spec_set); > +} > + > +/* > + * optionsSpecSetAddString > + * Adds string Option Specification entry to the Spec Set > + * > + * "validator" is an optional function pointer that can be used to test the > + * validity of the values. It must elog(ERROR) when the argument string is > + * not acceptable for the variable. Note that the default value must pass > + * the validation. > + */ > +void > +optionsSpecSetAddString(options_spec_set * spec_set, const char *name, const char *desc, > + LOCKMODE lockmode, option_spec_flags flags, int struct_offset, > + const char *default_val, validate_string_option validator) > +{ > + option_spec_string *spec_set_item; > + > + /* make sure the validator/default combination is sane */ > + if (validator) > + (validator) (default_val); > + > + spec_set_item = (option_spec_string *) > + allocateOptionSpec(OPTION_TYPE_STRING, name, desc, lockmode, > + flags, struct_offset); > + spec_set_item->validate_cb = validator; > + > + if (default_val) > + spec_set_item->default_val = MemoryContextStrdup(TopMemoryContext, > + default_val); > + else > + spec_set_item->default_val = NULL; > + optionSpecSetAddItem((option_spec_basic *) spec_set_item, spec_set); > +} > + > + > +/* > + * Options transform functions > + */ > + > +/* FIXME this comment should be updated > + * Option values exists in five representations: DefList, TextArray, Values and > + * Bytea: > + * > + * DefList: Is a List of DefElem structures, that comes from syntax analyzer. > + * It can be transformed to Values representation for further parsing and > + * validating > + * > + * Values: A List of option_value structures. Is divided into two subclasses: > + * RawValues, when values are already transformed from DefList or TextArray, > + * but not parsed yet. (In this case you should use raw_name and raw_value > + * structure members to see option content). ParsedValues (or just simple > + * Values) is crated after finding a definition for this option in a spec_set > + * and after parsing of the raw value. For ParsedValues content is stored in > + * values structure member, and name can be taken from option definition in gen > + * structure member. Actually Value list can have both Raw and Parsed values, > + * as we do not validate options that came from database, and db option that > + * does not exist in spec_set is just ignored, and kept as RawValues > + * > + * TextArray: The representation in which options for existing object comes > + * and goes from/to database; for example from pg_class.reloptions. It is a > + * plain TEXT[] db object with name=value text inside. This representation can > + * be transformed into Values for further processing, using options spec_set. > + * > + * Bytea: Is a binary representation of options. Each object that has code that > + * uses options, should create a C-structure for this options, with varlen > + * 4-byte header in front of the data; all items of options spec_set should have > + * an offset of a corresponding binary data in this structure, so transform > + * function can put this data in the correct place. One can transform options > + * data from values representation into Bytea, using spec_set data, and then use > + * it as a usual Datum object, when needed. This Datum should be cached > + * somewhere (for example in rel->rd_options for relations) when object that > + * has option is loaded from db. > + */ > + > + > +/* optionsDefListToRawValues > + * Converts option values that came from syntax analyzer (DefList) into > + * Values List. > + * > + * No parsing is done here except for checking that RESET syntax is correct > + * (syntax analyzer do not see difference between SET and RESET cases, we > + * should treat it here manually > + */ > +static List * > +optionsDefListToRawValues(List *defList, options_parse_mode parse_mode) > +{ > + ListCell *cell; > + List *result = NIL; > + > + foreach(cell, defList) > + { > + option_value *option_dst; > + DefElem *def = (DefElem *) lfirst(cell); > + char *value; > + > + option_dst = palloc(sizeof(option_value)); > + > + if (def->defnamespace) > + { > + option_dst->namespace = palloc(strlen(def->defnamespace) + 1); > + strcpy(option_dst->namespace, def->defnamespace); > + } > + else > + { > + option_dst->namespace = NULL; > + } > + option_dst->raw_name = palloc(strlen(def->defname) + 1); > + strcpy(option_dst->raw_name, def->defname); > + > + if (parse_mode & OPTIONS_PARSE_MODE_FOR_RESET) > + { > + /* > + * If this option came from RESET statement we should throw error > + * it it brings us name=value data, as syntax analyzer do not > + * prevent it > + */ > + if (def->arg != NULL) > + ereport(ERROR, > + (errcode(ERRCODE_SYNTAX_ERROR), > + errmsg("RESET must not include values for parameters"))); > + > + option_dst->status = OPTION_VALUE_STATUS_FOR_RESET; > + } > + else > + { > + /* > + * For SET statement we should treat (name) expression as if it is > + * actually (name=true) so do it here manually. In other cases > + * just use value as we should use it > + */ > + option_dst->status = OPTION_VALUE_STATUS_RAW; > + if (def->arg != NULL) > + value = defGetString(def); > + else > + value = "true"; > + option_dst->raw_value = palloc(strlen(value) + 1); > + strcpy(option_dst->raw_value, value); > + } > + > + result = lappend(result, option_dst); > + } > + return result; > +} > + > +/* > + * optionsValuesToTextArray > + * Converts List of option_values into TextArray > + * > + * Convertation is made to put options into database (e.g. in > + * pg_class.reloptions for all relation options) > + */ > + > +Datum > +optionsValuesToTextArray(List *options_values) > +{ > + ArrayBuildState *astate = NULL; > + ListCell *cell; > + Datum result; > + > + foreach(cell, options_values) > + { > + option_value *option = (option_value *) lfirst(cell); > + const char *name; > + char *value; > + text *t; > + int len; > + > + /* > + * Raw value were not cleared while parsing, so instead of converting > + * it back, just use it to store value as text > + */ > + value = option->raw_value; > + > + Assert(option->status != OPTION_VALUE_STATUS_EMPTY); > + > + /* > + * Name will be taken from option definition, if option were parsed or > + * from raw_name if option were not parsed for some reason > + */ > + if (option->status == OPTION_VALUE_STATUS_PARSED) > + name = option->gen->name; > + else > + name = option->raw_name; > + > + /* > + * Now build "name=value" string and append it to the array > + */ > + len = VARHDRSZ + strlen(name) + strlen(value) + 1; > + t = (text *) palloc(len + 1); > + SET_VARSIZE(t, len); > + sprintf(VARDATA(t), "%s=%s", name, value); > + astate = accumArrayResult(astate, PointerGetDatum(t), false, > + TEXTOID, CurrentMemoryContext); > + } > + if (astate) > + result = makeArrayResult(astate, CurrentMemoryContext); > + else > + result = (Datum) 0; > + > + return result; > +} > + > +/* > + * optionsTextArrayToRawValues > + * Converts options from TextArray format into RawValues list. > + * > + * This function is used to convert options data that comes from database to > + * List of option_values, for further parsing, and, in the case of ALTER > + * command, for merging with new option values. > + */ > +List * > +optionsTextArrayToRawValues(Datum array_datum) > +{ > + List *result = NIL; > + > + if (PointerIsValid(DatumGetPointer(array_datum))) > + { > + ArrayType *array = DatumGetArrayTypeP(array_datum); > + Datum *options; > + int noptions; > + int i; > + > + deconstruct_array(array, TEXTOID, -1, false, 'i', > + &options, NULL, &noptions); > + > + for (i = 0; i < noptions; i++) > + { > + option_value *option_dst; > + char *text_str = VARDATA(options[i]); > + int text_len = VARSIZE(options[i]) - VARHDRSZ; > + int i; > + int name_len = -1; > + char *name; > + int raw_value_len; > + char *raw_value; > + > + /* > + * Find position of '=' sign and treat id as a separator between > + * name and value in "name=value" item > + */ > + for (i = 0; i < text_len; i = i + pg_mblen(text_str)) > + { > + if (text_str[i] == '=') > + { > + name_len = i; > + break; > + } > + } > + Assert(name_len >= 1); /* Just in case */ > + > + raw_value_len = text_len - name_len - 1; > + > + /* > + * Copy name from src > + */ > + name = palloc(name_len + 1); > + memcpy(name, text_str, name_len); > + name[name_len] = '\0'; > + > + /* > + * Copy value from src > + */ > + raw_value = palloc(raw_value_len + 1); > + memcpy(raw_value, text_str + name_len + 1, raw_value_len); > + raw_value[raw_value_len] = '\0'; > + > + /* > + * Create new option_value item > + */ > + option_dst = palloc(sizeof(option_value)); > + option_dst->status = OPTION_VALUE_STATUS_RAW; > + option_dst->raw_name = name; > + option_dst->raw_value = raw_value; > + option_dst->namespace = NULL; > + > + result = lappend(result, option_dst); > + } > + } > + return result; > +} > + > +/* > + * optionsMergeOptionValues > + * Merges two lists of option_values into one list > + * > + * This function is used to merge two Values list into one. It is used for all > + * kinds of ALTER commands when existing options are merged|replaced with new > + * options list. This function also process RESET variant of ALTER command. It > + * merges two lists as usual, and then removes all items with RESET flag on. > + * > + * Both incoming lists will be destroyed while merging > + */ > +static List * > +optionsMergeOptionValues(List *old_options, List *new_options) > +{ > + List *result = NIL; > + ListCell *old_cell; > + ListCell *new_cell; > + > + /* > + * First add to result all old options that are not mentioned in new list > + */ > + foreach(old_cell, old_options) > + { > + bool found; > + const char *old_name; > + option_value *old_option; > + > + old_option = (option_value *) lfirst(old_cell); > + if (old_option->status == OPTION_VALUE_STATUS_PARSED) > + old_name = old_option->gen->name; > + else > + old_name = old_option->raw_name; > + > + /* > + * Looking for a new option with same name > + */ > + found = false; > + foreach(new_cell, new_options) > + { > + option_value *new_option; > + const char *new_name; > + > + new_option = (option_value *) lfirst(new_cell); > + if (new_option->status == OPTION_VALUE_STATUS_PARSED) > + new_name = new_option->gen->name; > + else > + new_name = new_option->raw_name; > + > + if (strcmp(new_name, old_name) == 0) > + { > + found = true; > + break; > + } > + } > + if (!found) > + result = lappend(result, old_option); > + } > + /* > + * Now add all to result all new options that are not designated for reset > + */ > + foreach(new_cell, new_options) > + { > + option_value *new_option; > + new_option = (option_value *) lfirst(new_cell); > + > + if(new_option->status != OPTION_VALUE_STATUS_FOR_RESET) > + result = lappend(result, new_option); > + } > + return result; > +} > + > +/* > + * optionsDefListValdateNamespaces > + * Function checks that all options represented as DefList has no > + * namespaces or have namespaces only from allowed list > + * > + * Function accept options as DefList and NULL terminated list of allowed > + * namespaces. It throws an error if not proper namespace was found. > + * > + * This function actually used only for tables with it's toast. namespace > + */ > +void > +optionsDefListValdateNamespaces(List *defList, char **allowed_namespaces) > +{ > + ListCell *cell; > + > + foreach(cell, defList) > + { > + DefElem *def = (DefElem *) lfirst(cell); > + > + /* > + * Checking namespace only for options that have namespaces. Options > + * with no namespaces are always accepted > + */ > + if (def->defnamespace) > + { > + bool found = false; > + int i = 0; > + > + while (allowed_namespaces[i]) > + { > + if (strcmp(def->defnamespace, > + allowed_namespaces[i]) == 0) > + { > + found = true; > + break; > + } > + i++; > + } > + if (!found) > + ereport(ERROR, > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > + errmsg("unrecognized parameter namespace \"%s\"", > + def->defnamespace))); > + } > + } > +} > + > +/* > + * optionsDefListFilterNamespaces > + * Iterates over DefList, choose items with specified namespace and adds > + * them to a result List > + * > + * This function does not destroy source DefList but does not create copies > + * of List nodes. > + * It is actually used only for tables, in order to split toast and heap > + * reloptions, so each one can be stored in on it's own pg_class record > + */ > +List * > +optionsDefListFilterNamespaces(List *defList, const char *namespace) > +{ > + ListCell *cell; > + List *result = NIL; > + > + foreach(cell, defList) > + { > + DefElem *def = (DefElem *) lfirst(cell); > + > + if ((!namespace && !def->defnamespace) || > + (namespace && def->defnamespace && > + strcmp(namespace, def->defnamespace) == 0)) > + { > + result = lappend(result, def); > + } > + } > + return result; > +} > + > +/* > + * optionsTextArrayToDefList > + * Convert the text-array format of reloptions into a List of DefElem. > + */ > +List * > +optionsTextArrayToDefList(Datum options) > +{ > + List *result = NIL; > + ArrayType *array; > + Datum *optiondatums; > + int noptions; > + int i; > + > + /* Nothing to do if no options */ > + if (!PointerIsValid(DatumGetPointer(options))) > + return result; > + > + array = DatumGetArrayTypeP(options); > + > + deconstruct_array(array, TEXTOID, -1, false, 'i', > + &optiondatums, NULL, &noptions); > + > + for (i = 0; i < noptions; i++) > + { > + char *s; > + char *p; > + Node *val = NULL; > + > + s = TextDatumGetCString(optiondatums[i]); > + p = strchr(s, '='); > + if (p) > + { > + *p++ = '\0'; > + val = (Node *) makeString(pstrdup(p)); > + } > + result = lappend(result, makeDefElem(pstrdup(s), val, -1)); > + } > + > + return result; > +} > + > +/* FIXME write comment here */ > + > +Datum > +optionsDefListToTextArray(List *defList) > +{ > + ListCell *cell; > + Datum result; > + ArrayBuildState *astate = NULL; > + > + foreach(cell, defList) > + { > + DefElem *def = (DefElem *) lfirst(cell); > + const char *name = def->defname; > + const char *value; > + text *t; > + int len; > + > + if (def->arg != NULL) > + value = defGetString(def); > + else > + value = "true"; > + > + if (def->defnamespace) > + { > + Assert(false); /* Should not get here */ > + /* This function is used for backward compatibility in the place were namespases are not allowed */ > + return (Datum) 0; > + } > + len = VARHDRSZ + strlen(name) + strlen(value) + 1; > + t = (text *) palloc(len + 1); > + SET_VARSIZE(t, len); > + sprintf(VARDATA(t), "%s=%s", name, value); > + astate = accumArrayResult(astate, PointerGetDatum(t), false, > + TEXTOID, CurrentMemoryContext); > + > + } > + if (astate) > + result = makeArrayResult(astate, CurrentMemoryContext); > + else > + result = (Datum) 0; > + return result; > +} > + > + > +/* > + * optionsParseRawValues > + * Parses and vlaidates (if proper flag is set) option_values. As a result > + * caller will get the list of parsed (or partly parsed) option_values > + * > + * This function is used in cases when caller gets raw values from db or > + * syntax and want to parse them. > + * This function uses option_spec_set to get information about how each option > + * should be parsed. > + * If validate mode is off, function found an option that do not have proper > + * option_spec_set entry, this option kept unparsed (if some garbage came from > + * the DB, we should put it back there) > + * > + * This function destroys incoming list. > + */ > +List * > +optionsParseRawValues(List *raw_values, options_spec_set * spec_set, > + options_parse_mode mode) > +{ > + ListCell *cell; > + List *result = NIL; > + bool *is_set; > + int i; > + bool validate = mode & OPTIONS_PARSE_MODE_VALIDATE; > + bool for_alter = mode & OPTIONS_PARSE_MODE_FOR_ALTER; > + > + > + is_set = palloc0(sizeof(bool) * spec_set->num); > + foreach(cell, raw_values) > + { > + option_value *option = (option_value *) lfirst(cell); > + bool found = false; > + bool skip = false; > + > + > + if (option->status == OPTION_VALUE_STATUS_PARSED) > + { > + /* > + * This can happen while ALTER, when new values were already > + * parsed, but old values merged from DB are still raw > + */ > + result = lappend(result, option); > + continue; > + } > + if (validate && option->namespace && (!spec_set->namespace || > + strcmp(spec_set->namespace, option->namespace) != 0)) > + { > + ereport(ERROR, > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > + errmsg("unrecognized parameter namespace \"%s\"", > + option->namespace))); > + } > + > + for (i = 0; i < spec_set->num; i++) > + { > + option_spec_basic *definition = spec_set->definitions[i]; > + > + if (strcmp(option->raw_name, > + definition->name) == 0) > + { > + /* > + * Skip option with "ignore" flag, as it is processed > + * somewhere else. (WITH OIDS special case) > + */ > + if (definition->flags & OPTION_DEFINITION_FLAG_IGNORE) > + { > + found = true; > + skip = true; > + break; > + } > + > + /* > + * Reject option as if it was not in spec_set. Needed for cases > + * when option should have default value, but should not be > + * changed > + */ > + if (definition->flags & OPTION_DEFINITION_FLAG_REJECT) > + { > + found = false; > + break; > + } > + > + if (validate && is_set[i]) > + { > + ereport(ERROR, > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > + errmsg("parameter \"%s\" specified more than once", > + option->raw_name))); > + } > + if ((for_alter) && > + (definition->flags & OPTION_DEFINITION_FLAG_FORBID_ALTER)) > + { > + ereport(ERROR, > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > + errmsg("changing parameter \"%s\" is not allowed", > + definition->name))); > + } > + if (option->status == OPTION_VALUE_STATUS_FOR_RESET) > + { > + /* > + * For RESET options do not need further processing so > + * mark it found and stop searching > + */ > + found = true; > + break; > + } > + pfree(option->raw_name); > + option->raw_name = NULL; > + option->gen = definition; > + parse_one_option(option, NULL, -1, validate); > + is_set[i] = true; > + found = true; > + break; > + } > + } > + if (!found) > + { > + if (validate) > + { > + if (option->namespace) > + ereport(ERROR, > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > + errmsg("unrecognized parameter \"%s.%s\"", > + option->namespace, option->raw_name))); > + else > + ereport(ERROR, > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > + errmsg("unrecognized parameter \"%s\"", > + option->raw_name))); > + } else > + { > + /* RESET is always in non-validating mode, unkown names should > + * be ignored. This is traditional behaviour of postgres/ > + * FIXME may be it should be changed someday > + */ > + if (option->status == OPTION_VALUE_STATUS_FOR_RESET) > + { > + skip = true; > + } > + } > + /* > + * In other cases, if we are parsing not in validate mode, then > + * we should keep unknown node, because non-validate mode is for > + * data that is already in the DB and should not be changed after > + * altering another entries > + */ > + } > + if (!skip) > + result = lappend(result, option); > + } > + return result; > +} > + > +/* > + * parse_one_option > + * > + * Subroutine for optionsParseRawValues, to parse and validate a > + * single option's value > + */ > +static void > +parse_one_option(option_value * option, const char *text_str, int text_len, > + bool validate) > +{ > + char *value; > + bool parsed; > + > + value = option->raw_value; > + > + switch (option->gen->type) > + { > + case OPTION_TYPE_BOOL: > + { > + parsed = parse_bool(value, &option->values.bool_val); > + if (validate && !parsed) > + ereport(ERROR, > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > + errmsg("invalid value for boolean option \"%s\": %s", > + option->gen->name, value))); > + } > + break; > + case OPTION_TYPE_INT: > + { > + option_spec_int *optint = > + (option_spec_int *) option->gen; > + > + parsed = parse_int(value, &option->values.int_val, 0, NULL); > + if (validate && !parsed) > + ereport(ERROR, > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > + errmsg("invalid value for integer option \"%s\": %s", > + option->gen->name, value))); > + if (validate && (option->values.int_val < optint->min || > + option->values.int_val > optint->max)) > + ereport(ERROR, > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > + errmsg("value %s out of bounds for option \"%s\"", > + value, option->gen->name), > + errdetail("Valid values are between \"%d\" and \"%d\".", > + optint->min, optint->max))); > + } > + break; > + case OPTION_TYPE_REAL: > + { > + option_spec_real *optreal = > + (option_spec_real *) option->gen; > + > + parsed = parse_real(value, &option->values.real_val, 0, NULL); > + if (validate && !parsed) > + ereport(ERROR, > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > + errmsg("invalid value for floating point option \"%s\": %s", > + option->gen->name, value))); > + if (validate && (option->values.real_val < optreal->min || > + option->values.real_val > optreal->max)) > + ereport(ERROR, > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > + errmsg("value %s out of bounds for option \"%s\"", > + value, option->gen->name), > + errdetail("Valid values are between \"%f\" and \"%f\".", > + optreal->min, optreal->max))); > + } > + break; > + case OPTION_TYPE_ENUM: > + { > + option_spec_enum *optenum = > + (option_spec_enum *) option->gen; > + opt_enum_elt_def *elt; > + parsed = false; > + for (elt = optenum->members; elt->string_val; elt++) > + { > + if (strcmp(value, elt->string_val) == 0) > + { > + option->values.enum_val = elt->symbol_val; > + parsed = true; > + break; > + } > + } > + if (!parsed) > + { > + ereport(ERROR, > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > + errmsg("invalid value for enum option \"%s\": %s", > + option->gen->name, value), > + optenum->detailmsg ? > + errdetail_internal("%s", _(optenum->detailmsg)) : 0)); > + } > + } > + break; > + case OPTION_TYPE_STRING: > + { > + option_spec_string *optstring = > + (option_spec_string *) option->gen; > + > + option->values.string_val = value; > + if (validate && optstring->validate_cb) > + (optstring->validate_cb) (value); > + parsed = true; > + } > + break; > + default: > + elog(ERROR, "unsupported reloption type %d", option->gen->type); > + parsed = true; /* quiet compiler */ > + break; > + } > + > + if (parsed) > + option->status = OPTION_VALUE_STATUS_PARSED; > + > +} > + > +/* > + * optionsAllocateBytea > + * Allocates memory for bytea options representation > + * > + * Function allocates memory for byrea structure of an option, plus adds space > + * for values of string options. We should keep all data including string > + * values in the same memory chunk, because Cache code copies bytea option > + * data from one MemoryConext to another without knowing about it's internal > + * structure, so it would not be able to copy string values if they are outside > + * of bytea memory chunk. > + */ > +static void * > +optionsAllocateBytea(options_spec_set * spec_set, List *options) > +{ > + Size size; > + int i; > + ListCell *cell; > + int length; > + void *res; > + > + size = spec_set->struct_size; > + > + /* Calculate size needed to store all string values for this option */ > + for (i = 0; i < spec_set->num; i++) > + { > + option_spec_basic *definition = spec_set->definitions[i]; > + bool found = false; > + option_value *option; > + > + /* Not interested in non-string options, skipping */ > + if (definition->type != OPTION_TYPE_STRING) > + continue; > + > + /* > + * Trying to find option_value that references definition spec_set > + * entry > + */ > + foreach(cell, options) > + { > + option = (option_value *) lfirst(cell); > + if (option->status == OPTION_VALUE_STATUS_PARSED && > + strcmp(option->gen->name, definition->name) == 0) > + { > + found = true; > + break; > + } > + } > + if (found) > + /* If found, it'value will be stored */ > + length = strlen(option->values.string_val) + 1; > + else > + /* If not found, then there would be default value there */ > + if (((option_spec_string *) definition)->default_val) > + length = strlen( > + ((option_spec_string *) definition)->default_val) + 1; > + else > + length = 0; > + /* Add total length of all string values to basic size */ > + size += length; > + } > + > + res = palloc0(size); > + SET_VARSIZE(res, size); > + return res; > +} > + > +/* > + * optionsValuesToBytea > + * Converts options from List of option_values to binary bytea structure > + * > + * Convertation goes according to options_spec_set: each spec_set item > + * has offset value, and option value in binary mode is written to the > + * structure with that offset. > + * > + * More special case is string values. Memory for bytea structure is allocated > + * by optionsAllocateBytea which adds some more space for string values to > + * the size of original structure. All string values are copied there and > + * inside the bytea structure an offset to that value is kept. > + * > + */ > +static bytea * > +optionsValuesToBytea(List *options, options_spec_set * spec_set) > +{ > + char *data; > + char *string_values_buffer; > + int i; > + > + data = optionsAllocateBytea(spec_set, options); > + > + /* place for string data starts right after original structure */ > + string_values_buffer = data + spec_set->struct_size; > + > + for (i = 0; i < spec_set->num; i++) > + { > + option_value *found = NULL; > + ListCell *cell; > + char *item_pos; > + option_spec_basic *definition = spec_set->definitions[i]; > + > + if (definition->flags & OPTION_DEFINITION_FLAG_IGNORE) > + continue; > + > + /* Calculate the position of the item inside the structure */ > + item_pos = data + definition->struct_offset; > + > + /* Looking for the corresponding option from options list */ > + foreach(cell, options) > + { > + option_value *option = (option_value *) lfirst(cell); > + > + if (option->status == OPTION_VALUE_STATUS_RAW) > + continue; /* raw can come from db. Just ignore them then */ > + Assert(option->status != OPTION_VALUE_STATUS_EMPTY); > + > + if (strcmp(definition->name, option->gen->name) == 0) > + { > + found = option; > + break; > + } > + } > + /* writing to the proper position either option value or default val */ > + switch (definition->type) > + { > + case OPTION_TYPE_BOOL: > + *(bool *) item_pos = found ? > + found->values.bool_val : > + ((option_spec_bool *) definition)->default_val; > + break; > + case OPTION_TYPE_INT: > + *(int *) item_pos = found ? > + found->values.int_val : > + ((option_spec_int *) definition)->default_val; > + break; > + case OPTION_TYPE_REAL: > + *(double *) item_pos = found ? > + found->values.real_val : > + ((option_spec_real *) definition)->default_val; > + break; > + case OPTION_TYPE_ENUM: > + *(int *) item_pos = found ? > + found->values.enum_val : > + ((option_spec_enum *) definition)->default_val; > + break; > + > + case OPTION_TYPE_STRING: > + { > + /* > + * For string options: writing string value at the string > + * buffer after the structure, and storing and offset to > + * that value > + */ > + char *value = NULL; > + > + if (found) > + value = found->values.string_val; > + else > + value = ((option_spec_string *) definition) > + ->default_val; > + *(int *) item_pos = value ? > + string_values_buffer - data : > + OPTION_STRING_VALUE_NOT_SET_OFFSET; > + if (value) > + { > + strcpy(string_values_buffer, value); > + string_values_buffer += strlen(value) + 1; > + } > + } > + break; > + default: > + elog(ERROR, "unsupported reloption type %d", > + definition->type); > + break; > + } > + } > + return (void *) data; > +} > + > + > +/* > + * transformOptions > + * This function is used by src/backend/commands/Xxxx in order to process > + * new option values, merge them with existing values (in the case of > + * ALTER command) and prepare to put them [back] into DB > + */ > + > +Datum > +transformOptions(options_spec_set * spec_set, Datum oldOptions, > + List *defList, options_parse_mode parse_mode) > +{ > + Datum result; > + List *new_values; > + List *old_values; > + List *merged_values; > + > + /* > + * Parse and validate New values > + */ > + new_values = optionsDefListToRawValues(defList, parse_mode); > + if (! (parse_mode & OPTIONS_PARSE_MODE_FOR_RESET)) > + { > + /* FIXME: postgres usual behaviour vas not to vaidate names that > + * came from RESET command. Once this behavious should be changed, > + * I guess. But for now we keep it as it was. > + */ > + parse_mode|= OPTIONS_PARSE_MODE_VALIDATE; > + } > + new_values = optionsParseRawValues(new_values, spec_set, parse_mode); > + > + /* > + * Old values exists in case of ALTER commands. Transform them to raw > + * values and merge them with new_values, and parse it. > + */ > + if (PointerIsValid(DatumGetPointer(oldOptions))) > + { > + old_values = optionsTextArrayToRawValues(oldOptions); > + merged_values = optionsMergeOptionValues(old_values, new_values); > + > + /* > + * Parse options only after merging in order not to parse options that > + * would be removed by merging later > + */ > + merged_values = optionsParseRawValues(merged_values, spec_set, 0); > + } > + else > + { > + merged_values = new_values; > + } > + > + /* > + * If we have postprocess_fun function defined in spec_set, then there > + * might be some custom options checks there, with error throwing. So we > + * should do it here to throw these errors while CREATing or ALTERing > + * options > + */ > + if (spec_set->postprocess_fun) > + { > + bytea *data = optionsValuesToBytea(merged_values, spec_set); > + > + spec_set->postprocess_fun(data, true); > + pfree(data); > + } > + > + /* > + * Convert options to TextArray format so caller can store them into > + * database > + */ > + result = optionsValuesToTextArray(merged_values); > + return result; > +} > + > + > +/* > + * optionsTextArrayToBytea > + * A meta-function that transforms options stored as TextArray into binary > + * (bytea) representation. > + * > + * This function runs other transform functions that leads to the desired > + * result in no-validation mode. This function is used by cache mechanism, > + * in order to load and cache options when object itself is loaded and cached > + */ > +bytea * > +optionsTextArrayToBytea(options_spec_set * spec_set, Datum data, bool validate) > +{ > + List *values; > + bytea *options; > + > + values = optionsTextArrayToRawValues(data); > + values = optionsParseRawValues(values, spec_set, > + validate ? OPTIONS_PARSE_MODE_VALIDATE : 0); > + options = optionsValuesToBytea(values, spec_set); > + > + if (spec_set->postprocess_fun) > + { > + spec_set->postprocess_fun(options, false); > + } > + return options; > +} > diff --git a/src/backend/access/common/relation.c b/src/backend/access/common/relation.c > index 632d13c..49ad197 100644 > --- a/src/backend/access/common/relation.c > +++ b/src/backend/access/common/relation.c > @@ -65,9 +65,13 @@ relation_open(Oid relationId, LOCKMODE lockmode) > * If we didn't get the lock ourselves, assert that caller holds one, > * except in bootstrap mode where no locks are used. > */ > - Assert(lockmode != NoLock || > - IsBootstrapProcessingMode() || > - CheckRelationLockedByMe(r, AccessShareLock, true)); > + > +// FIXME We need NoLock mode to get AM data when choosing Lock for > +// attoptions is changed. See ProcessUtilitySlow problems comes from there > +// This is a dirty hack, we need better solution for this case; > +// Assert(lockmode != NoLock || > +// IsBootstrapProcessingMode() || > +// CheckRelationLockedByMe(r, AccessShareLock, true)); > > /* Make note that we've accessed a temporary relation */ > if (RelationUsesLocalBuffers(r)) > diff --git a/src/backend/access/common/reloptions.c b/src/backend/access/common/reloptions.c > index b5602f5..29ab98a 100644 > --- a/src/backend/access/common/reloptions.c > +++ b/src/backend/access/common/reloptions.c > @@ -1,7 +1,7 @@ > /*------------------------------------------------------------------------- > * > * reloptions.c > - * Core support for relation options (pg_class.reloptions) > + * Support for relation options (pg_class.reloptions) > * > * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group > * Portions Copyright (c) 1994, Regents of the University of California > @@ -17,13 +17,10 @@ > > #include <float.h> > > -#include "access/gist_private.h" > -#include "access/hash.h" > #include "access/heaptoast.h" > #include "access/htup_details.h" > -#include "access/nbtree.h" > #include "access/reloptions.h" > -#include "access/spgist_private.h" > +#include "access/options.h" > #include "catalog/pg_type.h" > #include "commands/defrem.h" > #include "commands/tablespace.h" > @@ -36,6 +33,7 @@ > #include "utils/guc.h" > #include "utils/memutils.h" > #include "utils/rel.h" > +#include "storage/bufmgr.h" > > /* > * Contents of pg_class.reloptions > @@ -93,380 +91,8 @@ > * value has no effect until the next VACUUM, so no need for stronger lock. > */ > > -static relopt_bool boolRelOpts[] = > -{ > - { > - { > - "autosummarize", > - "Enables automatic summarization on this BRIN index", > - RELOPT_KIND_BRIN, > - AccessExclusiveLock > - }, > - false > - }, > - { > - { > - "autovacuum_enabled", > - "Enables autovacuum in this relation", > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > - ShareUpdateExclusiveLock > - }, > - true > - }, > - { > - { > - "user_catalog_table", > - "Declare a table as an additional catalog table, e.g. for the purpose of logical replication", > - RELOPT_KIND_HEAP, > - AccessExclusiveLock > - }, > - false > - }, > - { > - { > - "fastupdate", > - "Enables \"fast update\" feature for this GIN index", > - RELOPT_KIND_GIN, > - AccessExclusiveLock > - }, > - true > - }, > - { > - { > - "security_barrier", > - "View acts as a row security barrier", > - RELOPT_KIND_VIEW, > - AccessExclusiveLock > - }, > - false > - }, > - { > - { > - "vacuum_truncate", > - "Enables vacuum to truncate empty pages at the end of this table", > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > - ShareUpdateExclusiveLock > - }, > - true > - }, > - { > - { > - "deduplicate_items", > - "Enables \"deduplicate items\" feature for this btree index", > - RELOPT_KIND_BTREE, > - ShareUpdateExclusiveLock /* since it applies only to later > - * inserts */ > - }, > - true > - }, > - /* list terminator */ > - {{NULL}} > -}; > - > -static relopt_int intRelOpts[] = > -{ > - { > - { > - "fillfactor", > - "Packs table pages only to this percentage", > - RELOPT_KIND_HEAP, > - ShareUpdateExclusiveLock /* since it applies only to later > - * inserts */ > - }, > - HEAP_DEFAULT_FILLFACTOR, HEAP_MIN_FILLFACTOR, 100 > - }, > - { > - { > - "fillfactor", > - "Packs btree index pages only to this percentage", > - RELOPT_KIND_BTREE, > - ShareUpdateExclusiveLock /* since it applies only to later > - * inserts */ > - }, > - BTREE_DEFAULT_FILLFACTOR, BTREE_MIN_FILLFACTOR, 100 > - }, > - { > - { > - "fillfactor", > - "Packs hash index pages only to this percentage", > - RELOPT_KIND_HASH, > - ShareUpdateExclusiveLock /* since it applies only to later > - * inserts */ > - }, > - HASH_DEFAULT_FILLFACTOR, HASH_MIN_FILLFACTOR, 100 > - }, > - { > - { > - "fillfactor", > - "Packs gist index pages only to this percentage", > - RELOPT_KIND_GIST, > - ShareUpdateExclusiveLock /* since it applies only to later > - * inserts */ > - }, > - GIST_DEFAULT_FILLFACTOR, GIST_MIN_FILLFACTOR, 100 > - }, > - { > - { > - "fillfactor", > - "Packs spgist index pages only to this percentage", > - RELOPT_KIND_SPGIST, > - ShareUpdateExclusiveLock /* since it applies only to later > - * inserts */ > - }, > - SPGIST_DEFAULT_FILLFACTOR, SPGIST_MIN_FILLFACTOR, 100 > - }, > - { > - { > - "autovacuum_vacuum_threshold", > - "Minimum number of tuple updates or deletes prior to vacuum", > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > - ShareUpdateExclusiveLock > - }, > - -1, 0, INT_MAX > - }, > - { > - { > - "autovacuum_vacuum_insert_threshold", > - "Minimum number of tuple inserts prior to vacuum, or -1 to disable insert vacuums", > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > - ShareUpdateExclusiveLock > - }, > - -2, -1, INT_MAX > - }, > - { > - { > - "autovacuum_analyze_threshold", > - "Minimum number of tuple inserts, updates or deletes prior to analyze", > - RELOPT_KIND_HEAP, > - ShareUpdateExclusiveLock > - }, > - -1, 0, INT_MAX > - }, > - { > - { > - "autovacuum_vacuum_cost_limit", > - "Vacuum cost amount available before napping, for autovacuum", > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > - ShareUpdateExclusiveLock > - }, > - -1, 1, 10000 > - }, > - { > - { > - "autovacuum_freeze_min_age", > - "Minimum age at which VACUUM should freeze a table row, for autovacuum", > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > - ShareUpdateExclusiveLock > - }, > - -1, 0, 1000000000 > - }, > - { > - { > - "autovacuum_multixact_freeze_min_age", > - "Minimum multixact age at which VACUUM should freeze a row multixact's, for autovacuum", > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > - ShareUpdateExclusiveLock > - }, > - -1, 0, 1000000000 > - }, > - { > - { > - "autovacuum_freeze_max_age", > - "Age at which to autovacuum a table to prevent transaction ID wraparound", > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > - ShareUpdateExclusiveLock > - }, > - -1, 100000, 2000000000 > - }, > - { > - { > - "autovacuum_multixact_freeze_max_age", > - "Multixact age at which to autovacuum a table to prevent multixact wraparound", > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > - ShareUpdateExclusiveLock > - }, > - -1, 10000, 2000000000 > - }, > - { > - { > - "autovacuum_freeze_table_age", > - "Age at which VACUUM should perform a full table sweep to freeze row versions", > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > - ShareUpdateExclusiveLock > - }, -1, 0, 2000000000 > - }, > - { > - { > - "autovacuum_multixact_freeze_table_age", > - "Age of multixact at which VACUUM should perform a full table sweep to freeze row versions", > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > - ShareUpdateExclusiveLock > - }, -1, 0, 2000000000 > - }, > - { > - { > - "log_autovacuum_min_duration", > - "Sets the minimum execution time above which autovacuum actions will be logged", > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > - ShareUpdateExclusiveLock > - }, > - -1, -1, INT_MAX > - }, > - { > - { > - "toast_tuple_target", > - "Sets the target tuple length at which external columns will be toasted", > - RELOPT_KIND_HEAP, > - ShareUpdateExclusiveLock > - }, > - TOAST_TUPLE_TARGET, 128, TOAST_TUPLE_TARGET_MAIN > - }, > - { > - { > - "pages_per_range", > - "Number of pages that each page range covers in a BRIN index", > - RELOPT_KIND_BRIN, > - AccessExclusiveLock > - }, 128, 1, 131072 > - }, > - { > - { > - "gin_pending_list_limit", > - "Maximum size of the pending list for this GIN index, in kilobytes.", > - RELOPT_KIND_GIN, > - AccessExclusiveLock > - }, > - -1, 64, MAX_KILOBYTES > - }, > - { > - { > - "effective_io_concurrency", > - "Number of simultaneous requests that can be handled efficiently by the disk subsystem.", > - RELOPT_KIND_TABLESPACE, > - ShareUpdateExclusiveLock > - }, > -#ifdef USE_PREFETCH > - -1, 0, MAX_IO_CONCURRENCY > -#else > - 0, 0, 0 > -#endif > - }, > - { > - { > - "maintenance_io_concurrency", > - "Number of simultaneous requests that can be handled efficiently by the disk subsystem for maintenance work.", > - RELOPT_KIND_TABLESPACE, > - ShareUpdateExclusiveLock > - }, > -#ifdef USE_PREFETCH > - -1, 0, MAX_IO_CONCURRENCY > -#else > - 0, 0, 0 > -#endif > - }, > - { > - { > - "parallel_workers", > - "Number of parallel processes that can be used per executor node for this relation.", > - RELOPT_KIND_HEAP, > - ShareUpdateExclusiveLock > - }, > - -1, 0, 1024 > - }, > - > - /* list terminator */ > - {{NULL}} > -}; > - > -static relopt_real realRelOpts[] = > -{ > - { > - { > - "autovacuum_vacuum_cost_delay", > - "Vacuum cost delay in milliseconds, for autovacuum", > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > - ShareUpdateExclusiveLock > - }, > - -1, 0.0, 100.0 > - }, > - { > - { > - "autovacuum_vacuum_scale_factor", > - "Number of tuple updates or deletes prior to vacuum as a fraction of reltuples", > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > - ShareUpdateExclusiveLock > - }, > - -1, 0.0, 100.0 > - }, > - { > - { > - "autovacuum_vacuum_insert_scale_factor", > - "Number of tuple inserts prior to vacuum as a fraction of reltuples", > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > - ShareUpdateExclusiveLock > - }, > - -1, 0.0, 100.0 > - }, > - { > - { > - "autovacuum_analyze_scale_factor", > - "Number of tuple inserts, updates or deletes prior to analyze as a fraction of reltuples", > - RELOPT_KIND_HEAP, > - ShareUpdateExclusiveLock > - }, > - -1, 0.0, 100.0 > - }, > - { > - { > - "seq_page_cost", > - "Sets the planner's estimate of the cost of a sequentially fetched disk page.", > - RELOPT_KIND_TABLESPACE, > - ShareUpdateExclusiveLock > - }, > - -1, 0.0, DBL_MAX > - }, > - { > - { > - "random_page_cost", > - "Sets the planner's estimate of the cost of a nonsequentially fetched disk page.", > - RELOPT_KIND_TABLESPACE, > - ShareUpdateExclusiveLock > - }, > - -1, 0.0, DBL_MAX > - }, > - { > - { > - "n_distinct", > - "Sets the planner's estimate of the number of distinct values appearing in a column (excluding child relations).", > - RELOPT_KIND_ATTRIBUTE, > - ShareUpdateExclusiveLock > - }, > - 0, -1.0, DBL_MAX > - }, > - { > - { > - "n_distinct_inherited", > - "Sets the planner's estimate of the number of distinct values appearing in a column (including child relations).", > - RELOPT_KIND_ATTRIBUTE, > - ShareUpdateExclusiveLock > - }, > - 0, -1.0, DBL_MAX > - }, > - { > - { > - "vacuum_cleanup_index_scale_factor", > - "Deprecated B-Tree parameter.", > - RELOPT_KIND_BTREE, > - ShareUpdateExclusiveLock > - }, > - -1, 0.0, 1e10 > - }, > - /* list terminator */ > - {{NULL}} > -}; > - > /* values from StdRdOptIndexCleanup */ > -relopt_enum_elt_def StdRdOptIndexCleanupValues[] = > +opt_enum_elt_def StdRdOptIndexCleanupValues[] = > { > {"auto", STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO}, > {"on", STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON}, > @@ -480,17 +106,8 @@ relopt_enum_elt_def StdRdOptIndexCleanupValues[] = > {(const char *) NULL} /* list terminator */ > }; > > -/* values from GistOptBufferingMode */ > -relopt_enum_elt_def gistBufferingOptValues[] = > -{ > - {"auto", GIST_OPTION_BUFFERING_AUTO}, > - {"on", GIST_OPTION_BUFFERING_ON}, > - {"off", GIST_OPTION_BUFFERING_OFF}, > - {(const char *) NULL} /* list terminator */ > -}; > - > /* values from ViewOptCheckOption */ > -relopt_enum_elt_def viewCheckOptValues[] = > +opt_enum_elt_def viewCheckOptValues[] = > { > /* no value for NOT_SET */ > {"local", VIEW_OPTION_CHECK_OPTION_LOCAL}, > @@ -498,61 +115,8 @@ relopt_enum_elt_def viewCheckOptValues[] = > {(const char *) NULL} /* list terminator */ > }; > > -static relopt_enum enumRelOpts[] = > -{ > - { > - { > - "vacuum_index_cleanup", > - "Controls index vacuuming and index cleanup", > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > - ShareUpdateExclusiveLock > - }, > - StdRdOptIndexCleanupValues, > - STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO, > - gettext_noop("Valid values are \"on\", \"off\", and \"auto\".") > - }, > - { > - { > - "buffering", > - "Enables buffering build for this GiST index", > - RELOPT_KIND_GIST, > - AccessExclusiveLock > - }, > - gistBufferingOptValues, > - GIST_OPTION_BUFFERING_AUTO, > - gettext_noop("Valid values are \"on\", \"off\", and \"auto\".") > - }, > - { > - { > - "check_option", > - "View has WITH CHECK OPTION defined (local or cascaded).", > - RELOPT_KIND_VIEW, > - AccessExclusiveLock > - }, > - viewCheckOptValues, > - VIEW_OPTION_CHECK_OPTION_NOT_SET, > - gettext_noop("Valid values are \"local\" and \"cascaded\".") > - }, > - /* list terminator */ > - {{NULL}} > -}; > - > -static relopt_string stringRelOpts[] = > -{ > - /* list terminator */ > - {{NULL}} > -}; > - > -static relopt_gen **relOpts = NULL; > -static bits32 last_assigned_kind = RELOPT_KIND_LAST_DEFAULT; > - > -static int num_custom_options = 0; > -static relopt_gen **custom_options = NULL; > -static bool need_initialization = true; > > -static void initialize_reloptions(void); > -static void parse_one_reloption(relopt_value *option, char *text_str, > - int text_len, bool validate); > +options_spec_set *get_stdrd_relopt_spec_set(relopt_kind kind); > > /* > * Get the length of a string reloption (either default or the user-defined > @@ -563,160 +127,6 @@ static void parse_one_reloption(relopt_value *option, char *text_str, > ((option).isset ? strlen((option).values.string_val) : \ > ((relopt_string *) (option).gen)->default_len) > > -/* > - * initialize_reloptions > - * initialization routine, must be called before parsing > - * > - * Initialize the relOpts array and fill each variable's type and name length. > - */ > -static void > -initialize_reloptions(void) > -{ > - int i; > - int j; > - > - j = 0; > - for (i = 0; boolRelOpts[i].gen.name; i++) > - { > - Assert(DoLockModesConflict(boolRelOpts[i].gen.lockmode, > - boolRelOpts[i].gen.lockmode)); > - j++; > - } > - for (i = 0; intRelOpts[i].gen.name; i++) > - { > - Assert(DoLockModesConflict(intRelOpts[i].gen.lockmode, > - intRelOpts[i].gen.lockmode)); > - j++; > - } > - for (i = 0; realRelOpts[i].gen.name; i++) > - { > - Assert(DoLockModesConflict(realRelOpts[i].gen.lockmode, > - realRelOpts[i].gen.lockmode)); > - j++; > - } > - for (i = 0; enumRelOpts[i].gen.name; i++) > - { > - Assert(DoLockModesConflict(enumRelOpts[i].gen.lockmode, > - enumRelOpts[i].gen.lockmode)); > - j++; > - } > - for (i = 0; stringRelOpts[i].gen.name; i++) > - { > - Assert(DoLockModesConflict(stringRelOpts[i].gen.lockmode, > - stringRelOpts[i].gen.lockmode)); > - j++; > - } > - j += num_custom_options; > - > - if (relOpts) > - pfree(relOpts); > - relOpts = MemoryContextAlloc(TopMemoryContext, > - (j + 1) * sizeof(relopt_gen *)); > - > - j = 0; > - for (i = 0; boolRelOpts[i].gen.name; i++) > - { > - relOpts[j] = &boolRelOpts[i].gen; > - relOpts[j]->type = RELOPT_TYPE_BOOL; > - relOpts[j]->namelen = strlen(relOpts[j]->name); > - j++; > - } > - > - for (i = 0; intRelOpts[i].gen.name; i++) > - { > - relOpts[j] = &intRelOpts[i].gen; > - relOpts[j]->type = RELOPT_TYPE_INT; > - relOpts[j]->namelen = strlen(relOpts[j]->name); > - j++; > - } > - > - for (i = 0; realRelOpts[i].gen.name; i++) > - { > - relOpts[j] = &realRelOpts[i].gen; > - relOpts[j]->type = RELOPT_TYPE_REAL; > - relOpts[j]->namelen = strlen(relOpts[j]->name); > - j++; > - } > - > - for (i = 0; enumRelOpts[i].gen.name; i++) > - { > - relOpts[j] = &enumRelOpts[i].gen; > - relOpts[j]->type = RELOPT_TYPE_ENUM; > - relOpts[j]->namelen = strlen(relOpts[j]->name); > - j++; > - } > - > - for (i = 0; stringRelOpts[i].gen.name; i++) > - { > - relOpts[j] = &stringRelOpts[i].gen; > - relOpts[j]->type = RELOPT_TYPE_STRING; > - relOpts[j]->namelen = strlen(relOpts[j]->name); > - j++; > - } > - > - for (i = 0; i < num_custom_options; i++) > - { > - relOpts[j] = custom_options[i]; > - j++; > - } > - > - /* add a list terminator */ > - relOpts[j] = NULL; > - > - /* flag the work is complete */ > - need_initialization = false; > -} > - > -/* > - * add_reloption_kind > - * Create a new relopt_kind value, to be used in custom reloptions by > - * user-defined AMs. > - */ > -relopt_kind > -add_reloption_kind(void) > -{ > - /* don't hand out the last bit so that the enum's behavior is portable */ > - if (last_assigned_kind >= RELOPT_KIND_MAX) > - ereport(ERROR, > - (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), > - errmsg("user-defined relation parameter types limit exceeded"))); > - last_assigned_kind <<= 1; > - return (relopt_kind) last_assigned_kind; > -} > - > -/* > - * add_reloption > - * Add an already-created custom reloption to the list, and recompute the > - * main parser table. > - */ > -static void > -add_reloption(relopt_gen *newoption) > -{ > - static int max_custom_options = 0; > - > - if (num_custom_options >= max_custom_options) > - { > - MemoryContext oldcxt; > - > - oldcxt = MemoryContextSwitchTo(TopMemoryContext); > - > - if (max_custom_options == 0) > - { > - max_custom_options = 8; > - custom_options = palloc(max_custom_options * sizeof(relopt_gen *)); > - } > - else > - { > - max_custom_options *= 2; > - custom_options = repalloc(custom_options, > - max_custom_options * sizeof(relopt_gen *)); > - } > - MemoryContextSwitchTo(oldcxt); > - } > - custom_options[num_custom_options++] = newoption; > - > - need_initialization = true; > -} > > /* > * init_local_reloptions > @@ -729,6 +139,7 @@ init_local_reloptions(local_relopts *opts, Size relopt_struct_size) > opts->options = NIL; > opts->validators = NIL; > opts->relopt_struct_size = relopt_struct_size; > + opts->spec_set = allocateOptionsSpecSet(NULL, relopt_struct_size, 0); > } > > /* > @@ -743,112 +154,6 @@ register_reloptions_validator(local_relopts *opts, relopts_validator validator) > } > > /* > - * add_local_reloption > - * Add an already-created custom reloption to the local list. > - */ > -static void > -add_local_reloption(local_relopts *relopts, relopt_gen *newoption, int offset) > -{ > - local_relopt *opt = palloc(sizeof(*opt)); > - > - Assert(offset < relopts->relopt_struct_size); > - > - opt->option = newoption; > - opt->offset = offset; > - > - relopts->options = lappend(relopts->options, opt); > -} > - > -/* > - * allocate_reloption > - * Allocate a new reloption and initialize the type-agnostic fields > - * (for types other than string) > - */ > -static relopt_gen * > -allocate_reloption(bits32 kinds, int type, const char *name, const char *desc, > - LOCKMODE lockmode) > -{ > - MemoryContext oldcxt; > - size_t size; > - relopt_gen *newoption; > - > - if (kinds != RELOPT_KIND_LOCAL) > - oldcxt = MemoryContextSwitchTo(TopMemoryContext); > - else > - oldcxt = NULL; > - > - switch (type) > - { > - case RELOPT_TYPE_BOOL: > - size = sizeof(relopt_bool); > - break; > - case RELOPT_TYPE_INT: > - size = sizeof(relopt_int); > - break; > - case RELOPT_TYPE_REAL: > - size = sizeof(relopt_real); > - break; > - case RELOPT_TYPE_ENUM: > - size = sizeof(relopt_enum); > - break; > - case RELOPT_TYPE_STRING: > - size = sizeof(relopt_string); > - break; > - default: > - elog(ERROR, "unsupported reloption type %d", type); > - return NULL; /* keep compiler quiet */ > - } > - > - newoption = palloc(size); > - > - newoption->name = pstrdup(name); > - if (desc) > - newoption->desc = pstrdup(desc); > - else > - newoption->desc = NULL; > - newoption->kinds = kinds; > - newoption->namelen = strlen(name); > - newoption->type = type; > - newoption->lockmode = lockmode; > - > - if (oldcxt != NULL) > - MemoryContextSwitchTo(oldcxt); > - > - return newoption; > -} > - > -/* > - * init_bool_reloption > - * Allocate and initialize a new boolean reloption > - */ > -static relopt_bool * > -init_bool_reloption(bits32 kinds, const char *name, const char *desc, > - bool default_val, LOCKMODE lockmode) > -{ > - relopt_bool *newoption; > - > - newoption = (relopt_bool *) allocate_reloption(kinds, RELOPT_TYPE_BOOL, > - name, desc, lockmode); > - newoption->default_val = default_val; > - > - return newoption; > -} > - > -/* > - * add_bool_reloption > - * Add a new boolean reloption > - */ > -void > -add_bool_reloption(bits32 kinds, const char *name, const char *desc, > - bool default_val, LOCKMODE lockmode) > -{ > - relopt_bool *newoption = init_bool_reloption(kinds, name, desc, > - default_val, lockmode); > - > - add_reloption((relopt_gen *) newoption); > -} > - > -/* > * add_local_bool_reloption > * Add a new boolean local reloption > * > @@ -858,47 +163,8 @@ void > add_local_bool_reloption(local_relopts *relopts, const char *name, > const char *desc, bool default_val, int offset) > { > - relopt_bool *newoption = init_bool_reloption(RELOPT_KIND_LOCAL, > - name, desc, > - default_val, 0); > - > - add_local_reloption(relopts, (relopt_gen *) newoption, offset); > -} > - > - > -/* > - * init_real_reloption > - * Allocate and initialize a new integer reloption > - */ > -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) > -{ > - relopt_int *newoption; > - > - newoption = (relopt_int *) allocate_reloption(kinds, RELOPT_TYPE_INT, > - name, desc, lockmode); > - newoption->default_val = default_val; > - newoption->min = min_val; > - newoption->max = max_val; > - > - return newoption; > -} > - > -/* > - * add_int_reloption > - * Add a new integer reloption > - */ > -void > -add_int_reloption(bits32 kinds, const char *name, const char *desc, int default_val, > - int min_val, int max_val, LOCKMODE lockmode) > -{ > - relopt_int *newoption = init_int_reloption(kinds, name, desc, > - default_val, min_val, > - max_val, lockmode); > - > - add_reloption((relopt_gen *) newoption); > + optionsSpecSetAddBool(relopts->spec_set, name, desc, NoLock, 0, offset, > + default_val); > } > > /* > @@ -912,47 +178,8 @@ add_local_int_reloption(local_relopts *relopts, const char *name, > const char *desc, int default_val, int min_val, > int max_val, int offset) > { > - relopt_int *newoption = init_int_reloption(RELOPT_KIND_LOCAL, > - name, desc, default_val, > - min_val, max_val, 0); > - > - add_local_reloption(relopts, (relopt_gen *) newoption, offset); > -} > - > -/* > - * init_real_reloption > - * Allocate and initialize a new real reloption > - */ > -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) > -{ > - relopt_real *newoption; > - > - newoption = (relopt_real *) allocate_reloption(kinds, RELOPT_TYPE_REAL, > - name, desc, lockmode); > - newoption->default_val = default_val; > - newoption->min = min_val; > - newoption->max = max_val; > - > - return newoption; > -} > - > -/* > - * add_real_reloption > - * Add a new float reloption > - */ > -void > -add_real_reloption(bits32 kinds, const char *name, const char *desc, > - double default_val, double min_val, double max_val, > - LOCKMODE lockmode) > -{ > - relopt_real *newoption = init_real_reloption(kinds, name, desc, > - default_val, min_val, > - max_val, lockmode); > - > - add_reloption((relopt_gen *) newoption); > + optionsSpecSetAddInt(relopts->spec_set, name, desc, NoLock, 0, offset, > + default_val, min_val, max_val); > } > > /* > @@ -966,57 +193,9 @@ add_local_real_reloption(local_relopts *relopts, const char *name, > const char *desc, double default_val, > double min_val, double max_val, int offset) > { > - relopt_real *newoption = init_real_reloption(RELOPT_KIND_LOCAL, > - name, desc, > - default_val, min_val, > - max_val, 0); > - > - add_local_reloption(relopts, (relopt_gen *) newoption, offset); > -} > - > -/* > - * init_enum_reloption > - * Allocate and initialize a new enum reloption > - */ > -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) > -{ > - relopt_enum *newoption; > - > - newoption = (relopt_enum *) allocate_reloption(kinds, RELOPT_TYPE_ENUM, > - name, desc, lockmode); > - newoption->members = members; > - newoption->default_val = default_val; > - newoption->detailmsg = detailmsg; > - > - return newoption; > -} > - > - > -/* > - * add_enum_reloption > - * Add a new enum reloption > - * > - * The members array must have a terminating NULL entry. > - * > - * The detailmsg is shown when unsupported values are passed, and has this > - * form: "Valid values are \"foo\", \"bar\", and \"bar\"." > - * > - * The members array and detailmsg are not copied -- caller must ensure that > - * they are valid throughout the life of the process. > - */ > -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) > -{ > - relopt_enum *newoption = init_enum_reloption(kinds, name, desc, > - members, default_val, > - detailmsg, lockmode); > + optionsSpecSetAddReal(relopts->spec_set, name, desc, NoLock, 0, offset, > + default_val, min_val, max_val); > > - add_reloption((relopt_gen *) newoption); > } > > /* > @@ -1027,77 +206,11 @@ add_enum_reloption(bits32 kinds, const char *name, const char *desc, > */ > void > add_local_enum_reloption(local_relopts *relopts, const char *name, > - const char *desc, relopt_enum_elt_def *members, > + const char *desc, opt_enum_elt_def *members, > int default_val, const char *detailmsg, int offset) > { > - relopt_enum *newoption = init_enum_reloption(RELOPT_KIND_LOCAL, > - name, desc, > - members, default_val, > - detailmsg, 0); > - > - add_local_reloption(relopts, (relopt_gen *) newoption, offset); > -} > - > -/* > - * init_string_reloption > - * Allocate and initialize a new string reloption > - */ > -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) > -{ > - relopt_string *newoption; > - > - /* make sure the validator/default combination is sane */ > - if (validator) > - (validator) (default_val); > - > - newoption = (relopt_string *) allocate_reloption(kinds, RELOPT_TYPE_STRING, > - name, desc, lockmode); > - newoption->validate_cb = validator; > - newoption->fill_cb = filler; > - if (default_val) > - { > - if (kinds == RELOPT_KIND_LOCAL) > - newoption->default_val = strdup(default_val); > - else > - newoption->default_val = MemoryContextStrdup(TopMemoryContext, default_val); > - newoption->default_len = strlen(default_val); > - newoption->default_isnull = false; > - } > - else > - { > - newoption->default_val = ""; > - newoption->default_len = 0; > - newoption->default_isnull = true; > - } > - > - return newoption; > -} > - > -/* > - * add_string_reloption > - * Add a new string reloption > - * > - * "validator" is an optional function pointer that can be used to test the > - * validity of the values. It must elog(ERROR) when the argument string is > - * not acceptable for the variable. Note that the default value must pass > - * the validation. > - */ > -void > -add_string_reloption(bits32 kinds, const char *name, const char *desc, > - const char *default_val, validate_string_relopt validator, > - LOCKMODE lockmode) > -{ > - relopt_string *newoption = init_string_reloption(kinds, name, desc, > - default_val, > - validator, NULL, > - lockmode); > - > - add_reloption((relopt_gen *) newoption); > + optionsSpecSetAddEnum(relopts->spec_set, name, desc, NoLock, 0, offset, > + members, default_val, detailmsg); > } > > /* > @@ -1113,249 +226,9 @@ add_local_string_reloption(local_relopts *relopts, const char *name, > validate_string_relopt validator, > fill_string_relopt filler, int offset) > { > - relopt_string *newoption = init_string_reloption(RELOPT_KIND_LOCAL, > - name, desc, > - default_val, > - validator, filler, > - 0); > - > - add_local_reloption(relopts, (relopt_gen *) newoption, offset); > -} > - > -/* > - * Transform a relation options list (list of DefElem) into the text array > - * format that is kept in pg_class.reloptions, including only those options > - * that are in the passed namespace. The output values do not include the > - * namespace. > - * > - * This is used for three cases: CREATE TABLE/INDEX, ALTER TABLE SET, and > - * ALTER TABLE RESET. In the ALTER cases, oldOptions is the existing > - * reloptions value (possibly NULL), and we replace or remove entries > - * as needed. > - * > - * If acceptOidsOff is true, then we allow oids = false, but throw error when > - * on. This is solely needed for backwards compatibility. > - * > - * Note that this is not responsible for determining whether the options > - * are valid, but it does check that namespaces for all the options given are > - * listed in validnsps. The NULL namespace is always valid and need not be > - * explicitly listed. Passing a NULL pointer means that only the NULL > - * namespace is valid. > - * > - * Both oldOptions and the result are text arrays (or NULL for "default"), > - * but we declare them as Datums to avoid including array.h in reloptions.h. > - */ > -Datum > -transformRelOptions(Datum oldOptions, List *defList, const char *namspace, > - char *validnsps[], bool acceptOidsOff, bool isReset) > -{ > - Datum result; > - ArrayBuildState *astate; > - ListCell *cell; > - > - /* no change if empty list */ > - if (defList == NIL) > - return oldOptions; > - > - /* We build new array using accumArrayResult */ > - astate = NULL; > - > - /* Copy any oldOptions that aren't to be replaced */ > - if (PointerIsValid(DatumGetPointer(oldOptions))) > - { > - ArrayType *array = DatumGetArrayTypeP(oldOptions); > - Datum *oldoptions; > - int noldoptions; > - int i; > - > - deconstruct_array(array, TEXTOID, -1, false, TYPALIGN_INT, > - &oldoptions, NULL, &noldoptions); > - > - for (i = 0; i < noldoptions; i++) > - { > - char *text_str = VARDATA(oldoptions[i]); > - int text_len = VARSIZE(oldoptions[i]) - VARHDRSZ; > - > - /* Search for a match in defList */ > - foreach(cell, defList) > - { > - DefElem *def = (DefElem *) lfirst(cell); > - int kw_len; > - > - /* ignore if not in the same namespace */ > - if (namspace == NULL) > - { > - if (def->defnamespace != NULL) > - continue; > - } > - else if (def->defnamespace == NULL) > - continue; > - else if (strcmp(def->defnamespace, namspace) != 0) > - continue; > - > - kw_len = strlen(def->defname); > - if (text_len > kw_len && text_str[kw_len] == '=' && > - strncmp(text_str, def->defname, kw_len) == 0) > - break; > - } > - if (!cell) > - { > - /* No match, so keep old option */ > - astate = accumArrayResult(astate, oldoptions[i], > - false, TEXTOID, > - CurrentMemoryContext); > - } > - } > - } > - > - /* > - * If CREATE/SET, add new options to array; if RESET, just check that the > - * user didn't say RESET (option=val). (Must do this because the grammar > - * doesn't enforce it.) > - */ > - foreach(cell, defList) > - { > - DefElem *def = (DefElem *) lfirst(cell); > - > - if (isReset) > - { > - if (def->arg != NULL) > - ereport(ERROR, > - (errcode(ERRCODE_SYNTAX_ERROR), > - errmsg("RESET must not include values for parameters"))); > - } > - else > - { > - text *t; > - const char *value; > - Size len; > - > - /* > - * Error out if the namespace is not valid. A NULL namespace is > - * always valid. > - */ > - if (def->defnamespace != NULL) > - { > - bool valid = false; > - int i; > - > - if (validnsps) > - { > - for (i = 0; validnsps[i]; i++) > - { > - if (strcmp(def->defnamespace, validnsps[i]) == 0) > - { > - valid = true; > - break; > - } > - } > - } > - > - if (!valid) > - ereport(ERROR, > - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > - errmsg("unrecognized parameter namespace \"%s\"", > - def->defnamespace))); > - } > - > - /* ignore if not in the same namespace */ > - if (namspace == NULL) > - { > - if (def->defnamespace != NULL) > - continue; > - } > - else if (def->defnamespace == NULL) > - continue; > - else if (strcmp(def->defnamespace, namspace) != 0) > - continue; > - > - /* > - * Flatten the DefElem into a text string like "name=arg". If we > - * have just "name", assume "name=true" is meant. Note: the > - * namespace is not output. > - */ > - if (def->arg != NULL) > - value = defGetString(def); > - else > - value = "true"; > - > - /* > - * This is not a great place for this test, but there's no other > - * convenient place to filter the option out. As WITH (oids = > - * false) will be removed someday, this seems like an acceptable > - * amount of ugly. > - */ > - if (acceptOidsOff && def->defnamespace == NULL && > - strcmp(def->defname, "oids") == 0) > - { > - if (defGetBoolean(def)) > - ereport(ERROR, > - (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), > - errmsg("tables declared WITH OIDS are not supported"))); > - /* skip over option, reloptions machinery doesn't know it */ > - continue; > - } > - > - len = VARHDRSZ + strlen(def->defname) + 1 + strlen(value); > - /* +1 leaves room for sprintf's trailing null */ > - t = (text *) palloc(len + 1); > - SET_VARSIZE(t, len); > - sprintf(VARDATA(t), "%s=%s", def->defname, value); > - > - astate = accumArrayResult(astate, PointerGetDatum(t), > - false, TEXTOID, > - CurrentMemoryContext); > - } > - } > - > - if (astate) > - result = makeArrayResult(astate, CurrentMemoryContext); > - else > - result = (Datum) 0; > - > - return result; > -} > - > - > -/* > - * Convert the text-array format of reloptions into a List of DefElem. > - * This is the inverse of transformRelOptions(). > - */ > -List * > -untransformRelOptions(Datum options) > -{ > - List *result = NIL; > - ArrayType *array; > - Datum *optiondatums; > - int noptions; > - int i; > - > - /* Nothing to do if no options */ > - if (!PointerIsValid(DatumGetPointer(options))) > - return result; > - > - array = DatumGetArrayTypeP(options); > - > - deconstruct_array(array, TEXTOID, -1, false, TYPALIGN_INT, > - &optiondatums, NULL, &noptions); > - > - for (i = 0; i < noptions; i++) > - { > - char *s; > - char *p; > - Node *val = NULL; > - > - s = TextDatumGetCString(optiondatums[i]); > - p = strchr(s, '='); > - if (p) > - { > - *p++ = '\0'; > - val = (Node *) makeString(pstrdup(p)); > - } > - result = lappend(result, makeDefElem(pstrdup(s), val, -1)); > - } > - > - return result; > + optionsSpecSetAddString(relopts->spec_set, name, desc, NoLock, 0, offset, > + default_val, validator); > +/* FIXME solve mistery with filler option! */ > } > > /* > @@ -1372,12 +245,13 @@ untransformRelOptions(Datum options) > */ > bytea * > extractRelOptions(HeapTuple tuple, TupleDesc tupdesc, > - amoptions_function amoptions) > + amreloptspecset_function amoptionsspecsetfn) > { > bytea *options; > bool isnull; > Datum datum; > Form_pg_class classForm; > + options_spec_set *spec_set; > > datum = fastgetattr(tuple, > Anum_pg_class_reloptions, > @@ -1394,702 +268,341 @@ extractRelOptions(HeapTuple tuple, TupleDesc tupdesc, > case RELKIND_RELATION: > case RELKIND_TOASTVALUE: > case RELKIND_MATVIEW: > - options = heap_reloptions(classForm->relkind, datum, false); > + spec_set = get_heap_relopt_spec_set(); > break; > case RELKIND_PARTITIONED_TABLE: > - options = partitioned_table_reloptions(datum, false); > + spec_set = get_partitioned_relopt_spec_set(); > break; > case RELKIND_VIEW: > - options = view_reloptions(datum, false); > + spec_set = get_view_relopt_spec_set(); > break; > case RELKIND_INDEX: > case RELKIND_PARTITIONED_INDEX: > - options = index_reloptions(amoptions, datum, false); > + if (amoptionsspecsetfn) > + spec_set = amoptionsspecsetfn(); > + else > + spec_set = NULL; > break; > case RELKIND_FOREIGN_TABLE: > - options = NULL; > + spec_set = NULL; > break; > default: > Assert(false); /* can't get here */ > - options = NULL; /* keep compiler quiet */ > + spec_set = NULL; /* keep compiler quiet */ > break; > } > + if (spec_set) > + options = optionsTextArrayToBytea(spec_set, datum, 0); > + else > + options = NULL; > > return options; > } > > -static void > -parseRelOptionsInternal(Datum options, bool validate, > - relopt_value *reloptions, int numoptions) > -{ > - ArrayType *array = DatumGetArrayTypeP(options); > - Datum *optiondatums; > - int noptions; > - int i; > - > - deconstruct_array(array, TEXTOID, -1, false, TYPALIGN_INT, > - &optiondatums, NULL, &noptions); > +options_spec_set * > +get_stdrd_relopt_spec_set(relopt_kind kind) > +{ > + bool is_for_toast = (kind == RELOPT_KIND_TOAST); > + > + options_spec_set * stdrd_relopt_spec_set = allocateOptionsSpecSet( > + is_for_toast ? "toast" : NULL, sizeof(StdRdOptions), 0); //FIXME change 0 to actual value (may be) > + optionsSpecSetAddInt(stdrd_relopt_spec_set, "fillfactor", > + "Packs table pages only to this percentag", > + ShareUpdateExclusiveLock, /* since it applies only > + * to later inserts */ > + is_for_toast ? OPTION_DEFINITION_FLAG_REJECT : 0, > + offsetof(StdRdOptions, fillfactor), > + HEAP_DEFAULT_FILLFACTOR, HEAP_MIN_FILLFACTOR, 100); > + optionsSpecSetAddBool(stdrd_relopt_spec_set, "autovacuum_enabled", > + "Enables autovacuum in this relation", > + ShareUpdateExclusiveLock, 0, > + offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, enabled), > + true); > + optionsSpecSetAddInt(stdrd_relopt_spec_set, "autovacuum_vacuum_threshold", > + "Minimum number of tuple updates or deletes prior to vacuum", > + ShareUpdateExclusiveLock, > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_threshold), > + -1, 0, INT_MAX); > + optionsSpecSetAddInt(stdrd_relopt_spec_set, "autovacuum_analyze_threshold", > + "Minimum number of tuple updates or deletes prior to vacuum", > + ShareUpdateExclusiveLock, > + is_for_toast ? OPTION_DEFINITION_FLAG_REJECT : 0, > + offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_threshold), > + -1, 0, INT_MAX); > + optionsSpecSetAddInt(stdrd_relopt_spec_set, "autovacuum_vacuum_cost_limit", > + "Vacuum cost amount available before napping, for autovacuum", > + ShareUpdateExclusiveLock, > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_limit), > + -1, 0, 10000); > + optionsSpecSetAddInt(stdrd_relopt_spec_set, "autovacuum_freeze_min_age", > + "Minimum age at which VACUUM should freeze a table row, for autovacuum", > + ShareUpdateExclusiveLock, > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_min_age), > + -1, 0, 1000000000); > + optionsSpecSetAddInt(stdrd_relopt_spec_set, "autovacuum_freeze_max_age", > + "Age at which to autovacuum a table to prevent transaction ID wraparound", > + ShareUpdateExclusiveLock, > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_max_age), > + -1, 100000, 2000000000); > + optionsSpecSetAddInt(stdrd_relopt_spec_set, "autovacuum_freeze_table_age", > + "Age at which VACUUM should perform a full table sweep to freeze row versions", > + ShareUpdateExclusiveLock, > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_table_age), > + -1, 0, 2000000000); > + optionsSpecSetAddInt(stdrd_relopt_spec_set, "autovacuum_multixact_freeze_min_age", > + "Minimum multixact age at which VACUUM should freeze a row multixact's, for autovacuum", > + ShareUpdateExclusiveLock, > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_min_age), > + -1, 0, 1000000000); > + optionsSpecSetAddInt(stdrd_relopt_spec_set, "autovacuum_multixact_freeze_max_age", > + "Multixact age at which to autovacuum a table to prevent multixact wraparound", > + ShareUpdateExclusiveLock, > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_max_age), > + -1, 10000, 2000000000); > + optionsSpecSetAddInt(stdrd_relopt_spec_set, "autovacuum_multixact_freeze_table_age", > + "Age of multixact at which VACUUM should perform a full table sweep to freeze row versions", > + ShareUpdateExclusiveLock, > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_table_age), > + -1, 0, 2000000000); > + optionsSpecSetAddInt(stdrd_relopt_spec_set,"log_autovacuum_min_duration", > + "Sets the minimum execution time above which autovacuum actions will be logged", > + ShareUpdateExclusiveLock, > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, log_min_duration), > + -1, -1, INT_MAX); > + optionsSpecSetAddReal(stdrd_relopt_spec_set, "autovacuum_vacuum_cost_delay", > + "Vacuum cost delay in milliseconds, for autovacuum", > + ShareUpdateExclusiveLock, > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_delay), > + -1, 0.0, 100.0); > + optionsSpecSetAddReal(stdrd_relopt_spec_set, "autovacuum_vacuum_scale_factor", > + "Number of tuple updates or deletes prior to vacuum as a fraction of reltuples", > + ShareUpdateExclusiveLock, > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_scale_factor), > + -1, 0.0, 100.0); > + > + optionsSpecSetAddReal(stdrd_relopt_spec_set, "autovacuum_vacuum_insert_scale_factor", > + "Number of tuple inserts prior to vacuum as a fraction of reltuples", > + ShareUpdateExclusiveLock, > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_ins_scale_factor), > + -1, 0.0, 100.0); > + > + optionsSpecSetAddReal(stdrd_relopt_spec_set, "autovacuum_analyze_scale_factor", > + "Number of tuple inserts, updates or deletes prior to analyze as a fraction of reltuples", > + ShareUpdateExclusiveLock, > + is_for_toast ? OPTION_DEFINITION_FLAG_REJECT : 0, > + offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_scale_factor), > + -1, 0.0, 100.0); > + > + > + > + optionsSpecSetAddInt(stdrd_relopt_spec_set, "toast_tuple_target", > + "Sets the target tuple length at which external columns will be toasted", > + ShareUpdateExclusiveLock, > + is_for_toast ? OPTION_DEFINITION_FLAG_REJECT : 0, > + offsetof(StdRdOptions, toast_tuple_target), > + TOAST_TUPLE_TARGET, 128, TOAST_TUPLE_TARGET_MAIN); > + > + optionsSpecSetAddBool(stdrd_relopt_spec_set, "user_catalog_table", > + "Declare a table as an additional catalog table, e.g. for the purpose of logical replication", > + AccessExclusiveLock, > + is_for_toast ? OPTION_DEFINITION_FLAG_REJECT : 0, > + offsetof(StdRdOptions, user_catalog_table), > + false); > + > + optionsSpecSetAddInt(stdrd_relopt_spec_set, "parallel_workers", > + "Number of parallel processes that can be used per executor node for this relation.", > + ShareUpdateExclusiveLock, > + is_for_toast ? OPTION_DEFINITION_FLAG_REJECT : 0, > + offsetof(StdRdOptions, parallel_workers), > + -1, 0, 1024); > + > + optionsSpecSetAddEnum(stdrd_relopt_spec_set, "vacuum_index_cleanup", > + "Controls index vacuuming and index cleanup", > + ShareUpdateExclusiveLock, 0, > + offsetof(StdRdOptions, vacuum_index_cleanup), > + StdRdOptIndexCleanupValues, > + STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO, > + gettext_noop("Valid values are \"on\", \"off\", and \"auto\".")); > + > + optionsSpecSetAddBool(stdrd_relopt_spec_set, "vacuum_truncate", > + "Enables vacuum to truncate empty pages at the end of this table", > + ShareUpdateExclusiveLock, 0, > + offsetof(StdRdOptions, vacuum_truncate), > + true); > + > +// FIXME Do something with OIDS > + > + return stdrd_relopt_spec_set; > +} > + > + > +static options_spec_set *heap_relopt_spec_set = NULL; > + > +options_spec_set * > +get_heap_relopt_spec_set(void) > +{ > + if (heap_relopt_spec_set) > + return heap_relopt_spec_set; > + heap_relopt_spec_set = get_stdrd_relopt_spec_set(RELOPT_KIND_HEAP); > + return heap_relopt_spec_set; > +} > + > +static options_spec_set *toast_relopt_spec_set = NULL; > + > +options_spec_set * > +get_toast_relopt_spec_set(void) > +{ > + if (toast_relopt_spec_set) > + return toast_relopt_spec_set; > + toast_relopt_spec_set = get_stdrd_relopt_spec_set(RELOPT_KIND_TOAST); > + return toast_relopt_spec_set; > +} > + > +static options_spec_set *partitioned_relopt_spec_set = NULL; > > - for (i = 0; i < noptions; i++) > - { > - char *text_str = VARDATA(optiondatums[i]); > - int text_len = VARSIZE(optiondatums[i]) - VARHDRSZ; > - int j; > - > - /* Search for a match in reloptions */ > - for (j = 0; j < numoptions; j++) > - { > - int kw_len = reloptions[j].gen->namelen; > - > - if (text_len > kw_len && text_str[kw_len] == '=' && > - strncmp(text_str, reloptions[j].gen->name, kw_len) == 0) > - { > - parse_one_reloption(&reloptions[j], text_str, text_len, > - validate); > - break; > - } > - } > - > - if (j >= numoptions && validate) > - { > - char *s; > - char *p; > - > - s = TextDatumGetCString(optiondatums[i]); > - p = strchr(s, '='); > - if (p) > - *p = '\0'; > - ereport(ERROR, > - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > - errmsg("unrecognized parameter \"%s\"", s))); > - } > - } > - > - /* It's worth avoiding memory leaks in this function */ > - pfree(optiondatums); > +options_spec_set * > +get_partitioned_relopt_spec_set(void) > +{ > + if (partitioned_relopt_spec_set) > + return partitioned_relopt_spec_set; > + partitioned_relopt_spec_set = allocateOptionsSpecSet( > + NULL, sizeof(StdRdOptions), 0); > + /* No options for now, so spec set is empty */ > > - if (((void *) array) != DatumGetPointer(options)) > - pfree(array); > + return partitioned_relopt_spec_set; > } > > /* > - * Interpret reloptions that are given in text-array format. > - * > - * options is a reloption text array as constructed by transformRelOptions. > - * kind specifies the family of options to be processed. > - * > - * The return value is a relopt_value * array on which the options actually > - * set in the options array are marked with isset=true. The length of this > - * array is returned in *numrelopts. Options not set are also present in the > - * array; this is so that the caller can easily locate the default values. > - * > - * If there are no options of the given kind, numrelopts is set to 0 and NULL > - * is returned (unless options are illegally supplied despite none being > - * defined, in which case an error occurs). > - * > - * Note: values of type int, bool and real are allocated as part of the > - * returned array. Values of type string are allocated separately and must > - * be freed by the caller. > + * Parse local options, allocate a bytea struct that's of the specified > + * 'base_size' plus any extra space that's needed for string variables, > + * fill its option's fields located at the given offsets and return it. > */ > -static relopt_value * > -parseRelOptions(Datum options, bool validate, relopt_kind kind, > - int *numrelopts) > -{ > - relopt_value *reloptions = NULL; > - int numoptions = 0; > - int i; > - int j; > - > - if (need_initialization) > - initialize_reloptions(); > - > - /* Build a list of expected options, based on kind */ > - > - for (i = 0; relOpts[i]; i++) > - if (relOpts[i]->kinds & kind) > - numoptions++; > - > - if (numoptions > 0) > - { > - reloptions = palloc(numoptions * sizeof(relopt_value)); > - > - for (i = 0, j = 0; relOpts[i]; i++) > - { > - if (relOpts[i]->kinds & kind) > - { > - reloptions[j].gen = relOpts[i]; > - reloptions[j].isset = false; > - j++; > - } > - } > - } > - > - /* Done if no options */ > - if (PointerIsValid(DatumGetPointer(options))) > - parseRelOptionsInternal(options, validate, reloptions, numoptions); > - > - *numrelopts = numoptions; > - return reloptions; > -} > - > -/* Parse local unregistered options. */ > -static relopt_value * > -parseLocalRelOptions(local_relopts *relopts, Datum options, bool validate) > +void * > +build_local_reloptions(local_relopts *relopts, Datum options, bool validate) > { > - int nopts = list_length(relopts->options); > - relopt_value *values = palloc(sizeof(*values) * nopts); > + void *opts; > ListCell *lc; > - int i = 0; > - > - foreach(lc, relopts->options) > - { > - local_relopt *opt = lfirst(lc); > - > - values[i].gen = opt->option; > - values[i].isset = false; > - > - i++; > - } > - > - if (options != (Datum) 0) > - parseRelOptionsInternal(options, validate, values, nopts); > + opts = (void *) optionsTextArrayToBytea(relopts->spec_set, options, validate); > > - return values; > -} > - > -/* > - * Subroutine for parseRelOptions, to parse and validate a single option's > - * value > - */ > -static void > -parse_one_reloption(relopt_value *option, char *text_str, int text_len, > - bool validate) > -{ > - char *value; > - int value_len; > - bool parsed; > - bool nofree = false; > - > - if (option->isset && validate) > - ereport(ERROR, > - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > - errmsg("parameter \"%s\" specified more than once", > - option->gen->name))); > - > - value_len = text_len - option->gen->namelen - 1; > - value = (char *) palloc(value_len + 1); > - memcpy(value, text_str + option->gen->namelen + 1, value_len); > - value[value_len] = '\0'; > - > - switch (option->gen->type) > - { > - case RELOPT_TYPE_BOOL: > - { > - parsed = parse_bool(value, &option->values.bool_val); > - if (validate && !parsed) > - ereport(ERROR, > - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > - errmsg("invalid value for boolean option \"%s\": %s", > - option->gen->name, value))); > - } > - break; > - case RELOPT_TYPE_INT: > - { > - relopt_int *optint = (relopt_int *) option->gen; > - > - parsed = parse_int(value, &option->values.int_val, 0, NULL); > - if (validate && !parsed) > - ereport(ERROR, > - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > - errmsg("invalid value for integer option \"%s\": %s", > - option->gen->name, value))); > - if (validate && (option->values.int_val < optint->min || > - option->values.int_val > optint->max)) > - ereport(ERROR, > - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > - errmsg("value %s out of bounds for option \"%s\"", > - value, option->gen->name), > - errdetail("Valid values are between \"%d\" and \"%d\".", > - optint->min, optint->max))); > - } > - break; > - case RELOPT_TYPE_REAL: > - { > - relopt_real *optreal = (relopt_real *) option->gen; > - > - parsed = parse_real(value, &option->values.real_val, 0, NULL); > - if (validate && !parsed) > - ereport(ERROR, > - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > - errmsg("invalid value for floating point option \"%s\": %s", > - option->gen->name, value))); > - if (validate && (option->values.real_val < optreal->min || > - option->values.real_val > optreal->max)) > - ereport(ERROR, > - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > - errmsg("value %s out of bounds for option \"%s\"", > - value, option->gen->name), > - errdetail("Valid values are between \"%f\" and \"%f\".", > - optreal->min, optreal->max))); > - } > - break; > - case RELOPT_TYPE_ENUM: > - { > - relopt_enum *optenum = (relopt_enum *) option->gen; > - relopt_enum_elt_def *elt; > - > - parsed = false; > - for (elt = optenum->members; elt->string_val; elt++) > - { > - if (pg_strcasecmp(value, elt->string_val) == 0) > - { > - option->values.enum_val = elt->symbol_val; > - parsed = true; > - break; > - } > - } > - if (validate && !parsed) > - ereport(ERROR, > - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > - errmsg("invalid value for enum option \"%s\": %s", > - option->gen->name, value), > - optenum->detailmsg ? > - errdetail_internal("%s", _(optenum->detailmsg)) : 0)); > - > - /* > - * If value is not among the allowed string values, but we are > - * not asked to validate, just use the default numeric value. > - */ > - if (!parsed) > - option->values.enum_val = optenum->default_val; > - } > - break; > - case RELOPT_TYPE_STRING: > - { > - relopt_string *optstring = (relopt_string *) option->gen; > - > - option->values.string_val = value; > - nofree = true; > - if (validate && optstring->validate_cb) > - (optstring->validate_cb) (value); > - parsed = true; > - } > - break; > - default: > - elog(ERROR, "unsupported reloption type %d", option->gen->type); > - parsed = true; /* quiet compiler */ > - break; > - } > + foreach(lc, relopts->validators) > + ((relopts_validator) lfirst(lc)) (opts, NULL, 0); > +// ((relopts_validator) lfirst(lc)) (opts, vals, noptions); > +// FIXME solve problem with validation of separate option values; > + return opts; > > - if (parsed) > - option->isset = true; > - if (!nofree) > - pfree(value); > } > > /* > - * Given the result from parseRelOptions, allocate a struct that's of the > - * specified base size plus any extra space that's needed for string variables. > - * > - * "base" should be sizeof(struct) of the reloptions struct (StdRdOptions or > - * equivalent). > + * get_view_relopt_spec_set > + * Returns an options catalog for view relation. > */ > -static void * > -allocateReloptStruct(Size base, relopt_value *options, int numoptions) > -{ > - Size size = base; > - int i; > - > - for (i = 0; i < numoptions; i++) > - { > - relopt_value *optval = &options[i]; > - > - if (optval->gen->type == RELOPT_TYPE_STRING) > - { > - relopt_string *optstr = (relopt_string *) optval->gen; > - > - if (optstr->fill_cb) > - { > - const char *val = optval->isset ? optval->values.string_val : > - optstr->default_isnull ? NULL : optstr->default_val; > - > - size += optstr->fill_cb(val, NULL); > - } > - else > - size += GET_STRING_RELOPTION_LEN(*optval) + 1; > - } > - } > - > - return palloc0(size); > -} > +static options_spec_set *view_relopt_spec_set = NULL; > > -/* > - * Given the result of parseRelOptions and a parsing table, fill in the > - * struct (previously allocated with allocateReloptStruct) with the parsed > - * values. > - * > - * rdopts is the pointer to the allocated struct to be filled. > - * basesize is the sizeof(struct) that was passed to allocateReloptStruct. > - * options, of length numoptions, is parseRelOptions' output. > - * elems, of length numelems, is the table describing the allowed options. > - * When validate is true, it is expected that all options appear in elems. > - */ > -static void > -fillRelOptions(void *rdopts, Size basesize, > - relopt_value *options, int numoptions, > - bool validate, > - const relopt_parse_elt *elems, int numelems) > +options_spec_set * > +get_view_relopt_spec_set(void) > { > - int i; > - int offset = basesize; > + if (view_relopt_spec_set) > + return view_relopt_spec_set; > > - for (i = 0; i < numoptions; i++) > - { > - int j; > - bool found = false; > + view_relopt_spec_set = allocateOptionsSpecSet(NULL, > + sizeof(ViewOptions), 2); > > - for (j = 0; j < numelems; j++) > - { > - if (strcmp(options[i].gen->name, elems[j].optname) == 0) > - { > - relopt_string *optstring; > - char *itempos = ((char *) rdopts) + elems[j].offset; > - char *string_val; > - > - switch (options[i].gen->type) > - { > - case RELOPT_TYPE_BOOL: > - *(bool *) itempos = options[i].isset ? > - options[i].values.bool_val : > - ((relopt_bool *) options[i].gen)->default_val; > - break; > - case RELOPT_TYPE_INT: > - *(int *) itempos = options[i].isset ? > - options[i].values.int_val : > - ((relopt_int *) options[i].gen)->default_val; > - break; > - case RELOPT_TYPE_REAL: > - *(double *) itempos = options[i].isset ? > - options[i].values.real_val : > - ((relopt_real *) options[i].gen)->default_val; > - break; > - case RELOPT_TYPE_ENUM: > - *(int *) itempos = options[i].isset ? > - options[i].values.enum_val : > - ((relopt_enum *) options[i].gen)->default_val; > - break; > - case RELOPT_TYPE_STRING: > - optstring = (relopt_string *) options[i].gen; > - if (options[i].isset) > - string_val = options[i].values.string_val; > - else if (!optstring->default_isnull) > - string_val = optstring->default_val; > - else > - string_val = NULL; > - > - if (optstring->fill_cb) > - { > - Size size = > - optstring->fill_cb(string_val, > - (char *) rdopts + offset); > - > - if (size) > - { > - *(int *) itempos = offset; > - offset += size; > - } > - else > - *(int *) itempos = 0; > - } > - else if (string_val == NULL) > - *(int *) itempos = 0; > - else > - { > - strcpy((char *) rdopts + offset, string_val); > - *(int *) itempos = offset; > - offset += strlen(string_val) + 1; > - } > - break; > - default: > - elog(ERROR, "unsupported reloption type %d", > - options[i].gen->type); > - break; > - } > - found = true; > - break; > - } > - } > - if (validate && !found) > - elog(ERROR, "reloption \"%s\" not found in parse table", > - options[i].gen->name); > - } > - SET_VARSIZE(rdopts, offset); > -} > + optionsSpecSetAddBool(view_relopt_spec_set, "security_barrier", > + "View acts as a row security barrier", > + AccessExclusiveLock, > + 0, offsetof(ViewOptions, security_barrier), false); > > + optionsSpecSetAddEnum(view_relopt_spec_set, "check_option", > + "View has WITH CHECK OPTION defined (local or cascaded)", > + AccessExclusiveLock, 0, > + offsetof(ViewOptions, check_option), > + viewCheckOptValues, > + VIEW_OPTION_CHECK_OPTION_NOT_SET, > + gettext_noop("Valid values are \"local\" and \"cascaded\".")); > > -/* > - * Option parser for anything that uses StdRdOptions. > - */ > -bytea * > -default_reloptions(Datum reloptions, bool validate, relopt_kind kind) > -{ > - static const relopt_parse_elt tab[] = { > - {"fillfactor", RELOPT_TYPE_INT, offsetof(StdRdOptions, fillfactor)}, > - {"autovacuum_enabled", RELOPT_TYPE_BOOL, > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, enabled)}, > - {"autovacuum_vacuum_threshold", RELOPT_TYPE_INT, > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_threshold)}, > - {"autovacuum_vacuum_insert_threshold", RELOPT_TYPE_INT, > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_ins_threshold)}, > - {"autovacuum_analyze_threshold", RELOPT_TYPE_INT, > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_threshold)}, > - {"autovacuum_vacuum_cost_limit", RELOPT_TYPE_INT, > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_limit)}, > - {"autovacuum_freeze_min_age", RELOPT_TYPE_INT, > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_min_age)}, > - {"autovacuum_freeze_max_age", RELOPT_TYPE_INT, > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_max_age)}, > - {"autovacuum_freeze_table_age", RELOPT_TYPE_INT, > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_table_age)}, > - {"autovacuum_multixact_freeze_min_age", RELOPT_TYPE_INT, > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_min_age)}, > - {"autovacuum_multixact_freeze_max_age", RELOPT_TYPE_INT, > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_max_age)}, > - {"autovacuum_multixact_freeze_table_age", RELOPT_TYPE_INT, > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_table_age)}, > - {"log_autovacuum_min_duration", RELOPT_TYPE_INT, > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, log_min_duration)}, > - {"toast_tuple_target", RELOPT_TYPE_INT, > - offsetof(StdRdOptions, toast_tuple_target)}, > - {"autovacuum_vacuum_cost_delay", RELOPT_TYPE_REAL, > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_delay)}, > - {"autovacuum_vacuum_scale_factor", RELOPT_TYPE_REAL, > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_scale_factor)}, > - {"autovacuum_vacuum_insert_scale_factor", RELOPT_TYPE_REAL, > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_ins_scale_factor)}, > - {"autovacuum_analyze_scale_factor", RELOPT_TYPE_REAL, > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_scale_factor)}, > - {"user_catalog_table", RELOPT_TYPE_BOOL, > - offsetof(StdRdOptions, user_catalog_table)}, > - {"parallel_workers", RELOPT_TYPE_INT, > - offsetof(StdRdOptions, parallel_workers)}, > - {"vacuum_index_cleanup", RELOPT_TYPE_ENUM, > - offsetof(StdRdOptions, vacuum_index_cleanup)}, > - {"vacuum_truncate", RELOPT_TYPE_BOOL, > - offsetof(StdRdOptions, vacuum_truncate)} > - }; > - > - return (bytea *) build_reloptions(reloptions, validate, kind, > - sizeof(StdRdOptions), > - tab, lengthof(tab)); > + return view_relopt_spec_set; > } > > /* > - * build_reloptions > - * > - * Parses "reloptions" provided by the caller, returning them in a > - * structure containing the parsed options. The parsing is done with > - * the help of a parsing table describing the allowed options, defined > - * by "relopt_elems" of length "num_relopt_elems". > - * > - * "validate" must be true if reloptions value is freshly built by > - * transformRelOptions(), as opposed to being read from the catalog, in which > - * case the values contained in it must already be valid. > - * > - * NULL is returned if the passed-in options did not match any of the options > - * in the parsing table, unless validate is true in which case an error would > - * be reported. > + * get_attribute_options_spec_set > + * Returns an options spec det for heap attributes > */ > -void * > -build_reloptions(Datum reloptions, bool validate, > - relopt_kind kind, > - Size relopt_struct_size, > - const relopt_parse_elt *relopt_elems, > - int num_relopt_elems) > -{ > - int numoptions; > - relopt_value *options; > - void *rdopts; > - > - /* parse options specific to given relation option kind */ > - options = parseRelOptions(reloptions, validate, kind, &numoptions); > - Assert(numoptions <= num_relopt_elems); > - > - /* if none set, we're done */ > - if (numoptions == 0) > - { > - Assert(options == NULL); > - return NULL; > - } > - > - /* allocate and fill the structure */ > - rdopts = allocateReloptStruct(relopt_struct_size, options, numoptions); > - fillRelOptions(rdopts, relopt_struct_size, options, numoptions, > - validate, relopt_elems, num_relopt_elems); > +static options_spec_set *attribute_options_spec_set = NULL; > > - pfree(options); > - > - return rdopts; > -} > - > -/* > - * Parse local options, allocate a bytea struct that's of the specified > - * 'base_size' plus any extra space that's needed for string variables, > - * fill its option's fields located at the given offsets and return it. > - */ > -void * > -build_local_reloptions(local_relopts *relopts, Datum options, bool validate) > +options_spec_set * > +get_attribute_options_spec_set(void) > { > - int noptions = list_length(relopts->options); > - relopt_parse_elt *elems = palloc(sizeof(*elems) * noptions); > - relopt_value *vals; > - void *opts; > - int i = 0; > - ListCell *lc; > + if (attribute_options_spec_set) > + return attribute_options_spec_set; > > - foreach(lc, relopts->options) > - { > - local_relopt *opt = lfirst(lc); > - > - elems[i].optname = opt->option->name; > - elems[i].opttype = opt->option->type; > - elems[i].offset = opt->offset; > - > - i++; > - } > + attribute_options_spec_set = allocateOptionsSpecSet(NULL, > + sizeof(AttributeOpts), 2); > > - vals = parseLocalRelOptions(relopts, options, validate); > - opts = allocateReloptStruct(relopts->relopt_struct_size, vals, noptions); > - fillRelOptions(opts, relopts->relopt_struct_size, vals, noptions, validate, > - elems, noptions); > + optionsSpecSetAddReal(attribute_options_spec_set, "n_distinct", > + "Sets the planner's estimate of the number of distinct values appearing in a column (excludingchild relations).", > + ShareUpdateExclusiveLock, > + 0, offsetof(AttributeOpts, n_distinct), 0, -1.0, DBL_MAX); > > - foreach(lc, relopts->validators) > - ((relopts_validator) lfirst(lc)) (opts, vals, noptions); > - > - if (elems) > - pfree(elems); > + optionsSpecSetAddReal(attribute_options_spec_set, > + "n_distinct_inherited", > + "Sets the planner's estimate of the number of distinct values appearing in a column (includingchild relations).", > + ShareUpdateExclusiveLock, > + 0, offsetof(AttributeOpts, n_distinct_inherited), 0, -1.0, DBL_MAX); > > - return opts; > + return attribute_options_spec_set; > } > > -/* > - * Option parser for partitioned tables > - */ > -bytea * > -partitioned_table_reloptions(Datum reloptions, bool validate) > -{ > - /* > - * There are no options for partitioned tables yet, but this is able to do > - * some validation. > - */ > - return (bytea *) build_reloptions(reloptions, validate, > - RELOPT_KIND_PARTITIONED, > - 0, NULL, 0); > -} > > /* > - * Option parser for views > - */ > -bytea * > -view_reloptions(Datum reloptions, bool validate) > -{ > - static const relopt_parse_elt tab[] = { > - {"security_barrier", RELOPT_TYPE_BOOL, > - offsetof(ViewOptions, security_barrier)}, > - {"check_option", RELOPT_TYPE_ENUM, > - offsetof(ViewOptions, check_option)} > - }; > - > - return (bytea *) build_reloptions(reloptions, validate, > - RELOPT_KIND_VIEW, > - sizeof(ViewOptions), > - tab, lengthof(tab)); > -} > + * get_tablespace_options_spec_set > + * Returns an options spec set for tablespaces > +*/ > +static options_spec_set *tablespace_options_spec_set = NULL; > > -/* > - * Parse options for heaps, views and toast tables. > - */ > -bytea * > -heap_reloptions(char relkind, Datum reloptions, bool validate) > +options_spec_set * > +get_tablespace_options_spec_set(void) > { > - StdRdOptions *rdopts; > - > - switch (relkind) > + if (!tablespace_options_spec_set) > { > - case RELKIND_TOASTVALUE: > - rdopts = (StdRdOptions *) > - default_reloptions(reloptions, validate, RELOPT_KIND_TOAST); > - if (rdopts != NULL) > - { > - /* adjust default-only parameters for TOAST relations */ > - rdopts->fillfactor = 100; > - rdopts->autovacuum.analyze_threshold = -1; > - rdopts->autovacuum.analyze_scale_factor = -1; > - } > - return (bytea *) rdopts; > - case RELKIND_RELATION: > - case RELKIND_MATVIEW: > - return default_reloptions(reloptions, validate, RELOPT_KIND_HEAP); > - default: > - /* other relkinds are not supported */ > - return NULL; > - } > -} > - > - > -/* > - * Parse options for indexes. > - * > - * amoptions index AM's option parser function > - * reloptions options as text[] datum > - * validate error flag > - */ > -bytea * > -index_reloptions(amoptions_function amoptions, Datum reloptions, bool validate) > -{ > - Assert(amoptions != NULL); > + tablespace_options_spec_set = allocateOptionsSpecSet(NULL, > + sizeof(TableSpaceOpts), 4); > > - /* Assume function is strict */ > - if (!PointerIsValid(DatumGetPointer(reloptions))) > - return NULL; > + optionsSpecSetAddReal(tablespace_options_spec_set, > + "random_page_cost", > + "Sets the planner's estimate of the cost of a nonsequentially fetched disk page", > + ShareUpdateExclusiveLock, > + 0, offsetof(TableSpaceOpts, random_page_cost), -1, 0.0, DBL_MAX); > > - return amoptions(reloptions, validate); > -} > + optionsSpecSetAddReal(tablespace_options_spec_set, "seq_page_cost", > + "Sets the planner's estimate of the cost of a sequentially fetched disk page", > + ShareUpdateExclusiveLock, > + 0, offsetof(TableSpaceOpts, seq_page_cost), -1, 0.0, DBL_MAX); > > -/* > - * Option parser for attribute reloptions > - */ > -bytea * > -attribute_reloptions(Datum reloptions, bool validate) > -{ > - static const relopt_parse_elt tab[] = { > - {"n_distinct", RELOPT_TYPE_REAL, offsetof(AttributeOpts, n_distinct)}, > - {"n_distinct_inherited", RELOPT_TYPE_REAL, offsetof(AttributeOpts, n_distinct_inherited)} > - }; > - > - return (bytea *) build_reloptions(reloptions, validate, > - RELOPT_KIND_ATTRIBUTE, > - sizeof(AttributeOpts), > - tab, lengthof(tab)); > -} > + optionsSpecSetAddInt(tablespace_options_spec_set, > + "effective_io_concurrency", > + "Number of simultaneous requests that can be handled efficiently by the disk subsystem", > + ShareUpdateExclusiveLock, > + 0, offsetof(TableSpaceOpts, effective_io_concurrency), > +#ifdef USE_PREFETCH > + -1, 0, MAX_IO_CONCURRENCY > +#else > + 0, 0, 0 > +#endif > + ); > > -/* > - * Option parser for tablespace reloptions > - */ > -bytea * > -tablespace_reloptions(Datum reloptions, bool validate) > -{ > - static const relopt_parse_elt tab[] = { > - {"random_page_cost", RELOPT_TYPE_REAL, offsetof(TableSpaceOpts, random_page_cost)}, > - {"seq_page_cost", RELOPT_TYPE_REAL, offsetof(TableSpaceOpts, seq_page_cost)}, > - {"effective_io_concurrency", RELOPT_TYPE_INT, offsetof(TableSpaceOpts, effective_io_concurrency)}, > - {"maintenance_io_concurrency", RELOPT_TYPE_INT, offsetof(TableSpaceOpts, maintenance_io_concurrency)} > - }; > - > - return (bytea *) build_reloptions(reloptions, validate, > - RELOPT_KIND_TABLESPACE, > - sizeof(TableSpaceOpts), > - tab, lengthof(tab)); > + optionsSpecSetAddInt(tablespace_options_spec_set, > + "maintenance_io_concurrency", > + "Number of simultaneous requests that can be handled efficiently by the disk subsystemfor maintenance work.", > + ShareUpdateExclusiveLock, > + 0, offsetof(TableSpaceOpts, maintenance_io_concurrency), > +#ifdef USE_PREFETCH > + -1, 0, MAX_IO_CONCURRENCY > +#else > + 0, 0, 0 > +#endif > + ); > + } > + return tablespace_options_spec_set; > } > > /* > @@ -2099,33 +612,55 @@ tablespace_reloptions(Datum reloptions, bool validate) > * for a longer explanation of how this works. > */ > LOCKMODE > -AlterTableGetRelOptionsLockLevel(List *defList) > +AlterTableGetRelOptionsLockLevel(Relation rel, List *defList) > { > LOCKMODE lockmode = NoLock; > ListCell *cell; > + options_spec_set *spec_set = NULL; > > if (defList == NIL) > return AccessExclusiveLock; > > - if (need_initialization) > - initialize_reloptions(); > + switch (rel->rd_rel->relkind) > + { > + case RELKIND_TOASTVALUE: > + spec_set = get_toast_relopt_spec_set(); > + break; > + case RELKIND_RELATION: > + case RELKIND_MATVIEW: > + spec_set = get_heap_relopt_spec_set(); > + break; > + case RELKIND_INDEX: > + spec_set = rel->rd_indam->amreloptspecset(); > + break; > + case RELKIND_VIEW: > + spec_set = get_view_relopt_spec_set(); > + break; > + case RELKIND_PARTITIONED_TABLE: > + spec_set = get_partitioned_relopt_spec_set(); > + break; > + default: > + Assert(false); /* can't get here */ > + break; > + } > + Assert(spec_set); /* No spec set - no reloption change. Should > + * never get here */ > > foreach(cell, defList) > { > DefElem *def = (DefElem *) lfirst(cell); > + > int i; > > - for (i = 0; relOpts[i]; i++) > + for (i = 0; i < spec_set->num; i++) > { > - if (strncmp(relOpts[i]->name, > - def->defname, > - relOpts[i]->namelen + 1) == 0) > - { > - if (lockmode < relOpts[i]->lockmode) > - lockmode = relOpts[i]->lockmode; > - } > + option_spec_basic *gen = spec_set->definitions[i]; > + > + if (pg_strcasecmp(gen->name, > + def->defname) == 0) > + if (lockmode < gen->lockmode) > + lockmode = gen->lockmode; > } > } > - > return lockmode; > -} > +} > \ No newline at end of file > diff --git a/src/backend/access/gin/gininsert.c b/src/backend/access/gin/gininsert.c > index 0e8672c..0cbffad 100644 > --- a/src/backend/access/gin/gininsert.c > +++ b/src/backend/access/gin/gininsert.c > @@ -512,6 +512,8 @@ gininsert(Relation index, Datum *values, bool *isnull, > > oldCtx = MemoryContextSwitchTo(insertCtx); > > +// elog(WARNING, "GinGetUseFastUpdate = %i", GinGetUseFastUpdate(index)); > + > if (GinGetUseFastUpdate(index)) > { > GinTupleCollector collector; > diff --git a/src/backend/access/gin/ginutil.c b/src/backend/access/gin/ginutil.c > index 6d2d71b..d1fa3a0 100644 > --- a/src/backend/access/gin/ginutil.c > +++ b/src/backend/access/gin/ginutil.c > @@ -16,7 +16,7 @@ > > #include "access/gin_private.h" > #include "access/ginxlog.h" > -#include "access/reloptions.h" > +#include "access/options.h" > #include "access/xloginsert.h" > #include "catalog/pg_collation.h" > #include "catalog/pg_type.h" > @@ -28,6 +28,7 @@ > #include "utils/builtins.h" > #include "utils/index_selfuncs.h" > #include "utils/typcache.h" > +#include "utils/guc.h" > > > /* > @@ -67,7 +68,6 @@ ginhandler(PG_FUNCTION_ARGS) > amroutine->amvacuumcleanup = ginvacuumcleanup; > amroutine->amcanreturn = NULL; > amroutine->amcostestimate = gincostestimate; > - amroutine->amoptions = ginoptions; > amroutine->amproperty = NULL; > amroutine->ambuildphasename = NULL; > amroutine->amvalidate = ginvalidate; > @@ -82,6 +82,7 @@ ginhandler(PG_FUNCTION_ARGS) > amroutine->amestimateparallelscan = NULL; > amroutine->aminitparallelscan = NULL; > amroutine->amparallelrescan = NULL; > + amroutine->amreloptspecset = gingetreloptspecset; > > PG_RETURN_POINTER(amroutine); > } > @@ -604,6 +605,7 @@ ginExtractEntries(GinState *ginstate, OffsetNumber attnum, > return entries; > } > > +/* > bytea * > ginoptions(Datum reloptions, bool validate) > { > @@ -618,6 +620,7 @@ ginoptions(Datum reloptions, bool validate) > sizeof(GinOptions), > tab, lengthof(tab)); > } > +*/ > > /* > * Fetch index's statistical data into *stats > @@ -705,3 +708,31 @@ ginUpdateStats(Relation index, const GinStatsData *stats, bool is_build) > > END_CRIT_SECTION(); > } > + > +static options_spec_set *gin_relopt_specset = NULL; > + > +void * > +gingetreloptspecset(void) > +{ > + if (gin_relopt_specset) > + return gin_relopt_specset; > + > + gin_relopt_specset = allocateOptionsSpecSet(NULL, > + sizeof(GinOptions), 2); > + > + optionsSpecSetAddBool(gin_relopt_specset, "fastupdate", > + "Enables \"fast update\" feature for this GIN index", > + AccessExclusiveLock, > + 0, > + offsetof(GinOptions, useFastUpdate), > + GIN_DEFAULT_USE_FASTUPDATE); > + > + optionsSpecSetAddInt(gin_relopt_specset, "gin_pending_list_limit", > + "Maximum size of the pending list for this GIN index, in kilobytes", > + AccessExclusiveLock, > + 0, > + offsetof(GinOptions, pendingListCleanupSize), > + -1, 64, MAX_KILOBYTES); > + > + return gin_relopt_specset; > +} > diff --git a/src/backend/access/gist/gist.c b/src/backend/access/gist/gist.c > index 0683f42..cbbc6a5 100644 > --- a/src/backend/access/gist/gist.c > +++ b/src/backend/access/gist/gist.c > @@ -88,7 +88,6 @@ gisthandler(PG_FUNCTION_ARGS) > amroutine->amvacuumcleanup = gistvacuumcleanup; > amroutine->amcanreturn = gistcanreturn; > amroutine->amcostestimate = gistcostestimate; > - amroutine->amoptions = gistoptions; > amroutine->amproperty = gistproperty; > amroutine->ambuildphasename = NULL; > amroutine->amvalidate = gistvalidate; > @@ -103,6 +102,7 @@ gisthandler(PG_FUNCTION_ARGS) > amroutine->amestimateparallelscan = NULL; > amroutine->aminitparallelscan = NULL; > amroutine->amparallelrescan = NULL; > + amroutine->amreloptspecset = gistgetreloptspecset; > > PG_RETURN_POINTER(amroutine); > } > diff --git a/src/backend/access/gist/gistbuild.c b/src/backend/access/gist/gistbuild.c > index baad28c..931d249 100644 > --- a/src/backend/access/gist/gistbuild.c > +++ b/src/backend/access/gist/gistbuild.c > @@ -215,6 +215,7 @@ gistbuild(Relation heap, Relation index, IndexInfo *indexInfo) > buildstate.buildMode = GIST_BUFFERING_DISABLED; > else /* must be "auto" */ > buildstate.buildMode = GIST_BUFFERING_AUTO; > +//elog(WARNING, "biffering_mode = %i", options->buffering_mode); > } > else > { > diff --git a/src/backend/access/gist/gistutil.c b/src/backend/access/gist/gistutil.c > index 43ba03b..0391915 100644 > --- a/src/backend/access/gist/gistutil.c > +++ b/src/backend/access/gist/gistutil.c > @@ -17,7 +17,7 @@ > > #include "access/gist_private.h" > #include "access/htup_details.h" > -#include "access/reloptions.h" > +#include "access/options.h" > #include "catalog/pg_opclass.h" > #include "storage/indexfsm.h" > #include "storage/lmgr.h" > @@ -916,20 +916,6 @@ gistPageRecyclable(Page page) > return false; > } > > -bytea * > -gistoptions(Datum reloptions, bool validate) > -{ > - static const relopt_parse_elt tab[] = { > - {"fillfactor", RELOPT_TYPE_INT, offsetof(GiSTOptions, fillfactor)}, > - {"buffering", RELOPT_TYPE_ENUM, offsetof(GiSTOptions, buffering_mode)} > - }; > - > - return (bytea *) build_reloptions(reloptions, validate, > - RELOPT_KIND_GIST, > - sizeof(GiSTOptions), > - tab, lengthof(tab)); > -} > - > /* > * gistproperty() -- Check boolean properties of indexes. > * > @@ -1064,3 +1050,42 @@ gistGetFakeLSN(Relation rel) > return GetFakeLSNForUnloggedRel(); > } > } > + > +/* values from GistOptBufferingMode */ > +opt_enum_elt_def gistBufferingOptValues[] = > +{ > + {"auto", GIST_OPTION_BUFFERING_AUTO}, > + {"on", GIST_OPTION_BUFFERING_ON}, > + {"off", GIST_OPTION_BUFFERING_OFF}, > + {(const char *) NULL} /* list terminator */ > +}; > + > +static options_spec_set *gist_relopt_specset = NULL; > + > +void * > +gistgetreloptspecset(void) > +{ > + if (gist_relopt_specset) > + return gist_relopt_specset; > + > + gist_relopt_specset = allocateOptionsSpecSet(NULL, > + sizeof(GiSTOptions), 2); > + > + optionsSpecSetAddInt(gist_relopt_specset, "fillfactor", > + "Packs gist index pages only to this percentage", > + NoLock, /* No ALTER, no lock */ > + 0, > + offsetof(GiSTOptions, fillfactor), > + GIST_DEFAULT_FILLFACTOR, > + GIST_MIN_FILLFACTOR, 100); > + > + optionsSpecSetAddEnum(gist_relopt_specset, "buffering", > + "Enables buffering build for this GiST index", > + NoLock, /* No ALTER, no lock */ > + 0, > + offsetof(GiSTOptions, buffering_mode), > + gistBufferingOptValues, > + GIST_OPTION_BUFFERING_AUTO, > + gettext_noop("Valid values are \"on\", \"off\", and \"auto\".")); > + return gist_relopt_specset; > +} > diff --git a/src/backend/access/hash/hash.c b/src/backend/access/hash/hash.c > index eb38104..8dc4ca7 100644 > --- a/src/backend/access/hash/hash.c > +++ b/src/backend/access/hash/hash.c > @@ -85,7 +85,6 @@ hashhandler(PG_FUNCTION_ARGS) > amroutine->amvacuumcleanup = hashvacuumcleanup; > amroutine->amcanreturn = NULL; > amroutine->amcostestimate = hashcostestimate; > - amroutine->amoptions = hashoptions; > amroutine->amproperty = NULL; > amroutine->ambuildphasename = NULL; > amroutine->amvalidate = hashvalidate; > @@ -100,6 +99,7 @@ hashhandler(PG_FUNCTION_ARGS) > amroutine->amestimateparallelscan = NULL; > amroutine->aminitparallelscan = NULL; > amroutine->amparallelrescan = NULL; > + amroutine->amreloptspecset = hashgetreloptspecset; > > PG_RETURN_POINTER(amroutine); > } > diff --git a/src/backend/access/hash/hashpage.c b/src/backend/access/hash/hashpage.c > index 159646c..38f64ef 100644 > --- a/src/backend/access/hash/hashpage.c > +++ b/src/backend/access/hash/hashpage.c > @@ -359,6 +359,8 @@ _hash_init(Relation rel, double num_tuples, ForkNumber forkNum) > data_width = sizeof(uint32); > item_width = MAXALIGN(sizeof(IndexTupleData)) + MAXALIGN(data_width) + > sizeof(ItemIdData); /* include the line pointer */ > +//elog(WARNING, "fillfactor = %i", HashGetFillFactor(rel)); > + > ffactor = HashGetTargetPageUsage(rel) / item_width; > /* keep to a sane range */ > if (ffactor < 10) > diff --git a/src/backend/access/hash/hashutil.c b/src/backend/access/hash/hashutil.c > index 5198728..826beab 100644 > --- a/src/backend/access/hash/hashutil.c > +++ b/src/backend/access/hash/hashutil.c > @@ -15,7 +15,7 @@ > #include "postgres.h" > > #include "access/hash.h" > -#include "access/reloptions.h" > +#include "access/options.h" > #include "access/relscan.h" > #include "port/pg_bitutils.h" > #include "storage/buf_internals.h" > @@ -272,19 +272,6 @@ _hash_checkpage(Relation rel, Buffer buf, int flags) > } > } > > -bytea * > -hashoptions(Datum reloptions, bool validate) > -{ > - static const relopt_parse_elt tab[] = { > - {"fillfactor", RELOPT_TYPE_INT, offsetof(HashOptions, fillfactor)}, > - }; > - > - return (bytea *) build_reloptions(reloptions, validate, > - RELOPT_KIND_HASH, > - sizeof(HashOptions), > - tab, lengthof(tab)); > -} > - > /* > * _hash_get_indextuple_hashkey - get the hash index tuple's hash key value > */ > @@ -620,3 +607,24 @@ _hash_kill_items(IndexScanDesc scan) > else > _hash_relbuf(rel, buf); > } > + > +static options_spec_set *hash_relopt_specset = NULL; > + > +void * > +hashgetreloptspecset(void) > +{ > + if (hash_relopt_specset) > + return hash_relopt_specset; > + > + hash_relopt_specset = allocateOptionsSpecSet(NULL, > + sizeof(HashOptions), 1); > + optionsSpecSetAddInt(hash_relopt_specset, "fillfactor", > + "Packs hash index pages only to this percentage", > + NoLock, /* No ALTER -- no lock */ > + 0, > + offsetof(HashOptions, fillfactor), > + HASH_DEFAULT_FILLFACTOR, > + HASH_MIN_FILLFACTOR, 100); > + > + return hash_relopt_specset; > +} > diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c > index 7355e1d..f7b117e 100644 > --- a/src/backend/access/nbtree/nbtinsert.c > +++ b/src/backend/access/nbtree/nbtinsert.c > @@ -2745,6 +2745,8 @@ _bt_delete_or_dedup_one_page(Relation rel, Relation heapRel, > _bt_bottomupdel_pass(rel, buffer, heapRel, insertstate->itemsz)) > return; > > +// elog(WARNING, "Deduplicate_items = %i", BTGetDeduplicateItems(rel)); > + > /* Perform deduplication pass (when enabled and index-is-allequalimage) */ > if (BTGetDeduplicateItems(rel) && itup_key->allequalimage) > _bt_dedup_pass(rel, buffer, heapRel, insertstate->itup, > diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c > index 40ad095..f171c54 100644 > --- a/src/backend/access/nbtree/nbtree.c > +++ b/src/backend/access/nbtree/nbtree.c > @@ -22,6 +22,7 @@ > #include "access/nbtxlog.h" > #include "access/relscan.h" > #include "access/xlog.h" > +#include "access/options.h" > #include "commands/progress.h" > #include "commands/vacuum.h" > #include "miscadmin.h" > @@ -124,7 +125,6 @@ bthandler(PG_FUNCTION_ARGS) > amroutine->amvacuumcleanup = btvacuumcleanup; > amroutine->amcanreturn = btcanreturn; > amroutine->amcostestimate = btcostestimate; > - amroutine->amoptions = btoptions; > amroutine->amproperty = btproperty; > amroutine->ambuildphasename = btbuildphasename; > amroutine->amvalidate = btvalidate; > @@ -139,6 +139,7 @@ bthandler(PG_FUNCTION_ARGS) > amroutine->amestimateparallelscan = btestimateparallelscan; > amroutine->aminitparallelscan = btinitparallelscan; > amroutine->amparallelrescan = btparallelrescan; > + amroutine->amreloptspecset = btgetreloptspecset; > > PG_RETURN_POINTER(amroutine); > } > @@ -1418,3 +1419,37 @@ btcanreturn(Relation index, int attno) > { > return true; > } > + > +static options_spec_set *bt_relopt_specset = NULL; > + > +void * > +btgetreloptspecset(void) > +{ > + if (bt_relopt_specset) > + return bt_relopt_specset; > + > + bt_relopt_specset = allocateOptionsSpecSet(NULL, > + sizeof(BTOptions), 3); > + > + optionsSpecSetAddInt( > + bt_relopt_specset, "fillfactor", > + "Packs btree index pages only to this percentage", > + ShareUpdateExclusiveLock, /* since it applies only to later inserts */ > + 0, offsetof(BTOptions, fillfactor), > + BTREE_DEFAULT_FILLFACTOR, BTREE_MIN_FILLFACTOR, 100 > + ); > + optionsSpecSetAddReal( > + bt_relopt_specset, "vacuum_cleanup_index_scale_factor", > + "Number of tuple inserts prior to index cleanup as a fraction of reltuples", > + ShareUpdateExclusiveLock, > + 0, offsetof(BTOptions,vacuum_cleanup_index_scale_factor), > + -1, 0.0, 1e10 > + ); > + optionsSpecSetAddBool( > + bt_relopt_specset, "deduplicate_items", > + "Enables \"deduplicate items\" feature for this btree index", > + ShareUpdateExclusiveLock, /* since it applies only to later inserts */ > + 0, offsetof(BTOptions,deduplicate_items), true > + ); > + return bt_relopt_specset; > +} > diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c > index c72b456..2588a30 100644 > --- a/src/backend/access/nbtree/nbtutils.c > +++ b/src/backend/access/nbtree/nbtutils.c > @@ -18,7 +18,7 @@ > #include <time.h> > > #include "access/nbtree.h" > -#include "access/reloptions.h" > +#include "storage/lock.h" > #include "access/relscan.h" > #include "catalog/catalog.h" > #include "commands/progress.h" > @@ -2100,25 +2100,6 @@ BTreeShmemInit(void) > Assert(found); > } > > -bytea * > -btoptions(Datum reloptions, bool validate) > -{ > - static const relopt_parse_elt tab[] = { > - {"fillfactor", RELOPT_TYPE_INT, offsetof(BTOptions, fillfactor)}, > - {"vacuum_cleanup_index_scale_factor", RELOPT_TYPE_REAL, > - offsetof(BTOptions, vacuum_cleanup_index_scale_factor)}, > - {"deduplicate_items", RELOPT_TYPE_BOOL, > - offsetof(BTOptions, deduplicate_items)} > - > - }; > - > - return (bytea *) build_reloptions(reloptions, validate, > - RELOPT_KIND_BTREE, > - sizeof(BTOptions), > - tab, lengthof(tab)); > - > -} > - > /* > * btproperty() -- Check boolean properties of indexes. > * > diff --git a/src/backend/access/spgist/spgutils.c b/src/backend/access/spgist/spgutils.c > index 03a9cd3..14429ad 100644 > --- a/src/backend/access/spgist/spgutils.c > +++ b/src/backend/access/spgist/spgutils.c > @@ -17,7 +17,7 @@ > > #include "access/amvalidate.h" > #include "access/htup_details.h" > -#include "access/reloptions.h" > +#include "access/options.h" > #include "access/spgist_private.h" > #include "access/toast_compression.h" > #include "access/transam.h" > @@ -72,7 +72,6 @@ spghandler(PG_FUNCTION_ARGS) > amroutine->amvacuumcleanup = spgvacuumcleanup; > amroutine->amcanreturn = spgcanreturn; > amroutine->amcostestimate = spgcostestimate; > - amroutine->amoptions = spgoptions; > amroutine->amproperty = spgproperty; > amroutine->ambuildphasename = NULL; > amroutine->amvalidate = spgvalidate; > @@ -87,6 +86,7 @@ spghandler(PG_FUNCTION_ARGS) > amroutine->amestimateparallelscan = NULL; > amroutine->aminitparallelscan = NULL; > amroutine->amparallelrescan = NULL; > + amroutine->amreloptspecset = spggetreloptspecset; > > PG_RETURN_POINTER(amroutine); > } > @@ -550,6 +550,7 @@ SpGistGetBuffer(Relation index, int flags, int needSpace, bool *isNew) > * related to the ones already on it. But fillfactor mustn't cause an > * error for requests that would otherwise be legal. > */ > +//elog(WARNING, "fillfactor = %i", SpGistGetFillFactor(index)); > needSpace += SpGistGetTargetPageFreeSpace(index); > needSpace = Min(needSpace, SPGIST_PAGE_CAPACITY); > > @@ -721,23 +722,6 @@ SpGistInitMetapage(Page page) > } > > /* > - * reloptions processing for SPGiST > - */ > -bytea * > -spgoptions(Datum reloptions, bool validate) > -{ > - static const relopt_parse_elt tab[] = { > - {"fillfactor", RELOPT_TYPE_INT, offsetof(SpGistOptions, fillfactor)}, > - }; > - > - return (bytea *) build_reloptions(reloptions, validate, > - RELOPT_KIND_SPGIST, > - sizeof(SpGistOptions), > - tab, lengthof(tab)); > - > -} > - > -/* > * Get the space needed to store a non-null datum of the indicated type > * in an inner tuple (that is, as a prefix or node label). > * Note the result is already rounded up to a MAXALIGN boundary. > @@ -1336,3 +1320,25 @@ spgproperty(Oid index_oid, int attno, > > return true; > } > + > +static options_spec_set *spgist_relopt_specset = NULL; > + > +void * > +spggetreloptspecset(void) > +{ > + if (!spgist_relopt_specset) > + { > + spgist_relopt_specset = allocateOptionsSpecSet(NULL, > + sizeof(SpGistOptions), 1); > + > + optionsSpecSetAddInt(spgist_relopt_specset, "fillfactor", > + "Packs spgist index pages only to this percentage", > + ShareUpdateExclusiveLock, /* since it applies only > + * to later inserts */ > + 0, > + offsetof(SpGistOptions, fillfactor), > + SPGIST_DEFAULT_FILLFACTOR, > + SPGIST_MIN_FILLFACTOR, 100); > + } > + return spgist_relopt_specset; > +} > diff --git a/src/backend/commands/createas.c b/src/backend/commands/createas.c > index 0982851..4f3dbb8 100644 > --- a/src/backend/commands/createas.c > +++ b/src/backend/commands/createas.c > @@ -90,6 +90,7 @@ create_ctas_internal(List *attrList, IntoClause *into) > Datum toast_options; > static char *validnsps[] = HEAP_RELOPT_NAMESPACES; > ObjectAddress intoRelationAddr; > + List *toastDefList; > > /* This code supports both CREATE TABLE AS and CREATE MATERIALIZED VIEW */ > is_matview = (into->viewQuery != NULL); > @@ -124,14 +125,12 @@ create_ctas_internal(List *attrList, IntoClause *into) > CommandCounterIncrement(); > > /* parse and validate reloptions for the toast table */ > - toast_options = transformRelOptions((Datum) 0, > - create->options, > - "toast", > - validnsps, > - true, false); > > - (void) heap_reloptions(RELKIND_TOASTVALUE, toast_options, true); > + optionsDefListValdateNamespaces(create->options, validnsps); > + toastDefList = optionsDefListFilterNamespaces(create->options, "toast"); > > + toast_options = transformOptions(get_toast_relopt_spec_set(), (Datum) 0, > + toastDefList, 0); > NewRelationCreateToastTable(intoRelationAddr.objectId, toast_options); > > /* Create the "view" part of a materialized view. */ > diff --git a/src/backend/commands/foreigncmds.c b/src/backend/commands/foreigncmds.c > index 146fa57..758ca34 100644 > --- a/src/backend/commands/foreigncmds.c > +++ b/src/backend/commands/foreigncmds.c > @@ -112,7 +112,7 @@ transformGenericOptions(Oid catalogId, > List *options, > Oid fdwvalidator) > { > - List *resultOptions = untransformRelOptions(oldOptions); > + List *resultOptions = optionsTextArrayToDefList(oldOptions); > ListCell *optcell; > Datum result; > > diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c > index c14ca27..96d465a 100644 > --- a/src/backend/commands/indexcmds.c > +++ b/src/backend/commands/indexcmds.c > @@ -19,6 +19,7 @@ > #include "access/heapam.h" > #include "access/htup_details.h" > #include "access/reloptions.h" > +#include "access/options.h" > #include "access/sysattr.h" > #include "access/tableam.h" > #include "access/xact.h" > @@ -531,7 +532,7 @@ DefineIndex(Oid relationId, > Form_pg_am accessMethodForm; > IndexAmRoutine *amRoutine; > bool amcanorder; > - amoptions_function amoptions; > + amreloptspecset_function amreloptspecsetfn; > bool partitioned; > bool safe_index; > Datum reloptions; > @@ -837,7 +838,7 @@ DefineIndex(Oid relationId, > accessMethodName))); > > amcanorder = amRoutine->amcanorder; > - amoptions = amRoutine->amoptions; > + amreloptspecsetfn = amRoutine->amreloptspecset; > > pfree(amRoutine); > ReleaseSysCache(tuple); > @@ -851,10 +852,19 @@ DefineIndex(Oid relationId, > /* > * Parse AM-specific options, convert to text array form, validate. > */ > - reloptions = transformRelOptions((Datum) 0, stmt->options, > - NULL, NULL, false, false); > > - (void) index_reloptions(amoptions, reloptions, true); > + if (amreloptspecsetfn) > + { > + reloptions = transformOptions(amreloptspecsetfn(), > + (Datum) 0, stmt->options, 0); > + } > + else > + { > + ereport(ERROR, > + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), > + errmsg("access method %s does not support options", > + accessMethodName))); > + } > > /* > * Prepare arguments for index_create, primarily an IndexInfo structure. > @@ -1986,8 +1996,7 @@ ComputeIndexAttrs(IndexInfo *indexInfo, > palloc0(sizeof(Datum) * indexInfo->ii_NumIndexAttrs); > > indexInfo->ii_OpclassOptions[attn] = > - transformRelOptions((Datum) 0, attribute->opclassopts, > - NULL, NULL, false, false); > + optionsDefListToTextArray(attribute->opclassopts); > } > > attn++; > diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c > index 1c2ebe1..7f3004f 100644 > --- a/src/backend/commands/tablecmds.c > +++ b/src/backend/commands/tablecmds.c > @@ -20,6 +20,7 @@ > #include "access/heapam_xlog.h" > #include "access/multixact.h" > #include "access/reloptions.h" > +#include "access/options.h" > #include "access/relscan.h" > #include "access/sysattr.h" > #include "access/tableam.h" > @@ -641,7 +642,6 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId, > ListCell *listptr; > AttrNumber attnum; > bool partitioned; > - static char *validnsps[] = HEAP_RELOPT_NAMESPACES; > Oid ofTypeId; > ObjectAddress address; > LOCKMODE parentLockmode; > @@ -789,19 +789,37 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId, > /* > * Parse and validate reloptions, if any. > */ > - reloptions = transformRelOptions((Datum) 0, stmt->options, NULL, validnsps, > - true, false); > > switch (relkind) > { > case RELKIND_VIEW: > - (void) view_reloptions(reloptions, true); > + reloptions = transformOptions( > + get_view_relopt_spec_set(), > + (Datum) 0, stmt->options, 0); > break; > case RELKIND_PARTITIONED_TABLE: > - (void) partitioned_table_reloptions(reloptions, true); > + { > + /* If it is not all listed above, then it if heap */ > + char *namespaces[] = HEAP_RELOPT_NAMESPACES; > + List *heapDefList; > + > + optionsDefListValdateNamespaces(stmt->options, namespaces); > + heapDefList = optionsDefListFilterNamespaces(stmt->options, NULL); > + reloptions = transformOptions(get_partitioned_relopt_spec_set(), > + (Datum) 0, heapDefList, 0); > break; > + } > default: > - (void) heap_reloptions(relkind, reloptions, true); > + { > + /* If it is not all listed above, then it if heap */ > + char *namespaces[] = HEAP_RELOPT_NAMESPACES; > + List *heapDefList; > + > + optionsDefListValdateNamespaces(stmt->options, namespaces); > + heapDefList = optionsDefListFilterNamespaces(stmt->options, NULL); > + reloptions = transformOptions(get_heap_relopt_spec_set(), > + (Datum) 0, heapDefList, 0); > + } > } > > if (stmt->ofTypename) > @@ -4022,7 +4040,7 @@ void > AlterTableInternal(Oid relid, List *cmds, bool recurse) > { > Relation rel; > - LOCKMODE lockmode = AlterTableGetLockLevel(cmds); > + LOCKMODE lockmode = AlterTableGetLockLevel(relid, cmds); > > rel = relation_open(relid, lockmode); > > @@ -4064,7 +4082,7 @@ AlterTableInternal(Oid relid, List *cmds, bool recurse) > * otherwise we might end up with an inconsistent dump that can't restore. > */ > LOCKMODE > -AlterTableGetLockLevel(List *cmds) > +AlterTableGetLockLevel(Oid relid, List *cmds) > { > /* > * This only works if we read catalog tables using MVCC snapshots. > @@ -4285,9 +4303,13 @@ AlterTableGetLockLevel(List *cmds) > * getTables() */ > case AT_ResetRelOptions: /* Uses MVCC in getIndexes() and > * getTables() */ > - cmd_lockmode = AlterTableGetRelOptionsLockLevel((List *) cmd->def); > - break; > - > + { > + Relation rel = relation_open(relid, NoLock); // FIXME I am not sure how wise it is > + cmd_lockmode = AlterTableGetRelOptionsLockLevel(rel, > + castNode(List, cmd->def)); > + relation_close(rel,NoLock); > + break; > + } > case AT_AttachPartition: > cmd_lockmode = ShareUpdateExclusiveLock; > break; > @@ -8062,11 +8084,11 @@ ATExecSetOptions(Relation rel, const char *colName, Node *options, > /* Generate new proposed attoptions (text array) */ > datum = SysCacheGetAttr(ATTNAME, tuple, Anum_pg_attribute_attoptions, > &isnull); > - newOptions = transformRelOptions(isnull ? (Datum) 0 : datum, > - castNode(List, options), NULL, NULL, > - false, isReset); > - /* Validate new options */ > - (void) attribute_reloptions(newOptions, true); > + > + newOptions = transformOptions(get_attribute_options_spec_set(), > + isnull ? (Datum) 0 : datum, > + castNode(List, options), OPTIONS_PARSE_MODE_FOR_ALTER | > + (isReset ? OPTIONS_PARSE_MODE_FOR_RESET : 0)); > > /* Build new tuple. */ > memset(repl_null, false, sizeof(repl_null)); > @@ -13704,7 +13726,8 @@ ATExecSetRelOptions(Relation rel, List *defList, AlterTableType operation, > Datum repl_val[Natts_pg_class]; > bool repl_null[Natts_pg_class]; > bool repl_repl[Natts_pg_class]; > - static char *validnsps[] = HEAP_RELOPT_NAMESPACES; > + List *toastDefList; > + options_parse_mode parse_mode; > > if (defList == NIL && operation != AT_ReplaceRelOptions) > return; /* nothing to do */ > @@ -13734,27 +13757,68 @@ ATExecSetRelOptions(Relation rel, List *defList, AlterTableType operation, > } > > /* Generate new proposed reloptions (text array) */ > - newOptions = transformRelOptions(isnull ? (Datum) 0 : datum, > - defList, NULL, validnsps, false, > - operation == AT_ResetRelOptions); > > /* Validate */ > + parse_mode = OPTIONS_PARSE_MODE_FOR_ALTER; > + if (operation == AT_ResetRelOptions) > + parse_mode |= OPTIONS_PARSE_MODE_FOR_RESET; > + > switch (rel->rd_rel->relkind) > { > case RELKIND_RELATION: > - case RELKIND_TOASTVALUE: > + case RELKIND_TOASTVALUE: // FIXME why it is here??? > case RELKIND_MATVIEW: > - (void) heap_reloptions(rel->rd_rel->relkind, newOptions, true); > + { > + char *namespaces[] = HEAP_RELOPT_NAMESPACES; > + List *heapDefList; > + > + optionsDefListValdateNamespaces(defList, namespaces); > + heapDefList = optionsDefListFilterNamespaces( > + defList, NULL); > + newOptions = transformOptions(get_heap_relopt_spec_set(), > + isnull ? (Datum) 0 : datum, > + heapDefList, parse_mode); > + } > break; > + > case RELKIND_PARTITIONED_TABLE: > - (void) partitioned_table_reloptions(newOptions, true); > - break; > + { > + char *namespaces[] = HEAP_RELOPT_NAMESPACES; > + List *heapDefList; > + > + optionsDefListValdateNamespaces(defList, namespaces); > + heapDefList = optionsDefListFilterNamespaces( > + defList, NULL); > + newOptions = transformOptions(get_partitioned_relopt_spec_set(), > + isnull ? (Datum) 0 : datum, > + heapDefList, parse_mode); > + break; > + } > case RELKIND_VIEW: > - (void) view_reloptions(newOptions, true); > - break; > + { > + > + newOptions = transformOptions( > + get_view_relopt_spec_set(), > + datum, defList, parse_mode); > + break; > + } > case RELKIND_INDEX: > case RELKIND_PARTITIONED_INDEX: > - (void) index_reloptions(rel->rd_indam->amoptions, newOptions, true); > + if (! rel->rd_indam->amreloptspecset) > + { > + ereport(ERROR, > + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), > + errmsg("index %s does not support options", > + RelationGetRelationName(rel)))); > + break; > + } > + parse_mode = OPTIONS_PARSE_MODE_FOR_ALTER; > + if (operation == AT_ResetRelOptions) > + parse_mode |= OPTIONS_PARSE_MODE_FOR_RESET; > + newOptions = transformOptions( > + rel->rd_indam->amreloptspecset(), > + isnull ? (Datum) 0 : datum, > + defList, parse_mode); > break; > default: > ereport(ERROR, > @@ -13769,7 +13833,7 @@ ATExecSetRelOptions(Relation rel, List *defList, AlterTableType operation, > if (rel->rd_rel->relkind == RELKIND_VIEW) > { > Query *view_query = get_view_query(rel); > - List *view_options = untransformRelOptions(newOptions); > + List *view_options = optionsTextArrayToDefList(newOptions); > ListCell *cell; > bool check_option = false; > > @@ -13853,11 +13917,15 @@ ATExecSetRelOptions(Relation rel, List *defList, AlterTableType operation, > &isnull); > } > > - newOptions = transformRelOptions(isnull ? (Datum) 0 : datum, > - defList, "toast", validnsps, false, > - operation == AT_ResetRelOptions); > + parse_mode = OPTIONS_PARSE_MODE_FOR_ALTER; > + if (operation == AT_ResetRelOptions) > + parse_mode |= OPTIONS_PARSE_MODE_FOR_RESET; > + > + toastDefList = optionsDefListFilterNamespaces(defList, "toast"); > > - (void) heap_reloptions(RELKIND_TOASTVALUE, newOptions, true); > + newOptions = transformOptions(get_toast_relopt_spec_set(), > + isnull ? (Datum) 0 : datum, > + toastDefList, parse_mode); > > memset(repl_val, 0, sizeof(repl_val)); > memset(repl_null, false, sizeof(repl_null)); > diff --git a/src/backend/commands/tablespace.c b/src/backend/commands/tablespace.c > index 4b96eec..912699b 100644 > --- a/src/backend/commands/tablespace.c > +++ b/src/backend/commands/tablespace.c > @@ -345,10 +345,9 @@ CreateTableSpace(CreateTableSpaceStmt *stmt) > nulls[Anum_pg_tablespace_spcacl - 1] = true; > > /* Generate new proposed spcoptions (text array) */ > - newOptions = transformRelOptions((Datum) 0, > - stmt->options, > - NULL, NULL, false, false); > - (void) tablespace_reloptions(newOptions, true); > + newOptions = transformOptions(get_tablespace_options_spec_set(), > + (Datum) 0, stmt->options, 0); > + > if (newOptions != (Datum) 0) > values[Anum_pg_tablespace_spcoptions - 1] = newOptions; > else > @@ -1053,10 +1052,11 @@ AlterTableSpaceOptions(AlterTableSpaceOptionsStmt *stmt) > /* Generate new proposed spcoptions (text array) */ > datum = heap_getattr(tup, Anum_pg_tablespace_spcoptions, > RelationGetDescr(rel), &isnull); > - newOptions = transformRelOptions(isnull ? (Datum) 0 : datum, > - stmt->options, NULL, NULL, false, > - stmt->isReset); > - (void) tablespace_reloptions(newOptions, true); > + newOptions = transformOptions(get_tablespace_options_spec_set(), > + isnull ? (Datum) 0 : datum, > + stmt->options, > + OPTIONS_PARSE_MODE_FOR_ALTER | > + (stmt->isReset ? OPTIONS_PARSE_MODE_FOR_RESET : 0)); > > /* Build new tuple. */ > memset(repl_null, false, sizeof(repl_null)); > diff --git a/src/backend/foreign/foreign.c b/src/backend/foreign/foreign.c > index 5564dc3..0370be7 100644 > --- a/src/backend/foreign/foreign.c > +++ b/src/backend/foreign/foreign.c > @@ -78,7 +78,7 @@ GetForeignDataWrapperExtended(Oid fdwid, bits16 flags) > if (isnull) > fdw->options = NIL; > else > - fdw->options = untransformRelOptions(datum); > + fdw->options = optionsTextArrayToDefList(datum); > > ReleaseSysCache(tp); > > @@ -165,7 +165,7 @@ GetForeignServerExtended(Oid serverid, bits16 flags) > if (isnull) > server->options = NIL; > else > - server->options = untransformRelOptions(datum); > + server->options = optionsTextArrayToDefList(datum); > > ReleaseSysCache(tp); > > @@ -233,7 +233,7 @@ GetUserMapping(Oid userid, Oid serverid) > if (isnull) > um->options = NIL; > else > - um->options = untransformRelOptions(datum); > + um->options = optionsTextArrayToDefList(datum); > > ReleaseSysCache(tp); > > @@ -270,7 +270,7 @@ GetForeignTable(Oid relid) > if (isnull) > ft->options = NIL; > else > - ft->options = untransformRelOptions(datum); > + ft->options = optionsTextArrayToDefList(datum); > > ReleaseSysCache(tp); > > @@ -303,7 +303,7 @@ GetForeignColumnOptions(Oid relid, AttrNumber attnum) > if (isnull) > options = NIL; > else > - options = untransformRelOptions(datum); > + options = optionsTextArrayToDefList(datum); > > ReleaseSysCache(tp); > > @@ -572,7 +572,7 @@ pg_options_to_table(PG_FUNCTION_ARGS) > Datum array = PG_GETARG_DATUM(0); > > deflist_to_tuplestore((ReturnSetInfo *) fcinfo->resultinfo, > - untransformRelOptions(array)); > + optionsTextArrayToDefList(array)); > > return (Datum) 0; > } > @@ -643,7 +643,7 @@ is_conninfo_option(const char *option, Oid context) > Datum > postgresql_fdw_validator(PG_FUNCTION_ARGS) > { > - List *options_list = untransformRelOptions(PG_GETARG_DATUM(0)); > + List *options_list = optionsTextArrayToDefList(PG_GETARG_DATUM(0)); > Oid catalog = PG_GETARG_OID(1); > > ListCell *cell; > diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c > index 313d7b6..1fe41b4 100644 > --- a/src/backend/parser/parse_utilcmd.c > +++ b/src/backend/parser/parse_utilcmd.c > @@ -1757,7 +1757,7 @@ generateClonedIndexStmt(RangeVar *heapRel, Relation source_idx, > /* Add the operator class name, if non-default */ > iparam->opclass = get_opclass(indclass->values[keyno], keycoltype); > iparam->opclassopts = > - untransformRelOptions(get_attoptions(source_relid, keyno + 1)); > + optionsTextArrayToDefList(get_attoptions(source_relid, keyno + 1)); > > iparam->ordering = SORTBY_DEFAULT; > iparam->nulls_ordering = SORTBY_NULLS_DEFAULT; > @@ -1821,7 +1821,7 @@ generateClonedIndexStmt(RangeVar *heapRel, Relation source_idx, > datum = SysCacheGetAttr(RELOID, ht_idxrel, > Anum_pg_class_reloptions, &isnull); > if (!isnull) > - index->options = untransformRelOptions(datum); > + index->options = optionsTextArrayToDefList(datum); > > /* If it's a partial index, decompile and append the predicate */ > datum = SysCacheGetAttr(INDEXRELID, ht_idx, > diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c > index bf085aa..d12ab1a 100644 > --- a/src/backend/tcop/utility.c > +++ b/src/backend/tcop/utility.c > @@ -1155,6 +1155,7 @@ ProcessUtilitySlow(ParseState *pstate, > CreateStmt *cstmt = (CreateStmt *) stmt; > Datum toast_options; > static char *validnsps[] = HEAP_RELOPT_NAMESPACES; > + List *toastDefList; > > /* Remember transformed RangeVar for LIKE */ > table_rv = cstmt->relation; > @@ -1178,15 +1179,17 @@ ProcessUtilitySlow(ParseState *pstate, > * parse and validate reloptions for the toast > * table > */ > - toast_options = transformRelOptions((Datum) 0, > - cstmt->options, > - "toast", > - validnsps, > - true, > - false); > - (void) heap_reloptions(RELKIND_TOASTVALUE, > - toast_options, > - true); > + > + optionsDefListValdateNamespaces( > + ((CreateStmt *) stmt)->options, > + validnsps); > + > + toastDefList = optionsDefListFilterNamespaces( > + ((CreateStmt *) stmt)->options, "toast"); > + > + toast_options = transformOptions( > + get_toast_relopt_spec_set(), (Datum) 0, > + toastDefList, 0); > > NewRelationCreateToastTable(address.objectId, > toast_options); > @@ -1295,9 +1298,12 @@ ProcessUtilitySlow(ParseState *pstate, > * lock on (for example) a relation on which we have no > * permissions. > */ > - lockmode = AlterTableGetLockLevel(atstmt->cmds); > - relid = AlterTableLookupRelation(atstmt, lockmode); > - > + relid = AlterTableLookupRelation(atstmt, NoLock); // FIXME! > + if (OidIsValid(relid)) > + { > + lockmode = AlterTableGetLockLevel(relid, atstmt->cmds); > + relid = AlterTableLookupRelation(atstmt, lockmode); > + } > if (OidIsValid(relid)) > { > AlterTableUtilityContext atcontext; > diff --git a/src/backend/utils/cache/attoptcache.c b/src/backend/utils/cache/attoptcache.c > index 72d89cb..f651129 100644 > --- a/src/backend/utils/cache/attoptcache.c > +++ b/src/backend/utils/cache/attoptcache.c > @@ -16,6 +16,7 @@ > */ > #include "postgres.h" > > +#include "access/options.h" > #include "access/reloptions.h" > #include "utils/attoptcache.h" > #include "utils/catcache.h" > @@ -148,7 +149,8 @@ get_attribute_options(Oid attrelid, int attnum) > opts = NULL; > else > { > - bytea *bytea_opts = attribute_reloptions(datum, false); > + bytea *bytea_opts = optionsTextArrayToBytea( > + get_attribute_options_spec_set(), datum, 0); > > opts = MemoryContextAlloc(CacheMemoryContext, > VARSIZE(bytea_opts)); > diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c > index 13d9994..f22c2d9 100644 > --- a/src/backend/utils/cache/relcache.c > +++ b/src/backend/utils/cache/relcache.c > @@ -441,7 +441,7 @@ static void > RelationParseRelOptions(Relation relation, HeapTuple tuple) > { > bytea *options; > - amoptions_function amoptsfn; > + amreloptspecset_function amoptspecsetfn; > > relation->rd_options = NULL; > > @@ -456,11 +456,11 @@ RelationParseRelOptions(Relation relation, HeapTuple tuple) > case RELKIND_VIEW: > case RELKIND_MATVIEW: > case RELKIND_PARTITIONED_TABLE: > - amoptsfn = NULL; > + amoptspecsetfn = NULL; > break; > case RELKIND_INDEX: > case RELKIND_PARTITIONED_INDEX: > - amoptsfn = relation->rd_indam->amoptions; > + amoptspecsetfn = relation->rd_indam->amreloptspecset; > break; > default: > return; > @@ -471,7 +471,7 @@ RelationParseRelOptions(Relation relation, HeapTuple tuple) > * we might not have any other for pg_class yet (consider executing this > * code for pg_class itself) > */ > - options = extractRelOptions(tuple, GetPgClassDescriptor(), amoptsfn); > + options = extractRelOptions(tuple, GetPgClassDescriptor(), amoptspecsetfn); > > /* > * Copy parsed data into CacheMemoryContext. To guard against the > diff --git a/src/backend/utils/cache/spccache.c b/src/backend/utils/cache/spccache.c > index 5870f43..87f2fa5 100644 > --- a/src/backend/utils/cache/spccache.c > +++ b/src/backend/utils/cache/spccache.c > @@ -148,7 +148,8 @@ get_tablespace(Oid spcid) > opts = NULL; > else > { > - bytea *bytea_opts = tablespace_reloptions(datum, false); > + bytea *bytea_opts = optionsTextArrayToBytea( > + get_tablespace_options_spec_set(), datum, 0); > > opts = MemoryContextAlloc(CacheMemoryContext, VARSIZE(bytea_opts)); > memcpy(opts, bytea_opts, VARSIZE(bytea_opts)); > diff --git a/src/include/access/amapi.h b/src/include/access/amapi.h > index d357ebb..b8fb6b9 100644 > --- a/src/include/access/amapi.h > +++ b/src/include/access/amapi.h > @@ -136,10 +136,6 @@ typedef void (*amcostestimate_function) (struct PlannerInfo *root, > double *indexCorrelation, > double *indexPages); > > -/* parse index reloptions */ > -typedef bytea *(*amoptions_function) (Datum reloptions, > - bool validate); > - > /* report AM, index, or index column property */ > typedef bool (*amproperty_function) (Oid index_oid, int attno, > IndexAMProperty prop, const char *propname, > @@ -186,6 +182,9 @@ typedef void (*ammarkpos_function) (IndexScanDesc scan); > /* restore marked scan position */ > typedef void (*amrestrpos_function) (IndexScanDesc scan); > > +/* get catalog of reloptions definitions */ > +typedef void *(*amreloptspecset_function) (); > + > /* > * Callback function signatures - for parallel index scans. > */ > @@ -263,7 +262,6 @@ typedef struct IndexAmRoutine > amvacuumcleanup_function amvacuumcleanup; > amcanreturn_function amcanreturn; /* can be NULL */ > amcostestimate_function amcostestimate; > - amoptions_function amoptions; > amproperty_function amproperty; /* can be NULL */ > ambuildphasename_function ambuildphasename; /* can be NULL */ > amvalidate_function amvalidate; > @@ -275,6 +273,7 @@ typedef struct IndexAmRoutine > amendscan_function amendscan; > ammarkpos_function ammarkpos; /* can be NULL */ > amrestrpos_function amrestrpos; /* can be NULL */ > + amreloptspecset_function amreloptspecset; /* can be NULL */ > > /* interface functions to support parallel index scans */ > amestimateparallelscan_function amestimateparallelscan; /* can be NULL */ > diff --git a/src/include/access/brin.h b/src/include/access/brin.h > index 4e2be13..25b3456 100644 > --- a/src/include/access/brin.h > +++ b/src/include/access/brin.h > @@ -36,6 +36,8 @@ typedef struct BrinStatsData > > > #define BRIN_DEFAULT_PAGES_PER_RANGE 128 > +#define BRIN_MIN_PAGES_PER_RANGE 1 > +#define BRIN_MAX_PAGES_PER_RANGE 131072 > #define BrinGetPagesPerRange(relation) \ > (AssertMacro(relation->rd_rel->relkind == RELKIND_INDEX && \ > relation->rd_rel->relam == BRIN_AM_OID), \ > diff --git a/src/include/access/brin_internal.h b/src/include/access/brin_internal.h > index 79440eb..a798a96 100644 > --- a/src/include/access/brin_internal.h > +++ b/src/include/access/brin_internal.h > @@ -14,6 +14,7 @@ > #include "access/amapi.h" > #include "storage/bufpage.h" > #include "utils/typcache.h" > +#include "access/options.h" > > > /* > @@ -108,6 +109,7 @@ extern IndexBulkDeleteResult *brinbulkdelete(IndexVacuumInfo *info, > extern IndexBulkDeleteResult *brinvacuumcleanup(IndexVacuumInfo *info, > IndexBulkDeleteResult *stats); > extern bytea *brinoptions(Datum reloptions, bool validate); > +extern void * bringetreloptspecset (void); > > /* brin_validate.c */ > extern bool brinvalidate(Oid opclassoid); > diff --git a/src/include/access/gin_private.h b/src/include/access/gin_private.h > index 670a40b..2b7c25c 100644 > --- a/src/include/access/gin_private.h > +++ b/src/include/access/gin_private.h > @@ -108,6 +108,7 @@ extern Datum *ginExtractEntries(GinState *ginstate, OffsetNumber attnum, > extern OffsetNumber gintuple_get_attrnum(GinState *ginstate, IndexTuple tuple); > extern Datum gintuple_get_key(GinState *ginstate, IndexTuple tuple, > GinNullCategory *category); > +extern void *gingetreloptspecset(void); > > /* gininsert.c */ > extern IndexBuildResult *ginbuild(Relation heap, Relation index, > diff --git a/src/include/access/gist_private.h b/src/include/access/gist_private.h > index 553d364..015b75a 100644 > --- a/src/include/access/gist_private.h > +++ b/src/include/access/gist_private.h > @@ -22,6 +22,7 @@ > #include "storage/buffile.h" > #include "utils/hsearch.h" > #include "access/genam.h" > +#include "access/reloptions.h" //FIXME! should be replaced with options.h finally > > /* > * Maximum number of "halves" a page can be split into in one operation. > @@ -388,6 +389,7 @@ typedef enum GistOptBufferingMode > GIST_OPTION_BUFFERING_OFF > } GistOptBufferingMode; > > + > /* > * Storage type for GiST's reloptions > */ > @@ -478,7 +480,7 @@ extern void gistadjustmembers(Oid opfamilyoid, > #define GIST_MIN_FILLFACTOR 10 > #define GIST_DEFAULT_FILLFACTOR 90 > > -extern bytea *gistoptions(Datum reloptions, bool validate); > +extern void *gistgetreloptspecset(void); > extern bool gistproperty(Oid index_oid, int attno, > IndexAMProperty prop, const char *propname, > bool *res, bool *isnull); > diff --git a/src/include/access/hash.h b/src/include/access/hash.h > index 1cce865..91922ef 100644 > --- a/src/include/access/hash.h > +++ b/src/include/access/hash.h > @@ -378,7 +378,6 @@ extern IndexBulkDeleteResult *hashbulkdelete(IndexVacuumInfo *info, > void *callback_state); > extern IndexBulkDeleteResult *hashvacuumcleanup(IndexVacuumInfo *info, > IndexBulkDeleteResult *stats); > -extern bytea *hashoptions(Datum reloptions, bool validate); > extern bool hashvalidate(Oid opclassoid); > extern void hashadjustmembers(Oid opfamilyoid, > Oid opclassoid, > @@ -470,6 +469,7 @@ extern BlockNumber _hash_get_newblock_from_oldbucket(Relation rel, Bucket old_bu > extern Bucket _hash_get_newbucket_from_oldbucket(Relation rel, Bucket old_bucket, > uint32 lowmask, uint32 maxbucket); > extern void _hash_kill_items(IndexScanDesc scan); > +extern void *hashgetreloptspecset(void); > > /* hash.c */ > extern void hashbucketcleanup(Relation rel, Bucket cur_bucket, > diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h > index 30a216e..1fcb5f5 100644 > --- a/src/include/access/nbtree.h > +++ b/src/include/access/nbtree.h > @@ -1252,7 +1252,7 @@ extern void _bt_end_vacuum(Relation rel); > extern void _bt_end_vacuum_callback(int code, Datum arg); > extern Size BTreeShmemSize(void); > extern void BTreeShmemInit(void); > -extern bytea *btoptions(Datum reloptions, bool validate); > +extern void * btgetreloptspecset (void); > extern bool btproperty(Oid index_oid, int attno, > IndexAMProperty prop, const char *propname, > bool *res, bool *isnull); > diff --git a/src/include/access/options.h b/src/include/access/options.h > new file mode 100644 > index 0000000..34e2917 > --- /dev/null > +++ b/src/include/access/options.h > @@ -0,0 +1,245 @@ > +/*------------------------------------------------------------------------- > + * > + * options.h > + * Core support for relation and tablespace options (pg_class.reloptions > + * and pg_tablespace.spcoptions) > + * > + * Note: the functions dealing with text-array options values declare > + * them as Datum, not ArrayType *, to avoid needing to include array.h > + * into a lot of low-level code. > + * > + * > + * Portions Copyright (c) 1996-2016, PostgreSQL Global Development Group > + * Portions Copyright (c) 1994, Regents of the University of California > + * > + * src/include/access/options.h > + * > + *------------------------------------------------------------------------- > + */ > +#ifndef OPTIONS_H > +#define OPTIONS_H > + > +#include "storage/lock.h" > +#include "nodes/pg_list.h" > + > + > +/* supported option types */ > +typedef enum option_type > +{ > + OPTION_TYPE_BOOL, > + OPTION_TYPE_INT, > + OPTION_TYPE_REAL, > + OPTION_TYPE_ENUM, > + OPTION_TYPE_STRING > +} option_type; > + > + > +typedef enum option_value_status > +{ > + OPTION_VALUE_STATUS_EMPTY, /* Option was just initialized */ > + OPTION_VALUE_STATUS_RAW, /* Option just came from syntax analyzer in > + * has name, and raw (unparsed) value */ > + OPTION_VALUE_STATUS_PARSED, /* Option was parsed and has link to catalog > + * entry and proper value */ > + OPTION_VALUE_STATUS_FOR_RESET /* This option came from ALTER xxx > + * RESET */ > +} option_value_status; > + > +/* flags for reloptinon definition */ > +typedef enum option_spec_flags > +{ > + OPTION_DEFINITION_FLAG_FORBID_ALTER = (1 << 0), /* Altering this option > + * is forbidden */ > + OPTION_DEFINITION_FLAG_IGNORE = (1 << 1), /* Skip this option while > + * parsing. Used for WITH OIDS > + * special case */ > + OPTION_DEFINITION_FLAG_REJECT = (1 << 2) /* Option will be rejected > + * when comes from syntax > + * analyzer, but still have > + * default value and offset */ > +} option_spec_flags; > + > +/* flags that tells reloption parser how to parse*/ > +typedef enum options_parse_mode > +{ > + OPTIONS_PARSE_MODE_VALIDATE = (1 << 0), > + OPTIONS_PARSE_MODE_FOR_ALTER = (1 << 1), > + OPTIONS_PARSE_MODE_FOR_RESET = (1 << 2) > +} options_parse_mode; > + > + > + > +/* > + * opt_enum_elt_def -- One member of the array of acceptable values > + * of an enum reloption. > + */ > +typedef struct opt_enum_elt_def > +{ > + const char *string_val; > + int symbol_val; > +} opt_enum_elt_def; > + > + > +/* generic structure to store Option Spec information */ > +typedef struct option_spec_basic > +{ > + const char *name; /* must be first (used as list termination > + * marker) */ > + const char *desc; > + LOCKMODE lockmode; > + option_spec_flags flags; > + option_type type; > + int struct_offset; /* offset of the value in Bytea representation */ > +} option_spec_basic; > + > + > +/* reloptions records for specific variable types */ > +typedef struct option_spec_bool > +{ > + option_spec_basic base; > + bool default_val; > +} option_spec_bool; > + > +typedef struct option_spec_int > +{ > + option_spec_basic base; > + int default_val; > + int min; > + int max; > +} option_spec_int; > + > +typedef struct option_spec_real > +{ > + option_spec_basic base; > + double default_val; > + double min; > + double max; > +} option_spec_real; > + > +typedef struct option_spec_enum > +{ > + option_spec_basic base; > + opt_enum_elt_def *members;/* FIXME rewrite. Null terminated array of allowed values for > + * the option */ > + int default_val; /* Number of item of allowed_values array */ > + const char *detailmsg; > +} option_spec_enum; > + > +/* validation routines for strings */ > +typedef void (*validate_string_option) (const char *value); > + > +/* > + * When storing sting reloptions, we shoud deal with special case when > + * option value is not set. For fixed length options, we just copy default > + * option value into the binary structure. For varlen value, there can be > + * "not set" special case, with no default value offered. > + * In this case we will set offset value to -1, so code that use relptions > + * can deal this case. For better readability it was defined as a constant. > + */ > +#define OPTION_STRING_VALUE_NOT_SET_OFFSET -1 > + > +typedef struct option_spec_string > +{ > + option_spec_basic base; > + validate_string_option validate_cb; > + char *default_val; > +} option_spec_string; > + > +typedef void (*postprocess_bytea_options_function) (void *data, bool validate); > + > +typedef struct options_spec_set > +{ > + option_spec_basic **definitions; > + int num; /* Number of spec_set items in use */ > + int num_allocated; /* Number of spec_set items allocated */ > + bool forbid_realloc; /* If number of items of the spec_set were > + * strictly set to certain value do no allow > + * adding more idems */ > + Size struct_size; /* Size of a structure for options in binary > + * representation */ > + postprocess_bytea_options_function postprocess_fun; /* This function is > + * called after options > + * were converted in > + * Bytea represenation. > + * Can be used for extra > + * validation and so on */ > + char *namespace; /* spec_set is used for options from this > + * namespase */ > +} options_spec_set; > + > + > +/* holds an option value parsed or unparsed */ > +typedef struct option_value > +{ > + option_spec_basic *gen; > + char *namespace; > + option_value_status status; > + char *raw_value; /* allocated separately */ > + char *raw_name; > + union > + { > + bool bool_val; > + int int_val; > + double real_val; > + int enum_val; > + char *string_val; /* allocated separately */ > + } values; > +} option_value; > + > + > + > + > +/* > + * Options spec_set related functions > + */ > +extern options_spec_set *allocateOptionsSpecSet(const char *namespace, > + int size_of_bytea, int num_items_expected); > +extern void optionsSpecSetAddBool(options_spec_set * spec_set, const char *name, > + const char *desc, LOCKMODE lockmode, option_spec_flags flags, > + int struct_offset, bool default_val); > +extern void optionsSpecSetAddInt(options_spec_set * spec_set, const char *name, > + const char *desc, LOCKMODE lockmode, option_spec_flags flags, > + int struct_offset, int default_val, int min_val, int max_val); > +extern void optionsSpecSetAddReal(options_spec_set * spec_set, const char *name, > + const char *desc, LOCKMODE lockmode, option_spec_flags flags, > + int struct_offset, double default_val, double min_val, double max_val); > +extern void optionsSpecSetAddEnum(options_spec_set * spec_set, > + const char *name, const char *desc, LOCKMODE lockmode, option_spec_flags flags, > + int struct_offset, opt_enum_elt_def* members, int default_val, const char *detailmsg); > +extern void optionsSpecSetAddString(options_spec_set * spec_set, const char *name, > + const char *desc, LOCKMODE lockmode, option_spec_flags flags, > +int struct_offset, const char *default_val, validate_string_option validator); > + > + > +/* > + * This macro allows to get string option value from bytea representation. > + * "optstruct" - is a structure that is stored in bytea options representation > + * "member" - member of this structure that has string option value > + * (actually string values are stored in bytea after the structure, and > + * and "member" will contain an offset to this value. This macro do all > + * the math > + */ > +#define GET_STRING_OPTION(optstruct, member) \ > + ((optstruct)->member == OPTION_STRING_VALUE_NOT_SET_OFFSET ? NULL : \ > + (char *)(optstruct) + (optstruct)->member) > + > +/* > + * Functions related to option convertation, parsing, manipulation > + * and validation > + */ > +extern void optionsDefListValdateNamespaces(List *defList, > + char **allowed_namespaces); > +extern List *optionsDefListFilterNamespaces(List *defList, const char *namespace); > +extern List *optionsTextArrayToDefList(Datum options); > +extern Datum optionsDefListToTextArray(List *defList); > +/* > + * Meta functions that uses functions above to get options for relations, > + * tablespaces, views and so on > + */ > + > +extern bytea *optionsTextArrayToBytea(options_spec_set * spec_set, Datum data, > + bool validate); > +extern Datum transformOptions(options_spec_set * spec_set, Datum oldOptions, > + List *defList, options_parse_mode parse_mode); > + > +#endif /* OPTIONS_H */ > diff --git a/src/include/access/reloptions.h b/src/include/access/reloptions.h > index 7c5fbeb..21b91df 100644 > --- a/src/include/access/reloptions.h > +++ b/src/include/access/reloptions.h > @@ -22,6 +22,7 @@ > #include "access/amapi.h" > #include "access/htup.h" > #include "access/tupdesc.h" > +#include "access/options.h" > #include "nodes/pg_list.h" > #include "storage/lock.h" > > @@ -110,20 +111,10 @@ typedef struct relopt_real > double max; > } relopt_real; > > -/* > - * relopt_enum_elt_def -- One member of the array of acceptable values > - * of an enum reloption. > - */ > -typedef struct relopt_enum_elt_def > -{ > - const char *string_val; > - int symbol_val; > -} relopt_enum_elt_def; > - > typedef struct relopt_enum > { > relopt_gen gen; > - relopt_enum_elt_def *members; > + opt_enum_elt_def *members; > int default_val; > const char *detailmsg; > /* null-terminated array of members */ > @@ -167,6 +158,7 @@ typedef struct local_relopts > List *options; /* list of local_relopt definitions */ > List *validators; /* list of relopts_validator callbacks */ > Size relopt_struct_size; /* size of parsed bytea structure */ > + options_spec_set * spec_set; /* FIXME */ > } local_relopts; > > /* > @@ -179,21 +171,6 @@ typedef struct local_relopts > ((optstruct)->member == 0 ? NULL : \ > (char *)(optstruct) + (optstruct)->member) > > -extern relopt_kind add_reloption_kind(void); > -extern void add_bool_reloption(bits32 kinds, const char *name, const char *desc, > - bool default_val, LOCKMODE lockmode); > -extern void add_int_reloption(bits32 kinds, const char *name, const char *desc, > - int default_val, int min_val, int max_val, > - LOCKMODE lockmode); > -extern void add_real_reloption(bits32 kinds, const char *name, const char *desc, > - double default_val, double min_val, double max_val, > - LOCKMODE lockmode); > -extern 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); > -extern void add_string_reloption(bits32 kinds, const char *name, const char *desc, > - const char *default_val, validate_string_relopt validator, > - LOCKMODE lockmode); > > extern void init_local_reloptions(local_relopts *opts, Size relopt_struct_size); > extern void register_reloptions_validator(local_relopts *opts, > @@ -210,7 +187,7 @@ extern void add_local_real_reloption(local_relopts *opts, const char *name, > int offset); > extern void add_local_enum_reloption(local_relopts *relopts, > const char *name, const char *desc, > - relopt_enum_elt_def *members, > + opt_enum_elt_def *members, > int default_val, const char *detailmsg, > int offset); > extern void add_local_string_reloption(local_relopts *opts, const char *name, > @@ -219,29 +196,17 @@ extern void add_local_string_reloption(local_relopts *opts, const char *name, > validate_string_relopt validator, > fill_string_relopt filler, int offset); > > -extern Datum transformRelOptions(Datum oldOptions, List *defList, > - const char *namspace, char *validnsps[], > - bool acceptOidsOff, bool isReset); > -extern List *untransformRelOptions(Datum options); > extern bytea *extractRelOptions(HeapTuple tuple, TupleDesc tupdesc, > - amoptions_function amoptions); > -extern void *build_reloptions(Datum reloptions, bool validate, > - relopt_kind kind, > - Size relopt_struct_size, > - const relopt_parse_elt *relopt_elems, > - int num_relopt_elems); > + amreloptspecset_function amoptions_def_set); > extern void *build_local_reloptions(local_relopts *relopts, Datum options, > bool validate); > > -extern bytea *default_reloptions(Datum reloptions, bool validate, > - relopt_kind kind); > -extern bytea *heap_reloptions(char relkind, Datum reloptions, bool validate); > -extern bytea *view_reloptions(Datum reloptions, bool validate); > -extern bytea *partitioned_table_reloptions(Datum reloptions, bool validate); > -extern bytea *index_reloptions(amoptions_function amoptions, Datum reloptions, > - bool validate); > -extern bytea *attribute_reloptions(Datum reloptions, bool validate); > -extern bytea *tablespace_reloptions(Datum reloptions, bool validate); > -extern LOCKMODE AlterTableGetRelOptionsLockLevel(List *defList); > +options_spec_set *get_heap_relopt_spec_set(void); > +options_spec_set *get_toast_relopt_spec_set(void); > +options_spec_set *get_partitioned_relopt_spec_set(void); > +options_spec_set *get_view_relopt_spec_set(void); > +options_spec_set *get_attribute_options_spec_set(void); > +options_spec_set *get_tablespace_options_spec_set(void); > +extern LOCKMODE AlterTableGetRelOptionsLockLevel(Relation rel, List *defList); > > #endif /* RELOPTIONS_H */ > diff --git a/src/include/access/spgist.h b/src/include/access/spgist.h > index 2eb2f42..d9a9b2d 100644 > --- a/src/include/access/spgist.h > +++ b/src/include/access/spgist.h > @@ -189,9 +189,6 @@ typedef struct spgLeafConsistentOut > } spgLeafConsistentOut; > > > -/* spgutils.c */ > -extern bytea *spgoptions(Datum reloptions, bool validate); > - > /* spginsert.c */ > extern IndexBuildResult *spgbuild(Relation heap, Relation index, > struct IndexInfo *indexInfo); > diff --git a/src/include/access/spgist_private.h b/src/include/access/spgist_private.h > index 40d3b71..dd9a05a 100644 > --- a/src/include/access/spgist_private.h > +++ b/src/include/access/spgist_private.h > @@ -529,6 +529,7 @@ extern OffsetNumber SpGistPageAddNewItem(SpGistState *state, Page page, > extern bool spgproperty(Oid index_oid, int attno, > IndexAMProperty prop, const char *propname, > bool *res, bool *isnull); > +extern void *spggetreloptspecset(void); > > /* spgdoinsert.c */ > extern void spgUpdateNodeLink(SpGistInnerTuple tup, int nodeN, > diff --git a/src/include/commands/tablecmds.h b/src/include/commands/tablecmds.h > index 336549c..3f87f98 100644 > --- a/src/include/commands/tablecmds.h > +++ b/src/include/commands/tablecmds.h > @@ -34,7 +34,7 @@ extern Oid AlterTableLookupRelation(AlterTableStmt *stmt, LOCKMODE lockmode); > extern void AlterTable(AlterTableStmt *stmt, LOCKMODE lockmode, > struct AlterTableUtilityContext *context); > > -extern LOCKMODE AlterTableGetLockLevel(List *cmds); > +extern LOCKMODE AlterTableGetLockLevel(Oid relid, List *cmds); > > extern void ATExecChangeOwner(Oid relationOid, Oid newOwnerId, bool recursing, LOCKMODE lockmode); > > diff --git a/src/test/modules/dummy_index_am/dummy_index_am.c b/src/test/modules/dummy_index_am/dummy_index_am.c > index 5365b063..80b39e8 100644 > --- a/src/test/modules/dummy_index_am/dummy_index_am.c > +++ b/src/test/modules/dummy_index_am/dummy_index_am.c > @@ -14,7 +14,7 @@ > #include "postgres.h" > > #include "access/amapi.h" > -#include "access/reloptions.h" > +#include "access/options.h" > #include "catalog/index.h" > #include "commands/vacuum.h" > #include "nodes/pathnodes.h" > @@ -25,12 +25,6 @@ PG_MODULE_MAGIC; > > void _PG_init(void); > > -/* parse table for fillRelOptions */ > -relopt_parse_elt di_relopt_tab[6]; > - > -/* Kind of relation options for dummy index */ > -relopt_kind di_relopt_kind; > - > typedef enum DummyAmEnum > { > DUMMY_AM_ENUM_ONE, > @@ -49,7 +43,7 @@ typedef struct DummyIndexOptions > int option_string_null_offset; > } DummyIndexOptions; > > -relopt_enum_elt_def dummyAmEnumValues[] = > +opt_enum_elt_def dummyAmEnumValues[] = > { > {"one", DUMMY_AM_ENUM_ONE}, > {"two", DUMMY_AM_ENUM_TWO}, > @@ -63,77 +57,85 @@ PG_FUNCTION_INFO_V1(dihandler); > * Validation function for string relation options. > */ > static void > -validate_string_option(const char *value) > +divalidate_string_option(const char *value) > { > ereport(NOTICE, > (errmsg("new option value for string parameter %s", > value ? value : "NULL"))); > } > > -/* > - * This function creates a full set of relation option types, > - * with various patterns. > - */ > -static void > -create_reloptions_table(void) > +static options_spec_set *di_relopt_specset = NULL; > +void * digetreloptspecset(void); > + > +void * > +digetreloptspecset(void) > { > - di_relopt_kind = add_reloption_kind(); > - > - add_int_reloption(di_relopt_kind, "option_int", > - "Integer option for dummy_index_am", > - 10, -10, 100, AccessExclusiveLock); > - di_relopt_tab[0].optname = "option_int"; > - di_relopt_tab[0].opttype = RELOPT_TYPE_INT; > - di_relopt_tab[0].offset = offsetof(DummyIndexOptions, option_int); > - > - add_real_reloption(di_relopt_kind, "option_real", > - "Real option for dummy_index_am", > - 3.1415, -10, 100, AccessExclusiveLock); > - di_relopt_tab[1].optname = "option_real"; > - di_relopt_tab[1].opttype = RELOPT_TYPE_REAL; > - di_relopt_tab[1].offset = offsetof(DummyIndexOptions, option_real); > - > - add_bool_reloption(di_relopt_kind, "option_bool", > - "Boolean option for dummy_index_am", > - true, AccessExclusiveLock); > - di_relopt_tab[2].optname = "option_bool"; > - di_relopt_tab[2].opttype = RELOPT_TYPE_BOOL; > - di_relopt_tab[2].offset = offsetof(DummyIndexOptions, option_bool); > - > - add_enum_reloption(di_relopt_kind, "option_enum", > - "Enum option for dummy_index_am", > - dummyAmEnumValues, > - DUMMY_AM_ENUM_ONE, > - "Valid values are \"one\" and \"two\".", > - AccessExclusiveLock); > - di_relopt_tab[3].optname = "option_enum"; > - di_relopt_tab[3].opttype = RELOPT_TYPE_ENUM; > - di_relopt_tab[3].offset = offsetof(DummyIndexOptions, option_enum); > - > - add_string_reloption(di_relopt_kind, "option_string_val", > - "String option for dummy_index_am with non-NULL default", > - "DefaultValue", &validate_string_option, > - AccessExclusiveLock); > - di_relopt_tab[4].optname = "option_string_val"; > - di_relopt_tab[4].opttype = RELOPT_TYPE_STRING; > - di_relopt_tab[4].offset = offsetof(DummyIndexOptions, > - option_string_val_offset); > + if (di_relopt_specset) > + return di_relopt_specset; > + > + di_relopt_specset = allocateOptionsSpecSet(NULL, > + sizeof(DummyIndexOptions), 6); > + > + optionsSpecSetAddInt( > + di_relopt_specset, "option_int", > + "Integer option for dummy_index_am", > + AccessExclusiveLock, > + 0, offsetof(DummyIndexOptions, option_int), > + 10, -10, 100 > + ); > + > + > + optionsSpecSetAddReal( > + di_relopt_specset, "option_real", > + "Real option for dummy_index_am", > + AccessExclusiveLock, > + 0, offsetof(DummyIndexOptions, option_real), > + 3.1415, -10, 100 > + ); > + > + optionsSpecSetAddBool( > + di_relopt_specset, "option_bool", > + "Boolean option for dummy_index_am", > + AccessExclusiveLock, > + 0, offsetof(DummyIndexOptions, option_bool), true > + ); > + > + optionsSpecSetAddEnum(di_relopt_specset, "option_enum", > + "Enum option for dummy_index_am", > + AccessExclusiveLock, > + 0, > + offsetof(DummyIndexOptions, option_enum), > + dummyAmEnumValues, > + DUMMY_AM_ENUM_ONE, > + "Valid values are \"one\" and \"two\"." > + ); > + > + optionsSpecSetAddString(di_relopt_specset, "option_string_val", > + "String option for dummy_index_am with non-NULL default", > + AccessExclusiveLock, > + 0, > + offsetof(DummyIndexOptions, option_string_val_offset), > + "DefaultValue", &divalidate_string_option > + ); > > /* > * String option for dummy_index_am with NULL default, and without > * description. > */ > - add_string_reloption(di_relopt_kind, "option_string_null", > - NULL, /* description */ > - NULL, &validate_string_option, > - AccessExclusiveLock); > - di_relopt_tab[5].optname = "option_string_null"; > - di_relopt_tab[5].opttype = RELOPT_TYPE_STRING; > - di_relopt_tab[5].offset = offsetof(DummyIndexOptions, > - option_string_null_offset); > + > + optionsSpecSetAddString(di_relopt_specset, "option_string_null", > + NULL, /* description */ > + AccessExclusiveLock, > + 0, > + offsetof(DummyIndexOptions, option_string_null_offset), > + NULL, &divalidate_string_option > + ); > + > + return di_relopt_specset; > } > > > + > /* > * Build a new index. > */ > @@ -219,19 +221,6 @@ dicostestimate(PlannerInfo *root, IndexPath *path, double loop_count, > } > > /* > - * Parse relation options for index AM, returning a DummyIndexOptions > - * structure filled with option values. > - */ > -static bytea * > -dioptions(Datum reloptions, bool validate) > -{ > - return (bytea *) build_reloptions(reloptions, validate, > - di_relopt_kind, > - sizeof(DummyIndexOptions), > - di_relopt_tab, lengthof(di_relopt_tab)); > -} > - > -/* > * Validator for index AM. > */ > static bool > @@ -308,7 +297,6 @@ dihandler(PG_FUNCTION_ARGS) > amroutine->amvacuumcleanup = divacuumcleanup; > amroutine->amcanreturn = NULL; > amroutine->amcostestimate = dicostestimate; > - amroutine->amoptions = dioptions; > amroutine->amproperty = NULL; > amroutine->ambuildphasename = NULL; > amroutine->amvalidate = divalidate; > @@ -322,12 +310,7 @@ dihandler(PG_FUNCTION_ARGS) > amroutine->amestimateparallelscan = NULL; > amroutine->aminitparallelscan = NULL; > amroutine->amparallelrescan = NULL; > + amroutine->amreloptspecset = digetreloptspecset; > > PG_RETURN_POINTER(amroutine); > } > - > -void > -_PG_init(void) > -{ > - create_reloptions_table(); > -} -- Bruce Momjian <bruce@momjian.us> https://momjian.us EDB https://enterprisedb.com If only the physical world exists, free will is an illusion.
В письме от вторник, 26 октября 2021 г. 17:25:32 MSK пользователь Bruce Momjian написал: > Uh, the core team does not get involved in development issues, unless > there is a issue that clearly cannot be resolved by discussion on the > hackers list. Then may be I used wrong therm. May be I should say "experienced postgres developers". > > --------------------------------------------------------------------------- > > On Mon, Oct 18, 2021 at 04:24:23PM +0300, Nikolay Shaplov wrote: > > Hi! > > > > I am still hoping to finish my work on reloptions I've started some years > > ago. > > > > I've renewed my patch and I think I need help from core team to finish it. > > > > General idea of the patch: Now we have three ways to define options for > > different objects, with more or less different code used for it. It wold > > be > > better to have unified context independent API for processing options, > > instead. > > > > Long story short: > > > > There is Option Specification object, that has all information about > > single > > option, how it should be parsed and validated. > > > > There is Option Specification Set object, an array of Option Specs, that > > defines all options available for certain object (am of some index for > > example). > > > > When some object (relation, opclass, etc) wants to have an options, it > > creates an Option Spec Set for there options, and uses it for converting > > options between different representations (to get is from SQL, to store it > > in pg_class, to pass it to the core code as bytea etc) > > > > For indexes Option Spec Set is available via Access Method API. > > > > For non-index relations all Option Spec Sets are left in reloption.c file, > > and should be moved to heap AM later. (They are not in AM now so will not > > change it now) > > > > Main problem: > > > > There are LockModes. LockModes for options is also stored in Option Spec > > Set. For indexes Option Spec Sec is accessable via AM. So to get LockMode > > for option of an index you need to have access for it's relation object > > (so you can call proper AM method to fetch spec set). So you need > > "Relation rel" in AlterTableGetRelOptionsLockLevel where Lock Level is > > determinated (src/ backend/access/common/reloptions.c) > > AlterTableGetRelOptionsLockLevel is called from AlterTableGetLockLevel > > (src/ backend/commands/tablecmds.c) so we need "Relation rel" there too. > > AlterTableGetLockLevel is called from AlterTableInternal (/src/backend/ > > commands/tablecmds.c) There we have "Oid relid" so we can try to open > > relation like this > > > > Relation rel = relation_open(relid, NoLock); > > cmd_lockmode = AlterTableGetRelOptionsLockLevel(rel, > > > > castNode(List, > > cmd->def)); > > > > relation_close(rel,NoLock); > > break; > > > > but this will trigger the assertion > > > > Assert(lockmode != NoLock || > > > > IsBootstrapProcessingMode() || > > CheckRelationLockedByMe(r, c, true)); > > > > in relation_open (b/src/backend/access/common/relation.c) > > > > For now I've commented this assertion out. I've tried to open relation > > with > > AccessShareLock but this caused one test to fail, and I am not sure this > > solution is better. > > > > What I have done here I consider a hack, so I need a help of core-team > > here to do it in right way. > > > > General problems: > > > > I guess I need a coauthor, or supervisor from core team, to finish this > > patch. The amount of code is big, and I guess there are parts that can be > > made more in postgres way, then I did them. And I would need an advice > > there, and I guess it would be better to do if before sending it to > > commitfest. > > > > > > Current patch status: > > > > 1. It is Beta. Some minor issues and FIXMEs are not solved. Some code > > comments needs revising, but in general it do what it is intended to do. > > > > 2. This patch does not intend to change postgres behavior at all, all > > should work as before, all changes are internal only. > > > > The only exception is error message for unexciting option name in toast > > namespace > > > > CREATE TABLE reloptions_test2 (i int) WITH (toast.not_existing_option = > > 42);> > > -ERROR: unrecognized parameter "not_existing_option" > > +ERROR: unrecognized parameter "toast.not_existing_option" > > > > New message is better I guess, though I can change it back if needed. > > > > 3. I am doing my development in this blanch > > https://gitlab.com/dhyannataraj/ postgres/-/tree/new_options_take_two I > > am making changes every day, so last version will be available there > > > > Would be glad to hear from coreteam before I finish with this patch and > > made it ready for commit-fest. > > > > > > > > diff --git a/contrib/bloom/bloom.h b/contrib/bloom/bloom.h > > index a22a6df..8f2d5e7 100644 > > --- a/contrib/bloom/bloom.h > > +++ b/contrib/bloom/bloom.h > > @@ -17,6 +17,7 @@ > > > > #include "access/generic_xlog.h" > > #include "access/itup.h" > > #include "access/xlog.h" > > > > +#include "access/options.h" > > > > #include "fmgr.h" > > #include "nodes/pathnodes.h" > > > > @@ -207,7 +208,8 @@ extern IndexBulkDeleteResult > > *blbulkdelete(IndexVacuumInfo *info,> > > void *callback_state); > > > > extern IndexBulkDeleteResult *blvacuumcleanup(IndexVacuumInfo *info, > > > > IndexBulkDeleteResult *stats); > > > > -extern bytea *bloptions(Datum reloptions, bool validate); > > +extern void *blrelopt_specset(void); > > +extern void blReloptionPostprocess(void *, bool validate); > > > > extern void blcostestimate(PlannerInfo *root, IndexPath *path, > > > > double loop_count, Cost *indexStartupCost, > > Cost *indexTotalCost, Selectivity *indexSelectivity, > > > > diff --git a/contrib/bloom/blutils.c b/contrib/bloom/blutils.c > > index 754de00..54dad16 100644 > > --- a/contrib/bloom/blutils.c > > +++ b/contrib/bloom/blutils.c > > @@ -15,7 +15,7 @@ > > > > #include "access/amapi.h" > > #include "access/generic_xlog.h" > > > > -#include "access/reloptions.h" > > +#include "access/options.h" > > > > #include "bloom.h" > > #include "catalog/index.h" > > #include "commands/vacuum.h" > > > > @@ -34,53 +34,13 @@ > > > > PG_FUNCTION_INFO_V1(blhandler); > > > > -/* Kind of relation options for bloom index */ > > -static relopt_kind bl_relopt_kind; > > - > > -/* parse table for fillRelOptions */ > > -static relopt_parse_elt bl_relopt_tab[INDEX_MAX_KEYS + 1]; > > +/* Catalog of relation options for bloom index */ > > +static options_spec_set *bl_relopt_specset; > > > > static int32 myRand(void); > > static void mySrand(uint32 seed); > > > > /* > > > > - * Module initialize function: initialize info about Bloom relation > > options. - * > > - * Note: keep this in sync with makeDefaultBloomOptions(). > > - */ > > -void > > -_PG_init(void) > > -{ > > - int i; > > - char buf[16]; > > - > > - bl_relopt_kind = add_reloption_kind(); > > - > > - /* Option for length of signature */ > > - add_int_reloption(bl_relopt_kind, "length", > > - "Length of signature in bits", > > - DEFAULT_BLOOM_LENGTH, 1, MAX_BLOOM_LENGTH, > > - AccessExclusiveLock); > > - bl_relopt_tab[0].optname = "length"; > > - bl_relopt_tab[0].opttype = RELOPT_TYPE_INT; > > - bl_relopt_tab[0].offset = offsetof(BloomOptions, bloomLength); > > - > > - /* Number of bits for each possible index column: col1, col2, ... */ > > - for (i = 0; i < INDEX_MAX_KEYS; i++) > > - { > > - snprintf(buf, sizeof(buf), "col%d", i + 1); > > - add_int_reloption(bl_relopt_kind, buf, > > - "Number of bits generated for each index column", > > - DEFAULT_BLOOM_BITS, 1, MAX_BLOOM_BITS, > > - AccessExclusiveLock); > > - bl_relopt_tab[i + 1].optname = MemoryContextStrdup(TopMemoryContext, > > - buf); > > - bl_relopt_tab[i + 1].opttype = RELOPT_TYPE_INT; > > - bl_relopt_tab[i + 1].offset = offsetof(BloomOptions, bitSize[0]) + > > sizeof(int) * i; - } > > -} > > - > > -/* > > > > * Construct a default set of Bloom options. > > */ > > > > static BloomOptions * > > > > @@ -135,7 +95,7 @@ blhandler(PG_FUNCTION_ARGS) > > > > amroutine->amvacuumcleanup = blvacuumcleanup; > > amroutine->amcanreturn = NULL; > > amroutine->amcostestimate = blcostestimate; > > > > - amroutine->amoptions = bloptions; > > + amroutine->amreloptspecset = blrelopt_specset; > > > > amroutine->amproperty = NULL; > > amroutine->ambuildphasename = NULL; > > amroutine->amvalidate = blvalidate; > > > > @@ -154,6 +114,28 @@ blhandler(PG_FUNCTION_ARGS) > > > > PG_RETURN_POINTER(amroutine); > > > > } > > > > +void > > +blReloptionPostprocess(void *data, bool validate) > > +{ > > + BloomOptions *opts = (BloomOptions *) data; > > + int i; > > + > > + if (validate) > > + for (i = 0; i < INDEX_MAX_KEYS; i++) > > + { > > + if (opts->bitSize[i] >= opts->bloomLength) > > + { > > + ereport(ERROR, > > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > + errmsg("col%i should not be grater than length", i))); > > + } > > + } > > + > > + /* Convert signature length from # of bits to # to words, rounding up */ > > + opts->bloomLength = (opts->bloomLength + SIGNWORDBITS - 1) / > > SIGNWORDBITS; +} > > + > > + > > > > /* > > > > * Fill BloomState structure for particular index. > > */ > > > > @@ -474,24 +456,39 @@ BloomInitMetapage(Relation index) > > > > UnlockReleaseBuffer(metaBuffer); > > > > } > > > > -/* > > - * Parse reloptions for bloom index, producing a BloomOptions struct. > > - */ > > -bytea * > > -bloptions(Datum reloptions, bool validate) > > +void * > > +blrelopt_specset(void) > > > > { > > > > - BloomOptions *rdopts; > > + int i; > > + char buf[16]; > > > > - /* Parse the user-given reloptions */ > > - rdopts = (BloomOptions *) build_reloptions(reloptions, validate, > > - bl_relopt_kind, > > - sizeof(BloomOptions), > > - bl_relopt_tab, > > - lengthof(bl_relopt_tab)); > > + if (bl_relopt_specset) > > + return bl_relopt_specset; > > > > - /* Convert signature length from # of bits to # to words, rounding up */ > > - if (rdopts) > > - rdopts->bloomLength = (rdopts->bloomLength + SIGNWORDBITS - 1) / > > SIGNWORDBITS; > > > > - return (bytea *) rdopts; > > + bl_relopt_specset = allocateOptionsSpecSet(NULL, > > + sizeof(BloomOptions), INDEX_MAX_KEYS + 1); > > + bl_relopt_specset->postprocess_fun = blReloptionPostprocess; > > + > > + optionsSpecSetAddInt(bl_relopt_specset, "length", > > + "Length of signature in bits", > > + NoLock, /* No lock as far as ALTER is > > + * forbidden */ > > + 0, > > + offsetof(BloomOptions, bloomLength), > > + DEFAULT_BLOOM_LENGTH, 1, MAX_BLOOM_LENGTH); > > + > > + /* Number of bits for each possible index column: col1, col2, ... */ > > + for (i = 0; i < INDEX_MAX_KEYS; i++) > > + { > > + snprintf(buf, 16, "col%d", i + 1); > > + optionsSpecSetAddInt(bl_relopt_specset, buf, > > + "Number of bits for corresponding column", > > + NoLock, /* No lock as far as ALTER is > > + * forbidden */ > > + 0, > > + offsetof(BloomOptions, bitSize[i]), > > + DEFAULT_BLOOM_BITS, 1, MAX_BLOOM_BITS); > > + } > > + return bl_relopt_specset; > > > > } > > > > diff --git a/contrib/bloom/expected/bloom.out > > b/contrib/bloom/expected/bloom.out index dae12a7..e79456d 100644 > > --- a/contrib/bloom/expected/bloom.out > > +++ b/contrib/bloom/expected/bloom.out > > @@ -228,3 +228,6 @@ CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH > > (length=0);> > > ERROR: value 0 out of bounds for option "length" > > CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH (col1=0); > > ERROR: value 0 out of bounds for option "col1" > > > > +-- check post_validate for colN<lengh > > +CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH > > (length=10,col1=11); > > +ERROR: col0 should not be grater than length > > diff --git a/contrib/bloom/sql/bloom.sql b/contrib/bloom/sql/bloom.sql > > index 4733e1e..0bfc767 100644 > > --- a/contrib/bloom/sql/bloom.sql > > +++ b/contrib/bloom/sql/bloom.sql > > @@ -93,3 +93,6 @@ SELECT reloptions FROM pg_class WHERE oid = > > 'bloomidx'::regclass;> > > \set VERBOSITY terse > > CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH (length=0); > > CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH (col1=0); > > > > + > > +-- check post_validate for colN<lengh > > +CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH > > (length=10,col1=11); > > diff --git a/contrib/dblink/dblink.c b/contrib/dblink/dblink.c > > index 3a0beaa..a15a10b 100644 > > --- a/contrib/dblink/dblink.c > > +++ b/contrib/dblink/dblink.c > > @@ -2005,7 +2005,7 @@ PG_FUNCTION_INFO_V1(dblink_fdw_validator); > > > > Datum > > dblink_fdw_validator(PG_FUNCTION_ARGS) > > { > > > > - List *options_list = untransformRelOptions(PG_GETARG_DATUM(0)); > > + List *options_list = optionsTextArrayToDefList(PG_GETARG_DATUM(0)); > > > > Oid context = PG_GETARG_OID(1); > > ListCell *cell; > > > > diff --git a/contrib/file_fdw/file_fdw.c b/contrib/file_fdw/file_fdw.c > > index 2c2f149..1194747 100644 > > --- a/contrib/file_fdw/file_fdw.c > > +++ b/contrib/file_fdw/file_fdw.c > > @@ -195,7 +195,7 @@ file_fdw_handler(PG_FUNCTION_ARGS) > > > > Datum > > file_fdw_validator(PG_FUNCTION_ARGS) > > { > > > > - List *options_list = untransformRelOptions(PG_GETARG_DATUM(0)); > > + List *options_list = optionsTextArrayToDefList(PG_GETARG_DATUM(0)); > > > > Oid catalog = PG_GETARG_OID(1); > > char *filename = NULL; > > DefElem *force_not_null = NULL; > > > > diff --git a/contrib/postgres_fdw/option.c b/contrib/postgres_fdw/option.c > > index 5bb1af4..bbd4167 100644 > > --- a/contrib/postgres_fdw/option.c > > +++ b/contrib/postgres_fdw/option.c > > @@ -72,7 +72,7 @@ PG_FUNCTION_INFO_V1(postgres_fdw_validator); > > > > Datum > > postgres_fdw_validator(PG_FUNCTION_ARGS) > > { > > > > - List *options_list = untransformRelOptions(PG_GETARG_DATUM(0)); > > + List *options_list = optionsTextArrayToDefList(PG_GETARG_DATUM(0)); > > > > Oid catalog = PG_GETARG_OID(1); > > ListCell *cell; > > > > diff --git a/src/backend/access/brin/brin.c > > b/src/backend/access/brin/brin.c index ccc9fa0..5dd52a4 100644 > > --- a/src/backend/access/brin/brin.c > > +++ b/src/backend/access/brin/brin.c > > @@ -20,7 +20,6 @@ > > > > #include "access/brin_pageops.h" > > #include "access/brin_xlog.h" > > #include "access/relation.h" > > > > -#include "access/reloptions.h" > > > > #include "access/relscan.h" > > #include "access/table.h" > > #include "access/tableam.h" > > > > @@ -40,7 +39,6 @@ > > > > #include "utils/memutils.h" > > #include "utils/rel.h" > > > > - > > > > /* > > > > * We use a BrinBuildState during initial construction of a BRIN index. > > * The running state is kept in a BrinMemTuple. > > > > @@ -119,7 +117,6 @@ brinhandler(PG_FUNCTION_ARGS) > > > > amroutine->amvacuumcleanup = brinvacuumcleanup; > > amroutine->amcanreturn = NULL; > > amroutine->amcostestimate = brincostestimate; > > > > - amroutine->amoptions = brinoptions; > > > > amroutine->amproperty = NULL; > > amroutine->ambuildphasename = NULL; > > amroutine->amvalidate = brinvalidate; > > > > @@ -134,6 +131,7 @@ brinhandler(PG_FUNCTION_ARGS) > > > > amroutine->amestimateparallelscan = NULL; > > amroutine->aminitparallelscan = NULL; > > amroutine->amparallelrescan = NULL; > > > > + amroutine->amreloptspecset = bringetreloptspecset; > > > > PG_RETURN_POINTER(amroutine); > > > > } > > > > @@ -963,23 +961,6 @@ brinvacuumcleanup(IndexVacuumInfo *info, > > IndexBulkDeleteResult *stats)> > > } > > > > /* > > > > - * reloptions processor for BRIN indexes > > - */ > > -bytea * > > -brinoptions(Datum reloptions, bool validate) > > -{ > > - static const relopt_parse_elt tab[] = { > > - {"pages_per_range", RELOPT_TYPE_INT, offsetof(BrinOptions, > > pagesPerRange)}, - {"autosummarize", RELOPT_TYPE_BOOL, > > offsetof(BrinOptions, autosummarize)} - }; > > - > > - return (bytea *) build_reloptions(reloptions, validate, > > - RELOPT_KIND_BRIN, > > - sizeof(BrinOptions), > > - tab, lengthof(tab)); > > -} > > - > > -/* > > > > * SQL-callable function to scan through an index and summarize all > > ranges > > * that are not currently summarized. > > */ > > > > @@ -1765,3 +1746,32 @@ check_null_keys(BrinValues *bval, ScanKey > > *nullkeys, int nnullkeys)> > > return true; > > > > } > > > > + > > +static options_spec_set *brin_relopt_specset = NULL; > > + > > +void * > > +bringetreloptspecset(void) > > +{ > > + if (brin_relopt_specset) > > + return brin_relopt_specset; > > + brin_relopt_specset = allocateOptionsSpecSet(NULL, > > + sizeof(BrinOptions), 2); > > + > > + optionsSpecSetAddInt(brin_relopt_specset, "pages_per_range", > > + "Number of pages that each page range covers in a BRIN index", > > + NoLock, /* since ALTER is not allowed > > + * no lock needed */ > > + 0, > > + offsetof(BrinOptions, pagesPerRange), > > + BRIN_DEFAULT_PAGES_PER_RANGE, > > + BRIN_MIN_PAGES_PER_RANGE, > > + BRIN_MAX_PAGES_PER_RANGE); > > + optionsSpecSetAddBool(brin_relopt_specset, "autosummarize", > > + "Enables automatic summarization on this BRIN index", > > + AccessExclusiveLock, > > + 0, > > + offsetof(BrinOptions, autosummarize), > > + false); > > + return brin_relopt_specset; > > +} > > + > > diff --git a/src/backend/access/brin/brin_pageops.c > > b/src/backend/access/brin/brin_pageops.c index df9ffc2..1940b3d 100644 > > --- a/src/backend/access/brin/brin_pageops.c > > +++ b/src/backend/access/brin/brin_pageops.c > > @@ -420,6 +420,9 @@ brin_doinsert(Relation idxrel, BlockNumber > > pagesPerRange,> > > freespace = br_page_get_freespace(page); > > > > ItemPointerSet(&tid, blk, off); > > > > + > > +//elog(WARNING, "pages_per_range = %i", pagesPerRange); > > + > > > > brinSetHeapBlockItemptr(revmapbuf, pagesPerRange, heapBlk, tid); > > MarkBufferDirty(revmapbuf); > > > > diff --git a/src/backend/access/common/Makefile > > b/src/backend/access/common/Makefile index b9aff0c..78c9c5a 100644 > > --- a/src/backend/access/common/Makefile > > +++ b/src/backend/access/common/Makefile > > @@ -18,6 +18,7 @@ OBJS = \ > > > > detoast.o \ > > heaptuple.o \ > > indextuple.o \ > > > > + options.o \ > > > > printsimple.o \ > > printtup.o \ > > relation.o \ > > > > diff --git a/src/backend/access/common/options.c > > b/src/backend/access/common/options.c new file mode 100644 > > index 0000000..752cddc > > --- /dev/null > > +++ b/src/backend/access/common/options.c > > @@ -0,0 +1,1468 @@ > > +/*----------------------------------------------------------------------- > > -- + * > > + * options.c > > + * An unifom, context-free API for processing name=value options. Used > > + * to process relation optons (reloptions), attribute options, opclass > > + * options, etc. > > + * > > + * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group > > + * Portions Copyright (c) 1994, Regents of the University of California > > + * > > + * > > + * IDENTIFICATION > > + * src/backend/access/common/options.c > > + * > > + > > *------------------------------------------------------------------------ > > - + */ > > + > > +#include "postgres.h" > > + > > +#include "access/options.h" > > +#include "catalog/pg_type.h" > > +#include "commands/defrem.h" > > +#include "nodes/makefuncs.h" > > +#include "utils/builtins.h" > > +#include "utils/guc.h" > > +#include "utils/memutils.h" > > +#include "mb/pg_wchar.h" > > + > > + > > +/* > > + * OPTIONS SPECIFICATION and OPTION SPECIFICATION SET > > + * > > + * Each option is defined via Option Specification object (Option Spec). > > + * Option Spec should have all information that is needed for processing > > + * (parsing, validating, converting) of a single option. Implemented via > > set of + * option_spec_* structures. > > + * > > + * A set of Option Specs (Options Spec Set), defines all options > > available for + * certain object (certain relation kind for example). It > > is a list of + * Options Specs, plus validation functions that can be > > used to validate whole + * option set, if needed. Implemenred via > > options_spec_set structure and set of + * optionsSpecSetAdd* functions > > that are used for adding Option Specs items to + * a Set. > > + * > > + * NOTE: we choose therm "sepcification" instead of "definition" because > > therm + * "definition" is used for objects that came from lexer. So to > > avoud confusion + * here we have Option Specifications, and all > > "definitions" are from lexer. + */ > > + > > +/* > > + * OPTION VALUES REPRESENTATIONS > > + * > > + * Option values usually came from lexer in form of defList obect, stored > > in + * pg_catalog as text array, and used when they are stored in memory > > as + * C-structure. These are different option values representations. > > Here goes + * brief description of all representations used in the code. > > + * > > + * Values > > + * > > + * Values are an internal representation that is used while converting > > + * Values between other representation. Value is called "parsed", > > + * when Value's value is converted to a proper type and validated, or is > > called + * "unparsed", when Value's value is stored as raw string that > > was obtained + * from the source without any cheks. In convertation > > funcion names first case + * is refered as Values, second case is refered > > as RawValues. Values is + * implemented as List of option_value > > C-structures. > > + * > > + * defList > > + * > > + * Options in form of definition List that comes from lexer. (For > > reloptions it + * is a part of SQL query that goes after WITH, SET or > > RESET keywords). Can be + * converted to and from Values using > > optionsDefListToRawValues and + * optionsTextArrayToRawValues functions. > > + * > > + * TEXT[] > > + * > > + * Options in form suitable for storig in TEXT[] field in DB. (E.g. > > reloptions + * are stores in pg_catalog.pg_class table in reloptions > > field). Can be converted + * to and from Values using > > optionsValuesToTextArray and optionsTextArrayToRawValues + * functions. > > + * > > + * Bytea > > + * > > + * Option data stored in C-structure with varlena header in the beginning > > of the + * structure. This representation is used to pass option values > > to the core + * postgres. It is fast to read, it can be cached and so on. > > Bytea rpresentation + * can be obtained from Vales using > > optionsValuesToBytea function, and can't be + * converted back. > > + */ > > + > > +static option_spec_basic *allocateOptionSpec(int type, const char *name, > > + const char *desc, LOCKMODE lockmode, > > + option_spec_flags flags, int struct_offset); > > + > > +static void parse_one_option(option_value * option, const char *text_str, > > + int text_len, bool validate); > > +static void *optionsAllocateBytea(options_spec_set * spec_set, List > > *options); + > > + > > +static List * > > +optionsDefListToRawValues(List *defList, options_parse_mode > > + parse_mode); > > +static Datum optionsValuesToTextArray(List *options_values); > > +static List *optionsMergeOptionValues(List *old_options, List > > *new_options); +static bytea *optionsValuesToBytea(List *options, > > options_spec_set * spec_set); +List *optionsTextArrayToRawValues(Datum > > array_datum); > > +List *optionsParseRawValues(List *raw_values, options_spec_set * > > spec_set, > > + options_parse_mode mode); > > + > > + > > +/* > > + * Options spec_set functions > > + */ > > + > > +/* > > + * Options catalog describes options available for certain object. > > Catalog has + * all necessary information for parsing transforming and > > validating options + * for an object. All > > parsing/validation/transformation functions should not + * know any > > details of option implementation for certain object, all this + * > > information should be stored in catalog instead and interpreted by + * > > pars/valid/transf functions blindly. > > + * > > + * The heart of the option catalog is an array of option definitions. > > Options + * definition specifies name of option, type, range of > > acceptable values, and + * default value. > > + * > > + * Options values can be one of the following types: bool, int, real, > > enum, + * string. For more info see "option_type" and > > "optionsCatalogAddItemYyyy" + * functions. > > + * > > + * Option definition flags allows to define parser behavior for special > > (or not + * so special) cases. See option_spec_flags for more info. > > + * > > + * Options and Lock levels: > > + * > > + * The default choice for any new option should be AccessExclusiveLock. > > + * In some cases the lock level can be reduced from there, but the lock > > + * level chosen should always conflict with itself to ensure that > > multiple > > + * changes aren't lost when we attempt concurrent changes. > > + * The choice of lock level depends completely upon how that parameter > > + * is used within the server, not upon how and when you'd like to change > > it. + * Safety first. Existing choices are documented here, and elsewhere > > in + * backend code where the parameters are used. > > + * > > + * In general, anything that affects the results obtained from a SELECT > > must be + * protected by AccessExclusiveLock. > > + * > > + * Autovacuum related parameters can be set at ShareUpdateExclusiveLock > > + * since they are only used by the AV procs and don't change anything > > + * currently executing. > > + * > > + * Fillfactor can be set because it applies only to subsequent changes > > made to + * data blocks, as documented in heapio.c > > + * > > + * n_distinct options can be set at ShareUpdateExclusiveLock because they > > + * are only used during ANALYZE, which uses a ShareUpdateExclusiveLock, > > + * so the ANALYZE will not be affected by in-flight changes. Changing > > those + * values has no affect until the next ANALYZE, so no need for > > stronger lock. + * > > + * Planner-related parameters can be set with ShareUpdateExclusiveLock > > because + * they only affect planning and not the correctness of the > > execution. Plans + * cannot be changed in mid-flight, so changes here > > could not easily result in + * new improved plans in any case. So we > > allow existing queries to continue + * and existing plans to survive, a > > small price to pay for allowing better + * plans to be introduced > > concurrently without interfering with users. + * > > + * Setting parallel_workers is safe, since it acts the same as > > + * max_parallel_workers_per_gather which is a USERSET parameter that > > doesn't + * affect existing plans or queries. > > +*/ > > + > > +/* > > + * allocateOptionsSpecSet > > + * Creates new Option Spec Set object: Allocates memory and initializes > > + * structure members. > > + * > > + * Spec Set items can be add via allocateOptionSpec and > > optionSpecSetAddItem functions + * or by calling directly any of > > optionsSpecSetAdd* function (preferable way) + * > > + * namespace - Spec Set can be bind to certain namespace (E.g. > > + * namespace.option=value). Options from other namespaces will be ignored > > while + * processing. If set to NULL, no namespace will be used at all. > > + * > > + * size_of_bytea - size of target structure of Bytea options > > represenation > > + * > > + * num_items_expected - if you know expected number of Spec Set items set > > it here. + * Set to -1 in other cases. num_items_expected will be used > > for preallocating memory + * and will trigger error, if you try to add > > more items than you expected. + */ > > + > > +options_spec_set * > > +allocateOptionsSpecSet(const char *namespace, int size_of_bytea, int > > num_items_expected) +{ > > + MemoryContext oldcxt; > > + options_spec_set *spec_set; > > + > > + oldcxt = MemoryContextSwitchTo(TopMemoryContext); > > + spec_set = palloc(sizeof(options_spec_set)); > > + if (namespace) > > + { > > + spec_set->namespace = palloc(strlen(namespace) + 1); > > + strcpy(spec_set->namespace, namespace); > > + } > > + else > > + spec_set->namespace = NULL; > > + if (num_items_expected > 0) > > + { > > + spec_set->num_allocated = num_items_expected; > > + spec_set->forbid_realloc = true; > > + spec_set->definitions = palloc( > > + spec_set->num_allocated * sizeof(option_spec_basic *)); > > + } > > + else > > + { > > + spec_set->num_allocated = 0; > > + spec_set->forbid_realloc = false; > > + spec_set->definitions = NULL; > > + } > > + spec_set->num = 0; > > + spec_set->struct_size = size_of_bytea; > > + spec_set->postprocess_fun = NULL; > > + MemoryContextSwitchTo(oldcxt); > > + return spec_set; > > +} > > + > > +/* > > + * allocateOptionSpec > > + * Allocates a new Option Specifiation object of desired type and > > + * initialize the type-independent fields > > + */ > > +static option_spec_basic * > > +allocateOptionSpec(int type, const char *name, const char *desc, LOCKMODE > > lockmode, + option_spec_flags flags, int struct_offset) > > +{ > > + MemoryContext oldcxt; > > + size_t size; > > + option_spec_basic *newoption; > > + > > + oldcxt = MemoryContextSwitchTo(TopMemoryContext); > > + > > + switch (type) > > + { > > + case OPTION_TYPE_BOOL: > > + size = sizeof(option_spec_bool); > > + break; > > + case OPTION_TYPE_INT: > > + size = sizeof(option_spec_int); > > + break; > > + case OPTION_TYPE_REAL: > > + size = sizeof(option_spec_real); > > + break; > > + case OPTION_TYPE_ENUM: > > + size = sizeof(option_spec_enum); > > + break; > > + case OPTION_TYPE_STRING: > > + size = sizeof(option_spec_string); > > + break; > > + default: > > + elog(ERROR, "unsupported reloption type %d", type); > > + return NULL; /* keep compiler quiet */ > > + } > > + > > + newoption = palloc(size); > > + > > + newoption->name = pstrdup(name); > > + if (desc) > > + newoption->desc = pstrdup(desc); > > + else > > + newoption->desc = NULL; > > + newoption->type = type; > > + newoption->lockmode = lockmode; > > + newoption->flags = flags; > > + newoption->struct_offset = struct_offset; > > + > > + MemoryContextSwitchTo(oldcxt); > > + > > + return newoption; > > +} > > + > > +/* > > + * optionSpecSetAddItem > > + * Adds pre-created Option Specification objec to the Spec Set > > + */ > > +static void > > +optionSpecSetAddItem(option_spec_basic * newoption, > > + options_spec_set * spec_set) > > +{ > > + if (spec_set->num >= spec_set->num_allocated) > > + { > > + MemoryContext oldcxt; > > + > > + Assert(!spec_set->forbid_realloc); > > + oldcxt = MemoryContextSwitchTo(TopMemoryContext); > > + > > + if (spec_set->num_allocated == 0) > > + { > > + spec_set->num_allocated = 8; > > + spec_set->definitions = palloc( > > + spec_set->num_allocated * sizeof(option_spec_basic *)); > > + } > > + else > > + { > > + spec_set->num_allocated *= 2; > > + spec_set->definitions = repalloc(spec_set->definitions, > > + spec_set->num_allocated * sizeof(option_spec_basic *)); > > + } > > + MemoryContextSwitchTo(oldcxt); > > + } > > + spec_set->definitions[spec_set->num] = newoption; > > + spec_set->num++; > > +} > > + > > + > > +/* > > + * optionsSpecSetAddBool > > + * Adds boolean Option Specification entry to the Spec Set > > + */ > > +void > > +optionsSpecSetAddBool(options_spec_set * spec_set, const char *name, > > const char *desc, + LOCKMODE lockmode, option_spec_flags flags, > > + int struct_offset, bool default_val) > > +{ > > + option_spec_bool *spec_set_item; > > + > > + spec_set_item = (option_spec_bool *) > > + allocateOptionSpec(OPTION_TYPE_BOOL, name, desc, lockmode, > > + flags, struct_offset); > > + > > + spec_set_item->default_val = default_val; > > + > > + optionSpecSetAddItem((option_spec_basic *) spec_set_item, spec_set); > > +} > > + > > +/* > > + * optionsSpecSetAddInt > > + * Adds integer Option Specification entry to the Spec Set > > + */ > > +void > > +optionsSpecSetAddInt(options_spec_set * spec_set, const char *name, > > + const char *desc, LOCKMODE lockmode, option_spec_flags flags, > > + int struct_offset, int default_val, int min_val, int max_val) > > +{ > > + option_spec_int *spec_set_item; > > + > > + spec_set_item = (option_spec_int *) > > + allocateOptionSpec(OPTION_TYPE_INT, name, desc, lockmode, > > + flags, struct_offset); > > + > > + spec_set_item->default_val = default_val; > > + spec_set_item->min = min_val; > > + spec_set_item->max = max_val; > > + > > + optionSpecSetAddItem((option_spec_basic *) spec_set_item, spec_set); > > +} > > + > > +/* > > + * optionsSpecSetAddReal > > + * Adds float Option Specification entry to the Spec Set > > + */ > > +void > > +optionsSpecSetAddReal(options_spec_set * spec_set, const char *name, > > const char *desc, + LOCKMODE lockmode, option_spec_flags flags, int > > struct_offset, + double default_val, double min_val, double > > max_val) > > +{ > > + option_spec_real *spec_set_item; > > + > > + spec_set_item = (option_spec_real *) > > + allocateOptionSpec(OPTION_TYPE_REAL, name, desc, lockmode, > > + flags, struct_offset); > > + > > + spec_set_item->default_val = default_val; > > + spec_set_item->min = min_val; > > + spec_set_item->max = max_val; > > + > > + optionSpecSetAddItem((option_spec_basic *) spec_set_item, spec_set); > > +} > > + > > +/* > > + * optionsSpecSetAddEnum > > + * Adds enum Option Specification entry to the Spec Set > > + * > > + * The members array must have a terminating NULL entry. > > + * > > + * The detailmsg is shown when unsupported values are passed, and has > > this > > + * form: "Valid values are \"foo\", \"bar\", and \"bar\"." > > + * > > + * The members array and detailmsg are not copied -- caller must ensure > > that + * they are valid throughout the life of the process. > > + */ > > + > > +void > > +optionsSpecSetAddEnum(options_spec_set * spec_set, const char *name, > > const char *desc, + LOCKMODE lockmode, option_spec_flags flags, int > > struct_offset, > > + opt_enum_elt_def * members, int default_val, const char *detailmsg) > > +{ > > + option_spec_enum *spec_set_item; > > + > > + spec_set_item = (option_spec_enum *) > > + allocateOptionSpec(OPTION_TYPE_ENUM, name, desc, lockmode, > > + flags, struct_offset); > > + > > + spec_set_item->default_val = default_val; > > + spec_set_item->members = members; > > + spec_set_item->detailmsg = detailmsg; > > + > > + optionSpecSetAddItem((option_spec_basic *) spec_set_item, spec_set); > > +} > > + > > +/* > > + * optionsSpecSetAddString > > + * Adds string Option Specification entry to the Spec Set > > + * > > + * "validator" is an optional function pointer that can be used to test > > the + * validity of the values. It must elog(ERROR) when the argument > > string is + * not acceptable for the variable. Note that the default > > value must pass + * the validation. > > + */ > > +void > > +optionsSpecSetAddString(options_spec_set * spec_set, const char *name, > > const char *desc, + LOCKMODE lockmode, option_spec_flags flags, int > > struct_offset, + const char *default_val, validate_string_option > > validator) +{ > > + option_spec_string *spec_set_item; > > + > > + /* make sure the validator/default combination is sane */ > > + if (validator) > > + (validator) (default_val); > > + > > + spec_set_item = (option_spec_string *) > > + allocateOptionSpec(OPTION_TYPE_STRING, name, desc, lockmode, > > + flags, struct_offset); > > + spec_set_item->validate_cb = validator; > > + > > + if (default_val) > > + spec_set_item->default_val = MemoryContextStrdup(TopMemoryContext, > > + default_val); > > + else > > + spec_set_item->default_val = NULL; > > + optionSpecSetAddItem((option_spec_basic *) spec_set_item, spec_set); > > +} > > + > > + > > +/* > > + * Options transform functions > > + */ > > + > > +/* FIXME this comment should be updated > > + * Option values exists in five representations: DefList, TextArray, > > Values and + * Bytea: > > + * > > + * DefList: Is a List of DefElem structures, that comes from syntax > > analyzer. + * It can be transformed to Values representation for further > > parsing and + * validating > > + * > > + * Values: A List of option_value structures. Is divided into two > > subclasses: + * RawValues, when values are already transformed from > > DefList or TextArray, + * but not parsed yet. (In this case you should > > use raw_name and raw_value + * structure members to see option content). > > ParsedValues (or just simple + * Values) is crated after finding a > > definition for this option in a spec_set + * and after parsing of the raw > > value. For ParsedValues content is stored in + * values structure member, > > and name can be taken from option definition in gen + * structure member. > > Actually Value list can have both Raw and Parsed values, + * as we do > > not validate options that came from database, and db option that + * does > > not exist in spec_set is just ignored, and kept as RawValues + * > > + * TextArray: The representation in which options for existing object > > comes + * and goes from/to database; for example from > > pg_class.reloptions. It is a + * plain TEXT[] db object with name=value > > text inside. This representation can + * be transformed into Values for > > further processing, using options spec_set. + * > > + * Bytea: Is a binary representation of options. Each object that has > > code that + * uses options, should create a C-structure for this options, > > with varlen + * 4-byte header in front of the data; all items of options > > spec_set should have + * an offset of a corresponding binary data in this > > structure, so transform + * function can put this data in the correct > > place. One can transform options + * data from values representation into > > Bytea, using spec_set data, and then use + * it as a usual Datum object, > > when needed. This Datum should be cached + * somewhere (for example in > > rel->rd_options for relations) when object that + * has option is loaded > > from db. > > + */ > > + > > + > > +/* optionsDefListToRawValues > > + * Converts option values that came from syntax analyzer (DefList) into > > + * Values List. > > + * > > + * No parsing is done here except for checking that RESET syntax is > > correct + * (syntax analyzer do not see difference between SET and RESET > > cases, we + * should treat it here manually > > + */ > > +static List * > > +optionsDefListToRawValues(List *defList, options_parse_mode parse_mode) > > +{ > > + ListCell *cell; > > + List *result = NIL; > > + > > + foreach(cell, defList) > > + { > > + option_value *option_dst; > > + DefElem *def = (DefElem *) lfirst(cell); > > + char *value; > > + > > + option_dst = palloc(sizeof(option_value)); > > + > > + if (def->defnamespace) > > + { > > + option_dst->namespace = palloc(strlen(def- >defnamespace) + 1); > > + strcpy(option_dst->namespace, def->defnamespace); > > + } > > + else > > + { > > + option_dst->namespace = NULL; > > + } > > + option_dst->raw_name = palloc(strlen(def->defname) + 1); > > + strcpy(option_dst->raw_name, def->defname); > > + > > + if (parse_mode & OPTIONS_PARSE_MODE_FOR_RESET) > > + { > > + /* > > + * If this option came from RESET statement we should throw error > > + * it it brings us name=value data, as syntax analyzer do not > > + * prevent it > > + */ > > + if (def->arg != NULL) > > + ereport(ERROR, > > + (errcode(ERRCODE_SYNTAX_ERROR), > > + errmsg("RESET must not include values for parameters"))); > > + > > + option_dst->status = OPTION_VALUE_STATUS_FOR_RESET; > > + } > > + else > > + { > > + /* > > + * For SET statement we should treat (name) expression as if it is > > + * actually (name=true) so do it here manually. In other cases > > + * just use value as we should use it > > + */ > > + option_dst->status = OPTION_VALUE_STATUS_RAW; > > + if (def->arg != NULL) > > + value = defGetString(def); > > + else > > + value = "true"; > > + option_dst->raw_value = palloc(strlen(value) + 1); > > + strcpy(option_dst->raw_value, value); > > + } > > + > > + result = lappend(result, option_dst); > > + } > > + return result; > > +} > > + > > +/* > > + * optionsValuesToTextArray > > + * Converts List of option_values into TextArray > > + * > > + * Convertation is made to put options into database (e.g. in > > + * pg_class.reloptions for all relation options) > > + */ > > + > > +Datum > > +optionsValuesToTextArray(List *options_values) > > +{ > > + ArrayBuildState *astate = NULL; > > + ListCell *cell; > > + Datum result; > > + > > + foreach(cell, options_values) > > + { > > + option_value *option = (option_value *) lfirst(cell); > > + const char *name; > > + char *value; > > + text *t; > > + int len; > > + > > + /* > > + * Raw value were not cleared while parsing, so instead of converting > > + * it back, just use it to store value as text > > + */ > > + value = option->raw_value; > > + > > + Assert(option->status != OPTION_VALUE_STATUS_EMPTY); > > + > > + /* > > + * Name will be taken from option definition, if option were parsed or > > + * from raw_name if option were not parsed for some reason > > + */ > > + if (option->status == OPTION_VALUE_STATUS_PARSED) > > + name = option->gen->name; > > + else > > + name = option->raw_name; > > + > > + /* > > + * Now build "name=value" string and append it to the array > > + */ > > + len = VARHDRSZ + strlen(name) + strlen(value) + 1; > > + t = (text *) palloc(len + 1); > > + SET_VARSIZE(t, len); > > + sprintf(VARDATA(t), "%s=%s", name, value); > > + astate = accumArrayResult(astate, PointerGetDatum(t), false, > > + TEXTOID, CurrentMemoryContext); > > + } > > + if (astate) > > + result = makeArrayResult(astate, CurrentMemoryContext); > > + else > > + result = (Datum) 0; > > + > > + return result; > > +} > > + > > +/* > > + * optionsTextArrayToRawValues > > + * Converts options from TextArray format into RawValues list. > > + * > > + * This function is used to convert options data that comes from database > > to + * List of option_values, for further parsing, and, in the case of > > ALTER + * command, for merging with new option values. > > + */ > > +List * > > +optionsTextArrayToRawValues(Datum array_datum) > > +{ > > + List *result = NIL; > > + > > + if (PointerIsValid(DatumGetPointer(array_datum))) > > + { > > + ArrayType *array = DatumGetArrayTypeP(array_datum); > > + Datum *options; > > + int noptions; > > + int i; > > + > > + deconstruct_array(array, TEXTOID, -1, false, 'i', > > + &options, NULL, &noptions); > > + > > + for (i = 0; i < noptions; i++) > > + { > > + option_value *option_dst; > > + char *text_str = VARDATA(options[i]); > > + int text_len = VARSIZE(options[i]) - VARHDRSZ; > > + int i; > > + int name_len = -1; > > + char *name; > > + int raw_value_len; > > + char *raw_value; > > + > > + /* > > + * Find position of '=' sign and treat id as a separator between > > + * name and value in "name=value" item > > + */ > > + for (i = 0; i < text_len; i = i + pg_mblen(text_str)) > > + { > > + if (text_str[i] == '=') > > + { > > + name_len = i; > > + break; > > + } > > + } > > + Assert(name_len >= 1); /* Just in case */ > > + > > + raw_value_len = text_len - name_len - 1; > > + > > + /* > > + * Copy name from src > > + */ > > + name = palloc(name_len + 1); > > + memcpy(name, text_str, name_len); > > + name[name_len] = '\0'; > > + > > + /* > > + * Copy value from src > > + */ > > + raw_value = palloc(raw_value_len + 1); > > + memcpy(raw_value, text_str + name_len + 1, raw_value_len); > > + raw_value[raw_value_len] = '\0'; > > + > > + /* > > + * Create new option_value item > > + */ > > + option_dst = palloc(sizeof(option_value)); > > + option_dst->status = OPTION_VALUE_STATUS_RAW; > > + option_dst->raw_name = name; > > + option_dst->raw_value = raw_value; > > + option_dst->namespace = NULL; > > + > > + result = lappend(result, option_dst); > > + } > > + } > > + return result; > > +} > > + > > +/* > > + * optionsMergeOptionValues > > + * Merges two lists of option_values into one list > > + * > > + * This function is used to merge two Values list into one. It is used > > for all + * kinds of ALTER commands when existing options are > > merged|replaced with new + * options list. This function also process > > RESET variant of ALTER command. It + * merges two lists as usual, and > > then removes all items with RESET flag on. + * > > + * Both incoming lists will be destroyed while merging > > + */ > > +static List * > > +optionsMergeOptionValues(List *old_options, List *new_options) > > +{ > > + List *result = NIL; > > + ListCell *old_cell; > > + ListCell *new_cell; > > + > > + /* > > + * First add to result all old options that are not mentioned in new > > list > > + */ > > + foreach(old_cell, old_options) > > + { > > + bool found; > > + const char *old_name; > > + option_value *old_option; > > + > > + old_option = (option_value *) lfirst(old_cell); > > + if (old_option->status == OPTION_VALUE_STATUS_PARSED) > > + old_name = old_option->gen->name; > > + else > > + old_name = old_option->raw_name; > > + > > + /* > > + * Looking for a new option with same name > > + */ > > + found = false; > > + foreach(new_cell, new_options) > > + { > > + option_value *new_option; > > + const char *new_name; > > + > > + new_option = (option_value *) lfirst(new_cell); > > + if (new_option->status == OPTION_VALUE_STATUS_PARSED) > > + new_name = new_option->gen->name; > > + else > > + new_name = new_option->raw_name; > > + > > + if (strcmp(new_name, old_name) == 0) > > + { > > + found = true; > > + break; > > + } > > + } > > + if (!found) > > + result = lappend(result, old_option); > > + } > > + /* > > + * Now add all to result all new options that are not designated for > > reset + */ > > + foreach(new_cell, new_options) > > + { > > + option_value *new_option; > > + new_option = (option_value *) lfirst(new_cell); > > + > > + if(new_option->status != OPTION_VALUE_STATUS_FOR_RESET) > > + result = lappend(result, new_option); > > + } > > + return result; > > +} > > + > > +/* > > + * optionsDefListValdateNamespaces > > + * Function checks that all options represented as DefList has no > > + * namespaces or have namespaces only from allowed list > > + * > > + * Function accept options as DefList and NULL terminated list of allowed > > + * namespaces. It throws an error if not proper namespace was found. > > + * > > + * This function actually used only for tables with it's toast. namespace > > + */ > > +void > > +optionsDefListValdateNamespaces(List *defList, char **allowed_namespaces) > > +{ > > + ListCell *cell; > > + > > + foreach(cell, defList) > > + { > > + DefElem *def = (DefElem *) lfirst(cell); > > + > > + /* > > + * Checking namespace only for options that have namespaces. Options > > + * with no namespaces are always accepted > > + */ > > + if (def->defnamespace) > > + { > > + bool found = false; > > + int i = 0; > > + > > + while (allowed_namespaces[i]) > > + { > > + if (strcmp(def->defnamespace, > > + allowed_namespaces[i]) == 0) > > + { > > + found = true; > > + break; > > + } > > + i++; > > + } > > + if (!found) > > + ereport(ERROR, > > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > + errmsg("unrecognized parameter namespace \"%s\"", > > + def- >defnamespace))); > > + } > > + } > > +} > > + > > +/* > > + * optionsDefListFilterNamespaces > > + * Iterates over DefList, choose items with specified namespace and adds > > + * them to a result List > > + * > > + * This function does not destroy source DefList but does not create > > copies + * of List nodes. > > + * It is actually used only for tables, in order to split toast and heap > > + * reloptions, so each one can be stored in on it's own pg_class record > > + */ > > +List * > > +optionsDefListFilterNamespaces(List *defList, const char *namespace) > > +{ > > + ListCell *cell; > > + List *result = NIL; > > + > > + foreach(cell, defList) > > + { > > + DefElem *def = (DefElem *) lfirst(cell); > > + > > + if ((!namespace && !def->defnamespace) || > > + (namespace && def->defnamespace && > > + strcmp(namespace, def->defnamespace) == 0)) > > + { > > + result = lappend(result, def); > > + } > > + } > > + return result; > > +} > > + > > +/* > > + * optionsTextArrayToDefList > > + * Convert the text-array format of reloptions into a List of DefElem. > > + */ > > +List * > > +optionsTextArrayToDefList(Datum options) > > +{ > > + List *result = NIL; > > + ArrayType *array; > > + Datum *optiondatums; > > + int noptions; > > + int i; > > + > > + /* Nothing to do if no options */ > > + if (!PointerIsValid(DatumGetPointer(options))) > > + return result; > > + > > + array = DatumGetArrayTypeP(options); > > + > > + deconstruct_array(array, TEXTOID, -1, false, 'i', > > + &optiondatums, NULL, &noptions); > > + > > + for (i = 0; i < noptions; i++) > > + { > > + char *s; > > + char *p; > > + Node *val = NULL; > > + > > + s = TextDatumGetCString(optiondatums[i]); > > + p = strchr(s, '='); > > + if (p) > > + { > > + *p++ = '\0'; > > + val = (Node *) makeString(pstrdup(p)); > > + } > > + result = lappend(result, makeDefElem(pstrdup(s), val, -1)); > > + } > > + > > + return result; > > +} > > + > > +/* FIXME write comment here */ > > + > > +Datum > > +optionsDefListToTextArray(List *defList) > > +{ > > + ListCell *cell; > > + Datum result; > > + ArrayBuildState *astate = NULL; > > + > > + foreach(cell, defList) > > + { > > + DefElem *def = (DefElem *) lfirst(cell); > > + const char *name = def->defname; > > + const char *value; > > + text *t; > > + int len; > > + > > + if (def->arg != NULL) > > + value = defGetString(def); > > + else > > + value = "true"; > > + > > + if (def->defnamespace) > > + { > > + Assert(false); /* Should not get here */ > > + /* This function is used for backward compatibility in the place were > > namespases are not allowed */ + return (Datum) 0; > > + } > > + len = VARHDRSZ + strlen(name) + strlen(value) + 1; > > + t = (text *) palloc(len + 1); > > + SET_VARSIZE(t, len); > > + sprintf(VARDATA(t), "%s=%s", name, value); > > + astate = accumArrayResult(astate, PointerGetDatum(t), false, > > + TEXTOID, CurrentMemoryContext); > > + > > + } > > + if (astate) > > + result = makeArrayResult(astate, CurrentMemoryContext); > > + else > > + result = (Datum) 0; > > + return result; > > +} > > + > > + > > +/* > > + * optionsParseRawValues > > + * Parses and vlaidates (if proper flag is set) option_values. As a > > result + * caller will get the list of parsed (or partly parsed) > > option_values + * > > + * This function is used in cases when caller gets raw values from db or > > + * syntax and want to parse them. > > + * This function uses option_spec_set to get information about how each > > option + * should be parsed. > > + * If validate mode is off, function found an option that do not have > > proper + * option_spec_set entry, this option kept unparsed (if some > > garbage came from + * the DB, we should put it back there) > > + * > > + * This function destroys incoming list. > > + */ > > +List * > > +optionsParseRawValues(List *raw_values, options_spec_set * spec_set, > > + options_parse_mode mode) > > +{ > > + ListCell *cell; > > + List *result = NIL; > > + bool *is_set; > > + int i; > > + bool validate = mode & OPTIONS_PARSE_MODE_VALIDATE; > > + bool for_alter = mode & OPTIONS_PARSE_MODE_FOR_ALTER; > > + > > + > > + is_set = palloc0(sizeof(bool) * spec_set->num); > > + foreach(cell, raw_values) > > + { > > + option_value *option = (option_value *) lfirst(cell); > > + bool found = false; > > + bool skip = false; > > + > > + > > + if (option->status == OPTION_VALUE_STATUS_PARSED) > > + { > > + /* > > + * This can happen while ALTER, when new values were already > > + * parsed, but old values merged from DB are still raw > > + */ > > + result = lappend(result, option); > > + continue; > > + } > > + if (validate && option->namespace && (!spec_set->namespace || > > + strcmp(spec_set->namespace, option- >namespace) != 0)) > > + { > > + ereport(ERROR, > > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > + errmsg("unrecognized parameter namespace \"%s\"", > > + option->namespace))); > > + } > > + > > + for (i = 0; i < spec_set->num; i++) > > + { > > + option_spec_basic *definition = spec_set- >definitions[i]; > > + > > + if (strcmp(option->raw_name, > > + definition->name) == 0) > > + { > > + /* > > + * Skip option with "ignore" flag, as it is processed > > + * somewhere else. (WITH OIDS special case) > > + */ > > + if (definition->flags & OPTION_DEFINITION_FLAG_IGNORE) > > + { > > + found = true; > > + skip = true; > > + break; > > + } > > + > > + /* > > + * Reject option as if it was not in spec_set. Needed for cases > > + * when option should have default value, but should not be > > + * changed > > + */ > > + if (definition->flags & OPTION_DEFINITION_FLAG_REJECT) > > + { > > + found = false; > > + break; > > + } > > + > > + if (validate && is_set[i]) > > + { > > + ereport(ERROR, > > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > + errmsg("parameter \"%s\" specified more than once", > > + option- >raw_name))); > > + } > > + if ((for_alter) && > > + (definition->flags & OPTION_DEFINITION_FLAG_FORBID_ALTER)) > > + { > > + ereport(ERROR, > > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > + errmsg("changing parameter \"%s\" is not allowed", > > + definition- >name))); > > + } > > + if (option->status == OPTION_VALUE_STATUS_FOR_RESET) > > + { > > + /* > > + * For RESET options do not need further processing so > > + * mark it found and stop searching > > + */ > > + found = true; > > + break; > > + } > > + pfree(option->raw_name); > > + option->raw_name = NULL; > > + option->gen = definition; > > + parse_one_option(option, NULL, -1, validate); > > + is_set[i] = true; > > + found = true; > > + break; > > + } > > + } > > + if (!found) > > + { > > + if (validate) > > + { > > + if (option->namespace) > > + ereport(ERROR, > > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > + errmsg("unrecognized parameter \"%s.%s\"", > > + option->namespace, option->raw_name))); > > + else > > + ereport(ERROR, > > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > + errmsg("unrecognized parameter \"%s\"", > > + option->raw_name))); > > + } else > > + { > > + /* RESET is always in non-validating mode, unkown names should > > + * be ignored. This is traditional behaviour of postgres/ > > + * FIXME may be it should be changed someday > > + */ > > + if (option->status == OPTION_VALUE_STATUS_FOR_RESET) > > + { > > + skip = true; > > + } > > + } > > + /* > > + * In other cases, if we are parsing not in validate mode, then > > + * we should keep unknown node, because non-validate mode is for > > + * data that is already in the DB and should not be changed after > > + * altering another entries > > + */ > > + } > > + if (!skip) > > + result = lappend(result, option); > > + } > > + return result; > > +} > > + > > +/* > > + * parse_one_option > > + * > > + * Subroutine for optionsParseRawValues, to parse and validate a > > + * single option's value > > + */ > > +static void > > +parse_one_option(option_value * option, const char *text_str, int > > text_len, + bool validate) > > +{ > > + char *value; > > + bool parsed; > > + > > + value = option->raw_value; > > + > > + switch (option->gen->type) > > + { > > + case OPTION_TYPE_BOOL: > > + { > > + parsed = parse_bool(value, &option- >values.bool_val); > > + if (validate && !parsed) > > + ereport(ERROR, > > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > + errmsg("invalid value for boolean option \"%s\": %s", > > + option->gen->name, value))); > > + } > > + break; > > + case OPTION_TYPE_INT: > > + { > > + option_spec_int *optint = > > + (option_spec_int *) option->gen; > > + > > + parsed = parse_int(value, &option- >values.int_val, 0, NULL); > > + if (validate && !parsed) > > + ereport(ERROR, > > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > + errmsg("invalid value for integer option \"%s\": %s", > > + option->gen->name, value))); > > + if (validate && (option->values.int_val < optint->min || > > + option- >values.int_val > optint->max)) > > + ereport(ERROR, > > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > + errmsg("value %s out of bounds for option \"%s\"", > > + value, option->gen->name), > > + errdetail("Valid values are between \"%d\" and \"%d\".", > > + optint->min, optint->max))); > > + } > > + break; > > + case OPTION_TYPE_REAL: > > + { > > + option_spec_real *optreal = > > + (option_spec_real *) option->gen; > > + > > + parsed = parse_real(value, &option- >values.real_val, 0, NULL); > > + if (validate && !parsed) > > + ereport(ERROR, > > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > + errmsg("invalid value for floating point option \"%s\": %s", > > + option->gen->name, value))); > > + if (validate && (option->values.real_val < optreal->min || > > + option- >values.real_val > optreal->max)) > > + ereport(ERROR, > > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > + errmsg("value %s out of bounds for option \"%s\"", > > + value, option->gen->name), > > + errdetail("Valid values are between \"%f\" and \"%f\".", > > + optreal->min, optreal->max))); > > + } > > + break; > > + case OPTION_TYPE_ENUM: > > + { > > + option_spec_enum *optenum = > > + (option_spec_enum *) option->gen; > > + opt_enum_elt_def *elt; > > + parsed = false; > > + for (elt = optenum->members; elt->string_val; elt++) > > + { > > + if (strcmp(value, elt->string_val) == 0) > > + { > > + option->values.enum_val = elt->symbol_val; > > + parsed = true; > > + break; > > + } > > + } > > + if (!parsed) > > + { > > + ereport(ERROR, > > + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > + errmsg("invalid value for enum option \"%s\": %s", > > + option->gen->name, value), > > + optenum->detailmsg ? > > + errdetail_internal("%s", _(optenum->detailmsg)) : 0)); > > + } > > + } > > + break; > > + case OPTION_TYPE_STRING: > > + { > > + option_spec_string *optstring = > > + (option_spec_string *) option->gen; > > + > > + option->values.string_val = value; > > + if (validate && optstring->validate_cb) > > + (optstring->validate_cb) (value); > > + parsed = true; > > + } > > + break; > > + default: > > + elog(ERROR, "unsupported reloption type %d", option- >gen->type); > > + parsed = true; /* quiet compiler */ > > + break; > > + } > > + > > + if (parsed) > > + option->status = OPTION_VALUE_STATUS_PARSED; > > + > > +} > > + > > +/* > > + * optionsAllocateBytea > > + * Allocates memory for bytea options representation > > + * > > + * Function allocates memory for byrea structure of an option, plus adds > > space + * for values of string options. We should keep all data including > > string + * values in the same memory chunk, because Cache code copies > > bytea option + * data from one MemoryConext to another without knowing > > about it's internal + * structure, so it would not be able to copy string > > values if they are outside + * of bytea memory chunk. > > + */ > > +static void * > > +optionsAllocateBytea(options_spec_set * spec_set, List *options) > > +{ > > + Size size; > > + int i; > > + ListCell *cell; > > + int length; > > + void *res; > > + > > + size = spec_set->struct_size; > > + > > + /* Calculate size needed to store all string values for this option */ > > + for (i = 0; i < spec_set->num; i++) > > + { > > + option_spec_basic *definition = spec_set->definitions[i]; > > + bool found = false; > > + option_value *option; > > + > > + /* Not interested in non-string options, skipping */ > > + if (definition->type != OPTION_TYPE_STRING) > > + continue; > > + > > + /* > > + * Trying to find option_value that references definition spec_set > > + * entry > > + */ > > + foreach(cell, options) > > + { > > + option = (option_value *) lfirst(cell); > > + if (option->status == OPTION_VALUE_STATUS_PARSED && > > + strcmp(option->gen->name, definition->name) == 0) > > + { > > + found = true; > > + break; > > + } > > + } > > + if (found) > > + /* If found, it'value will be stored */ > > + length = strlen(option->values.string_val) + 1; > > + else > > + /* If not found, then there would be default value there */ > > + if (((option_spec_string *) definition)->default_val) > > + length = strlen( > > + ((option_spec_string *) definition)- >default_val) + 1; > > + else > > + length = 0; > > + /* Add total length of all string values to basic size */ > > + size += length; > > + } > > + > > + res = palloc0(size); > > + SET_VARSIZE(res, size); > > + return res; > > +} > > + > > +/* > > + * optionsValuesToBytea > > + * Converts options from List of option_values to binary bytea structure > > + * > > + * Convertation goes according to options_spec_set: each spec_set item > > + * has offset value, and option value in binary mode is written to the > > + * structure with that offset. > > + * > > + * More special case is string values. Memory for bytea structure is > > allocated + * by optionsAllocateBytea which adds some more space for > > string values to + * the size of original structure. All string values > > are copied there and + * inside the bytea structure an offset to that > > value is kept. > > + * > > + */ > > +static bytea * > > +optionsValuesToBytea(List *options, options_spec_set * spec_set) > > +{ > > + char *data; > > + char *string_values_buffer; > > + int i; > > + > > + data = optionsAllocateBytea(spec_set, options); > > + > > + /* place for string data starts right after original structure */ > > + string_values_buffer = data + spec_set->struct_size; > > + > > + for (i = 0; i < spec_set->num; i++) > > + { > > + option_value *found = NULL; > > + ListCell *cell; > > + char *item_pos; > > + option_spec_basic *definition = spec_set->definitions[i]; > > + > > + if (definition->flags & OPTION_DEFINITION_FLAG_IGNORE) > > + continue; > > + > > + /* Calculate the position of the item inside the structure */ > > + item_pos = data + definition->struct_offset; > > + > > + /* Looking for the corresponding option from options list */ > > + foreach(cell, options) > > + { > > + option_value *option = (option_value *) lfirst(cell); > > + > > + if (option->status == OPTION_VALUE_STATUS_RAW) > > + continue; /* raw can come from db. Just ignore them then */ > > + Assert(option->status != OPTION_VALUE_STATUS_EMPTY); > > + > > + if (strcmp(definition->name, option->gen->name) == 0) > > + { > > + found = option; > > + break; > > + } > > + } > > + /* writing to the proper position either option value or default val */ > > + switch (definition->type) > > + { > > + case OPTION_TYPE_BOOL: > > + *(bool *) item_pos = found ? > > + found->values.bool_val : > > + ((option_spec_bool *) definition)- >default_val; > > + break; > > + case OPTION_TYPE_INT: > > + *(int *) item_pos = found ? > > + found->values.int_val : > > + ((option_spec_int *) definition)- >default_val; > > + break; > > + case OPTION_TYPE_REAL: > > + *(double *) item_pos = found ? > > + found->values.real_val : > > + ((option_spec_real *) definition)- >default_val; > > + break; > > + case OPTION_TYPE_ENUM: > > + *(int *) item_pos = found ? > > + found->values.enum_val : > > + ((option_spec_enum *) definition)- >default_val; > > + break; > > + > > + case OPTION_TYPE_STRING: > > + { > > + /* > > + * For string options: writing string value at the string > > + * buffer after the structure, and storing and offset to > > + * that value > > + */ > > + char *value = NULL; > > + > > + if (found) > > + value = found- >values.string_val; > > + else > > + value = ((option_spec_string *) definition) > > + ->default_val; > > + *(int *) item_pos = value ? > > + string_values_buffer - data : > > + OPTION_STRING_VALUE_NOT_SET_OFFSET; > > + if (value) > > + { > > + strcpy(string_values_buffer, value); > > + string_values_buffer += strlen(value) + 1; > > + } > > + } > > + break; > > + default: > > + elog(ERROR, "unsupported reloption type %d", > > + definition->type); > > + break; > > + } > > + } > > + return (void *) data; > > +} > > + > > + > > +/* > > + * transformOptions > > + * This function is used by src/backend/commands/Xxxx in order to > > process > > + * new option values, merge them with existing values (in the case of > > + * ALTER command) and prepare to put them [back] into DB > > + */ > > + > > +Datum > > +transformOptions(options_spec_set * spec_set, Datum oldOptions, > > + List *defList, options_parse_mode parse_mode) > > +{ > > + Datum result; > > + List *new_values; > > + List *old_values; > > + List *merged_values; > > + > > + /* > > + * Parse and validate New values > > + */ > > + new_values = optionsDefListToRawValues(defList, parse_mode); > > + if (! (parse_mode & OPTIONS_PARSE_MODE_FOR_RESET)) > > + { > > + /* FIXME: postgres usual behaviour vas not to vaidate names that > > + * came from RESET command. Once this behavious should be changed, > > + * I guess. But for now we keep it as it was. > > + */ > > + parse_mode|= OPTIONS_PARSE_MODE_VALIDATE; > > + } > > + new_values = optionsParseRawValues(new_values, spec_set, parse_mode); > > + > > + /* > > + * Old values exists in case of ALTER commands. Transform them to raw > > + * values and merge them with new_values, and parse it. > > + */ > > + if (PointerIsValid(DatumGetPointer(oldOptions))) > > + { > > + old_values = optionsTextArrayToRawValues(oldOptions); > > + merged_values = optionsMergeOptionValues(old_values, new_values); > > + > > + /* > > + * Parse options only after merging in order not to parse options that > > + * would be removed by merging later > > + */ > > + merged_values = optionsParseRawValues(merged_values, spec_set, 0); > > + } > > + else > > + { > > + merged_values = new_values; > > + } > > + > > + /* > > + * If we have postprocess_fun function defined in spec_set, then there > > + * might be some custom options checks there, with error throwing. So we > > + * should do it here to throw these errors while CREATing or ALTERing > > + * options > > + */ > > + if (spec_set->postprocess_fun) > > + { > > + bytea *data = optionsValuesToBytea(merged_values, spec_set); > > + > > + spec_set->postprocess_fun(data, true); > > + pfree(data); > > + } > > + > > + /* > > + * Convert options to TextArray format so caller can store them into > > + * database > > + */ > > + result = optionsValuesToTextArray(merged_values); > > + return result; > > +} > > + > > + > > +/* > > + * optionsTextArrayToBytea > > + * A meta-function that transforms options stored as TextArray into > > binary + * (bytea) representation. > > + * > > + * This function runs other transform functions that leads to the desired > > + * result in no-validation mode. This function is used by cache > > mechanism, > > + * in order to load and cache options when object itself is loaded and > > cached + */ > > +bytea * > > +optionsTextArrayToBytea(options_spec_set * spec_set, Datum data, bool > > validate) +{ > > + List *values; > > + bytea *options; > > + > > + values = optionsTextArrayToRawValues(data); > > + values = optionsParseRawValues(values, spec_set, > > + validate ? OPTIONS_PARSE_MODE_VALIDATE : 0); > > + options = optionsValuesToBytea(values, spec_set); > > + > > + if (spec_set->postprocess_fun) > > + { > > + spec_set->postprocess_fun(options, false); > > + } > > + return options; > > +} > > diff --git a/src/backend/access/common/relation.c > > b/src/backend/access/common/relation.c index 632d13c..49ad197 100644 > > --- a/src/backend/access/common/relation.c > > +++ b/src/backend/access/common/relation.c > > @@ -65,9 +65,13 @@ relation_open(Oid relationId, LOCKMODE lockmode) > > > > * If we didn't get the lock ourselves, assert that caller holds one, > > * except in bootstrap mode where no locks are used. > > */ > > > > - Assert(lockmode != NoLock || > > - IsBootstrapProcessingMode() || > > - CheckRelationLockedByMe(r, AccessShareLock, true)); > > + > > +// FIXME We need NoLock mode to get AM data when choosing Lock for > > +// attoptions is changed. See ProcessUtilitySlow problems comes from > > there > > +// This is a dirty hack, we need better solution for this case; > > +// Assert(lockmode != NoLock || > > +// IsBootstrapProcessingMode() || > > +// CheckRelationLockedByMe(r, AccessShareLock, true)); > > > > /* Make note that we've accessed a temporary relation */ > > if (RelationUsesLocalBuffers(r)) > > > > diff --git a/src/backend/access/common/reloptions.c > > b/src/backend/access/common/reloptions.c index b5602f5..29ab98a 100644 > > --- a/src/backend/access/common/reloptions.c > > +++ b/src/backend/access/common/reloptions.c > > @@ -1,7 +1,7 @@ > > > > /*----------------------------------------------------------------------- > > -- > > > > * > > * reloptions.c > > > > - * Core support for relation options (pg_class.reloptions) > > + * Support for relation options (pg_class.reloptions) > > > > * > > * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group > > * Portions Copyright (c) 1994, Regents of the University of California > > > > @@ -17,13 +17,10 @@ > > > > #include <float.h> > > > > -#include "access/gist_private.h" > > -#include "access/hash.h" > > > > #include "access/heaptoast.h" > > #include "access/htup_details.h" > > > > -#include "access/nbtree.h" > > > > #include "access/reloptions.h" > > > > -#include "access/spgist_private.h" > > +#include "access/options.h" > > > > #include "catalog/pg_type.h" > > #include "commands/defrem.h" > > #include "commands/tablespace.h" > > > > @@ -36,6 +33,7 @@ > > > > #include "utils/guc.h" > > #include "utils/memutils.h" > > #include "utils/rel.h" > > > > +#include "storage/bufmgr.h" > > > > /* > > > > * Contents of pg_class.reloptions > > > > @@ -93,380 +91,8 @@ > > > > * value has no effect until the next VACUUM, so no need for stronger > > lock. > > */ > > > > -static relopt_bool boolRelOpts[] = > > -{ > > - { > > - { > > - "autosummarize", > > - "Enables automatic summarization on this BRIN index", > > - RELOPT_KIND_BRIN, > > - AccessExclusiveLock > > - }, > > - false > > - }, > > - { > > - { > > - "autovacuum_enabled", > > - "Enables autovacuum in this relation", > > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > - ShareUpdateExclusiveLock > > - }, > > - true > > - }, > > - { > > - { > > - "user_catalog_table", > > - "Declare a table as an additional catalog table, e.g. for the purpose > > of logical replication", - RELOPT_KIND_HEAP, > > - AccessExclusiveLock > > - }, > > - false > > - }, > > - { > > - { > > - "fastupdate", > > - "Enables \"fast update\" feature for this GIN index", > > - RELOPT_KIND_GIN, > > - AccessExclusiveLock > > - }, > > - true > > - }, > > - { > > - { > > - "security_barrier", > > - "View acts as a row security barrier", > > - RELOPT_KIND_VIEW, > > - AccessExclusiveLock > > - }, > > - false > > - }, > > - { > > - { > > - "vacuum_truncate", > > - "Enables vacuum to truncate empty pages at the end of this table", > > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > - ShareUpdateExclusiveLock > > - }, > > - true > > - }, > > - { > > - { > > - "deduplicate_items", > > - "Enables \"deduplicate items\" feature for this btree index", > > - RELOPT_KIND_BTREE, > > - ShareUpdateExclusiveLock /* since it applies only to later > > - * inserts */ > > - }, > > - true > > - }, > > - /* list terminator */ > > - {{NULL}} > > -}; > > - > > -static relopt_int intRelOpts[] = > > -{ > > - { > > - { > > - "fillfactor", > > - "Packs table pages only to this percentage", > > - RELOPT_KIND_HEAP, > > - ShareUpdateExclusiveLock /* since it applies only to later > > - * inserts */ > > - }, > > - HEAP_DEFAULT_FILLFACTOR, HEAP_MIN_FILLFACTOR, 100 > > - }, > > - { > > - { > > - "fillfactor", > > - "Packs btree index pages only to this percentage", > > - RELOPT_KIND_BTREE, > > - ShareUpdateExclusiveLock /* since it applies only to later > > - * inserts */ > > - }, > > - BTREE_DEFAULT_FILLFACTOR, BTREE_MIN_FILLFACTOR, 100 > > - }, > > - { > > - { > > - "fillfactor", > > - "Packs hash index pages only to this percentage", > > - RELOPT_KIND_HASH, > > - ShareUpdateExclusiveLock /* since it applies only to later > > - * inserts */ > > - }, > > - HASH_DEFAULT_FILLFACTOR, HASH_MIN_FILLFACTOR, 100 > > - }, > > - { > > - { > > - "fillfactor", > > - "Packs gist index pages only to this percentage", > > - RELOPT_KIND_GIST, > > - ShareUpdateExclusiveLock /* since it applies only to later > > - * inserts */ > > - }, > > - GIST_DEFAULT_FILLFACTOR, GIST_MIN_FILLFACTOR, 100 > > - }, > > - { > > - { > > - "fillfactor", > > - "Packs spgist index pages only to this percentage", > > - RELOPT_KIND_SPGIST, > > - ShareUpdateExclusiveLock /* since it applies only to later > > - * inserts */ > > - }, > > - SPGIST_DEFAULT_FILLFACTOR, SPGIST_MIN_FILLFACTOR, 100 > > - }, > > - { > > - { > > - "autovacuum_vacuum_threshold", > > - "Minimum number of tuple updates or deletes prior to vacuum", > > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > - ShareUpdateExclusiveLock > > - }, > > - -1, 0, INT_MAX > > - }, > > - { > > - { > > - "autovacuum_vacuum_insert_threshold", > > - "Minimum number of tuple inserts prior to vacuum, or -1 to disable > > insert vacuums", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > - ShareUpdateExclusiveLock > > - }, > > - -2, -1, INT_MAX > > - }, > > - { > > - { > > - "autovacuum_analyze_threshold", > > - "Minimum number of tuple inserts, updates or deletes prior to > > analyze", > > - RELOPT_KIND_HEAP, > > - ShareUpdateExclusiveLock > > - }, > > - -1, 0, INT_MAX > > - }, > > - { > > - { > > - "autovacuum_vacuum_cost_limit", > > - "Vacuum cost amount available before napping, for autovacuum", > > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > - ShareUpdateExclusiveLock > > - }, > > - -1, 1, 10000 > > - }, > > - { > > - { > > - "autovacuum_freeze_min_age", > > - "Minimum age at which VACUUM should freeze a table row, for > > autovacuum", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > - ShareUpdateExclusiveLock > > - }, > > - -1, 0, 1000000000 > > - }, > > - { > > - { > > - "autovacuum_multixact_freeze_min_age", > > - "Minimum multixact age at which VACUUM should freeze a row > > multixact's, for autovacuum", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > - ShareUpdateExclusiveLock > > - }, > > - -1, 0, 1000000000 > > - }, > > - { > > - { > > - "autovacuum_freeze_max_age", > > - "Age at which to autovacuum a table to prevent transaction ID > > wraparound", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > - ShareUpdateExclusiveLock > > - }, > > - -1, 100000, 2000000000 > > - }, > > - { > > - { > > - "autovacuum_multixact_freeze_max_age", > > - "Multixact age at which to autovacuum a table to prevent multixact > > wraparound", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > - ShareUpdateExclusiveLock > > - }, > > - -1, 10000, 2000000000 > > - }, > > - { > > - { > > - "autovacuum_freeze_table_age", > > - "Age at which VACUUM should perform a full table sweep to freeze row > > versions", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > - ShareUpdateExclusiveLock > > - }, -1, 0, 2000000000 > > - }, > > - { > > - { > > - "autovacuum_multixact_freeze_table_age", > > - "Age of multixact at which VACUUM should perform a full table sweep to > > freeze row versions", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > - ShareUpdateExclusiveLock > > - }, -1, 0, 2000000000 > > - }, > > - { > > - { > > - "log_autovacuum_min_duration", > > - "Sets the minimum execution time above which autovacuum actions will > > be logged", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > - ShareUpdateExclusiveLock > > - }, > > - -1, -1, INT_MAX > > - }, > > - { > > - { > > - "toast_tuple_target", > > - "Sets the target tuple length at which external columns will be > > toasted", - RELOPT_KIND_HEAP, > > - ShareUpdateExclusiveLock > > - }, > > - TOAST_TUPLE_TARGET, 128, TOAST_TUPLE_TARGET_MAIN > > - }, > > - { > > - { > > - "pages_per_range", > > - "Number of pages that each page range covers in a BRIN index", > > - RELOPT_KIND_BRIN, > > - AccessExclusiveLock > > - }, 128, 1, 131072 > > - }, > > - { > > - { > > - "gin_pending_list_limit", > > - "Maximum size of the pending list for this GIN index, in kilobytes.", > > - RELOPT_KIND_GIN, > > - AccessExclusiveLock > > - }, > > - -1, 64, MAX_KILOBYTES > > - }, > > - { > > - { > > - "effective_io_concurrency", > > - "Number of simultaneous requests that can be handled efficiently by > > the disk subsystem.", - RELOPT_KIND_TABLESPACE, > > - ShareUpdateExclusiveLock > > - }, > > -#ifdef USE_PREFETCH > > - -1, 0, MAX_IO_CONCURRENCY > > -#else > > - 0, 0, 0 > > -#endif > > - }, > > - { > > - { > > - "maintenance_io_concurrency", > > - "Number of simultaneous requests that can be handled efficiently by > > the disk subsystem for maintenance work.", - RELOPT_KIND_TABLESPACE, > > - ShareUpdateExclusiveLock > > - }, > > -#ifdef USE_PREFETCH > > - -1, 0, MAX_IO_CONCURRENCY > > -#else > > - 0, 0, 0 > > -#endif > > - }, > > - { > > - { > > - "parallel_workers", > > - "Number of parallel processes that can be used per executor node for > > this relation.", - RELOPT_KIND_HEAP, > > - ShareUpdateExclusiveLock > > - }, > > - -1, 0, 1024 > > - }, > > - > > - /* list terminator */ > > - {{NULL}} > > -}; > > - > > -static relopt_real realRelOpts[] = > > -{ > > - { > > - { > > - "autovacuum_vacuum_cost_delay", > > - "Vacuum cost delay in milliseconds, for autovacuum", > > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > - ShareUpdateExclusiveLock > > - }, > > - -1, 0.0, 100.0 > > - }, > > - { > > - { > > - "autovacuum_vacuum_scale_factor", > > - "Number of tuple updates or deletes prior to vacuum as a fraction of > > reltuples", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > - ShareUpdateExclusiveLock > > - }, > > - -1, 0.0, 100.0 > > - }, > > - { > > - { > > - "autovacuum_vacuum_insert_scale_factor", > > - "Number of tuple inserts prior to vacuum as a fraction of reltuples", > > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > - ShareUpdateExclusiveLock > > - }, > > - -1, 0.0, 100.0 > > - }, > > - { > > - { > > - "autovacuum_analyze_scale_factor", > > - "Number of tuple inserts, updates or deletes prior to analyze as a > > fraction of reltuples", - RELOPT_KIND_HEAP, > > - ShareUpdateExclusiveLock > > - }, > > - -1, 0.0, 100.0 > > - }, > > - { > > - { > > - "seq_page_cost", > > - "Sets the planner's estimate of the cost of a sequentially fetched > > disk page.", - RELOPT_KIND_TABLESPACE, > > - ShareUpdateExclusiveLock > > - }, > > - -1, 0.0, DBL_MAX > > - }, > > - { > > - { > > - "random_page_cost", > > - "Sets the planner's estimate of the cost of a nonsequentially fetched > > disk page.", - RELOPT_KIND_TABLESPACE, > > - ShareUpdateExclusiveLock > > - }, > > - -1, 0.0, DBL_MAX > > - }, > > - { > > - { > > - "n_distinct", > > - "Sets the planner's estimate of the number of distinct values > > appearing in a column (excluding child relations).", > > - RELOPT_KIND_ATTRIBUTE, > > - ShareUpdateExclusiveLock > > - }, > > - 0, -1.0, DBL_MAX > > - }, > > - { > > - { > > - "n_distinct_inherited", > > - "Sets the planner's estimate of the number of distinct values > > appearing in a column (including child relations).", > > - RELOPT_KIND_ATTRIBUTE, > > - ShareUpdateExclusiveLock > > - }, > > - 0, -1.0, DBL_MAX > > - }, > > - { > > - { > > - "vacuum_cleanup_index_scale_factor", > > - "Deprecated B-Tree parameter.", > > - RELOPT_KIND_BTREE, > > - ShareUpdateExclusiveLock > > - }, > > - -1, 0.0, 1e10 > > - }, > > - /* list terminator */ > > - {{NULL}} > > -}; > > - > > > > /* values from StdRdOptIndexCleanup */ > > > > -relopt_enum_elt_def StdRdOptIndexCleanupValues[] = > > +opt_enum_elt_def StdRdOptIndexCleanupValues[] = > > > > { > > > > {"auto", STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO}, > > {"on", STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON}, > > > > @@ -480,17 +106,8 @@ relopt_enum_elt_def StdRdOptIndexCleanupValues[] = > > > > {(const char *) NULL} /* list terminator */ > > > > }; > > > > -/* values from GistOptBufferingMode */ > > -relopt_enum_elt_def gistBufferingOptValues[] = > > -{ > > - {"auto", GIST_OPTION_BUFFERING_AUTO}, > > - {"on", GIST_OPTION_BUFFERING_ON}, > > - {"off", GIST_OPTION_BUFFERING_OFF}, > > - {(const char *) NULL} /* list terminator */ > > -}; > > - > > > > /* values from ViewOptCheckOption */ > > > > -relopt_enum_elt_def viewCheckOptValues[] = > > +opt_enum_elt_def viewCheckOptValues[] = > > > > { > > > > /* no value for NOT_SET */ > > {"local", VIEW_OPTION_CHECK_OPTION_LOCAL}, > > > > @@ -498,61 +115,8 @@ relopt_enum_elt_def viewCheckOptValues[] = > > > > {(const char *) NULL} /* list terminator */ > > > > }; > > > > -static relopt_enum enumRelOpts[] = > > -{ > > - { > > - { > > - "vacuum_index_cleanup", > > - "Controls index vacuuming and index cleanup", > > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > - ShareUpdateExclusiveLock > > - }, > > - StdRdOptIndexCleanupValues, > > - STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO, > > - gettext_noop("Valid values are \"on\", \"off\", and \"auto\".") > > - }, > > - { > > - { > > - "buffering", > > - "Enables buffering build for this GiST index", > > - RELOPT_KIND_GIST, > > - AccessExclusiveLock > > - }, > > - gistBufferingOptValues, > > - GIST_OPTION_BUFFERING_AUTO, > > - gettext_noop("Valid values are \"on\", \"off\", and \"auto\".") > > - }, > > - { > > - { > > - "check_option", > > - "View has WITH CHECK OPTION defined (local or cascaded).", > > - RELOPT_KIND_VIEW, > > - AccessExclusiveLock > > - }, > > - viewCheckOptValues, > > - VIEW_OPTION_CHECK_OPTION_NOT_SET, > > - gettext_noop("Valid values are \"local\" and \"cascaded\".") > > - }, > > - /* list terminator */ > > - {{NULL}} > > -}; > > - > > -static relopt_string stringRelOpts[] = > > -{ > > - /* list terminator */ > > - {{NULL}} > > -}; > > - > > -static relopt_gen **relOpts = NULL; > > -static bits32 last_assigned_kind = RELOPT_KIND_LAST_DEFAULT; > > - > > -static int num_custom_options = 0; > > -static relopt_gen **custom_options = NULL; > > -static bool need_initialization = true; > > > > -static void initialize_reloptions(void); > > -static void parse_one_reloption(relopt_value *option, char *text_str, > > - int text_len, bool validate); > > +options_spec_set *get_stdrd_relopt_spec_set(relopt_kind kind); > > > > /* > > > > * Get the length of a string reloption (either default or the > > user-defined > > > > @@ -563,160 +127,6 @@ static void parse_one_reloption(relopt_value > > *option, char *text_str,> > > ((option).isset ? strlen((option).values.string_val) : \ > > > > ((relopt_string *) (option).gen)->default_len) > > > > -/* > > - * initialize_reloptions > > - * initialization routine, must be called before parsing > > - * > > - * Initialize the relOpts array and fill each variable's type and name > > length. - */ > > -static void > > -initialize_reloptions(void) > > -{ > > - int i; > > - int j; > > - > > - j = 0; > > - for (i = 0; boolRelOpts[i].gen.name; i++) > > - { > > - Assert(DoLockModesConflict(boolRelOpts[i].gen.lockmode, > > - boolRelOpts[i].gen.lockmode)); > > - j++; > > - } > > - for (i = 0; intRelOpts[i].gen.name; i++) > > - { > > - Assert(DoLockModesConflict(intRelOpts[i].gen.lockmode, > > - intRelOpts[i].gen.lockmode)); > > - j++; > > - } > > - for (i = 0; realRelOpts[i].gen.name; i++) > > - { > > - Assert(DoLockModesConflict(realRelOpts[i].gen.lockmode, > > - realRelOpts[i].gen.lockmode)); > > - j++; > > - } > > - for (i = 0; enumRelOpts[i].gen.name; i++) > > - { > > - Assert(DoLockModesConflict(enumRelOpts[i].gen.lockmode, > > - enumRelOpts[i].gen.lockmode)); > > - j++; > > - } > > - for (i = 0; stringRelOpts[i].gen.name; i++) > > - { > > - Assert(DoLockModesConflict(stringRelOpts[i].gen.lockmode, > > - stringRelOpts[i].gen.lockmode)); > > - j++; > > - } > > - j += num_custom_options; > > - > > - if (relOpts) > > - pfree(relOpts); > > - relOpts = MemoryContextAlloc(TopMemoryContext, > > - (j + 1) * sizeof(relopt_gen *)); > > - > > - j = 0; > > - for (i = 0; boolRelOpts[i].gen.name; i++) > > - { > > - relOpts[j] = &boolRelOpts[i].gen; > > - relOpts[j]->type = RELOPT_TYPE_BOOL; > > - relOpts[j]->namelen = strlen(relOpts[j]->name); > > - j++; > > - } > > - > > - for (i = 0; intRelOpts[i].gen.name; i++) > > - { > > - relOpts[j] = &intRelOpts[i].gen; > > - relOpts[j]->type = RELOPT_TYPE_INT; > > - relOpts[j]->namelen = strlen(relOpts[j]->name); > > - j++; > > - } > > - > > - for (i = 0; realRelOpts[i].gen.name; i++) > > - { > > - relOpts[j] = &realRelOpts[i].gen; > > - relOpts[j]->type = RELOPT_TYPE_REAL; > > - relOpts[j]->namelen = strlen(relOpts[j]->name); > > - j++; > > - } > > - > > - for (i = 0; enumRelOpts[i].gen.name; i++) > > - { > > - relOpts[j] = &enumRelOpts[i].gen; > > - relOpts[j]->type = RELOPT_TYPE_ENUM; > > - relOpts[j]->namelen = strlen(relOpts[j]->name); > > - j++; > > - } > > - > > - for (i = 0; stringRelOpts[i].gen.name; i++) > > - { > > - relOpts[j] = &stringRelOpts[i].gen; > > - relOpts[j]->type = RELOPT_TYPE_STRING; > > - relOpts[j]->namelen = strlen(relOpts[j]->name); > > - j++; > > - } > > - > > - for (i = 0; i < num_custom_options; i++) > > - { > > - relOpts[j] = custom_options[i]; > > - j++; > > - } > > - > > - /* add a list terminator */ > > - relOpts[j] = NULL; > > - > > - /* flag the work is complete */ > > - need_initialization = false; > > -} > > - > > -/* > > - * add_reloption_kind > > - * Create a new relopt_kind value, to be used in custom reloptions by > > - * user-defined AMs. > > - */ > > -relopt_kind > > -add_reloption_kind(void) > > -{ > > - /* don't hand out the last bit so that the enum's behavior is portable > > */ > > - if (last_assigned_kind >= RELOPT_KIND_MAX) > > - ereport(ERROR, > > - (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), > > - errmsg("user-defined relation parameter types limit exceeded"))); > > - last_assigned_kind <<= 1; > > - return (relopt_kind) last_assigned_kind; > > -} > > - > > -/* > > - * add_reloption > > - * Add an already-created custom reloption to the list, and recompute > > the > > - * main parser table. > > - */ > > -static void > > -add_reloption(relopt_gen *newoption) > > -{ > > - static int max_custom_options = 0; > > - > > - if (num_custom_options >= max_custom_options) > > - { > > - MemoryContext oldcxt; > > - > > - oldcxt = MemoryContextSwitchTo(TopMemoryContext); > > - > > - if (max_custom_options == 0) > > - { > > - max_custom_options = 8; > > - custom_options = palloc(max_custom_options * sizeof(relopt_gen *)); > > - } > > - else > > - { > > - max_custom_options *= 2; > > - custom_options = repalloc(custom_options, > > - max_custom_options * sizeof(relopt_gen *)); > > - } > > - MemoryContextSwitchTo(oldcxt); > > - } > > - custom_options[num_custom_options++] = newoption; > > - > > - need_initialization = true; > > -} > > > > /* > > > > * init_local_reloptions > > > > @@ -729,6 +139,7 @@ init_local_reloptions(local_relopts *opts, Size > > relopt_struct_size)> > > opts->options = NIL; > > opts->validators = NIL; > > opts->relopt_struct_size = relopt_struct_size; > > > > + opts->spec_set = allocateOptionsSpecSet(NULL, relopt_struct_size, 0); > > > > } > > > > /* > > > > @@ -743,112 +154,6 @@ register_reloptions_validator(local_relopts *opts, > > relopts_validator validator)> > > } > > > > /* > > > > - * add_local_reloption > > - * Add an already-created custom reloption to the local list. > > - */ > > -static void > > -add_local_reloption(local_relopts *relopts, relopt_gen *newoption, int > > offset) -{ > > - local_relopt *opt = palloc(sizeof(*opt)); > > - > > - Assert(offset < relopts->relopt_struct_size); > > - > > - opt->option = newoption; > > - opt->offset = offset; > > - > > - relopts->options = lappend(relopts->options, opt); > > -} > > - > > -/* > > - * allocate_reloption > > - * Allocate a new reloption and initialize the type-agnostic fields > > - * (for types other than string) > > - */ > > -static relopt_gen * > > -allocate_reloption(bits32 kinds, int type, const char *name, const char > > *desc, - LOCKMODE lockmode) > > -{ > > - MemoryContext oldcxt; > > - size_t size; > > - relopt_gen *newoption; > > - > > - if (kinds != RELOPT_KIND_LOCAL) > > - oldcxt = MemoryContextSwitchTo(TopMemoryContext); > > - else > > - oldcxt = NULL; > > - > > - switch (type) > > - { > > - case RELOPT_TYPE_BOOL: > > - size = sizeof(relopt_bool); > > - break; > > - case RELOPT_TYPE_INT: > > - size = sizeof(relopt_int); > > - break; > > - case RELOPT_TYPE_REAL: > > - size = sizeof(relopt_real); > > - break; > > - case RELOPT_TYPE_ENUM: > > - size = sizeof(relopt_enum); > > - break; > > - case RELOPT_TYPE_STRING: > > - size = sizeof(relopt_string); > > - break; > > - default: > > - elog(ERROR, "unsupported reloption type %d", type); > > - return NULL; /* keep compiler quiet */ > > - } > > - > > - newoption = palloc(size); > > - > > - newoption->name = pstrdup(name); > > - if (desc) > > - newoption->desc = pstrdup(desc); > > - else > > - newoption->desc = NULL; > > - newoption->kinds = kinds; > > - newoption->namelen = strlen(name); > > - newoption->type = type; > > - newoption->lockmode = lockmode; > > - > > - if (oldcxt != NULL) > > - MemoryContextSwitchTo(oldcxt); > > - > > - return newoption; > > -} > > - > > -/* > > - * init_bool_reloption > > - * Allocate and initialize a new boolean reloption > > - */ > > -static relopt_bool * > > -init_bool_reloption(bits32 kinds, const char *name, const char *desc, > > - bool default_val, LOCKMODE lockmode) > > -{ > > - relopt_bool *newoption; > > - > > - newoption = (relopt_bool *) allocate_reloption(kinds, RELOPT_TYPE_BOOL, > > - name, desc, lockmode); > > - newoption->default_val = default_val; > > - > > - return newoption; > > -} > > - > > -/* > > - * add_bool_reloption > > - * Add a new boolean reloption > > - */ > > -void > > -add_bool_reloption(bits32 kinds, const char *name, const char *desc, > > - bool default_val, LOCKMODE lockmode) > > -{ > > - relopt_bool *newoption = init_bool_reloption(kinds, name, desc, > > - default_val, lockmode); > > - > > - add_reloption((relopt_gen *) newoption); > > -} > > - > > -/* > > > > * add_local_bool_reloption > > * Add a new boolean local reloption > > * > > > > @@ -858,47 +163,8 @@ void > > > > add_local_bool_reloption(local_relopts *relopts, const char *name, > > > > const char *desc, bool default_val, int offset) > > > > { > > > > - relopt_bool *newoption = init_bool_reloption(RELOPT_KIND_LOCAL, > > - name, desc, > > - default_val, 0); > > - > > - add_local_reloption(relopts, (relopt_gen *) newoption, offset); > > -} > > - > > - > > -/* > > - * init_real_reloption > > - * Allocate and initialize a new integer reloption > > - */ > > -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) > > -{ > > - relopt_int *newoption; > > - > > - newoption = (relopt_int *) allocate_reloption(kinds, RELOPT_TYPE_INT, > > - name, desc, lockmode); > > - newoption->default_val = default_val; > > - newoption->min = min_val; > > - newoption->max = max_val; > > - > > - return newoption; > > -} > > - > > -/* > > - * add_int_reloption > > - * Add a new integer reloption > > - */ > > -void > > -add_int_reloption(bits32 kinds, const char *name, const char *desc, int > > default_val, - int min_val, int max_val, LOCKMODE lockmode) > > -{ > > - relopt_int *newoption = init_int_reloption(kinds, name, desc, > > - default_val, min_val, > > - max_val, lockmode); > > - > > - add_reloption((relopt_gen *) newoption); > > + optionsSpecSetAddBool(relopts->spec_set, name, desc, NoLock, 0, offset, > > + default_val); > > > > } > > > > /* > > > > @@ -912,47 +178,8 @@ add_local_int_reloption(local_relopts *relopts, const > > char *name,> > > const char *desc, int default_val, int min_val, > > int max_val, int offset) > > > > { > > > > - relopt_int *newoption = init_int_reloption(RELOPT_KIND_LOCAL, > > - name, desc, default_val, > > - min_val, max_val, 0); > > - > > - add_local_reloption(relopts, (relopt_gen *) newoption, offset); > > -} > > - > > -/* > > - * init_real_reloption > > - * Allocate and initialize a new real reloption > > - */ > > -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) > > -{ > > - relopt_real *newoption; > > - > > - newoption = (relopt_real *) allocate_reloption(kinds, RELOPT_TYPE_REAL, > > - name, desc, lockmode); > > - newoption->default_val = default_val; > > - newoption->min = min_val; > > - newoption->max = max_val; > > - > > - return newoption; > > -} > > - > > -/* > > - * add_real_reloption > > - * Add a new float reloption > > - */ > > -void > > -add_real_reloption(bits32 kinds, const char *name, const char *desc, > > - double default_val, double min_val, double max_val, > > - LOCKMODE lockmode) > > -{ > > - relopt_real *newoption = init_real_reloption(kinds, name, desc, > > - default_val, min_val, > > - max_val, lockmode); > > - > > - add_reloption((relopt_gen *) newoption); > > + optionsSpecSetAddInt(relopts->spec_set, name, desc, NoLock, 0, offset, > > + default_val, min_val, max_val); > > > > } > > > > /* > > > > @@ -966,57 +193,9 @@ add_local_real_reloption(local_relopts *relopts, > > const char *name,> > > const char *desc, double default_val, > > double min_val, double max_val, int offset) > > > > { > > > > - relopt_real *newoption = init_real_reloption(RELOPT_KIND_LOCAL, > > - name, desc, > > - default_val, min_val, > > - max_val, 0); > > - > > - add_local_reloption(relopts, (relopt_gen *) newoption, offset); > > -} > > - > > -/* > > - * init_enum_reloption > > - * Allocate and initialize a new enum reloption > > - */ > > -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) > > -{ > > - relopt_enum *newoption; > > - > > - newoption = (relopt_enum *) allocate_reloption(kinds, RELOPT_TYPE_ENUM, > > - name, desc, lockmode); > > - newoption->members = members; > > - newoption->default_val = default_val; > > - newoption->detailmsg = detailmsg; > > - > > - return newoption; > > -} > > - > > - > > -/* > > - * add_enum_reloption > > - * Add a new enum reloption > > - * > > - * The members array must have a terminating NULL entry. > > - * > > - * The detailmsg is shown when unsupported values are passed, and has > > this > > - * form: "Valid values are \"foo\", \"bar\", and \"bar\"." > > - * > > - * The members array and detailmsg are not copied -- caller must ensure > > that - * they are valid throughout the life of the process. > > - */ > > -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) > > -{ > > - relopt_enum *newoption = init_enum_reloption(kinds, name, desc, > > - members, default_val, > > - detailmsg, lockmode); > > + optionsSpecSetAddReal(relopts->spec_set, name, desc, NoLock, 0, offset, > > + default_val, min_val, max_val); > > > > - add_reloption((relopt_gen *) newoption); > > > > } > > > > /* > > > > @@ -1027,77 +206,11 @@ add_enum_reloption(bits32 kinds, const char *name, > > const char *desc,> > > */ > > > > void > > add_local_enum_reloption(local_relopts *relopts, const char *name, > > > > - const char *desc, relopt_enum_elt_def *members, > > + const char *desc, opt_enum_elt_def *members, > > > > int default_val, const char *detailmsg, int offset) > > > > { > > > > - relopt_enum *newoption = init_enum_reloption(RELOPT_KIND_LOCAL, > > - name, desc, > > - members, default_val, > > - detailmsg, 0); > > - > > - add_local_reloption(relopts, (relopt_gen *) newoption, offset); > > -} > > - > > -/* > > - * init_string_reloption > > - * Allocate and initialize a new string reloption > > - */ > > -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) > > -{ > > - relopt_string *newoption; > > - > > - /* make sure the validator/default combination is sane */ > > - if (validator) > > - (validator) (default_val); > > - > > - newoption = (relopt_string *) allocate_reloption(kinds, > > RELOPT_TYPE_STRING, - name, desc, lockmode); > > - newoption->validate_cb = validator; > > - newoption->fill_cb = filler; > > - if (default_val) > > - { > > - if (kinds == RELOPT_KIND_LOCAL) > > - newoption->default_val = strdup(default_val); > > - else > > - newoption->default_val = MemoryContextStrdup(TopMemoryContext, > > default_val); - newoption->default_len = strlen(default_val); > > - newoption->default_isnull = false; > > - } > > - else > > - { > > - newoption->default_val = ""; > > - newoption->default_len = 0; > > - newoption->default_isnull = true; > > - } > > - > > - return newoption; > > -} > > - > > -/* > > - * add_string_reloption > > - * Add a new string reloption > > - * > > - * "validator" is an optional function pointer that can be used to test > > the - * validity of the values. It must elog(ERROR) when the argument > > string is - * not acceptable for the variable. Note that the default > > value must pass - * the validation. > > - */ > > -void > > -add_string_reloption(bits32 kinds, const char *name, const char *desc, > > - const char *default_val, validate_string_relopt validator, > > - LOCKMODE lockmode) > > -{ > > - relopt_string *newoption = init_string_reloption(kinds, name, desc, > > - default_val, > > - validator, NULL, > > - lockmode); > > - > > - add_reloption((relopt_gen *) newoption); > > + optionsSpecSetAddEnum(relopts->spec_set, name, desc, NoLock, 0, offset, > > + members, default_val, detailmsg); > > > > } > > > > /* > > > > @@ -1113,249 +226,9 @@ add_local_string_reloption(local_relopts *relopts, > > const char *name,> > > validate_string_relopt validator, > > fill_string_relopt filler, int offset) > > > > { > > > > - relopt_string *newoption = init_string_reloption(RELOPT_KIND_LOCAL, > > - name, desc, > > - default_val, > > - validator, filler, > > - 0); > > - > > - add_local_reloption(relopts, (relopt_gen *) newoption, offset); > > -} > > - > > -/* > > - * Transform a relation options list (list of DefElem) into the text > > array > > - * format that is kept in pg_class.reloptions, including only those > > options - * that are in the passed namespace. The output values do not > > include the - * namespace. > > - * > > - * This is used for three cases: CREATE TABLE/INDEX, ALTER TABLE SET, and > > - * ALTER TABLE RESET. In the ALTER cases, oldOptions is the existing > > - * reloptions value (possibly NULL), and we replace or remove entries > > - * as needed. > > - * > > - * If acceptOidsOff is true, then we allow oids = false, but throw error > > when - * on. This is solely needed for backwards compatibility. > > - * > > - * Note that this is not responsible for determining whether the options > > - * are valid, but it does check that namespaces for all the options given > > are - * listed in validnsps. The NULL namespace is always valid and need > > not be - * explicitly listed. Passing a NULL pointer means that only the > > NULL - * namespace is valid. > > - * > > - * Both oldOptions and the result are text arrays (or NULL for > > "default"), > > - * but we declare them as Datums to avoid including array.h in > > reloptions.h. - */ > > -Datum > > -transformRelOptions(Datum oldOptions, List *defList, const char > > *namspace, > > - char *validnsps[], bool acceptOidsOff, bool isReset) > > -{ > > - Datum result; > > - ArrayBuildState *astate; > > - ListCell *cell; > > - > > - /* no change if empty list */ > > - if (defList == NIL) > > - return oldOptions; > > - > > - /* We build new array using accumArrayResult */ > > - astate = NULL; > > - > > - /* Copy any oldOptions that aren't to be replaced */ > > - if (PointerIsValid(DatumGetPointer(oldOptions))) > > - { > > - ArrayType *array = DatumGetArrayTypeP(oldOptions); > > - Datum *oldoptions; > > - int noldoptions; > > - int i; > > - > > - deconstruct_array(array, TEXTOID, -1, false, TYPALIGN_INT, > > - &oldoptions, NULL, &noldoptions); > > - > > - for (i = 0; i < noldoptions; i++) > > - { > > - char *text_str = VARDATA(oldoptions[i]); > > - int text_len = VARSIZE(oldoptions[i]) - VARHDRSZ; > > - > > - /* Search for a match in defList */ > > - foreach(cell, defList) > > - { > > - DefElem *def = (DefElem *) lfirst(cell); > > - int kw_len; > > - > > - /* ignore if not in the same namespace */ > > - if (namspace == NULL) > > - { > > - if (def->defnamespace != NULL) > > - continue; > > - } > > - else if (def->defnamespace == NULL) > > - continue; > > - else if (strcmp(def->defnamespace, namspace) != 0) > > - continue; > > - > > - kw_len = strlen(def->defname); > > - if (text_len > kw_len && text_str[kw_len] == '=' && > > - strncmp(text_str, def->defname, kw_len) == 0) > > - break; > > - } > > - if (!cell) > > - { > > - /* No match, so keep old option */ > > - astate = accumArrayResult(astate, oldoptions[i], > > - false, TEXTOID, > > - CurrentMemoryContext); > > - } > > - } > > - } > > - > > - /* > > - * If CREATE/SET, add new options to array; if RESET, just check that > > the > > - * user didn't say RESET (option=val). (Must do this because the > > grammar > > - * doesn't enforce it.) > > - */ > > - foreach(cell, defList) > > - { > > - DefElem *def = (DefElem *) lfirst(cell); > > - > > - if (isReset) > > - { > > - if (def->arg != NULL) > > - ereport(ERROR, > > - (errcode(ERRCODE_SYNTAX_ERROR), > > - errmsg("RESET must not include values for parameters"))); > > - } > > - else > > - { > > - text *t; > > - const char *value; > > - Size len; > > - > > - /* > > - * Error out if the namespace is not valid. A NULL namespace is > > - * always valid. > > - */ > > - if (def->defnamespace != NULL) > > - { > > - bool valid = false; > > - int i; > > - > > - if (validnsps) > > - { > > - for (i = 0; validnsps[i]; i++) > > - { > > - if (strcmp(def- >defnamespace, validnsps[i]) == 0) > > - { > > - valid = true; > > - break; > > - } > > - } > > - } > > - > > - if (!valid) > > - ereport(ERROR, > > - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > - errmsg("unrecognized parameter namespace \"%s\"", > > - def- >defnamespace))); > > - } > > - > > - /* ignore if not in the same namespace */ > > - if (namspace == NULL) > > - { > > - if (def->defnamespace != NULL) > > - continue; > > - } > > - else if (def->defnamespace == NULL) > > - continue; > > - else if (strcmp(def->defnamespace, namspace) != 0) > > - continue; > > - > > - /* > > - * Flatten the DefElem into a text string like "name=arg". If we > > - * have just "name", assume "name=true" is meant. Note: the > > - * namespace is not output. > > - */ > > - if (def->arg != NULL) > > - value = defGetString(def); > > - else > > - value = "true"; > > - > > - /* > > - * This is not a great place for this test, but there's no other > > - * convenient place to filter the option out. As WITH (oids = > > - * false) will be removed someday, this seems like an acceptable > > - * amount of ugly. > > - */ > > - if (acceptOidsOff && def->defnamespace == NULL && > > - strcmp(def->defname, "oids") == 0) > > - { > > - if (defGetBoolean(def)) > > - ereport(ERROR, > > - (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), > > - errmsg("tables declared WITH OIDS are not supported"))); > > - /* skip over option, reloptions machinery doesn't know it */ > > - continue; > > - } > > - > > - len = VARHDRSZ + strlen(def->defname) + 1 + strlen(value); > > - /* +1 leaves room for sprintf's trailing null */ > > - t = (text *) palloc(len + 1); > > - SET_VARSIZE(t, len); > > - sprintf(VARDATA(t), "%s=%s", def->defname, value); > > - > > - astate = accumArrayResult(astate, PointerGetDatum(t), > > - false, TEXTOID, > > - CurrentMemoryContext); > > - } > > - } > > - > > - if (astate) > > - result = makeArrayResult(astate, CurrentMemoryContext); > > - else > > - result = (Datum) 0; > > - > > - return result; > > -} > > - > > - > > -/* > > - * Convert the text-array format of reloptions into a List of DefElem. > > - * This is the inverse of transformRelOptions(). > > - */ > > -List * > > -untransformRelOptions(Datum options) > > -{ > > - List *result = NIL; > > - ArrayType *array; > > - Datum *optiondatums; > > - int noptions; > > - int i; > > - > > - /* Nothing to do if no options */ > > - if (!PointerIsValid(DatumGetPointer(options))) > > - return result; > > - > > - array = DatumGetArrayTypeP(options); > > - > > - deconstruct_array(array, TEXTOID, -1, false, TYPALIGN_INT, > > - &optiondatums, NULL, &noptions); > > - > > - for (i = 0; i < noptions; i++) > > - { > > - char *s; > > - char *p; > > - Node *val = NULL; > > - > > - s = TextDatumGetCString(optiondatums[i]); > > - p = strchr(s, '='); > > - if (p) > > - { > > - *p++ = '\0'; > > - val = (Node *) makeString(pstrdup(p)); > > - } > > - result = lappend(result, makeDefElem(pstrdup(s), val, -1)); > > - } > > - > > - return result; > > + optionsSpecSetAddString(relopts->spec_set, name, desc, NoLock, 0, > > offset, > > + default_val, validator); > > +/* FIXME solve mistery with filler option! */ > > > > } > > > > /* > > > > @@ -1372,12 +245,13 @@ untransformRelOptions(Datum options) > > > > */ > > > > bytea * > > extractRelOptions(HeapTuple tuple, TupleDesc tupdesc, > > > > - amoptions_function amoptions) > > + amreloptspecset_function amoptionsspecsetfn) > > > > { > > > > bytea *options; > > bool isnull; > > Datum datum; > > Form_pg_class classForm; > > > > + options_spec_set *spec_set; > > > > datum = fastgetattr(tuple, > > > > Anum_pg_class_reloptions, > > > > @@ -1394,702 +268,341 @@ extractRelOptions(HeapTuple tuple, TupleDesc > > tupdesc,> > > case RELKIND_RELATION: > > case RELKIND_TOASTVALUE: > > > > case RELKIND_MATVIEW: > > - options = heap_reloptions(classForm->relkind, datum, false); > > + spec_set = get_heap_relopt_spec_set(); > > > > break; > > > > case RELKIND_PARTITIONED_TABLE: > > - options = partitioned_table_reloptions(datum, false); > > + spec_set = get_partitioned_relopt_spec_set(); > > > > break; > > > > case RELKIND_VIEW: > > - options = view_reloptions(datum, false); > > + spec_set = get_view_relopt_spec_set(); > > > > break; > > > > case RELKIND_INDEX: > > > > case RELKIND_PARTITIONED_INDEX: > > - options = index_reloptions(amoptions, datum, false); > > + if (amoptionsspecsetfn) > > + spec_set = amoptionsspecsetfn(); > > + else > > + spec_set = NULL; > > > > break; > > > > case RELKIND_FOREIGN_TABLE: > > - options = NULL; > > + spec_set = NULL; > > > > break; > > > > default: > > Assert(false); /* can't get here */ > > > > - options = NULL; /* keep compiler quiet */ > > + spec_set = NULL; /* keep compiler quiet */ > > > > break; > > > > } > > > > + if (spec_set) > > + options = optionsTextArrayToBytea(spec_set, datum, 0); > > + else > > + options = NULL; > > > > return options; > > > > } > > > > -static void > > -parseRelOptionsInternal(Datum options, bool validate, > > - relopt_value *reloptions, int numoptions) > > -{ > > - ArrayType *array = DatumGetArrayTypeP(options); > > - Datum *optiondatums; > > - int noptions; > > - int i; > > - > > - deconstruct_array(array, TEXTOID, -1, false, TYPALIGN_INT, > > - &optiondatums, NULL, &noptions); > > +options_spec_set * > > +get_stdrd_relopt_spec_set(relopt_kind kind) > > +{ > > + bool is_for_toast = (kind == RELOPT_KIND_TOAST); > > + > > + options_spec_set * stdrd_relopt_spec_set = allocateOptionsSpecSet( > > + is_for_toast ? "toast" : NULL, sizeof(StdRdOptions), 0); //FIXME > > change 0 to actual value (may be) > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, "fillfactor", > > + "Packs table pages only to this percentag", > > + ShareUpdateExclusiveLock, /* since it applies only > > + * to later inserts */ > > + is_for_toast ? OPTION_DEFINITION_FLAG_REJECT : 0, > > + offsetof(StdRdOptions, fillfactor), > > + HEAP_DEFAULT_FILLFACTOR, HEAP_MIN_FILLFACTOR, 100); > > + optionsSpecSetAddBool(stdrd_relopt_spec_set, "autovacuum_enabled", > > + "Enables autovacuum in this relation", > > + ShareUpdateExclusiveLock, 0, > > + offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, enabled), > > + true); > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, > > "autovacuum_vacuum_threshold", + "Minimum number of tuple updates or > > deletes prior to vacuum", + ShareUpdateExclusiveLock, > > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > vacuum_threshold), + -1, 0, INT_MAX); > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, > > "autovacuum_analyze_threshold", + "Minimum number of tuple updates or > > deletes prior to vacuum", + ShareUpdateExclusiveLock, > > + is_for_toast ? OPTION_DEFINITION_FLAG_REJECT : 0, > > + offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > analyze_threshold), + -1, 0, INT_MAX); > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, > > "autovacuum_vacuum_cost_limit", + "Vacuum cost amount available > > before napping, for autovacuum", + ShareUpdateExclusiveLock, > > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > vacuum_cost_limit), + -1, 0, 10000); > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, "autovacuum_freeze_min_age", > > + "Minimum age at which VACUUM should freeze a table row, for > > autovacuum", > > + ShareUpdateExclusiveLock, > > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > freeze_min_age), + -1, 0, 1000000000); > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, "autovacuum_freeze_max_age", > > + "Age at which to autovacuum a table to prevent transaction ID > > wraparound", + ShareUpdateExclusiveLock, > > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > freeze_max_age), + -1, 100000, 2000000000); > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, > > "autovacuum_freeze_table_age", + "Age at which VACUUM should > > perform a full table sweep to freeze row versions", + > > ShareUpdateExclusiveLock, > > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > freeze_table_age), + -1, 0, 2000000000); > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, > > "autovacuum_multixact_freeze_min_age", + "Minimum multixact age at > > which VACUUM should freeze a row multixact's, for autovacuum", + > > ShareUpdateExclusiveLock, > > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > multixact_freeze_min_age), + -1, 0, 1000000000); > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, > > "autovacuum_multixact_freeze_max_age", + "Multixact age at which > > to autovacuum a table to prevent multixact wraparound", + > > ShareUpdateExclusiveLock, > > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > multixact_freeze_max_age), + -1, 10000, 2000000000); > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, > > "autovacuum_multixact_freeze_table_age", + "Age of multixact at > > which VACUUM should perform a full table sweep to freeze row versions", > > + ShareUpdateExclusiveLock, > > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > multixact_freeze_table_age), + -1, 0, 2000000000); > > + optionsSpecSetAddInt(stdrd_relopt_spec_set,"log_autovacuum_min_duration" > > , > > + "Sets the minimum execution time above which autovacuum actions > > will be logged", + ShareUpdateExclusiveLock, > > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > log_min_duration), + -1, -1, INT_MAX); > > + optionsSpecSetAddReal(stdrd_relopt_spec_set, > > "autovacuum_vacuum_cost_delay", + "Vacuum cost delay in > > milliseconds, for autovacuum", > > + ShareUpdateExclusiveLock, > > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > vacuum_cost_delay), + -1, 0.0, 100.0); > > + optionsSpecSetAddReal(stdrd_relopt_spec_set, > > "autovacuum_vacuum_scale_factor", + "Number of tuple updates or > > deletes prior to vacuum as a fraction of reltuples", + > > ShareUpdateExclusiveLock, > > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > vacuum_scale_factor), + -1, 0.0, 100.0); > > + > > + optionsSpecSetAddReal(stdrd_relopt_spec_set, > > "autovacuum_vacuum_insert_scale_factor", + "Number of tuple > > inserts prior to vacuum as a fraction of reltuples", + > > ShareUpdateExclusiveLock, > > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > vacuum_ins_scale_factor), + -1, 0.0, 100.0); > > + > > + optionsSpecSetAddReal(stdrd_relopt_spec_set, > > "autovacuum_analyze_scale_factor", + "Number of tuple inserts, > > updates or deletes prior to analyze as a fraction of reltuples", + > > ShareUpdateExclusiveLock, > > + is_for_toast ? OPTION_DEFINITION_FLAG_REJECT : 0, > > + offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > analyze_scale_factor), + -1, 0.0, 100.0); > > + > > + > > + > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, "toast_tuple_target", > > + "Sets the target tuple length at which external columns will be > > toasted", + ShareUpdateExclusiveLock, > > + is_for_toast ? OPTION_DEFINITION_FLAG_REJECT : 0, > > + offsetof(StdRdOptions, toast_tuple_target), > > + TOAST_TUPLE_TARGET, 128, TOAST_TUPLE_TARGET_MAIN); > > + > > + optionsSpecSetAddBool(stdrd_relopt_spec_set, "user_catalog_table", > > + "Declare a table as an additional catalog table, e.g. for the > > purpose of logical replication", + AccessExclusiveLock, > > + is_for_toast ? OPTION_DEFINITION_FLAG_REJECT : 0, > > + offsetof(StdRdOptions, user_catalog_table), > > + false); > > + > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, "parallel_workers", > > + "Number of parallel processes that can be used per executor node > > for this relation.", + ShareUpdateExclusiveLock, > > + is_for_toast ? OPTION_DEFINITION_FLAG_REJECT : 0, > > + offsetof(StdRdOptions, parallel_workers), > > + -1, 0, 1024); > > + > > + optionsSpecSetAddEnum(stdrd_relopt_spec_set, "vacuum_index_cleanup", > > + "Controls index vacuuming and index cleanup", > > + ShareUpdateExclusiveLock, 0, > > + offsetof(StdRdOptions, vacuum_index_cleanup), > > + StdRdOptIndexCleanupValues, > > + STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO, > > + gettext_noop("Valid values are \"on\", \"off\", and \"auto\".")); > > + > > + optionsSpecSetAddBool(stdrd_relopt_spec_set, "vacuum_truncate", > > + "Enables vacuum to truncate empty pages at the end of this > > table", > > + ShareUpdateExclusiveLock, 0, > > + offsetof(StdRdOptions, vacuum_truncate), > > + true); > > + > > +// FIXME Do something with OIDS > > + > > + return stdrd_relopt_spec_set; > > +} > > + > > + > > +static options_spec_set *heap_relopt_spec_set = NULL; > > + > > +options_spec_set * > > +get_heap_relopt_spec_set(void) > > +{ > > + if (heap_relopt_spec_set) > > + return heap_relopt_spec_set; > > + heap_relopt_spec_set = get_stdrd_relopt_spec_set(RELOPT_KIND_HEAP); > > + return heap_relopt_spec_set; > > +} > > + > > +static options_spec_set *toast_relopt_spec_set = NULL; > > + > > +options_spec_set * > > +get_toast_relopt_spec_set(void) > > +{ > > + if (toast_relopt_spec_set) > > + return toast_relopt_spec_set; > > + toast_relopt_spec_set = get_stdrd_relopt_spec_set(RELOPT_KIND_TOAST); > > + return toast_relopt_spec_set; > > +} > > + > > +static options_spec_set *partitioned_relopt_spec_set = NULL; > > > > - for (i = 0; i < noptions; i++) > > - { > > - char *text_str = VARDATA(optiondatums[i]); > > - int text_len = VARSIZE(optiondatums[i]) - VARHDRSZ; > > - int j; > > - > > - /* Search for a match in reloptions */ > > - for (j = 0; j < numoptions; j++) > > - { > > - int kw_len = reloptions[j].gen- >namelen; > > - > > - if (text_len > kw_len && text_str[kw_len] == '=' && > > - strncmp(text_str, reloptions[j].gen->name, kw_len) == 0) > > - { > > - parse_one_reloption(&reloptions[j], text_str, text_len, > > - validate); > > - break; > > - } > > - } > > - > > - if (j >= numoptions && validate) > > - { > > - char *s; > > - char *p; > > - > > - s = TextDatumGetCString(optiondatums[i]); > > - p = strchr(s, '='); > > - if (p) > > - *p = '\0'; > > - ereport(ERROR, > > - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > - errmsg("unrecognized parameter \"%s\"", s))); > > - } > > - } > > - > > - /* It's worth avoiding memory leaks in this function */ > > - pfree(optiondatums); > > +options_spec_set * > > +get_partitioned_relopt_spec_set(void) > > +{ > > + if (partitioned_relopt_spec_set) > > + return partitioned_relopt_spec_set; > > + partitioned_relopt_spec_set = allocateOptionsSpecSet( > > + NULL, sizeof(StdRdOptions), 0); > > + /* No options for now, so spec set is empty */ > > > > - if (((void *) array) != DatumGetPointer(options)) > > - pfree(array); > > + return partitioned_relopt_spec_set; > > > > } > > > > /* > > > > - * Interpret reloptions that are given in text-array format. > > - * > > - * options is a reloption text array as constructed by > > transformRelOptions. - * kind specifies the family of options to be > > processed. > > - * > > - * The return value is a relopt_value * array on which the options > > actually - * set in the options array are marked with isset=true. The > > length of this - * array is returned in *numrelopts. Options not set are > > also present in the - * array; this is so that the caller can easily > > locate the default values. - * > > - * If there are no options of the given kind, numrelopts is set to 0 and > > NULL - * is returned (unless options are illegally supplied despite none > > being - * defined, in which case an error occurs). > > - * > > - * Note: values of type int, bool and real are allocated as part of the > > - * returned array. Values of type string are allocated separately and > > must - * be freed by the caller. > > + * Parse local options, allocate a bytea struct that's of the specified > > + * 'base_size' plus any extra space that's needed for string variables, > > + * fill its option's fields located at the given offsets and return it. > > > > */ > > > > -static relopt_value * > > -parseRelOptions(Datum options, bool validate, relopt_kind kind, > > - int *numrelopts) > > -{ > > - relopt_value *reloptions = NULL; > > - int numoptions = 0; > > - int i; > > - int j; > > - > > - if (need_initialization) > > - initialize_reloptions(); > > - > > - /* Build a list of expected options, based on kind */ > > - > > - for (i = 0; relOpts[i]; i++) > > - if (relOpts[i]->kinds & kind) > > - numoptions++; > > - > > - if (numoptions > 0) > > - { > > - reloptions = palloc(numoptions * sizeof(relopt_value)); > > - > > - for (i = 0, j = 0; relOpts[i]; i++) > > - { > > - if (relOpts[i]->kinds & kind) > > - { > > - reloptions[j].gen = relOpts[i]; > > - reloptions[j].isset = false; > > - j++; > > - } > > - } > > - } > > - > > - /* Done if no options */ > > - if (PointerIsValid(DatumGetPointer(options))) > > - parseRelOptionsInternal(options, validate, reloptions, numoptions); > > - > > - *numrelopts = numoptions; > > - return reloptions; > > -} > > - > > -/* Parse local unregistered options. */ > > -static relopt_value * > > -parseLocalRelOptions(local_relopts *relopts, Datum options, bool > > validate) > > +void * > > +build_local_reloptions(local_relopts *relopts, Datum options, bool > > validate)> > > { > > > > - int nopts = list_length(relopts->options); > > - relopt_value *values = palloc(sizeof(*values) * nopts); > > + void *opts; > > > > ListCell *lc; > > > > - int i = 0; > > - > > - foreach(lc, relopts->options) > > - { > > - local_relopt *opt = lfirst(lc); > > - > > - values[i].gen = opt->option; > > - values[i].isset = false; > > - > > - i++; > > - } > > - > > - if (options != (Datum) 0) > > - parseRelOptionsInternal(options, validate, values, nopts); > > + opts = (void *) optionsTextArrayToBytea(relopts->spec_set, options, > > validate); > > > > - return values; > > -} > > - > > -/* > > - * Subroutine for parseRelOptions, to parse and validate a single > > option's > > - * value > > - */ > > -static void > > -parse_one_reloption(relopt_value *option, char *text_str, int text_len, > > - bool validate) > > -{ > > - char *value; > > - int value_len; > > - bool parsed; > > - bool nofree = false; > > - > > - if (option->isset && validate) > > - ereport(ERROR, > > - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > - errmsg("parameter \"%s\" specified more than once", > > - option->gen->name))); > > - > > - value_len = text_len - option->gen->namelen - 1; > > - value = (char *) palloc(value_len + 1); > > - memcpy(value, text_str + option->gen->namelen + 1, value_len); > > - value[value_len] = '\0'; > > - > > - switch (option->gen->type) > > - { > > - case RELOPT_TYPE_BOOL: > > - { > > - parsed = parse_bool(value, &option- >values.bool_val); > > - if (validate && !parsed) > > - ereport(ERROR, > > - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > - errmsg("invalid value for boolean option \"%s\": %s", > > - option->gen->name, value))); > > - } > > - break; > > - case RELOPT_TYPE_INT: > > - { > > - relopt_int *optint = (relopt_int *) option- >gen; > > - > > - parsed = parse_int(value, &option- >values.int_val, 0, NULL); > > - if (validate && !parsed) > > - ereport(ERROR, > > - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > - errmsg("invalid value for integer option \"%s\": %s", > > - option->gen->name, value))); > > - if (validate && (option->values.int_val < optint->min || > > - option- >values.int_val > optint->max)) > > - ereport(ERROR, > > - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > - errmsg("value %s out of bounds for option \"%s\"", > > - value, option->gen->name), > > - errdetail("Valid values are between \"%d\" and \"%d\".", > > - optint->min, optint->max))); > > - } > > - break; > > - case RELOPT_TYPE_REAL: > > - { > > - relopt_real *optreal = (relopt_real *) option->gen; > > - > > - parsed = parse_real(value, &option- >values.real_val, 0, NULL); > > - if (validate && !parsed) > > - ereport(ERROR, > > - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > - errmsg("invalid value for floating point option \"%s\": %s", > > - option->gen->name, value))); > > - if (validate && (option->values.real_val < optreal->min || > > - option- >values.real_val > optreal->max)) > > - ereport(ERROR, > > - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > - errmsg("value %s out of bounds for option \"%s\"", > > - value, option->gen->name), > > - errdetail("Valid values are between \"%f\" and \"%f\".", > > - optreal->min, optreal->max))); > > - } > > - break; > > - case RELOPT_TYPE_ENUM: > > - { > > - relopt_enum *optenum = (relopt_enum *) option->gen; > > - relopt_enum_elt_def *elt; > > - > > - parsed = false; > > - for (elt = optenum->members; elt- >string_val; elt++) > > - { > > - if (pg_strcasecmp(value, elt- >string_val) == 0) > > - { > > - option->values.enum_val = elt->symbol_val; > > - parsed = true; > > - break; > > - } > > - } > > - if (validate && !parsed) > > - ereport(ERROR, > > - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > - errmsg("invalid value for enum option \"%s\": %s", > > - option->gen->name, value), > > - optenum->detailmsg ? > > - errdetail_internal("%s", _(optenum->detailmsg)) : 0)); > > - > > - /* > > - * If value is not among the allowed string values, but we are > > - * not asked to validate, just use the default numeric value. > > - */ > > - if (!parsed) > > - option->values.enum_val = optenum- >default_val; > > - } > > - break; > > - case RELOPT_TYPE_STRING: > > - { > > - relopt_string *optstring = (relopt_string *) option->gen; > > - > > - option->values.string_val = value; > > - nofree = true; > > - if (validate && optstring->validate_cb) > > - (optstring->validate_cb) (value); > > - parsed = true; > > - } > > - break; > > - default: > > - elog(ERROR, "unsupported reloption type %d", option- >gen->type); > > - parsed = true; /* quiet compiler */ > > - break; > > - } > > + foreach(lc, relopts->validators) > > + ((relopts_validator) lfirst(lc)) (opts, NULL, 0); > > +// ((relopts_validator) lfirst(lc)) (opts, vals, noptions); > > +// FIXME solve problem with validation of separate option values; > > + return opts; > > > > - if (parsed) > > - option->isset = true; > > - if (!nofree) > > - pfree(value); > > > > } > > > > /* > > > > - * Given the result from parseRelOptions, allocate a struct that's of the > > - * specified base size plus any extra space that's needed for string > > variables. - * > > - * "base" should be sizeof(struct) of the reloptions struct (StdRdOptions > > or - * equivalent). > > + * get_view_relopt_spec_set > > + * Returns an options catalog for view relation. > > > > */ > > > > -static void * > > -allocateReloptStruct(Size base, relopt_value *options, int numoptions) > > -{ > > - Size size = base; > > - int i; > > - > > - for (i = 0; i < numoptions; i++) > > - { > > - relopt_value *optval = &options[i]; > > - > > - if (optval->gen->type == RELOPT_TYPE_STRING) > > - { > > - relopt_string *optstr = (relopt_string *) optval- >gen; > > - > > - if (optstr->fill_cb) > > - { > > - const char *val = optval->isset ? optval- >values.string_val : > > - optstr->default_isnull ? NULL : optstr- >default_val; > > - > > - size += optstr->fill_cb(val, NULL); > > - } > > - else > > - size += GET_STRING_RELOPTION_LEN(*optval) + 1; > > - } > > - } > > - > > - return palloc0(size); > > -} > > +static options_spec_set *view_relopt_spec_set = NULL; > > > > -/* > > - * Given the result of parseRelOptions and a parsing table, fill in the > > - * struct (previously allocated with allocateReloptStruct) with the > > parsed > > - * values. > > - * > > - * rdopts is the pointer to the allocated struct to be filled. > > - * basesize is the sizeof(struct) that was passed to > > allocateReloptStruct. > > - * options, of length numoptions, is parseRelOptions' output. > > - * elems, of length numelems, is the table describing the allowed > > options. > > - * When validate is true, it is expected that all options appear in > > elems. > > - */ > > -static void > > -fillRelOptions(void *rdopts, Size basesize, > > - relopt_value *options, int numoptions, > > - bool validate, > > - const relopt_parse_elt *elems, int numelems) > > +options_spec_set * > > +get_view_relopt_spec_set(void) > > > > { > > > > - int i; > > - int offset = basesize; > > + if (view_relopt_spec_set) > > + return view_relopt_spec_set; > > > > - for (i = 0; i < numoptions; i++) > > - { > > - int j; > > - bool found = false; > > + view_relopt_spec_set = allocateOptionsSpecSet(NULL, > > + sizeof(ViewOptions), 2); > > > > - for (j = 0; j < numelems; j++) > > - { > > - if (strcmp(options[i].gen->name, elems[j].optname) == 0) > > - { > > - relopt_string *optstring; > > - char *itempos = ((char *) rdopts) + elems[j].offset; > > - char *string_val; > > - > > - switch (options[i].gen->type) > > - { > > - case RELOPT_TYPE_BOOL: > > - *(bool *) itempos = options[i].isset ? > > - options[i].values.bool_val : > > - ((relopt_bool *) options[i].gen)->default_val; > > - break; > > - case RELOPT_TYPE_INT: > > - *(int *) itempos = options[i].isset ? > > - options[i].values.int_val : > > - ((relopt_int *) options[i].gen)->default_val; > > - break; > > - case RELOPT_TYPE_REAL: > > - *(double *) itempos = options[i].isset ? > > - options[i].values.real_val : > > - ((relopt_real *) options[i].gen)->default_val; > > - break; > > - case RELOPT_TYPE_ENUM: > > - *(int *) itempos = options[i].isset ? > > - options[i].values.enum_val : > > - ((relopt_enum *) options[i].gen)->default_val; > > - break; > > - case RELOPT_TYPE_STRING: > > - optstring = (relopt_string *) options[i].gen; > > - if (options[i].isset) > > - string_val = options[i].values.string_val; > > - else if (!optstring- >default_isnull) > > - string_val = optstring->default_val; > > - else > > - string_val = NULL; > > - > > - if (optstring->fill_cb) > > - { > > - Size size = > > - optstring- >fill_cb(string_val, > > - (char *) rdopts + offset); > > - > > - if (size) > > - { > > - *(int *) itempos = offset; > > - offset += size; > > - } > > - else > > - *(int *) itempos = 0; > > - } > > - else if (string_val == NULL) > > - *(int *) itempos = 0; > > - else > > - { > > - strcpy((char *) rdopts + offset, string_val); > > - *(int *) itempos = offset; > > - offset += strlen(string_val) + 1; > > - } > > - break; > > - default: > > - elog(ERROR, "unsupported reloption type %d", > > - options[i].gen- >type); > > - break; > > - } > > - found = true; > > - break; > > - } > > - } > > - if (validate && !found) > > - elog(ERROR, "reloption \"%s\" not found in parse table", > > - options[i].gen->name); > > - } > > - SET_VARSIZE(rdopts, offset); > > -} > > + optionsSpecSetAddBool(view_relopt_spec_set, "security_barrier", > > + "View acts as a row security barrier", > > + AccessExclusiveLock, > > + 0, offsetof(ViewOptions, security_barrier), false); > > > > + optionsSpecSetAddEnum(view_relopt_spec_set, "check_option", > > + "View has WITH CHECK OPTION defined (local or cascaded)", > > + AccessExclusiveLock, 0, > > + offsetof(ViewOptions, check_option), > > + viewCheckOptValues, > > + VIEW_OPTION_CHECK_OPTION_NOT_SET, > > + gettext_noop("Valid values are \"local\" and \"cascaded\".")); > > > > -/* > > - * Option parser for anything that uses StdRdOptions. > > - */ > > -bytea * > > -default_reloptions(Datum reloptions, bool validate, relopt_kind kind) > > -{ > > - static const relopt_parse_elt tab[] = { > > - {"fillfactor", RELOPT_TYPE_INT, offsetof(StdRdOptions, fillfactor)}, > > - {"autovacuum_enabled", RELOPT_TYPE_BOOL, > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, enabled)}, > > - {"autovacuum_vacuum_threshold", RELOPT_TYPE_INT, > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > vacuum_threshold)}, - {"autovacuum_vacuum_insert_threshold", > > RELOPT_TYPE_INT, > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > vacuum_ins_threshold)}, - {"autovacuum_analyze_threshold", > > RELOPT_TYPE_INT, > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > analyze_threshold)}, - {"autovacuum_vacuum_cost_limit", RELOPT_TYPE_INT, > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > vacuum_cost_limit)}, - {"autovacuum_freeze_min_age", RELOPT_TYPE_INT, > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > freeze_min_age)}, - {"autovacuum_freeze_max_age", RELOPT_TYPE_INT, > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > freeze_max_age)}, - {"autovacuum_freeze_table_age", RELOPT_TYPE_INT, > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > freeze_table_age)}, - {"autovacuum_multixact_freeze_min_age", > > RELOPT_TYPE_INT, > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > multixact_freeze_min_age)}, - {"autovacuum_multixact_freeze_max_age", > > RELOPT_TYPE_INT, > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > multixact_freeze_max_age)}, - {"autovacuum_multixact_freeze_table_age", > > RELOPT_TYPE_INT, > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > multixact_freeze_table_age)}, - {"log_autovacuum_min_duration", > > RELOPT_TYPE_INT, > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > log_min_duration)}, - {"toast_tuple_target", RELOPT_TYPE_INT, > > - offsetof(StdRdOptions, toast_tuple_target)}, > > - {"autovacuum_vacuum_cost_delay", RELOPT_TYPE_REAL, > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > vacuum_cost_delay)}, - {"autovacuum_vacuum_scale_factor", > > RELOPT_TYPE_REAL, > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > vacuum_scale_factor)}, - {"autovacuum_vacuum_insert_scale_factor", > > RELOPT_TYPE_REAL, > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > vacuum_ins_scale_factor)}, - {"autovacuum_analyze_scale_factor", > > RELOPT_TYPE_REAL, > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > analyze_scale_factor)}, - {"user_catalog_table", RELOPT_TYPE_BOOL, > > - offsetof(StdRdOptions, user_catalog_table)}, > > - {"parallel_workers", RELOPT_TYPE_INT, > > - offsetof(StdRdOptions, parallel_workers)}, > > - {"vacuum_index_cleanup", RELOPT_TYPE_ENUM, > > - offsetof(StdRdOptions, vacuum_index_cleanup)}, > > - {"vacuum_truncate", RELOPT_TYPE_BOOL, > > - offsetof(StdRdOptions, vacuum_truncate)} > > - }; > > - > > - return (bytea *) build_reloptions(reloptions, validate, kind, > > - sizeof(StdRdOptions), > > - tab, lengthof(tab)); > > + return view_relopt_spec_set; > > > > } > > > > /* > > > > - * build_reloptions > > - * > > - * Parses "reloptions" provided by the caller, returning them in a > > - * structure containing the parsed options. The parsing is done with > > - * the help of a parsing table describing the allowed options, defined > > - * by "relopt_elems" of length "num_relopt_elems". > > - * > > - * "validate" must be true if reloptions value is freshly built by > > - * transformRelOptions(), as opposed to being read from the catalog, in > > which - * case the values contained in it must already be valid. > > - * > > - * NULL is returned if the passed-in options did not match any of the > > options - * in the parsing table, unless validate is true in which case > > an error would - * be reported. > > + * get_attribute_options_spec_set > > + * Returns an options spec det for heap attributes > > > > */ > > > > -void * > > -build_reloptions(Datum reloptions, bool validate, > > - relopt_kind kind, > > - Size relopt_struct_size, > > - const relopt_parse_elt *relopt_elems, > > - int num_relopt_elems) > > -{ > > - int numoptions; > > - relopt_value *options; > > - void *rdopts; > > - > > - /* parse options specific to given relation option kind */ > > - options = parseRelOptions(reloptions, validate, kind, &numoptions); > > - Assert(numoptions <= num_relopt_elems); > > - > > - /* if none set, we're done */ > > - if (numoptions == 0) > > - { > > - Assert(options == NULL); > > - return NULL; > > - } > > - > > - /* allocate and fill the structure */ > > - rdopts = allocateReloptStruct(relopt_struct_size, options, numoptions); > > - fillRelOptions(rdopts, relopt_struct_size, options, numoptions, > > - validate, relopt_elems, num_relopt_elems); > > +static options_spec_set *attribute_options_spec_set = NULL; > > > > - pfree(options); > > - > > - return rdopts; > > -} > > - > > -/* > > - * Parse local options, allocate a bytea struct that's of the specified > > - * 'base_size' plus any extra space that's needed for string variables, > > - * fill its option's fields located at the given offsets and return it. > > - */ > > -void * > > -build_local_reloptions(local_relopts *relopts, Datum options, bool > > validate) +options_spec_set * > > +get_attribute_options_spec_set(void) > > > > { > > > > - int noptions = list_length(relopts->options); > > - relopt_parse_elt *elems = palloc(sizeof(*elems) * noptions); > > - relopt_value *vals; > > - void *opts; > > - int i = 0; > > - ListCell *lc; > > + if (attribute_options_spec_set) > > + return attribute_options_spec_set; > > > > - foreach(lc, relopts->options) > > - { > > - local_relopt *opt = lfirst(lc); > > - > > - elems[i].optname = opt->option->name; > > - elems[i].opttype = opt->option->type; > > - elems[i].offset = opt->offset; > > - > > - i++; > > - } > > + attribute_options_spec_set = allocateOptionsSpecSet(NULL, > > + sizeof(AttributeOpts), 2); > > > > - vals = parseLocalRelOptions(relopts, options, validate); > > - opts = allocateReloptStruct(relopts->relopt_struct_size, vals, > > noptions); > > - fillRelOptions(opts, relopts->relopt_struct_size, vals, noptions, > > validate, - elems, noptions); > > + optionsSpecSetAddReal(attribute_options_spec_set, "n_distinct", > > + "Sets the planner's estimate of the number of distinct values > > appearing in a column (excluding child relations).", + > > ShareUpdateExclusiveLock, > > + 0, offsetof(AttributeOpts, n_distinct), 0, -1.0, DBL_MAX); > > > > - foreach(lc, relopts->validators) > > - ((relopts_validator) lfirst(lc)) (opts, vals, noptions); > > - > > - if (elems) > > - pfree(elems); > > + optionsSpecSetAddReal(attribute_options_spec_set, > > + "n_distinct_inherited", > > + "Sets the planner's estimate of the number of distinct values > > appearing in a column (including child relations).", + > > ShareUpdateExclusiveLock, > > + 0, offsetof(AttributeOpts, n_distinct_inherited), 0, -1.0, DBL_MAX); > > > > - return opts; > > + return attribute_options_spec_set; > > > > } > > > > -/* > > - * Option parser for partitioned tables > > - */ > > -bytea * > > -partitioned_table_reloptions(Datum reloptions, bool validate) > > -{ > > - /* > > - * There are no options for partitioned tables yet, but this is able to > > do - * some validation. > > - */ > > - return (bytea *) build_reloptions(reloptions, validate, > > - RELOPT_KIND_PARTITIONED, > > - 0, NULL, 0); > > -} > > > > /* > > > > - * Option parser for views > > - */ > > -bytea * > > -view_reloptions(Datum reloptions, bool validate) > > -{ > > - static const relopt_parse_elt tab[] = { > > - {"security_barrier", RELOPT_TYPE_BOOL, > > - offsetof(ViewOptions, security_barrier)}, > > - {"check_option", RELOPT_TYPE_ENUM, > > - offsetof(ViewOptions, check_option)} > > - }; > > - > > - return (bytea *) build_reloptions(reloptions, validate, > > - RELOPT_KIND_VIEW, > > - sizeof(ViewOptions), > > - tab, lengthof(tab)); > > -} > > + * get_tablespace_options_spec_set > > + * Returns an options spec set for tablespaces > > +*/ > > +static options_spec_set *tablespace_options_spec_set = NULL; > > > > -/* > > - * Parse options for heaps, views and toast tables. > > - */ > > -bytea * > > -heap_reloptions(char relkind, Datum reloptions, bool validate) > > +options_spec_set * > > +get_tablespace_options_spec_set(void) > > > > { > > > > - StdRdOptions *rdopts; > > - > > - switch (relkind) > > + if (!tablespace_options_spec_set) > > > > { > > > > - case RELKIND_TOASTVALUE: > > - rdopts = (StdRdOptions *) > > - default_reloptions(reloptions, validate, RELOPT_KIND_TOAST); > > - if (rdopts != NULL) > > - { > > - /* adjust default-only parameters for TOAST relations */ > > - rdopts->fillfactor = 100; > > - rdopts->autovacuum.analyze_threshold = -1; > > - rdopts->autovacuum.analyze_scale_factor = -1; > > - } > > - return (bytea *) rdopts; > > - case RELKIND_RELATION: > > - case RELKIND_MATVIEW: > > - return default_reloptions(reloptions, validate, RELOPT_KIND_HEAP); > > - default: > > - /* other relkinds are not supported */ > > - return NULL; > > - } > > -} > > - > > - > > -/* > > - * Parse options for indexes. > > - * > > - * amoptions index AM's option parser function > > - * reloptions options as text[] datum > > - * validate error flag > > - */ > > -bytea * > > -index_reloptions(amoptions_function amoptions, Datum reloptions, bool > > validate) -{ > > - Assert(amoptions != NULL); > > + tablespace_options_spec_set = allocateOptionsSpecSet(NULL, > > + sizeof(TableSpaceOpts), 4); > > > > - /* Assume function is strict */ > > - if (!PointerIsValid(DatumGetPointer(reloptions))) > > - return NULL; > > + optionsSpecSetAddReal(tablespace_options_spec_set, > > + "random_page_cost", > > + "Sets the planner's estimate of the cost of a nonsequentially > > fetched disk page", + ShareUpdateExclusiveLock, > > + 0, offsetof(TableSpaceOpts, random_page_cost), -1, 0.0, DBL_MAX); > > > > - return amoptions(reloptions, validate); > > -} > > + optionsSpecSetAddReal(tablespace_options_spec_set, "seq_page_cost", > > + "Sets the planner's estimate of the cost of a sequentially > > fetched disk page", + ShareUpdateExclusiveLock, > > + 0, offsetof(TableSpaceOpts, seq_page_cost), -1, 0.0, DBL_MAX); > > > > -/* > > - * Option parser for attribute reloptions > > - */ > > -bytea * > > -attribute_reloptions(Datum reloptions, bool validate) > > -{ > > - static const relopt_parse_elt tab[] = { > > - {"n_distinct", RELOPT_TYPE_REAL, offsetof(AttributeOpts, n_distinct)}, > > - {"n_distinct_inherited", RELOPT_TYPE_REAL, offsetof(AttributeOpts, > > n_distinct_inherited)} - }; > > - > > - return (bytea *) build_reloptions(reloptions, validate, > > - RELOPT_KIND_ATTRIBUTE, > > - sizeof(AttributeOpts), > > - tab, lengthof(tab)); > > -} > > + optionsSpecSetAddInt(tablespace_options_spec_set, > > + "effective_io_concurrency", > > + "Number of simultaneous requests that can be handled efficiently > > by the disk subsystem", + ShareUpdateExclusiveLock, > > + 0, offsetof(TableSpaceOpts, effective_io_concurrency), > > +#ifdef USE_PREFETCH > > + -1, 0, MAX_IO_CONCURRENCY > > +#else > > + 0, 0, 0 > > +#endif > > + ); > > > > -/* > > - * Option parser for tablespace reloptions > > - */ > > -bytea * > > -tablespace_reloptions(Datum reloptions, bool validate) > > -{ > > - static const relopt_parse_elt tab[] = { > > - {"random_page_cost", RELOPT_TYPE_REAL, offsetof(TableSpaceOpts, > > random_page_cost)}, - {"seq_page_cost", RELOPT_TYPE_REAL, > > offsetof(TableSpaceOpts, seq_page_cost)}, - {"effective_io_concurrency", > > RELOPT_TYPE_INT, offsetof(TableSpaceOpts, effective_io_concurrency)}, > > - {"maintenance_io_concurrency", RELOPT_TYPE_INT, > > offsetof(TableSpaceOpts, maintenance_io_concurrency)} - }; > > - > > - return (bytea *) build_reloptions(reloptions, validate, > > - RELOPT_KIND_TABLESPACE, > > - sizeof(TableSpaceOpts), > > - tab, lengthof(tab)); > > + optionsSpecSetAddInt(tablespace_options_spec_set, > > + "maintenance_io_concurrency", > > + "Number of simultaneous requests that can be handled efficiently > > by the disk subsystem for maintenance work.", + > > ShareUpdateExclusiveLock, > > + 0, offsetof(TableSpaceOpts, maintenance_io_concurrency), > > +#ifdef USE_PREFETCH > > + -1, 0, MAX_IO_CONCURRENCY > > +#else > > + 0, 0, 0 > > +#endif > > + ); > > + } > > + return tablespace_options_spec_set; > > > > } > > > > /* > > > > @@ -2099,33 +612,55 @@ tablespace_reloptions(Datum reloptions, bool > > validate)> > > * for a longer explanation of how this works. > > */ > > > > LOCKMODE > > > > -AlterTableGetRelOptionsLockLevel(List *defList) > > +AlterTableGetRelOptionsLockLevel(Relation rel, List *defList) > > > > { > > > > LOCKMODE lockmode = NoLock; > > ListCell *cell; > > > > + options_spec_set *spec_set = NULL; > > > > if (defList == NIL) > > > > return AccessExclusiveLock; > > > > - if (need_initialization) > > - initialize_reloptions(); > > + switch (rel->rd_rel->relkind) > > + { > > + case RELKIND_TOASTVALUE: > > + spec_set = get_toast_relopt_spec_set(); > > + break; > > + case RELKIND_RELATION: > > + case RELKIND_MATVIEW: > > + spec_set = get_heap_relopt_spec_set(); > > + break; > > + case RELKIND_INDEX: > > + spec_set = rel->rd_indam->amreloptspecset(); > > + break; > > + case RELKIND_VIEW: > > + spec_set = get_view_relopt_spec_set(); > > + break; > > + case RELKIND_PARTITIONED_TABLE: > > + spec_set = get_partitioned_relopt_spec_set(); > > + break; > > + default: > > + Assert(false); /* can't get here */ > > + break; > > + } > > + Assert(spec_set); /* No spec set - no reloption change. Should > > + * never get here */ > > > > foreach(cell, defList) > > { > > > > DefElem *def = (DefElem *) lfirst(cell); > > > > + > > > > int i; > > > > - for (i = 0; relOpts[i]; i++) > > + for (i = 0; i < spec_set->num; i++) > > > > { > > > > - if (strncmp(relOpts[i]->name, > > - def->defname, > > - relOpts[i]->namelen + 1) == 0) > > - { > > - if (lockmode < relOpts[i]->lockmode) > > - lockmode = relOpts[i]->lockmode; > > - } > > + option_spec_basic *gen = spec_set->definitions[i]; > > + > > + if (pg_strcasecmp(gen->name, > > + def->defname) == 0) > > + if (lockmode < gen->lockmode) > > + lockmode = gen->lockmode; > > > > } > > > > } > > > > - > > > > return lockmode; > > > > -} > > +} > > \ No newline at end of file > > diff --git a/src/backend/access/gin/gininsert.c > > b/src/backend/access/gin/gininsert.c index 0e8672c..0cbffad 100644 > > --- a/src/backend/access/gin/gininsert.c > > +++ b/src/backend/access/gin/gininsert.c > > @@ -512,6 +512,8 @@ gininsert(Relation index, Datum *values, bool *isnull, > > > > oldCtx = MemoryContextSwitchTo(insertCtx); > > > > +// elog(WARNING, "GinGetUseFastUpdate = %i", GinGetUseFastUpdate(index)); > > + > > > > if (GinGetUseFastUpdate(index)) > > { > > > > GinTupleCollector collector; > > > > diff --git a/src/backend/access/gin/ginutil.c > > b/src/backend/access/gin/ginutil.c index 6d2d71b..d1fa3a0 100644 > > --- a/src/backend/access/gin/ginutil.c > > +++ b/src/backend/access/gin/ginutil.c > > @@ -16,7 +16,7 @@ > > > > #include "access/gin_private.h" > > #include "access/ginxlog.h" > > > > -#include "access/reloptions.h" > > +#include "access/options.h" > > > > #include "access/xloginsert.h" > > #include "catalog/pg_collation.h" > > #include "catalog/pg_type.h" > > > > @@ -28,6 +28,7 @@ > > > > #include "utils/builtins.h" > > #include "utils/index_selfuncs.h" > > #include "utils/typcache.h" > > > > +#include "utils/guc.h" > > > > /* > > > > @@ -67,7 +68,6 @@ ginhandler(PG_FUNCTION_ARGS) > > > > amroutine->amvacuumcleanup = ginvacuumcleanup; > > amroutine->amcanreturn = NULL; > > amroutine->amcostestimate = gincostestimate; > > > > - amroutine->amoptions = ginoptions; > > > > amroutine->amproperty = NULL; > > amroutine->ambuildphasename = NULL; > > amroutine->amvalidate = ginvalidate; > > > > @@ -82,6 +82,7 @@ ginhandler(PG_FUNCTION_ARGS) > > > > amroutine->amestimateparallelscan = NULL; > > amroutine->aminitparallelscan = NULL; > > amroutine->amparallelrescan = NULL; > > > > + amroutine->amreloptspecset = gingetreloptspecset; > > > > PG_RETURN_POINTER(amroutine); > > > > } > > > > @@ -604,6 +605,7 @@ ginExtractEntries(GinState *ginstate, OffsetNumber > > attnum,> > > return entries; > > > > } > > > > +/* > > > > bytea * > > ginoptions(Datum reloptions, bool validate) > > { > > > > @@ -618,6 +620,7 @@ ginoptions(Datum reloptions, bool validate) > > > > sizeof(GinOptions), > > tab, lengthof(tab)); > > > > } > > > > +*/ > > > > /* > > > > * Fetch index's statistical data into *stats > > > > @@ -705,3 +708,31 @@ ginUpdateStats(Relation index, const GinStatsData > > *stats, bool is_build)> > > END_CRIT_SECTION(); > > > > } > > > > + > > +static options_spec_set *gin_relopt_specset = NULL; > > + > > +void * > > +gingetreloptspecset(void) > > +{ > > + if (gin_relopt_specset) > > + return gin_relopt_specset; > > + > > + gin_relopt_specset = allocateOptionsSpecSet(NULL, > > + sizeof(GinOptions), 2); > > + > > + optionsSpecSetAddBool(gin_relopt_specset, "fastupdate", > > + "Enables \"fast update\" feature for this GIN index", > > + AccessExclusiveLock, > > + 0, > > + offsetof(GinOptions, useFastUpdate), > > + GIN_DEFAULT_USE_FASTUPDATE); > > + > > + optionsSpecSetAddInt(gin_relopt_specset, "gin_pending_list_limit", > > + "Maximum size of the pending list for this GIN index, in kilobytes", > > + AccessExclusiveLock, > > + 0, > > + offsetof(GinOptions, pendingListCleanupSize), > > + -1, 64, MAX_KILOBYTES); > > + > > + return gin_relopt_specset; > > +} > > diff --git a/src/backend/access/gist/gist.c > > b/src/backend/access/gist/gist.c index 0683f42..cbbc6a5 100644 > > --- a/src/backend/access/gist/gist.c > > +++ b/src/backend/access/gist/gist.c > > @@ -88,7 +88,6 @@ gisthandler(PG_FUNCTION_ARGS) > > > > amroutine->amvacuumcleanup = gistvacuumcleanup; > > amroutine->amcanreturn = gistcanreturn; > > amroutine->amcostestimate = gistcostestimate; > > > > - amroutine->amoptions = gistoptions; > > > > amroutine->amproperty = gistproperty; > > amroutine->ambuildphasename = NULL; > > amroutine->amvalidate = gistvalidate; > > > > @@ -103,6 +102,7 @@ gisthandler(PG_FUNCTION_ARGS) > > > > amroutine->amestimateparallelscan = NULL; > > amroutine->aminitparallelscan = NULL; > > amroutine->amparallelrescan = NULL; > > > > + amroutine->amreloptspecset = gistgetreloptspecset; > > > > PG_RETURN_POINTER(amroutine); > > > > } > > > > diff --git a/src/backend/access/gist/gistbuild.c > > b/src/backend/access/gist/gistbuild.c index baad28c..931d249 100644 > > --- a/src/backend/access/gist/gistbuild.c > > +++ b/src/backend/access/gist/gistbuild.c > > @@ -215,6 +215,7 @@ gistbuild(Relation heap, Relation index, IndexInfo > > *indexInfo)> > > buildstate.buildMode = GIST_BUFFERING_DISABLED; > > > > else /* must be "auto" */ > > > > buildstate.buildMode = GIST_BUFFERING_AUTO; > > > > +//elog(WARNING, "biffering_mode = %i", options->buffering_mode); > > > > } > > else > > { > > > > diff --git a/src/backend/access/gist/gistutil.c > > b/src/backend/access/gist/gistutil.c index 43ba03b..0391915 100644 > > --- a/src/backend/access/gist/gistutil.c > > +++ b/src/backend/access/gist/gistutil.c > > @@ -17,7 +17,7 @@ > > > > #include "access/gist_private.h" > > #include "access/htup_details.h" > > > > -#include "access/reloptions.h" > > +#include "access/options.h" > > > > #include "catalog/pg_opclass.h" > > #include "storage/indexfsm.h" > > #include "storage/lmgr.h" > > > > @@ -916,20 +916,6 @@ gistPageRecyclable(Page page) > > > > return false; > > > > } > > > > -bytea * > > -gistoptions(Datum reloptions, bool validate) > > -{ > > - static const relopt_parse_elt tab[] = { > > - {"fillfactor", RELOPT_TYPE_INT, offsetof(GiSTOptions, fillfactor)}, > > - {"buffering", RELOPT_TYPE_ENUM, offsetof(GiSTOptions, buffering_mode)} > > - }; > > - > > - return (bytea *) build_reloptions(reloptions, validate, > > - RELOPT_KIND_GIST, > > - sizeof(GiSTOptions), > > - tab, lengthof(tab)); > > -} > > - > > > > /* > > > > * gistproperty() -- Check boolean properties of indexes. > > * > > > > @@ -1064,3 +1050,42 @@ gistGetFakeLSN(Relation rel) > > > > return GetFakeLSNForUnloggedRel(); > > > > } > > > > } > > > > + > > +/* values from GistOptBufferingMode */ > > +opt_enum_elt_def gistBufferingOptValues[] = > > +{ > > + {"auto", GIST_OPTION_BUFFERING_AUTO}, > > + {"on", GIST_OPTION_BUFFERING_ON}, > > + {"off", GIST_OPTION_BUFFERING_OFF}, > > + {(const char *) NULL} /* list terminator */ > > +}; > > + > > +static options_spec_set *gist_relopt_specset = NULL; > > + > > +void * > > +gistgetreloptspecset(void) > > +{ > > + if (gist_relopt_specset) > > + return gist_relopt_specset; > > + > > + gist_relopt_specset = allocateOptionsSpecSet(NULL, > > + sizeof(GiSTOptions), 2); > > + > > + optionsSpecSetAddInt(gist_relopt_specset, "fillfactor", > > + "Packs gist index pages only to this percentage", > > + NoLock, /* No ALTER, no lock */ > > + 0, > > + offsetof(GiSTOptions, fillfactor), > > + GIST_DEFAULT_FILLFACTOR, > > + GIST_MIN_FILLFACTOR, 100); > > + > > + optionsSpecSetAddEnum(gist_relopt_specset, "buffering", > > + "Enables buffering build for this GiST index", > > + NoLock, /* No ALTER, no lock */ > > + 0, > > + offsetof(GiSTOptions, buffering_mode), > > + gistBufferingOptValues, > > + GIST_OPTION_BUFFERING_AUTO, > > + gettext_noop("Valid values are \"on\", \"off\", and > > \"auto\".")); > > + return gist_relopt_specset; > > +} > > diff --git a/src/backend/access/hash/hash.c > > b/src/backend/access/hash/hash.c index eb38104..8dc4ca7 100644 > > --- a/src/backend/access/hash/hash.c > > +++ b/src/backend/access/hash/hash.c > > @@ -85,7 +85,6 @@ hashhandler(PG_FUNCTION_ARGS) > > > > amroutine->amvacuumcleanup = hashvacuumcleanup; > > amroutine->amcanreturn = NULL; > > amroutine->amcostestimate = hashcostestimate; > > > > - amroutine->amoptions = hashoptions; > > > > amroutine->amproperty = NULL; > > amroutine->ambuildphasename = NULL; > > amroutine->amvalidate = hashvalidate; > > > > @@ -100,6 +99,7 @@ hashhandler(PG_FUNCTION_ARGS) > > > > amroutine->amestimateparallelscan = NULL; > > amroutine->aminitparallelscan = NULL; > > amroutine->amparallelrescan = NULL; > > > > + amroutine->amreloptspecset = hashgetreloptspecset; > > > > PG_RETURN_POINTER(amroutine); > > > > } > > > > diff --git a/src/backend/access/hash/hashpage.c > > b/src/backend/access/hash/hashpage.c index 159646c..38f64ef 100644 > > --- a/src/backend/access/hash/hashpage.c > > +++ b/src/backend/access/hash/hashpage.c > > @@ -359,6 +359,8 @@ _hash_init(Relation rel, double num_tuples, ForkNumber > > forkNum)> > > data_width = sizeof(uint32); > > item_width = MAXALIGN(sizeof(IndexTupleData)) + MAXALIGN(data_width) + > > > > sizeof(ItemIdData); /* include the line pointer */ > > > > +//elog(WARNING, "fillfactor = %i", HashGetFillFactor(rel)); > > + > > > > ffactor = HashGetTargetPageUsage(rel) / item_width; > > /* keep to a sane range */ > > if (ffactor < 10) > > > > diff --git a/src/backend/access/hash/hashutil.c > > b/src/backend/access/hash/hashutil.c index 5198728..826beab 100644 > > --- a/src/backend/access/hash/hashutil.c > > +++ b/src/backend/access/hash/hashutil.c > > @@ -15,7 +15,7 @@ > > > > #include "postgres.h" > > > > #include "access/hash.h" > > > > -#include "access/reloptions.h" > > +#include "access/options.h" > > > > #include "access/relscan.h" > > #include "port/pg_bitutils.h" > > #include "storage/buf_internals.h" > > > > @@ -272,19 +272,6 @@ _hash_checkpage(Relation rel, Buffer buf, int flags) > > > > } > > > > } > > > > -bytea * > > -hashoptions(Datum reloptions, bool validate) > > -{ > > - static const relopt_parse_elt tab[] = { > > - {"fillfactor", RELOPT_TYPE_INT, offsetof(HashOptions, fillfactor)}, > > - }; > > - > > - return (bytea *) build_reloptions(reloptions, validate, > > - RELOPT_KIND_HASH, > > - sizeof(HashOptions), > > - tab, lengthof(tab)); > > -} > > - > > > > /* > > > > * _hash_get_indextuple_hashkey - get the hash index tuple's hash key > > value > > */ > > > > @@ -620,3 +607,24 @@ _hash_kill_items(IndexScanDesc scan) > > > > else > > > > _hash_relbuf(rel, buf); > > > > } > > > > + > > +static options_spec_set *hash_relopt_specset = NULL; > > + > > +void * > > +hashgetreloptspecset(void) > > +{ > > + if (hash_relopt_specset) > > + return hash_relopt_specset; > > + > > + hash_relopt_specset = allocateOptionsSpecSet(NULL, > > + sizeof(HashOptions), 1); > > + optionsSpecSetAddInt(hash_relopt_specset, "fillfactor", > > + "Packs hash index pages only to this percentage", > > + NoLock, /* No ALTER -- no lock */ > > + 0, > > + offsetof(HashOptions, fillfactor), > > + HASH_DEFAULT_FILLFACTOR, > > + HASH_MIN_FILLFACTOR, 100); > > + > > + return hash_relopt_specset; > > +} > > diff --git a/src/backend/access/nbtree/nbtinsert.c > > b/src/backend/access/nbtree/nbtinsert.c index 7355e1d..f7b117e 100644 > > --- a/src/backend/access/nbtree/nbtinsert.c > > +++ b/src/backend/access/nbtree/nbtinsert.c > > @@ -2745,6 +2745,8 @@ _bt_delete_or_dedup_one_page(Relation rel, Relation > > heapRel,> > > _bt_bottomupdel_pass(rel, buffer, heapRel, insertstate- >itemsz)) > > return; > > > > +// elog(WARNING, "Deduplicate_items = %i", BTGetDeduplicateItems(rel)); > > + > > > > /* Perform deduplication pass (when enabled and index-is- allequalimage) > > */ > > if (BTGetDeduplicateItems(rel) && itup_key->allequalimage) > > > > _bt_dedup_pass(rel, buffer, heapRel, insertstate->itup, > > > > diff --git a/src/backend/access/nbtree/nbtree.c > > b/src/backend/access/nbtree/nbtree.c index 40ad095..f171c54 100644 > > --- a/src/backend/access/nbtree/nbtree.c > > +++ b/src/backend/access/nbtree/nbtree.c > > @@ -22,6 +22,7 @@ > > > > #include "access/nbtxlog.h" > > #include "access/relscan.h" > > #include "access/xlog.h" > > > > +#include "access/options.h" > > > > #include "commands/progress.h" > > #include "commands/vacuum.h" > > #include "miscadmin.h" > > > > @@ -124,7 +125,6 @@ bthandler(PG_FUNCTION_ARGS) > > > > amroutine->amvacuumcleanup = btvacuumcleanup; > > amroutine->amcanreturn = btcanreturn; > > amroutine->amcostestimate = btcostestimate; > > > > - amroutine->amoptions = btoptions; > > > > amroutine->amproperty = btproperty; > > amroutine->ambuildphasename = btbuildphasename; > > amroutine->amvalidate = btvalidate; > > > > @@ -139,6 +139,7 @@ bthandler(PG_FUNCTION_ARGS) > > > > amroutine->amestimateparallelscan = btestimateparallelscan; > > amroutine->aminitparallelscan = btinitparallelscan; > > amroutine->amparallelrescan = btparallelrescan; > > > > + amroutine->amreloptspecset = btgetreloptspecset; > > > > PG_RETURN_POINTER(amroutine); > > > > } > > > > @@ -1418,3 +1419,37 @@ btcanreturn(Relation index, int attno) > > > > { > > > > return true; > > > > } > > > > + > > +static options_spec_set *bt_relopt_specset = NULL; > > + > > +void * > > +btgetreloptspecset(void) > > +{ > > + if (bt_relopt_specset) > > + return bt_relopt_specset; > > + > > + bt_relopt_specset = allocateOptionsSpecSet(NULL, > > + sizeof(BTOptions), 3); > > + > > + optionsSpecSetAddInt( > > + bt_relopt_specset, "fillfactor", > > + "Packs btree index pages only to this percentage", > > + ShareUpdateExclusiveLock, /* since it applies only to later inserts */ > > + 0, offsetof(BTOptions, fillfactor), > > + BTREE_DEFAULT_FILLFACTOR, BTREE_MIN_FILLFACTOR, 100 > > + ); > > + optionsSpecSetAddReal( > > + bt_relopt_specset, "vacuum_cleanup_index_scale_factor", > > + "Number of tuple inserts prior to index cleanup as a fraction of > > reltuples", + ShareUpdateExclusiveLock, > > + 0, offsetof(BTOptions,vacuum_cleanup_index_scale_factor), > > + -1, 0.0, 1e10 > > + ); > > + optionsSpecSetAddBool( > > + bt_relopt_specset, "deduplicate_items", > > + "Enables \"deduplicate items\" feature for this btree index", > > + ShareUpdateExclusiveLock, /* since it applies only to later inserts */ > > + 0, offsetof(BTOptions,deduplicate_items), true > > + ); > > + return bt_relopt_specset; > > +} > > diff --git a/src/backend/access/nbtree/nbtutils.c > > b/src/backend/access/nbtree/nbtutils.c index c72b456..2588a30 100644 > > --- a/src/backend/access/nbtree/nbtutils.c > > +++ b/src/backend/access/nbtree/nbtutils.c > > @@ -18,7 +18,7 @@ > > > > #include <time.h> > > > > #include "access/nbtree.h" > > > > -#include "access/reloptions.h" > > +#include "storage/lock.h" > > > > #include "access/relscan.h" > > #include "catalog/catalog.h" > > #include "commands/progress.h" > > > > @@ -2100,25 +2100,6 @@ BTreeShmemInit(void) > > > > Assert(found); > > > > } > > > > -bytea * > > -btoptions(Datum reloptions, bool validate) > > -{ > > - static const relopt_parse_elt tab[] = { > > - {"fillfactor", RELOPT_TYPE_INT, offsetof(BTOptions, fillfactor)}, > > - {"vacuum_cleanup_index_scale_factor", RELOPT_TYPE_REAL, > > - offsetof(BTOptions, vacuum_cleanup_index_scale_factor)}, > > - {"deduplicate_items", RELOPT_TYPE_BOOL, > > - offsetof(BTOptions, deduplicate_items)} > > - > > - }; > > - > > - return (bytea *) build_reloptions(reloptions, validate, > > - RELOPT_KIND_BTREE, > > - sizeof(BTOptions), > > - tab, lengthof(tab)); > > - > > -} > > - > > > > /* > > > > * btproperty() -- Check boolean properties of indexes. > > * > > > > diff --git a/src/backend/access/spgist/spgutils.c > > b/src/backend/access/spgist/spgutils.c index 03a9cd3..14429ad 100644 > > --- a/src/backend/access/spgist/spgutils.c > > +++ b/src/backend/access/spgist/spgutils.c > > @@ -17,7 +17,7 @@ > > > > #include "access/amvalidate.h" > > #include "access/htup_details.h" > > > > -#include "access/reloptions.h" > > +#include "access/options.h" > > > > #include "access/spgist_private.h" > > #include "access/toast_compression.h" > > #include "access/transam.h" > > > > @@ -72,7 +72,6 @@ spghandler(PG_FUNCTION_ARGS) > > > > amroutine->amvacuumcleanup = spgvacuumcleanup; > > amroutine->amcanreturn = spgcanreturn; > > amroutine->amcostestimate = spgcostestimate; > > > > - amroutine->amoptions = spgoptions; > > > > amroutine->amproperty = spgproperty; > > amroutine->ambuildphasename = NULL; > > amroutine->amvalidate = spgvalidate; > > > > @@ -87,6 +86,7 @@ spghandler(PG_FUNCTION_ARGS) > > > > amroutine->amestimateparallelscan = NULL; > > amroutine->aminitparallelscan = NULL; > > amroutine->amparallelrescan = NULL; > > > > + amroutine->amreloptspecset = spggetreloptspecset; > > > > PG_RETURN_POINTER(amroutine); > > > > } > > > > @@ -550,6 +550,7 @@ SpGistGetBuffer(Relation index, int flags, int > > needSpace, bool *isNew)> > > * related to the ones already on it. But fillfactor mustn't cause an > > * error for requests that would otherwise be legal. > > */ > > > > +//elog(WARNING, "fillfactor = %i", SpGistGetFillFactor(index)); > > > > needSpace += SpGistGetTargetPageFreeSpace(index); > > needSpace = Min(needSpace, SPGIST_PAGE_CAPACITY); > > > > @@ -721,23 +722,6 @@ SpGistInitMetapage(Page page) > > > > } > > > > /* > > > > - * reloptions processing for SPGiST > > - */ > > -bytea * > > -spgoptions(Datum reloptions, bool validate) > > -{ > > - static const relopt_parse_elt tab[] = { > > - {"fillfactor", RELOPT_TYPE_INT, offsetof(SpGistOptions, fillfactor)}, > > - }; > > - > > - return (bytea *) build_reloptions(reloptions, validate, > > - RELOPT_KIND_SPGIST, > > - sizeof(SpGistOptions), > > - tab, lengthof(tab)); > > - > > -} > > - > > -/* > > > > * Get the space needed to store a non-null datum of the indicated type > > * in an inner tuple (that is, as a prefix or node label). > > * Note the result is already rounded up to a MAXALIGN boundary. > > > > @@ -1336,3 +1320,25 @@ spgproperty(Oid index_oid, int attno, > > > > return true; > > > > } > > > > + > > +static options_spec_set *spgist_relopt_specset = NULL; > > + > > +void * > > +spggetreloptspecset(void) > > +{ > > + if (!spgist_relopt_specset) > > + { > > + spgist_relopt_specset = allocateOptionsSpecSet(NULL, > > + sizeof(SpGistOptions), 1); > > + > > + optionsSpecSetAddInt(spgist_relopt_specset, "fillfactor", > > + "Packs spgist index pages only to this percentage", > > + ShareUpdateExclusiveLock, /* since it applies only > > + * to later inserts */ > > + 0, > > + offsetof(SpGistOptions, fillfactor), > > + SPGIST_DEFAULT_FILLFACTOR, > > + SPGIST_MIN_FILLFACTOR, 100); > > + } > > + return spgist_relopt_specset; > > +} > > diff --git a/src/backend/commands/createas.c > > b/src/backend/commands/createas.c index 0982851..4f3dbb8 100644 > > --- a/src/backend/commands/createas.c > > +++ b/src/backend/commands/createas.c > > @@ -90,6 +90,7 @@ create_ctas_internal(List *attrList, IntoClause *into) > > > > Datum toast_options; > > static char *validnsps[] = HEAP_RELOPT_NAMESPACES; > > ObjectAddress intoRelationAddr; > > > > + List *toastDefList; > > > > /* This code supports both CREATE TABLE AS and CREATE MATERIALIZED VIEW > > */ > > is_matview = (into->viewQuery != NULL); > > > > @@ -124,14 +125,12 @@ create_ctas_internal(List *attrList, IntoClause > > *into)> > > CommandCounterIncrement(); > > > > /* parse and validate reloptions for the toast table */ > > > > - toast_options = transformRelOptions((Datum) 0, > > - create->options, > > - "toast", > > - validnsps, > > - true, false); > > > > - (void) heap_reloptions(RELKIND_TOASTVALUE, toast_options, true); > > + optionsDefListValdateNamespaces(create->options, validnsps); > > + toastDefList = optionsDefListFilterNamespaces(create->options, "toast"); > > > > + toast_options = transformOptions(get_toast_relopt_spec_set(), (Datum) 0, > > + toastDefList, 0); > > > > NewRelationCreateToastTable(intoRelationAddr.objectId, toast_options); > > > > /* Create the "view" part of a materialized view. */ > > > > diff --git a/src/backend/commands/foreigncmds.c > > b/src/backend/commands/foreigncmds.c index 146fa57..758ca34 100644 > > --- a/src/backend/commands/foreigncmds.c > > +++ b/src/backend/commands/foreigncmds.c > > @@ -112,7 +112,7 @@ transformGenericOptions(Oid catalogId, > > > > List *options, > > Oid fdwvalidator) > > > > { > > > > - List *resultOptions = untransformRelOptions(oldOptions); > > + List *resultOptions = optionsTextArrayToDefList(oldOptions); > > > > ListCell *optcell; > > Datum result; > > > > diff --git a/src/backend/commands/indexcmds.c > > b/src/backend/commands/indexcmds.c index c14ca27..96d465a 100644 > > --- a/src/backend/commands/indexcmds.c > > +++ b/src/backend/commands/indexcmds.c > > @@ -19,6 +19,7 @@ > > > > #include "access/heapam.h" > > #include "access/htup_details.h" > > #include "access/reloptions.h" > > > > +#include "access/options.h" > > > > #include "access/sysattr.h" > > #include "access/tableam.h" > > #include "access/xact.h" > > > > @@ -531,7 +532,7 @@ DefineIndex(Oid relationId, > > > > Form_pg_am accessMethodForm; > > IndexAmRoutine *amRoutine; > > bool amcanorder; > > > > - amoptions_function amoptions; > > + amreloptspecset_function amreloptspecsetfn; > > > > bool partitioned; > > bool safe_index; > > Datum reloptions; > > > > @@ -837,7 +838,7 @@ DefineIndex(Oid relationId, > > > > accessMethodName))); > > > > amcanorder = amRoutine->amcanorder; > > > > - amoptions = amRoutine->amoptions; > > + amreloptspecsetfn = amRoutine->amreloptspecset; > > > > pfree(amRoutine); > > ReleaseSysCache(tuple); > > > > @@ -851,10 +852,19 @@ DefineIndex(Oid relationId, > > > > /* > > > > * Parse AM-specific options, convert to text array form, validate. > > */ > > > > - reloptions = transformRelOptions((Datum) 0, stmt->options, > > - NULL, NULL, false, false); > > > > - (void) index_reloptions(amoptions, reloptions, true); > > + if (amreloptspecsetfn) > > + { > > + reloptions = transformOptions(amreloptspecsetfn(), > > + (Datum) 0, stmt->options, 0); > > + } > > + else > > + { > > + ereport(ERROR, > > + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), > > + errmsg("access method %s does not support options", > > + accessMethodName))); > > + } > > > > /* > > > > * Prepare arguments for index_create, primarily an IndexInfo structure. > > > > @@ -1986,8 +1996,7 @@ ComputeIndexAttrs(IndexInfo *indexInfo, > > > > palloc0(sizeof(Datum) * indexInfo- >ii_NumIndexAttrs); > > > > indexInfo->ii_OpclassOptions[attn] = > > > > - transformRelOptions((Datum) 0, attribute- >opclassopts, > > - NULL, NULL, false, false); > > + optionsDefListToTextArray(attribute- >opclassopts); > > > > } > > > > attn++; > > > > diff --git a/src/backend/commands/tablecmds.c > > b/src/backend/commands/tablecmds.c index 1c2ebe1..7f3004f 100644 > > --- a/src/backend/commands/tablecmds.c > > +++ b/src/backend/commands/tablecmds.c > > @@ -20,6 +20,7 @@ > > > > #include "access/heapam_xlog.h" > > #include "access/multixact.h" > > #include "access/reloptions.h" > > > > +#include "access/options.h" > > > > #include "access/relscan.h" > > #include "access/sysattr.h" > > #include "access/tableam.h" > > > > @@ -641,7 +642,6 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid > > ownerId,> > > ListCell *listptr; > > AttrNumber attnum; > > bool partitioned; > > > > - static char *validnsps[] = HEAP_RELOPT_NAMESPACES; > > > > Oid ofTypeId; > > ObjectAddress address; > > LOCKMODE parentLockmode; > > > > @@ -789,19 +789,37 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid > > ownerId,> > > /* > > > > * Parse and validate reloptions, if any. > > */ > > > > - reloptions = transformRelOptions((Datum) 0, stmt->options, NULL, > > validnsps, - true, false); > > > > switch (relkind) > > { > > > > case RELKIND_VIEW: > > - (void) view_reloptions(reloptions, true); > > + reloptions = transformOptions( > > + get_view_relopt_spec_set(), > > + (Datum) 0, stmt->options, 0); > > > > break; > > > > case RELKIND_PARTITIONED_TABLE: > > - (void) partitioned_table_reloptions(reloptions, true); > > + { > > + /* If it is not all listed above, then it if heap */ > > + char *namespaces[] = HEAP_RELOPT_NAMESPACES; > > + List *heapDefList; > > + > > + optionsDefListValdateNamespaces(stmt->options, namespaces); > > + heapDefList = optionsDefListFilterNamespaces(stmt- >options, NULL); > > + reloptions = transformOptions(get_partitioned_relopt_spec_set(), > > + (Datum) 0, heapDefList, 0); > > > > break; > > > > + } > > > > default: > > - (void) heap_reloptions(relkind, reloptions, true); > > + { > > + /* If it is not all listed above, then it if heap */ > > + char *namespaces[] = HEAP_RELOPT_NAMESPACES; > > + List *heapDefList; > > + > > + optionsDefListValdateNamespaces(stmt->options, namespaces); > > + heapDefList = optionsDefListFilterNamespaces(stmt- >options, NULL); > > + reloptions = transformOptions(get_heap_relopt_spec_set(), > > + (Datum) 0, heapDefList, 0); > > + } > > > > } > > > > if (stmt->ofTypename) > > > > @@ -4022,7 +4040,7 @@ void > > > > AlterTableInternal(Oid relid, List *cmds, bool recurse) > > { > > > > Relation rel; > > > > - LOCKMODE lockmode = AlterTableGetLockLevel(cmds); > > + LOCKMODE lockmode = AlterTableGetLockLevel(relid, cmds); > > > > rel = relation_open(relid, lockmode); > > > > @@ -4064,7 +4082,7 @@ AlterTableInternal(Oid relid, List *cmds, bool > > recurse)> > > * otherwise we might end up with an inconsistent dump that can't > > restore. > > */ > > > > LOCKMODE > > > > -AlterTableGetLockLevel(List *cmds) > > +AlterTableGetLockLevel(Oid relid, List *cmds) > > > > { > > > > /* > > > > * This only works if we read catalog tables using MVCC snapshots. > > > > @@ -4285,9 +4303,13 @@ AlterTableGetLockLevel(List *cmds) > > > > * getTables() */ > > > > case AT_ResetRelOptions: /* Uses MVCC in getIndexes() and > > > > * getTables() */ > > > > - cmd_lockmode = AlterTableGetRelOptionsLockLevel((List *) cmd->def); > > - break; > > - > > + { > > + Relation rel = relation_open(relid, NoLock); // FIXME I am not sure > > how wise it is + cmd_lockmode = AlterTableGetRelOptionsLockLevel(rel, > > + castNode(List, cmd->def)); > > + relation_close(rel,NoLock); > > + break; > > + } > > > > case AT_AttachPartition: > > cmd_lockmode = ShareUpdateExclusiveLock; > > break; > > > > @@ -8062,11 +8084,11 @@ ATExecSetOptions(Relation rel, const char > > *colName, Node *options,> > > /* Generate new proposed attoptions (text array) */ > > datum = SysCacheGetAttr(ATTNAME, tuple, Anum_pg_attribute_attoptions, > > > > &isnull); > > > > - newOptions = transformRelOptions(isnull ? (Datum) 0 : datum, > > - castNode(List, options), NULL, NULL, > > - false, isReset); > > - /* Validate new options */ > > - (void) attribute_reloptions(newOptions, true); > > + > > + newOptions = transformOptions(get_attribute_options_spec_set(), > > + isnull ? (Datum) 0 : datum, > > + castNode(List, options), OPTIONS_PARSE_MODE_FOR_ALTER | > > + (isReset ? OPTIONS_PARSE_MODE_FOR_RESET : 0)); > > > > /* Build new tuple. */ > > memset(repl_null, false, sizeof(repl_null)); > > > > @@ -13704,7 +13726,8 @@ ATExecSetRelOptions(Relation rel, List *defList, > > AlterTableType operation,> > > Datum repl_val[Natts_pg_class]; > > bool repl_null[Natts_pg_class]; > > bool repl_repl[Natts_pg_class]; > > > > - static char *validnsps[] = HEAP_RELOPT_NAMESPACES; > > + List *toastDefList; > > + options_parse_mode parse_mode; > > > > if (defList == NIL && operation != AT_ReplaceRelOptions) > > > > return; /* nothing to do */ > > > > @@ -13734,27 +13757,68 @@ ATExecSetRelOptions(Relation rel, List *defList, > > AlterTableType operation,> > > } > > > > /* Generate new proposed reloptions (text array) */ > > > > - newOptions = transformRelOptions(isnull ? (Datum) 0 : datum, > > - defList, NULL, validnsps, false, > > - operation == AT_ResetRelOptions); > > > > /* Validate */ > > > > + parse_mode = OPTIONS_PARSE_MODE_FOR_ALTER; > > + if (operation == AT_ResetRelOptions) > > + parse_mode |= OPTIONS_PARSE_MODE_FOR_RESET; > > + > > > > switch (rel->rd_rel->relkind) > > { > > > > case RELKIND_RELATION: > > - case RELKIND_TOASTVALUE: > > + case RELKIND_TOASTVALUE: // FIXME why it is here??? > > > > case RELKIND_MATVIEW: > > - (void) heap_reloptions(rel->rd_rel->relkind, newOptions, true); > > + { > > + char *namespaces[] = HEAP_RELOPT_NAMESPACES; > > + List *heapDefList; > > + > > + optionsDefListValdateNamespaces(defList, namespaces); > > + heapDefList = optionsDefListFilterNamespaces( > > + defList, NULL); > > + newOptions = transformOptions(get_heap_relopt_spec_set(), > > + isnull ? (Datum) 0 : datum, > > + heapDefList, parse_mode); > > + } > > > > break; > > > > + > > > > case RELKIND_PARTITIONED_TABLE: > > - (void) partitioned_table_reloptions(newOptions, true); > > - break; > > + { > > + char *namespaces[] = HEAP_RELOPT_NAMESPACES; > > + List *heapDefList; > > + > > + optionsDefListValdateNamespaces(defList, namespaces); > > + heapDefList = optionsDefListFilterNamespaces( > > + defList, NULL); > > + newOptions = transformOptions(get_partitioned_relopt_spec_set(), > > + isnull ? (Datum) 0 : datum, > > + heapDefList, parse_mode); > > + break; > > + } > > > > case RELKIND_VIEW: > > - (void) view_reloptions(newOptions, true); > > - break; > > + { > > + > > + newOptions = transformOptions( > > + get_view_relopt_spec_set(), > > + datum, defList, parse_mode); > > + break; > > + } > > > > case RELKIND_INDEX: > > > > case RELKIND_PARTITIONED_INDEX: > > - (void) index_reloptions(rel->rd_indam->amoptions, newOptions, true); > > + if (! rel->rd_indam->amreloptspecset) > > + { > > + ereport(ERROR, > > + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), > > + errmsg("index %s does not support options", > > + RelationGetRelationName(rel)))); > > + break; > > + } > > + parse_mode = OPTIONS_PARSE_MODE_FOR_ALTER; > > + if (operation == AT_ResetRelOptions) > > + parse_mode |= OPTIONS_PARSE_MODE_FOR_RESET; > > + newOptions = transformOptions( > > + rel- >rd_indam->amreloptspecset(), > > + isnull ? (Datum) 0 : datum, > > + defList, parse_mode); > > > > break; > > > > default: > > ereport(ERROR, > > > > @@ -13769,7 +13833,7 @@ ATExecSetRelOptions(Relation rel, List *defList, > > AlterTableType operation,> > > if (rel->rd_rel->relkind == RELKIND_VIEW) > > { > > > > Query *view_query = get_view_query(rel); > > > > - List *view_options = untransformRelOptions(newOptions); > > + List *view_options = optionsTextArrayToDefList(newOptions); > > > > ListCell *cell; > > bool check_option = false; > > > > @@ -13853,11 +13917,15 @@ ATExecSetRelOptions(Relation rel, List *defList, > > AlterTableType operation,> > > &isnull); > > > > } > > > > - newOptions = transformRelOptions(isnull ? (Datum) 0 : datum, > > - defList, "toast", validnsps, false, > > - operation == AT_ResetRelOptions); > > + parse_mode = OPTIONS_PARSE_MODE_FOR_ALTER; > > + if (operation == AT_ResetRelOptions) > > + parse_mode |= OPTIONS_PARSE_MODE_FOR_RESET; > > + > > + toastDefList = optionsDefListFilterNamespaces(defList, "toast"); > > > > - (void) heap_reloptions(RELKIND_TOASTVALUE, newOptions, true); > > + newOptions = transformOptions(get_toast_relopt_spec_set(), > > + isnull ? (Datum) 0 : datum, > > + toastDefList, parse_mode); > > > > memset(repl_val, 0, sizeof(repl_val)); > > memset(repl_null, false, sizeof(repl_null)); > > > > diff --git a/src/backend/commands/tablespace.c > > b/src/backend/commands/tablespace.c index 4b96eec..912699b 100644 > > --- a/src/backend/commands/tablespace.c > > +++ b/src/backend/commands/tablespace.c > > @@ -345,10 +345,9 @@ CreateTableSpace(CreateTableSpaceStmt *stmt) > > > > nulls[Anum_pg_tablespace_spcacl - 1] = true; > > > > /* Generate new proposed spcoptions (text array) */ > > > > - newOptions = transformRelOptions((Datum) 0, > > - stmt->options, > > - NULL, NULL, false, false); > > - (void) tablespace_reloptions(newOptions, true); > > + newOptions = transformOptions(get_tablespace_options_spec_set(), > > + (Datum) 0, stmt->options, 0); > > + > > > > if (newOptions != (Datum) 0) > > > > values[Anum_pg_tablespace_spcoptions - 1] = newOptions; > > > > else > > > > @@ -1053,10 +1052,11 @@ AlterTableSpaceOptions(AlterTableSpaceOptionsStmt > > *stmt)> > > /* Generate new proposed spcoptions (text array) */ > > datum = heap_getattr(tup, Anum_pg_tablespace_spcoptions, > > > > RelationGetDescr(rel), &isnull); > > > > - newOptions = transformRelOptions(isnull ? (Datum) 0 : datum, > > - stmt->options, NULL, NULL, false, > > - stmt->isReset); > > - (void) tablespace_reloptions(newOptions, true); > > + newOptions = transformOptions(get_tablespace_options_spec_set(), > > + isnull ? (Datum) 0 : datum, > > + stmt- >options, > > + OPTIONS_PARSE_MODE_FOR_ALTER | > > + (stmt->isReset ? OPTIONS_PARSE_MODE_FOR_RESET : 0)); > > > > /* Build new tuple. */ > > memset(repl_null, false, sizeof(repl_null)); > > > > diff --git a/src/backend/foreign/foreign.c b/src/backend/foreign/foreign.c > > index 5564dc3..0370be7 100644 > > --- a/src/backend/foreign/foreign.c > > +++ b/src/backend/foreign/foreign.c > > @@ -78,7 +78,7 @@ GetForeignDataWrapperExtended(Oid fdwid, bits16 flags) > > > > if (isnull) > > > > fdw->options = NIL; > > > > else > > > > - fdw->options = untransformRelOptions(datum); > > + fdw->options = optionsTextArrayToDefList(datum); > > > > ReleaseSysCache(tp); > > > > @@ -165,7 +165,7 @@ GetForeignServerExtended(Oid serverid, bits16 flags) > > > > if (isnull) > > > > server->options = NIL; > > > > else > > > > - server->options = untransformRelOptions(datum); > > + server->options = optionsTextArrayToDefList(datum); > > > > ReleaseSysCache(tp); > > > > @@ -233,7 +233,7 @@ GetUserMapping(Oid userid, Oid serverid) > > > > if (isnull) > > > > um->options = NIL; > > > > else > > > > - um->options = untransformRelOptions(datum); > > + um->options = optionsTextArrayToDefList(datum); > > > > ReleaseSysCache(tp); > > > > @@ -270,7 +270,7 @@ GetForeignTable(Oid relid) > > > > if (isnull) > > > > ft->options = NIL; > > > > else > > > > - ft->options = untransformRelOptions(datum); > > + ft->options = optionsTextArrayToDefList(datum); > > > > ReleaseSysCache(tp); > > > > @@ -303,7 +303,7 @@ GetForeignColumnOptions(Oid relid, AttrNumber attnum) > > > > if (isnull) > > > > options = NIL; > > > > else > > > > - options = untransformRelOptions(datum); > > + options = optionsTextArrayToDefList(datum); > > > > ReleaseSysCache(tp); > > > > @@ -572,7 +572,7 @@ pg_options_to_table(PG_FUNCTION_ARGS) > > > > Datum array = PG_GETARG_DATUM(0); > > > > deflist_to_tuplestore((ReturnSetInfo *) fcinfo->resultinfo, > > > > - untransformRelOptions(array)); > > + optionsTextArrayToDefList(array)); > > > > return (Datum) 0; > > > > } > > > > @@ -643,7 +643,7 @@ is_conninfo_option(const char *option, Oid context) > > > > Datum > > postgresql_fdw_validator(PG_FUNCTION_ARGS) > > { > > > > - List *options_list = untransformRelOptions(PG_GETARG_DATUM(0)); > > + List *options_list = optionsTextArrayToDefList(PG_GETARG_DATUM(0)); > > > > Oid catalog = PG_GETARG_OID(1); > > > > ListCell *cell; > > > > diff --git a/src/backend/parser/parse_utilcmd.c > > b/src/backend/parser/parse_utilcmd.c index 313d7b6..1fe41b4 100644 > > --- a/src/backend/parser/parse_utilcmd.c > > +++ b/src/backend/parser/parse_utilcmd.c > > @@ -1757,7 +1757,7 @@ generateClonedIndexStmt(RangeVar *heapRel, Relation > > source_idx,> > > /* Add the operator class name, if non-default */ > > iparam->opclass = get_opclass(indclass->values[keyno], keycoltype); > > iparam->opclassopts = > > > > - untransformRelOptions(get_attoptions(source_relid, keyno + 1)); > > + optionsTextArrayToDefList(get_attoptions(source_relid, keyno + 1)); > > > > iparam->ordering = SORTBY_DEFAULT; > > iparam->nulls_ordering = SORTBY_NULLS_DEFAULT; > > > > @@ -1821,7 +1821,7 @@ generateClonedIndexStmt(RangeVar *heapRel, Relation > > source_idx,> > > datum = SysCacheGetAttr(RELOID, ht_idxrel, > > > > Anum_pg_class_reloptions, &isnull); > > > > if (!isnull) > > > > - index->options = untransformRelOptions(datum); > > + index->options = optionsTextArrayToDefList(datum); > > > > /* If it's a partial index, decompile and append the predicate */ > > datum = SysCacheGetAttr(INDEXRELID, ht_idx, > > > > diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c > > index bf085aa..d12ab1a 100644 > > --- a/src/backend/tcop/utility.c > > +++ b/src/backend/tcop/utility.c > > @@ -1155,6 +1155,7 @@ ProcessUtilitySlow(ParseState *pstate, > > > > CreateStmt *cstmt = (CreateStmt *) stmt; > > Datum toast_options; > > static char *validnsps[] = HEAP_RELOPT_NAMESPACES; > > > > + List *toastDefList; > > > > /* Remember transformed RangeVar for LIKE */ > > table_rv = cstmt- >relation; > > > > @@ -1178,15 +1179,17 @@ ProcessUtilitySlow(ParseState *pstate, > > > > * parse and validate reloptions for the toast > > * table > > */ > > > > - toast_options = transformRelOptions((Datum) 0, > > - cstmt->options, > > - "toast", > > - validnsps, > > - true, > > - false); > > - (void) heap_reloptions(RELKIND_TOASTVALUE, > > - toast_options, > > - true); > > + > > + optionsDefListValdateNamespaces( > > + ((CreateStmt *) stmt)->options, > > + validnsps); > > + > > + toastDefList = optionsDefListFilterNamespaces( > > + ((CreateStmt *) stmt)->options, "toast"); > > + > > + toast_options = transformOptions( > > + get_toast_relopt_spec_set(), (Datum) 0, > > + toastDefList, 0); > > > > NewRelationCreateToastTable(address.objectId, > > > > toast_options); > > > > @@ -1295,9 +1298,12 @@ ProcessUtilitySlow(ParseState *pstate, > > > > * lock on (for example) a relation on which we have no > > * permissions. > > */ > > > > - lockmode = AlterTableGetLockLevel(atstmt->cmds); > > - relid = AlterTableLookupRelation(atstmt, lockmode); > > - > > + relid = AlterTableLookupRelation(atstmt, NoLock); // FIXME! > > + if (OidIsValid(relid)) > > + { > > + lockmode = AlterTableGetLockLevel(relid, atstmt->cmds); > > + relid = AlterTableLookupRelation(atstmt, lockmode); > > + } > > > > if (OidIsValid(relid)) > > { > > > > AlterTableUtilityContext atcontext; > > > > diff --git a/src/backend/utils/cache/attoptcache.c > > b/src/backend/utils/cache/attoptcache.c index 72d89cb..f651129 100644 > > --- a/src/backend/utils/cache/attoptcache.c > > +++ b/src/backend/utils/cache/attoptcache.c > > @@ -16,6 +16,7 @@ > > > > */ > > > > #include "postgres.h" > > > > +#include "access/options.h" > > > > #include "access/reloptions.h" > > #include "utils/attoptcache.h" > > #include "utils/catcache.h" > > > > @@ -148,7 +149,8 @@ get_attribute_options(Oid attrelid, int attnum) > > > > opts = NULL; > > > > else > > { > > > > - bytea *bytea_opts = attribute_reloptions(datum, false); > > + bytea *bytea_opts = optionsTextArrayToBytea( > > + get_attribute_options_spec_set(), datum, 0); > > > > opts = MemoryContextAlloc(CacheMemoryContext, > > > > VARSIZE(bytea_opts)); > > > > diff --git a/src/backend/utils/cache/relcache.c > > b/src/backend/utils/cache/relcache.c index 13d9994..f22c2d9 100644 > > --- a/src/backend/utils/cache/relcache.c > > +++ b/src/backend/utils/cache/relcache.c > > @@ -441,7 +441,7 @@ static void > > > > RelationParseRelOptions(Relation relation, HeapTuple tuple) > > { > > > > bytea *options; > > > > - amoptions_function amoptsfn; > > + amreloptspecset_function amoptspecsetfn; > > > > relation->rd_options = NULL; > > > > @@ -456,11 +456,11 @@ RelationParseRelOptions(Relation relation, HeapTuple > > tuple)> > > case RELKIND_VIEW: > > case RELKIND_MATVIEW: > > > > case RELKIND_PARTITIONED_TABLE: > > - amoptsfn = NULL; > > + amoptspecsetfn = NULL; > > > > break; > > > > case RELKIND_INDEX: > > > > case RELKIND_PARTITIONED_INDEX: > > - amoptsfn = relation->rd_indam->amoptions; > > + amoptspecsetfn = relation->rd_indam->amreloptspecset; > > > > break; > > > > default: > > return; > > > > @@ -471,7 +471,7 @@ RelationParseRelOptions(Relation relation, HeapTuple > > tuple)> > > * we might not have any other for pg_class yet (consider executing this > > * code for pg_class itself) > > */ > > > > - options = extractRelOptions(tuple, GetPgClassDescriptor(), amoptsfn); > > + options = extractRelOptions(tuple, GetPgClassDescriptor(), > > amoptspecsetfn);> > > /* > > > > * Copy parsed data into CacheMemoryContext. To guard against the > > > > diff --git a/src/backend/utils/cache/spccache.c > > b/src/backend/utils/cache/spccache.c index 5870f43..87f2fa5 100644 > > --- a/src/backend/utils/cache/spccache.c > > +++ b/src/backend/utils/cache/spccache.c > > @@ -148,7 +148,8 @@ get_tablespace(Oid spcid) > > > > opts = NULL; > > > > else > > { > > > > - bytea *bytea_opts = tablespace_reloptions(datum, false); > > + bytea *bytea_opts = optionsTextArrayToBytea( > > + get_tablespace_options_spec_set(), datum, 0); > > > > opts = MemoryContextAlloc(CacheMemoryContext, VARSIZE(bytea_opts)); > > memcpy(opts, bytea_opts, VARSIZE(bytea_opts)); > > > > diff --git a/src/include/access/amapi.h b/src/include/access/amapi.h > > index d357ebb..b8fb6b9 100644 > > --- a/src/include/access/amapi.h > > +++ b/src/include/access/amapi.h > > @@ -136,10 +136,6 @@ typedef void (*amcostestimate_function) (struct > > PlannerInfo *root,> > > double *indexCorrelation, > > double *indexPages); > > > > -/* parse index reloptions */ > > -typedef bytea *(*amoptions_function) (Datum reloptions, > > - bool validate); > > - > > > > /* report AM, index, or index column property */ > > typedef bool (*amproperty_function) (Oid index_oid, int attno, > > > > IndexAMProperty prop, const char *propname, > > > > @@ -186,6 +182,9 @@ typedef void (*ammarkpos_function) (IndexScanDesc > > scan);> > > /* restore marked scan position */ > > typedef void (*amrestrpos_function) (IndexScanDesc scan); > > > > +/* get catalog of reloptions definitions */ > > +typedef void *(*amreloptspecset_function) (); > > + > > > > /* > > > > * Callback function signatures - for parallel index scans. > > */ > > > > @@ -263,7 +262,6 @@ typedef struct IndexAmRoutine > > > > amvacuumcleanup_function amvacuumcleanup; > > amcanreturn_function amcanreturn; /* can be NULL */ > > amcostestimate_function amcostestimate; > > > > - amoptions_function amoptions; > > > > amproperty_function amproperty; /* can be NULL */ > > ambuildphasename_function ambuildphasename; /* can be NULL */ > > amvalidate_function amvalidate; > > > > @@ -275,6 +273,7 @@ typedef struct IndexAmRoutine > > > > amendscan_function amendscan; > > ammarkpos_function ammarkpos; /* can be NULL */ > > amrestrpos_function amrestrpos; /* can be NULL */ > > > > + amreloptspecset_function amreloptspecset; /* can be NULL */ > > > > /* interface functions to support parallel index scans */ > > amestimateparallelscan_function amestimateparallelscan; /* can be NULL > > */ > > > > diff --git a/src/include/access/brin.h b/src/include/access/brin.h > > index 4e2be13..25b3456 100644 > > --- a/src/include/access/brin.h > > +++ b/src/include/access/brin.h > > @@ -36,6 +36,8 @@ typedef struct BrinStatsData > > > > #define BRIN_DEFAULT_PAGES_PER_RANGE 128 > > > > +#define BRIN_MIN_PAGES_PER_RANGE 1 > > +#define BRIN_MAX_PAGES_PER_RANGE 131072 > > > > #define BrinGetPagesPerRange(relation) \ > > > > (AssertMacro(relation->rd_rel->relkind == RELKIND_INDEX && \ > > > > relation->rd_rel->relam == BRIN_AM_OID), \ > > > > diff --git a/src/include/access/brin_internal.h > > b/src/include/access/brin_internal.h index 79440eb..a798a96 100644 > > --- a/src/include/access/brin_internal.h > > +++ b/src/include/access/brin_internal.h > > @@ -14,6 +14,7 @@ > > > > #include "access/amapi.h" > > #include "storage/bufpage.h" > > #include "utils/typcache.h" > > > > +#include "access/options.h" > > > > /* > > > > @@ -108,6 +109,7 @@ extern IndexBulkDeleteResult > > *brinbulkdelete(IndexVacuumInfo *info,> > > extern IndexBulkDeleteResult *brinvacuumcleanup(IndexVacuumInfo *info, > > > > IndexBulkDeleteResult *stats); > > > > extern bytea *brinoptions(Datum reloptions, bool validate); > > > > +extern void * bringetreloptspecset (void); > > > > /* brin_validate.c */ > > extern bool brinvalidate(Oid opclassoid); > > > > diff --git a/src/include/access/gin_private.h > > b/src/include/access/gin_private.h index 670a40b..2b7c25c 100644 > > --- a/src/include/access/gin_private.h > > +++ b/src/include/access/gin_private.h > > @@ -108,6 +108,7 @@ extern Datum *ginExtractEntries(GinState *ginstate, > > OffsetNumber attnum,> > > extern OffsetNumber gintuple_get_attrnum(GinState *ginstate, IndexTuple > > tuple); extern Datum gintuple_get_key(GinState *ginstate, IndexTuple > > tuple,> > > GinNullCategory *category); > > > > +extern void *gingetreloptspecset(void); > > > > /* gininsert.c */ > > extern IndexBuildResult *ginbuild(Relation heap, Relation index, > > > > diff --git a/src/include/access/gist_private.h > > b/src/include/access/gist_private.h index 553d364..015b75a 100644 > > --- a/src/include/access/gist_private.h > > +++ b/src/include/access/gist_private.h > > @@ -22,6 +22,7 @@ > > > > #include "storage/buffile.h" > > #include "utils/hsearch.h" > > #include "access/genam.h" > > > > +#include "access/reloptions.h" //FIXME! should be replaced with options.h > > finally> > > /* > > > > * Maximum number of "halves" a page can be split into in one operation. > > > > @@ -388,6 +389,7 @@ typedef enum GistOptBufferingMode > > > > GIST_OPTION_BUFFERING_OFF > > > > } GistOptBufferingMode; > > > > + > > > > /* > > > > * Storage type for GiST's reloptions > > */ > > > > @@ -478,7 +480,7 @@ extern void gistadjustmembers(Oid opfamilyoid, > > > > #define GIST_MIN_FILLFACTOR 10 > > #define GIST_DEFAULT_FILLFACTOR 90 > > > > -extern bytea *gistoptions(Datum reloptions, bool validate); > > +extern void *gistgetreloptspecset(void); > > > > extern bool gistproperty(Oid index_oid, int attno, > > > > IndexAMProperty prop, const char *propname, > > bool *res, bool *isnull); > > > > diff --git a/src/include/access/hash.h b/src/include/access/hash.h > > index 1cce865..91922ef 100644 > > --- a/src/include/access/hash.h > > +++ b/src/include/access/hash.h > > @@ -378,7 +378,6 @@ extern IndexBulkDeleteResult > > *hashbulkdelete(IndexVacuumInfo *info,> > > void *callback_state); > > > > extern IndexBulkDeleteResult *hashvacuumcleanup(IndexVacuumInfo *info, > > > > IndexBulkDeleteResult *stats); > > > > -extern bytea *hashoptions(Datum reloptions, bool validate); > > > > extern bool hashvalidate(Oid opclassoid); > > extern void hashadjustmembers(Oid opfamilyoid, > > > > Oid opclassoid, > > > > @@ -470,6 +469,7 @@ extern BlockNumber > > _hash_get_newblock_from_oldbucket(Relation rel, Bucket old_bu> > > extern Bucket _hash_get_newbucket_from_oldbucket(Relation rel, Bucket > > old_bucket,> > > uint32 lowmask, uint32 maxbucket); > > > > extern void _hash_kill_items(IndexScanDesc scan); > > > > +extern void *hashgetreloptspecset(void); > > > > /* hash.c */ > > extern void hashbucketcleanup(Relation rel, Bucket cur_bucket, > > > > diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h > > index 30a216e..1fcb5f5 100644 > > --- a/src/include/access/nbtree.h > > +++ b/src/include/access/nbtree.h > > @@ -1252,7 +1252,7 @@ extern void _bt_end_vacuum(Relation rel); > > > > extern void _bt_end_vacuum_callback(int code, Datum arg); > > extern Size BTreeShmemSize(void); > > extern void BTreeShmemInit(void); > > > > -extern bytea *btoptions(Datum reloptions, bool validate); > > +extern void * btgetreloptspecset (void); > > > > extern bool btproperty(Oid index_oid, int attno, > > > > IndexAMProperty prop, const char *propname, > > bool *res, bool *isnull); > > > > diff --git a/src/include/access/options.h b/src/include/access/options.h > > new file mode 100644 > > index 0000000..34e2917 > > --- /dev/null > > +++ b/src/include/access/options.h > > @@ -0,0 +1,245 @@ > > +/*----------------------------------------------------------------------- > > -- + * > > + * options.h > > + * Core support for relation and tablespace options > > (pg_class.reloptions > > + * and pg_tablespace.spcoptions) > > + * > > + * Note: the functions dealing with text-array options values declare > > + * them as Datum, not ArrayType *, to avoid needing to include array.h > > + * into a lot of low-level code. > > + * > > + * > > + * Portions Copyright (c) 1996-2016, PostgreSQL Global Development Group > > + * Portions Copyright (c) 1994, Regents of the University of California > > + * > > + * src/include/access/options.h > > + * > > + > > *------------------------------------------------------------------------ > > - + */ > > +#ifndef OPTIONS_H > > +#define OPTIONS_H > > + > > +#include "storage/lock.h" > > +#include "nodes/pg_list.h" > > + > > + > > +/* supported option types */ > > +typedef enum option_type > > +{ > > + OPTION_TYPE_BOOL, > > + OPTION_TYPE_INT, > > + OPTION_TYPE_REAL, > > + OPTION_TYPE_ENUM, > > + OPTION_TYPE_STRING > > +} option_type; > > + > > + > > +typedef enum option_value_status > > +{ > > + OPTION_VALUE_STATUS_EMPTY, /* Option was just initialized */ > > + OPTION_VALUE_STATUS_RAW, /* Option just came from syntax analyzer in > > + * has name, and raw (unparsed) value */ > > + OPTION_VALUE_STATUS_PARSED, /* Option was parsed and has link to catalog > > + * entry and proper value */ > > + OPTION_VALUE_STATUS_FOR_RESET /* This option came from ALTER xxx > > + * RESET */ > > +} option_value_status; > > + > > +/* flags for reloptinon definition */ > > +typedef enum option_spec_flags > > +{ > > + OPTION_DEFINITION_FLAG_FORBID_ALTER = (1 << 0), /* Altering this option > > + * is forbidden */ > > + OPTION_DEFINITION_FLAG_IGNORE = (1 << 1), /* Skip this option while > > + * parsing. Used for WITH OIDS > > + * special case */ > > + OPTION_DEFINITION_FLAG_REJECT = (1 << 2) /* Option will be rejected > > + * when comes from syntax > > + * analyzer, but still have > > + * default value and offset */ > > +} option_spec_flags; > > + > > +/* flags that tells reloption parser how to parse*/ > > +typedef enum options_parse_mode > > +{ > > + OPTIONS_PARSE_MODE_VALIDATE = (1 << 0), > > + OPTIONS_PARSE_MODE_FOR_ALTER = (1 << 1), > > + OPTIONS_PARSE_MODE_FOR_RESET = (1 << 2) > > +} options_parse_mode; > > + > > + > > + > > +/* > > + * opt_enum_elt_def -- One member of the array of acceptable values > > + * of an enum reloption. > > + */ > > +typedef struct opt_enum_elt_def > > +{ > > + const char *string_val; > > + int symbol_val; > > +} opt_enum_elt_def; > > + > > + > > +/* generic structure to store Option Spec information */ > > +typedef struct option_spec_basic > > +{ > > + const char *name; /* must be first (used as list termination > > + * marker) */ > > + const char *desc; > > + LOCKMODE lockmode; > > + option_spec_flags flags; > > + option_type type; > > + int struct_offset; /* offset of the value in Bytea representation */ > > +} option_spec_basic; > > + > > + > > +/* reloptions records for specific variable types */ > > +typedef struct option_spec_bool > > +{ > > + option_spec_basic base; > > + bool default_val; > > +} option_spec_bool; > > + > > +typedef struct option_spec_int > > +{ > > + option_spec_basic base; > > + int default_val; > > + int min; > > + int max; > > +} option_spec_int; > > + > > +typedef struct option_spec_real > > +{ > > + option_spec_basic base; > > + double default_val; > > + double min; > > + double max; > > +} option_spec_real; > > + > > +typedef struct option_spec_enum > > +{ > > + option_spec_basic base; > > + opt_enum_elt_def *members;/* FIXME rewrite. Null terminated array of > > allowed values for + * the option */ > > + int default_val; /* Number of item of allowed_values array */ > > + const char *detailmsg; > > +} option_spec_enum; > > + > > +/* validation routines for strings */ > > +typedef void (*validate_string_option) (const char *value); > > + > > +/* > > + * When storing sting reloptions, we shoud deal with special case when > > + * option value is not set. For fixed length options, we just copy > > default > > + * option value into the binary structure. For varlen value, there can be > > + * "not set" special case, with no default value offered. > > + * In this case we will set offset value to -1, so code that use > > relptions > > + * can deal this case. For better readability it was defined as a > > constant. + */ > > +#define OPTION_STRING_VALUE_NOT_SET_OFFSET -1 > > + > > +typedef struct option_spec_string > > +{ > > + option_spec_basic base; > > + validate_string_option validate_cb; > > + char *default_val; > > +} option_spec_string; > > + > > +typedef void (*postprocess_bytea_options_function) (void *data, bool > > validate); + > > +typedef struct options_spec_set > > +{ > > + option_spec_basic **definitions; > > + int num; /* Number of spec_set items in use */ > > + int num_allocated; /* Number of spec_set items allocated */ > > + bool forbid_realloc; /* If number of items of the spec_set were > > + * strictly set to certain value do no allow > > + * adding more idems */ > > + Size struct_size; /* Size of a structure for options in binary > > + * representation */ > > + postprocess_bytea_options_function postprocess_fun; /* This function is > > + * called after options > > + * were converted in > > + * Bytea represenation. > > + * Can be used for extra > > + * validation and so on */ > > + char *namespace; /* spec_set is used for options from this > > + * namespase */ > > +} options_spec_set; > > + > > + > > +/* holds an option value parsed or unparsed */ > > +typedef struct option_value > > +{ > > + option_spec_basic *gen; > > + char *namespace; > > + option_value_status status; > > + char *raw_value; /* allocated separately */ > > + char *raw_name; > > + union > > + { > > + bool bool_val; > > + int int_val; > > + double real_val; > > + int enum_val; > > + char *string_val; /* allocated separately */ > > + } values; > > +} option_value; > > + > > + > > + > > + > > +/* > > + * Options spec_set related functions > > + */ > > +extern options_spec_set *allocateOptionsSpecSet(const char *namespace, > > + int size_of_bytea, int num_items_expected); > > +extern void optionsSpecSetAddBool(options_spec_set * spec_set, const char > > *name, + const char *desc, LOCKMODE lockmode, option_spec_flags > > flags, + int struct_offset, bool default_val); > > +extern void optionsSpecSetAddInt(options_spec_set * spec_set, const char > > *name, + const char *desc, LOCKMODE lockmode, option_spec_flags > > flags, + int struct_offset, int default_val, int min_val, int > > max_val); +extern void optionsSpecSetAddReal(options_spec_set * spec_set, > > const char *name, + const char *desc, LOCKMODE lockmode, > > option_spec_flags flags, + int struct_offset, double default_val, > > double min_val, double max_val); +extern void > > optionsSpecSetAddEnum(options_spec_set * spec_set, > > + const char *name, const char *desc, LOCKMODE lockmode, > > option_spec_flags flags, + int struct_offset, opt_enum_elt_def* > > members, int default_val, const char *detailmsg); +extern void > > optionsSpecSetAddString(options_spec_set * spec_set, const char *name, > > + const char *desc, LOCKMODE lockmode, option_spec_flags flags, +int > > struct_offset, const char *default_val, validate_string_option > > validator); + > > + > > +/* > > + * This macro allows to get string option value from bytea > > representation. > > + * "optstruct" - is a structure that is stored in bytea options > > representation + * "member" - member of this structure that has string > > option value + * (actually string values are stored in bytea after the > > structure, and + * and "member" will contain an offset to this value. > > This macro do all + * the math > > + */ > > +#define GET_STRING_OPTION(optstruct, member) \ > > + ((optstruct)->member == OPTION_STRING_VALUE_NOT_SET_OFFSET ? NULL : \ > > + (char *)(optstruct) + (optstruct)->member) > > + > > +/* > > + * Functions related to option convertation, parsing, manipulation > > + * and validation > > + */ > > +extern void optionsDefListValdateNamespaces(List *defList, > > + char **allowed_namespaces); > > +extern List *optionsDefListFilterNamespaces(List *defList, const char > > *namespace); +extern List *optionsTextArrayToDefList(Datum options); > > +extern Datum optionsDefListToTextArray(List *defList); > > +/* > > + * Meta functions that uses functions above to get options for relations, > > + * tablespaces, views and so on > > + */ > > + > > +extern bytea *optionsTextArrayToBytea(options_spec_set * spec_set, Datum > > data, + bool validate); > > +extern Datum transformOptions(options_spec_set * spec_set, Datum > > oldOptions, + List *defList, options_parse_mode parse_mode); > > + > > +#endif /* OPTIONS_H */ > > diff --git a/src/include/access/reloptions.h > > b/src/include/access/reloptions.h index 7c5fbeb..21b91df 100644 > > --- a/src/include/access/reloptions.h > > +++ b/src/include/access/reloptions.h > > @@ -22,6 +22,7 @@ > > > > #include "access/amapi.h" > > #include "access/htup.h" > > #include "access/tupdesc.h" > > > > +#include "access/options.h" > > > > #include "nodes/pg_list.h" > > #include "storage/lock.h" > > > > @@ -110,20 +111,10 @@ typedef struct relopt_real > > > > double max; > > > > } relopt_real; > > > > -/* > > - * relopt_enum_elt_def -- One member of the array of acceptable values > > - * of an enum reloption. > > - */ > > -typedef struct relopt_enum_elt_def > > -{ > > - const char *string_val; > > - int symbol_val; > > -} relopt_enum_elt_def; > > - > > > > typedef struct relopt_enum > > { > > > > relopt_gen gen; > > > > - relopt_enum_elt_def *members; > > + opt_enum_elt_def *members; > > > > int default_val; > > const char *detailmsg; > > /* null-terminated array of members */ > > > > @@ -167,6 +158,7 @@ typedef struct local_relopts > > > > List *options; /* list of local_relopt definitions */ > > List *validators; /* list of relopts_validator callbacks */ > > Size relopt_struct_size; /* size of parsed bytea structure */ > > > > + options_spec_set * spec_set; /* FIXME */ > > > > } local_relopts; > > > > /* > > > > @@ -179,21 +171,6 @@ typedef struct local_relopts > > > > ((optstruct)->member == 0 ? NULL : \ > > > > (char *)(optstruct) + (optstruct)->member) > > > > -extern relopt_kind add_reloption_kind(void); > > -extern void add_bool_reloption(bits32 kinds, const char *name, const char > > *desc, - bool default_val, LOCKMODE lockmode); > > -extern void add_int_reloption(bits32 kinds, const char *name, const char > > *desc, - int default_val, int min_val, int max_val, > > - LOCKMODE lockmode); > > -extern void add_real_reloption(bits32 kinds, const char *name, const char > > *desc, - double default_val, double min_val, double max_val, > > - LOCKMODE lockmode); > > -extern 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); > > -extern void add_string_reloption(bits32 kinds, const char *name, const > > char *desc, - const char *default_val, validate_string_relopt > > validator, - LOCKMODE lockmode); > > > > extern void init_local_reloptions(local_relopts *opts, Size > > relopt_struct_size); extern void > > register_reloptions_validator(local_relopts *opts, > > > > @@ -210,7 +187,7 @@ extern void add_local_real_reloption(local_relopts > > *opts, const char *name,> > > int offset); > > > > extern void add_local_enum_reloption(local_relopts *relopts, > > > > const char *name, const char *desc, > > > > - relopt_enum_elt_def *members, > > + opt_enum_elt_def *members, > > > > int default_val, const char *detailmsg, > > int offset); > > > > extern void add_local_string_reloption(local_relopts *opts, const char > > *name,> > > @@ -219,29 +196,17 @@ extern void add_local_string_reloption(local_relopts > > *opts, const char *name,> > > validate_string_relopt validator, > > fill_string_relopt filler, int offset); > > > > -extern Datum transformRelOptions(Datum oldOptions, List *defList, > > - const char *namspace, char *validnsps[], > > - bool acceptOidsOff, bool isReset); > > -extern List *untransformRelOptions(Datum options); > > > > extern bytea *extractRelOptions(HeapTuple tuple, TupleDesc tupdesc, > > > > - amoptions_function amoptions); > > -extern void *build_reloptions(Datum reloptions, bool validate, > > - relopt_kind kind, > > - Size relopt_struct_size, > > - const relopt_parse_elt *relopt_elems, > > - int num_relopt_elems); > > + amreloptspecset_function amoptions_def_set); > > > > extern void *build_local_reloptions(local_relopts *relopts, Datum > > options, > > > > bool validate); > > > > -extern bytea *default_reloptions(Datum reloptions, bool validate, > > - relopt_kind kind); > > -extern bytea *heap_reloptions(char relkind, Datum reloptions, bool > > validate); -extern bytea *view_reloptions(Datum reloptions, bool > > validate); > > -extern bytea *partitioned_table_reloptions(Datum reloptions, bool > > validate); -extern bytea *index_reloptions(amoptions_function amoptions, > > Datum reloptions, - bool validate); > > -extern bytea *attribute_reloptions(Datum reloptions, bool validate); > > -extern bytea *tablespace_reloptions(Datum reloptions, bool validate); > > -extern LOCKMODE AlterTableGetRelOptionsLockLevel(List *defList); > > +options_spec_set *get_heap_relopt_spec_set(void); > > +options_spec_set *get_toast_relopt_spec_set(void); > > +options_spec_set *get_partitioned_relopt_spec_set(void); > > +options_spec_set *get_view_relopt_spec_set(void); > > +options_spec_set *get_attribute_options_spec_set(void); > > +options_spec_set *get_tablespace_options_spec_set(void); > > +extern LOCKMODE AlterTableGetRelOptionsLockLevel(Relation rel, List > > *defList);> > > #endif /* RELOPTIONS_H */ > > > > diff --git a/src/include/access/spgist.h b/src/include/access/spgist.h > > index 2eb2f42..d9a9b2d 100644 > > --- a/src/include/access/spgist.h > > +++ b/src/include/access/spgist.h > > @@ -189,9 +189,6 @@ typedef struct spgLeafConsistentOut > > > > } spgLeafConsistentOut; > > > > -/* spgutils.c */ > > -extern bytea *spgoptions(Datum reloptions, bool validate); > > - > > > > /* spginsert.c */ > > extern IndexBuildResult *spgbuild(Relation heap, Relation index, > > > > struct IndexInfo *indexInfo); > > > > diff --git a/src/include/access/spgist_private.h > > b/src/include/access/spgist_private.h index 40d3b71..dd9a05a 100644 > > --- a/src/include/access/spgist_private.h > > +++ b/src/include/access/spgist_private.h > > @@ -529,6 +529,7 @@ extern OffsetNumber SpGistPageAddNewItem(SpGistState > > *state, Page page,> > > extern bool spgproperty(Oid index_oid, int attno, > > > > IndexAMProperty prop, const char *propname, > > bool *res, bool *isnull); > > > > +extern void *spggetreloptspecset(void); > > > > /* spgdoinsert.c */ > > extern void spgUpdateNodeLink(SpGistInnerTuple tup, int nodeN, > > > > diff --git a/src/include/commands/tablecmds.h > > b/src/include/commands/tablecmds.h index 336549c..3f87f98 100644 > > --- a/src/include/commands/tablecmds.h > > +++ b/src/include/commands/tablecmds.h > > @@ -34,7 +34,7 @@ extern Oid AlterTableLookupRelation(AlterTableStmt > > *stmt, LOCKMODE lockmode);> > > extern void AlterTable(AlterTableStmt *stmt, LOCKMODE lockmode, > > > > struct AlterTableUtilityContext *context); > > > > -extern LOCKMODE AlterTableGetLockLevel(List *cmds); > > +extern LOCKMODE AlterTableGetLockLevel(Oid relid, List *cmds); > > > > extern void ATExecChangeOwner(Oid relationOid, Oid newOwnerId, bool > > recursing, LOCKMODE lockmode);> > > diff --git a/src/test/modules/dummy_index_am/dummy_index_am.c > > b/src/test/modules/dummy_index_am/dummy_index_am.c index > > 5365b063..80b39e8 100644 > > --- a/src/test/modules/dummy_index_am/dummy_index_am.c > > +++ b/src/test/modules/dummy_index_am/dummy_index_am.c > > @@ -14,7 +14,7 @@ > > > > #include "postgres.h" > > > > #include "access/amapi.h" > > > > -#include "access/reloptions.h" > > +#include "access/options.h" > > > > #include "catalog/index.h" > > #include "commands/vacuum.h" > > #include "nodes/pathnodes.h" > > > > @@ -25,12 +25,6 @@ PG_MODULE_MAGIC; > > > > void _PG_init(void); > > > > -/* parse table for fillRelOptions */ > > -relopt_parse_elt di_relopt_tab[6]; > > - > > -/* Kind of relation options for dummy index */ > > -relopt_kind di_relopt_kind; > > - > > > > typedef enum DummyAmEnum > > { > > > > DUMMY_AM_ENUM_ONE, > > > > @@ -49,7 +43,7 @@ typedef struct DummyIndexOptions > > > > int option_string_null_offset; > > > > } DummyIndexOptions; > > > > -relopt_enum_elt_def dummyAmEnumValues[] = > > +opt_enum_elt_def dummyAmEnumValues[] = > > > > { > > > > {"one", DUMMY_AM_ENUM_ONE}, > > {"two", DUMMY_AM_ENUM_TWO}, > > > > @@ -63,77 +57,85 @@ PG_FUNCTION_INFO_V1(dihandler); > > > > * Validation function for string relation options. > > */ > > > > static void > > > > -validate_string_option(const char *value) > > +divalidate_string_option(const char *value) > > > > { > > > > ereport(NOTICE, > > > > (errmsg("new option value for string parameter %s", > > > > value ? value : "NULL"))); > > > > } > > > > -/* > > - * This function creates a full set of relation option types, > > - * with various patterns. > > - */ > > -static void > > -create_reloptions_table(void) > > +static options_spec_set *di_relopt_specset = NULL; > > +void * digetreloptspecset(void); > > + > > +void * > > +digetreloptspecset(void) > > > > { > > > > - di_relopt_kind = add_reloption_kind(); > > - > > - add_int_reloption(di_relopt_kind, "option_int", > > - "Integer option for dummy_index_am", > > - 10, -10, 100, AccessExclusiveLock); > > - di_relopt_tab[0].optname = "option_int"; > > - di_relopt_tab[0].opttype = RELOPT_TYPE_INT; > > - di_relopt_tab[0].offset = offsetof(DummyIndexOptions, option_int); > > - > > - add_real_reloption(di_relopt_kind, "option_real", > > - "Real option for dummy_index_am", > > - 3.1415, -10, 100, AccessExclusiveLock); > > - di_relopt_tab[1].optname = "option_real"; > > - di_relopt_tab[1].opttype = RELOPT_TYPE_REAL; > > - di_relopt_tab[1].offset = offsetof(DummyIndexOptions, option_real); > > - > > - add_bool_reloption(di_relopt_kind, "option_bool", > > - "Boolean option for dummy_index_am", > > - true, AccessExclusiveLock); > > - di_relopt_tab[2].optname = "option_bool"; > > - di_relopt_tab[2].opttype = RELOPT_TYPE_BOOL; > > - di_relopt_tab[2].offset = offsetof(DummyIndexOptions, option_bool); > > - > > - add_enum_reloption(di_relopt_kind, "option_enum", > > - "Enum option for dummy_index_am", > > - dummyAmEnumValues, > > - DUMMY_AM_ENUM_ONE, > > - "Valid values are \"one\" and \"two\".", > > - AccessExclusiveLock); > > - di_relopt_tab[3].optname = "option_enum"; > > - di_relopt_tab[3].opttype = RELOPT_TYPE_ENUM; > > - di_relopt_tab[3].offset = offsetof(DummyIndexOptions, option_enum); > > - > > - add_string_reloption(di_relopt_kind, "option_string_val", > > - "String option for dummy_index_am with non-NULL default", > > - "DefaultValue", &validate_string_option, > > - AccessExclusiveLock); > > - di_relopt_tab[4].optname = "option_string_val"; > > - di_relopt_tab[4].opttype = RELOPT_TYPE_STRING; > > - di_relopt_tab[4].offset = offsetof(DummyIndexOptions, > > - option_string_val_offset); > > + if (di_relopt_specset) > > + return di_relopt_specset; > > + > > + di_relopt_specset = allocateOptionsSpecSet(NULL, > > + sizeof(DummyIndexOptions), 6); > > + > > + optionsSpecSetAddInt( > > + di_relopt_specset, "option_int", > > + "Integer option for dummy_index_am", > > + AccessExclusiveLock, > > + 0, offsetof(DummyIndexOptions, option_int), > > + 10, -10, 100 > > + ); > > + > > + > > + optionsSpecSetAddReal( > > + di_relopt_specset, "option_real", > > + "Real option for dummy_index_am", > > + AccessExclusiveLock, > > + 0, offsetof(DummyIndexOptions, option_real), > > + 3.1415, -10, 100 > > + ); > > + > > + optionsSpecSetAddBool( > > + di_relopt_specset, "option_bool", > > + "Boolean option for dummy_index_am", > > + AccessExclusiveLock, > > + 0, offsetof(DummyIndexOptions, option_bool), true > > + ); > > + > > + optionsSpecSetAddEnum(di_relopt_specset, "option_enum", > > + "Enum option for dummy_index_am", > > + AccessExclusiveLock, > > + 0, > > + offsetof(DummyIndexOptions, option_enum), > > + dummyAmEnumValues, > > + DUMMY_AM_ENUM_ONE, > > + "Valid values are \"one\" and \"two\"." > > + ); > > + > > + optionsSpecSetAddString(di_relopt_specset, "option_string_val", > > + "String option for dummy_index_am with non-NULL default", > > + AccessExclusiveLock, > > + 0, > > + offsetof(DummyIndexOptions, option_string_val_offset), > > + "DefaultValue", &divalidate_string_option > > + ); > > > > /* > > > > * String option for dummy_index_am with NULL default, and without > > * description. > > */ > > > > - add_string_reloption(di_relopt_kind, "option_string_null", > > - NULL, /* description */ > > - NULL, &validate_string_option, > > - AccessExclusiveLock); > > - di_relopt_tab[5].optname = "option_string_null"; > > - di_relopt_tab[5].opttype = RELOPT_TYPE_STRING; > > - di_relopt_tab[5].offset = offsetof(DummyIndexOptions, > > - option_string_null_offset); > > + > > + optionsSpecSetAddString(di_relopt_specset, "option_string_null", > > + NULL, /* description */ > > + AccessExclusiveLock, > > + 0, > > + offsetof(DummyIndexOptions, option_string_null_offset), > > + NULL, &divalidate_string_option > > + ); > > + > > + return di_relopt_specset; > > > > } > > > > + > > > > /* > > > > * Build a new index. > > */ > > > > @@ -219,19 +221,6 @@ dicostestimate(PlannerInfo *root, IndexPath *path, > > double loop_count,> > > } > > > > /* > > > > - * Parse relation options for index AM, returning a DummyIndexOptions > > - * structure filled with option values. > > - */ > > -static bytea * > > -dioptions(Datum reloptions, bool validate) > > -{ > > - return (bytea *) build_reloptions(reloptions, validate, > > - di_relopt_kind, > > - sizeof(DummyIndexOptions), > > - di_relopt_tab, lengthof(di_relopt_tab)); > > -} > > - > > -/* > > > > * Validator for index AM. > > */ > > > > static bool > > > > @@ -308,7 +297,6 @@ dihandler(PG_FUNCTION_ARGS) > > > > amroutine->amvacuumcleanup = divacuumcleanup; > > amroutine->amcanreturn = NULL; > > amroutine->amcostestimate = dicostestimate; > > > > - amroutine->amoptions = dioptions; > > > > amroutine->amproperty = NULL; > > amroutine->ambuildphasename = NULL; > > amroutine->amvalidate = divalidate; > > > > @@ -322,12 +310,7 @@ dihandler(PG_FUNCTION_ARGS) > > > > amroutine->amestimateparallelscan = NULL; > > amroutine->aminitparallelscan = NULL; > > amroutine->amparallelrescan = NULL; > > > > + amroutine->amreloptspecset = digetreloptspecset; > > > > PG_RETURN_POINTER(amroutine); > > > > } > > > > - > > -void > > -_PG_init(void) > > -{ > > - create_reloptions_table(); > > -}
On Fri, Nov 26, 2021 at 11:19:16AM +0300, Nikolay Shaplov wrote: > В письме от вторник, 26 октября 2021 г. 17:25:32 MSK пользователь Bruce > Momjian написал: > > Uh, the core team does not get involved in development issues, unless > > there is a issue that clearly cannot be resolved by discussion on the > > hackers list. > Then may be I used wrong therm. May be I should say "experienced postgres > developers". OK, but "experienced Postgres developers" are by definition on the hackers email list, not necessarily on the core team. In fact, some core team members are not Postgres backend developers. --------------------------------------------------------------------------- > > > > On Mon, Oct 18, 2021 at 04:24:23PM +0300, Nikolay Shaplov wrote: > > > Hi! > > > > > > I am still hoping to finish my work on reloptions I've started some years > > > ago. > > > > > > I've renewed my patch and I think I need help from core team to finish it. > > > > > > General idea of the patch: Now we have three ways to define options for > > > different objects, with more or less different code used for it. It wold > > > be > > > better to have unified context independent API for processing options, > > > instead. > > > > > > Long story short: > > > > > > There is Option Specification object, that has all information about > > > single > > > option, how it should be parsed and validated. > > > > > > There is Option Specification Set object, an array of Option Specs, that > > > defines all options available for certain object (am of some index for > > > example). > > > > > > When some object (relation, opclass, etc) wants to have an options, it > > > creates an Option Spec Set for there options, and uses it for converting > > > options between different representations (to get is from SQL, to store it > > > in pg_class, to pass it to the core code as bytea etc) > > > > > > For indexes Option Spec Set is available via Access Method API. > > > > > > For non-index relations all Option Spec Sets are left in reloption.c file, > > > and should be moved to heap AM later. (They are not in AM now so will not > > > change it now) > > > > > > Main problem: > > > > > > There are LockModes. LockModes for options is also stored in Option Spec > > > Set. For indexes Option Spec Sec is accessable via AM. So to get LockMode > > > for option of an index you need to have access for it's relation object > > > (so you can call proper AM method to fetch spec set). So you need > > > "Relation rel" in AlterTableGetRelOptionsLockLevel where Lock Level is > > > determinated (src/ backend/access/common/reloptions.c) > > > AlterTableGetRelOptionsLockLevel is called from AlterTableGetLockLevel > > > (src/ backend/commands/tablecmds.c) so we need "Relation rel" there too. > > > AlterTableGetLockLevel is called from AlterTableInternal (/src/backend/ > > > commands/tablecmds.c) There we have "Oid relid" so we can try to open > > > relation like this > > > > > > Relation rel = relation_open(relid, NoLock); > > > cmd_lockmode = AlterTableGetRelOptionsLockLevel(rel, > > > > > > castNode(List, > > > cmd->def)); > > > > > > relation_close(rel,NoLock); > > > break; > > > > > > but this will trigger the assertion > > > > > > Assert(lockmode != NoLock || > > > > > > IsBootstrapProcessingMode() || > > > CheckRelationLockedByMe(r, c, true)); > > > > > > in relation_open (b/src/backend/access/common/relation.c) > > > > > > For now I've commented this assertion out. I've tried to open relation > > > with > > > AccessShareLock but this caused one test to fail, and I am not sure this > > > solution is better. > > > > > > What I have done here I consider a hack, so I need a help of core-team > > > here to do it in right way. > > > > > > General problems: > > > > > > I guess I need a coauthor, or supervisor from core team, to finish this > > > patch. The amount of code is big, and I guess there are parts that can be > > > made more in postgres way, then I did them. And I would need an advice > > > there, and I guess it would be better to do if before sending it to > > > commitfest. > > > > > > > > > Current patch status: > > > > > > 1. It is Beta. Some minor issues and FIXMEs are not solved. Some code > > > comments needs revising, but in general it do what it is intended to do. > > > > > > 2. This patch does not intend to change postgres behavior at all, all > > > should work as before, all changes are internal only. > > > > > > The only exception is error message for unexciting option name in toast > > > namespace > > > > > > CREATE TABLE reloptions_test2 (i int) WITH (toast.not_existing_option = > > > 42);> > > > -ERROR: unrecognized parameter "not_existing_option" > > > +ERROR: unrecognized parameter "toast.not_existing_option" > > > > > > New message is better I guess, though I can change it back if needed. > > > > > > 3. I am doing my development in this blanch > > > https://gitlab.com/dhyannataraj/ postgres/-/tree/new_options_take_two I > > > am making changes every day, so last version will be available there > > > > > > Would be glad to hear from coreteam before I finish with this patch and > > > made it ready for commit-fest. > > > > > > > > > > > > diff --git a/contrib/bloom/bloom.h b/contrib/bloom/bloom.h > > > index a22a6df..8f2d5e7 100644 > > > --- a/contrib/bloom/bloom.h > > > +++ b/contrib/bloom/bloom.h > > > @@ -17,6 +17,7 @@ > > > > > > #include "access/generic_xlog.h" > > > #include "access/itup.h" > > > #include "access/xlog.h" > > > > > > +#include "access/options.h" > > > > > > #include "fmgr.h" > > > #include "nodes/pathnodes.h" > > > > > > @@ -207,7 +208,8 @@ extern IndexBulkDeleteResult > > > *blbulkdelete(IndexVacuumInfo *info,> > > > > void *callback_state); > > > > > > extern IndexBulkDeleteResult *blvacuumcleanup(IndexVacuumInfo *info, > > > > > > > IndexBulkDeleteResult *stats); > > > > > > -extern bytea *bloptions(Datum reloptions, bool validate); > > > +extern void *blrelopt_specset(void); > > > +extern void blReloptionPostprocess(void *, bool validate); > > > > > > extern void blcostestimate(PlannerInfo *root, IndexPath *path, > > > > > > double loop_count, Cost > *indexStartupCost, > > > Cost *indexTotalCost, > Selectivity *indexSelectivity, > > > > > > diff --git a/contrib/bloom/blutils.c b/contrib/bloom/blutils.c > > > index 754de00..54dad16 100644 > > > --- a/contrib/bloom/blutils.c > > > +++ b/contrib/bloom/blutils.c > > > @@ -15,7 +15,7 @@ > > > > > > #include "access/amapi.h" > > > #include "access/generic_xlog.h" > > > > > > -#include "access/reloptions.h" > > > +#include "access/options.h" > > > > > > #include "bloom.h" > > > #include "catalog/index.h" > > > #include "commands/vacuum.h" > > > > > > @@ -34,53 +34,13 @@ > > > > > > PG_FUNCTION_INFO_V1(blhandler); > > > > > > -/* Kind of relation options for bloom index */ > > > -static relopt_kind bl_relopt_kind; > > > - > > > -/* parse table for fillRelOptions */ > > > -static relopt_parse_elt bl_relopt_tab[INDEX_MAX_KEYS + 1]; > > > +/* Catalog of relation options for bloom index */ > > > +static options_spec_set *bl_relopt_specset; > > > > > > static int32 myRand(void); > > > static void mySrand(uint32 seed); > > > > > > /* > > > > > > - * Module initialize function: initialize info about Bloom relation > > > options. - * > > > - * Note: keep this in sync with makeDefaultBloomOptions(). > > > - */ > > > -void > > > -_PG_init(void) > > > -{ > > > - int i; > > > - char buf[16]; > > > - > > > - bl_relopt_kind = add_reloption_kind(); > > > - > > > - /* Option for length of signature */ > > > - add_int_reloption(bl_relopt_kind, "length", > > > - "Length of signature in bits", > > > - DEFAULT_BLOOM_LENGTH, 1, > MAX_BLOOM_LENGTH, > > > - AccessExclusiveLock); > > > - bl_relopt_tab[0].optname = "length"; > > > - bl_relopt_tab[0].opttype = RELOPT_TYPE_INT; > > > - bl_relopt_tab[0].offset = offsetof(BloomOptions, bloomLength); > > > - > > > - /* Number of bits for each possible index column: col1, col2, ... */ > > > - for (i = 0; i < INDEX_MAX_KEYS; i++) > > > - { > > > - snprintf(buf, sizeof(buf), "col%d", i + 1); > > > - add_int_reloption(bl_relopt_kind, buf, > > > - "Number of bits generated > for each index column", > > > - DEFAULT_BLOOM_BITS, 1, > MAX_BLOOM_BITS, > > > - AccessExclusiveLock); > > > - bl_relopt_tab[i + 1].optname = > MemoryContextStrdup(TopMemoryContext, > > > - > buf); > > > - bl_relopt_tab[i + 1].opttype = RELOPT_TYPE_INT; > > > - bl_relopt_tab[i + 1].offset = offsetof(BloomOptions, > bitSize[0]) + > > > sizeof(int) * i; - } > > > -} > > > - > > > -/* > > > > > > * Construct a default set of Bloom options. > > > */ > > > > > > static BloomOptions * > > > > > > @@ -135,7 +95,7 @@ blhandler(PG_FUNCTION_ARGS) > > > > > > amroutine->amvacuumcleanup = blvacuumcleanup; > > > amroutine->amcanreturn = NULL; > > > amroutine->amcostestimate = blcostestimate; > > > > > > - amroutine->amoptions = bloptions; > > > + amroutine->amreloptspecset = blrelopt_specset; > > > > > > amroutine->amproperty = NULL; > > > amroutine->ambuildphasename = NULL; > > > amroutine->amvalidate = blvalidate; > > > > > > @@ -154,6 +114,28 @@ blhandler(PG_FUNCTION_ARGS) > > > > > > PG_RETURN_POINTER(amroutine); > > > > > > } > > > > > > +void > > > +blReloptionPostprocess(void *data, bool validate) > > > +{ > > > + BloomOptions *opts = (BloomOptions *) data; > > > + int i; > > > + > > > + if (validate) > > > + for (i = 0; i < INDEX_MAX_KEYS; i++) > > > + { > > > + if (opts->bitSize[i] >= opts->bloomLength) > > > + { > > > + ereport(ERROR, > > > + > (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > + errmsg("col%i should not be grater > than length", i))); > > > + } > > > + } > > > + > > > + /* Convert signature length from # of bits to # to words, rounding up > */ > > > + opts->bloomLength = (opts->bloomLength + SIGNWORDBITS - 1) / > > > SIGNWORDBITS; +} > > > + > > > + > > > > > > /* > > > > > > * Fill BloomState structure for particular index. > > > */ > > > > > > @@ -474,24 +456,39 @@ BloomInitMetapage(Relation index) > > > > > > UnlockReleaseBuffer(metaBuffer); > > > > > > } > > > > > > -/* > > > - * Parse reloptions for bloom index, producing a BloomOptions struct. > > > - */ > > > -bytea * > > > -bloptions(Datum reloptions, bool validate) > > > +void * > > > +blrelopt_specset(void) > > > > > > { > > > > > > - BloomOptions *rdopts; > > > + int i; > > > + char buf[16]; > > > > > > - /* Parse the user-given reloptions */ > > > - rdopts = (BloomOptions *) build_reloptions(reloptions, validate, > > > - > bl_relopt_kind, > > > - > sizeof(BloomOptions), > > > - > bl_relopt_tab, > > > - > lengthof(bl_relopt_tab)); > > > + if (bl_relopt_specset) > > > + return bl_relopt_specset; > > > > > > - /* Convert signature length from # of bits to # to words, rounding > up */ > > > - if (rdopts) > > > - rdopts->bloomLength = (rdopts->bloomLength + SIGNWORDBITS - > 1) / > > > SIGNWORDBITS; > > > > > > - return (bytea *) rdopts; > > > + bl_relopt_specset = allocateOptionsSpecSet(NULL, > > > + > sizeof(BloomOptions), INDEX_MAX_KEYS + 1); > > > + bl_relopt_specset->postprocess_fun = blReloptionPostprocess; > > > + > > > + optionsSpecSetAddInt(bl_relopt_specset, "length", > > > + "Length of signature > in bits", > > > + NoLock, /* > No lock as far as ALTER is > > > + > * forbidden */ > > > + 0, > > > + > offsetof(BloomOptions, bloomLength), > > > + > DEFAULT_BLOOM_LENGTH, 1, MAX_BLOOM_LENGTH); > > > + > > > + /* Number of bits for each possible index column: col1, col2, ... */ > > > + for (i = 0; i < INDEX_MAX_KEYS; i++) > > > + { > > > + snprintf(buf, 16, "col%d", i + 1); > > > + optionsSpecSetAddInt(bl_relopt_specset, buf, > > > + "Number of bits > for corresponding column", > > > + NoLock, /* > No lock as far as ALTER is > > > + > * forbidden */ > > > + 0, > > > + > offsetof(BloomOptions, bitSize[i]), > > > + > DEFAULT_BLOOM_BITS, 1, MAX_BLOOM_BITS); > > > + } > > > + return bl_relopt_specset; > > > > > > } > > > > > > diff --git a/contrib/bloom/expected/bloom.out > > > b/contrib/bloom/expected/bloom.out index dae12a7..e79456d 100644 > > > --- a/contrib/bloom/expected/bloom.out > > > +++ b/contrib/bloom/expected/bloom.out > > > @@ -228,3 +228,6 @@ CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH > > > (length=0);> > > > ERROR: value 0 out of bounds for option "length" > > > CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH (col1=0); > > > ERROR: value 0 out of bounds for option "col1" > > > > > > +-- check post_validate for colN<lengh > > > +CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH > > > (length=10,col1=11); > > > +ERROR: col0 should not be grater than length > > > diff --git a/contrib/bloom/sql/bloom.sql b/contrib/bloom/sql/bloom.sql > > > index 4733e1e..0bfc767 100644 > > > --- a/contrib/bloom/sql/bloom.sql > > > +++ b/contrib/bloom/sql/bloom.sql > > > @@ -93,3 +93,6 @@ SELECT reloptions FROM pg_class WHERE oid = > > > 'bloomidx'::regclass;> > > > \set VERBOSITY terse > > > CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH (length=0); > > > CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH (col1=0); > > > > > > + > > > +-- check post_validate for colN<lengh > > > +CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH > > > (length=10,col1=11); > > > diff --git a/contrib/dblink/dblink.c b/contrib/dblink/dblink.c > > > index 3a0beaa..a15a10b 100644 > > > --- a/contrib/dblink/dblink.c > > > +++ b/contrib/dblink/dblink.c > > > @@ -2005,7 +2005,7 @@ PG_FUNCTION_INFO_V1(dblink_fdw_validator); > > > > > > Datum > > > dblink_fdw_validator(PG_FUNCTION_ARGS) > > > { > > > > > > - List *options_list = > untransformRelOptions(PG_GETARG_DATUM(0)); > > > + List *options_list = > optionsTextArrayToDefList(PG_GETARG_DATUM(0)); > > > > > > Oid context = PG_GETARG_OID(1); > > > ListCell *cell; > > > > > > diff --git a/contrib/file_fdw/file_fdw.c b/contrib/file_fdw/file_fdw.c > > > index 2c2f149..1194747 100644 > > > --- a/contrib/file_fdw/file_fdw.c > > > +++ b/contrib/file_fdw/file_fdw.c > > > @@ -195,7 +195,7 @@ file_fdw_handler(PG_FUNCTION_ARGS) > > > > > > Datum > > > file_fdw_validator(PG_FUNCTION_ARGS) > > > { > > > > > > - List *options_list = > untransformRelOptions(PG_GETARG_DATUM(0)); > > > + List *options_list = > optionsTextArrayToDefList(PG_GETARG_DATUM(0)); > > > > > > Oid catalog = PG_GETARG_OID(1); > > > char *filename = NULL; > > > DefElem *force_not_null = NULL; > > > > > > diff --git a/contrib/postgres_fdw/option.c b/contrib/postgres_fdw/option.c > > > index 5bb1af4..bbd4167 100644 > > > --- a/contrib/postgres_fdw/option.c > > > +++ b/contrib/postgres_fdw/option.c > > > @@ -72,7 +72,7 @@ PG_FUNCTION_INFO_V1(postgres_fdw_validator); > > > > > > Datum > > > postgres_fdw_validator(PG_FUNCTION_ARGS) > > > { > > > > > > - List *options_list = > untransformRelOptions(PG_GETARG_DATUM(0)); > > > + List *options_list = > optionsTextArrayToDefList(PG_GETARG_DATUM(0)); > > > > > > Oid catalog = PG_GETARG_OID(1); > > > ListCell *cell; > > > > > > diff --git a/src/backend/access/brin/brin.c > > > b/src/backend/access/brin/brin.c index ccc9fa0..5dd52a4 100644 > > > --- a/src/backend/access/brin/brin.c > > > +++ b/src/backend/access/brin/brin.c > > > @@ -20,7 +20,6 @@ > > > > > > #include "access/brin_pageops.h" > > > #include "access/brin_xlog.h" > > > #include "access/relation.h" > > > > > > -#include "access/reloptions.h" > > > > > > #include "access/relscan.h" > > > #include "access/table.h" > > > #include "access/tableam.h" > > > > > > @@ -40,7 +39,6 @@ > > > > > > #include "utils/memutils.h" > > > #include "utils/rel.h" > > > > > > - > > > > > > /* > > > > > > * We use a BrinBuildState during initial construction of a BRIN index. > > > * The running state is kept in a BrinMemTuple. > > > > > > @@ -119,7 +117,6 @@ brinhandler(PG_FUNCTION_ARGS) > > > > > > amroutine->amvacuumcleanup = brinvacuumcleanup; > > > amroutine->amcanreturn = NULL; > > > amroutine->amcostestimate = brincostestimate; > > > > > > - amroutine->amoptions = brinoptions; > > > > > > amroutine->amproperty = NULL; > > > amroutine->ambuildphasename = NULL; > > > amroutine->amvalidate = brinvalidate; > > > > > > @@ -134,6 +131,7 @@ brinhandler(PG_FUNCTION_ARGS) > > > > > > amroutine->amestimateparallelscan = NULL; > > > amroutine->aminitparallelscan = NULL; > > > amroutine->amparallelrescan = NULL; > > > > > > + amroutine->amreloptspecset = bringetreloptspecset; > > > > > > PG_RETURN_POINTER(amroutine); > > > > > > } > > > > > > @@ -963,23 +961,6 @@ brinvacuumcleanup(IndexVacuumInfo *info, > > > IndexBulkDeleteResult *stats)> > > > } > > > > > > /* > > > > > > - * reloptions processor for BRIN indexes > > > - */ > > > -bytea * > > > -brinoptions(Datum reloptions, bool validate) > > > -{ > > > - static const relopt_parse_elt tab[] = { > > > - {"pages_per_range", RELOPT_TYPE_INT, offsetof(BrinOptions, > > > pagesPerRange)}, - {"autosummarize", RELOPT_TYPE_BOOL, > > > offsetof(BrinOptions, autosummarize)} - }; > > > - > > > - return (bytea *) build_reloptions(reloptions, validate, > > > - > RELOPT_KIND_BRIN, > > > - > sizeof(BrinOptions), > > > - > tab, lengthof(tab)); > > > -} > > > - > > > -/* > > > > > > * SQL-callable function to scan through an index and summarize all > > > ranges > > > * that are not currently summarized. > > > */ > > > > > > @@ -1765,3 +1746,32 @@ check_null_keys(BrinValues *bval, ScanKey > > > *nullkeys, int nnullkeys)> > > > return true; > > > > > > } > > > > > > + > > > +static options_spec_set *brin_relopt_specset = NULL; > > > + > > > +void * > > > +bringetreloptspecset(void) > > > +{ > > > + if (brin_relopt_specset) > > > + return brin_relopt_specset; > > > + brin_relopt_specset = allocateOptionsSpecSet(NULL, > > > + > sizeof(BrinOptions), 2); > > > + > > > + optionsSpecSetAddInt(brin_relopt_specset, "pages_per_range", > > > + "Number of pages that each page range covers in a BRIN > index", > > > + NoLock, /* > since ALTER is not allowed > > > + > * no lock needed */ > > > + 0, > > > + offsetof(BrinOptions, > pagesPerRange), > > > + > BRIN_DEFAULT_PAGES_PER_RANGE, > > > + > BRIN_MIN_PAGES_PER_RANGE, > > > + > BRIN_MAX_PAGES_PER_RANGE); > > > + optionsSpecSetAddBool(brin_relopt_specset, "autosummarize", > > > + "Enables automatic summarization on > this BRIN index", > > > + > AccessExclusiveLock, > > > + 0, > > > + > offsetof(BrinOptions, autosummarize), > > > + false); > > > + return brin_relopt_specset; > > > +} > > > + > > > diff --git a/src/backend/access/brin/brin_pageops.c > > > b/src/backend/access/brin/brin_pageops.c index df9ffc2..1940b3d 100644 > > > --- a/src/backend/access/brin/brin_pageops.c > > > +++ b/src/backend/access/brin/brin_pageops.c > > > @@ -420,6 +420,9 @@ brin_doinsert(Relation idxrel, BlockNumber > > > pagesPerRange,> > > > freespace = br_page_get_freespace(page); > > > > > > ItemPointerSet(&tid, blk, off); > > > > > > + > > > +//elog(WARNING, "pages_per_range = %i", pagesPerRange); > > > + > > > > > > brinSetHeapBlockItemptr(revmapbuf, pagesPerRange, heapBlk, tid); > > > MarkBufferDirty(revmapbuf); > > > > > > diff --git a/src/backend/access/common/Makefile > > > b/src/backend/access/common/Makefile index b9aff0c..78c9c5a 100644 > > > --- a/src/backend/access/common/Makefile > > > +++ b/src/backend/access/common/Makefile > > > @@ -18,6 +18,7 @@ OBJS = \ > > > > > > detoast.o \ > > > heaptuple.o \ > > > indextuple.o \ > > > > > > + options.o \ > > > > > > printsimple.o \ > > > printtup.o \ > > > relation.o \ > > > > > > diff --git a/src/backend/access/common/options.c > > > b/src/backend/access/common/options.c new file mode 100644 > > > index 0000000..752cddc > > > --- /dev/null > > > +++ b/src/backend/access/common/options.c > > > @@ -0,0 +1,1468 @@ > > > +/*----------------------------------------------------------------------- > > > -- + * > > > + * options.c > > > + * An unifom, context-free API for processing name=value options. > Used > > > + * to process relation optons (reloptions), attribute options, > opclass > > > + * options, etc. > > > + * > > > + * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group > > > + * Portions Copyright (c) 1994, Regents of the University of California > > > + * > > > + * > > > + * IDENTIFICATION > > > + * src/backend/access/common/options.c > > > + * > > > + > > > *------------------------------------------------------------------------ > > > - + */ > > > + > > > +#include "postgres.h" > > > + > > > +#include "access/options.h" > > > +#include "catalog/pg_type.h" > > > +#include "commands/defrem.h" > > > +#include "nodes/makefuncs.h" > > > +#include "utils/builtins.h" > > > +#include "utils/guc.h" > > > +#include "utils/memutils.h" > > > +#include "mb/pg_wchar.h" > > > + > > > + > > > +/* > > > + * OPTIONS SPECIFICATION and OPTION SPECIFICATION SET > > > + * > > > + * Each option is defined via Option Specification object (Option Spec). > > > + * Option Spec should have all information that is needed for processing > > > + * (parsing, validating, converting) of a single option. Implemented via > > > set of + * option_spec_* structures. > > > + * > > > + * A set of Option Specs (Options Spec Set), defines all options > > > available for + * certain object (certain relation kind for example). It > > > is a list of + * Options Specs, plus validation functions that can be > > > used to validate whole + * option set, if needed. Implemenred via > > > options_spec_set structure and set of + * optionsSpecSetAdd* functions > > > that are used for adding Option Specs items to + * a Set. > > > + * > > > + * NOTE: we choose therm "sepcification" instead of "definition" because > > > therm + * "definition" is used for objects that came from lexer. So to > > > avoud confusion + * here we have Option Specifications, and all > > > "definitions" are from lexer. + */ > > > + > > > +/* > > > + * OPTION VALUES REPRESENTATIONS > > > + * > > > + * Option values usually came from lexer in form of defList obect, stored > > > in + * pg_catalog as text array, and used when they are stored in memory > > > as + * C-structure. These are different option values representations. > > > Here goes + * brief description of all representations used in the code. > > > + * > > > + * Values > > > + * > > > + * Values are an internal representation that is used while converting > > > + * Values between other representation. Value is called "parsed", > > > + * when Value's value is converted to a proper type and validated, or is > > > called + * "unparsed", when Value's value is stored as raw string that > > > was obtained + * from the source without any cheks. In convertation > > > funcion names first case + * is refered as Values, second case is refered > > > as RawValues. Values is + * implemented as List of option_value > > > C-structures. > > > + * > > > + * defList > > > + * > > > + * Options in form of definition List that comes from lexer. (For > > > reloptions it + * is a part of SQL query that goes after WITH, SET or > > > RESET keywords). Can be + * converted to and from Values using > > > optionsDefListToRawValues and + * optionsTextArrayToRawValues functions. > > > + * > > > + * TEXT[] > > > + * > > > + * Options in form suitable for storig in TEXT[] field in DB. (E.g. > > > reloptions + * are stores in pg_catalog.pg_class table in reloptions > > > field). Can be converted + * to and from Values using > > > optionsValuesToTextArray and optionsTextArrayToRawValues + * functions. > > > + * > > > + * Bytea > > > + * > > > + * Option data stored in C-structure with varlena header in the beginning > > > of the + * structure. This representation is used to pass option values > > > to the core + * postgres. It is fast to read, it can be cached and so on. > > > Bytea rpresentation + * can be obtained from Vales using > > > optionsValuesToBytea function, and can't be + * converted back. > > > + */ > > > + > > > +static option_spec_basic *allocateOptionSpec(int type, const char *name, > > > + const char *desc, LOCKMODE > lockmode, > > > + option_spec_flags flags, int > struct_offset); > > > + > > > +static void parse_one_option(option_value * option, const char *text_str, > > > + int text_len, bool validate); > > > +static void *optionsAllocateBytea(options_spec_set * spec_set, List > > > *options); + > > > + > > > +static List * > > > +optionsDefListToRawValues(List *defList, options_parse_mode > > > + parse_mode); > > > +static Datum optionsValuesToTextArray(List *options_values); > > > +static List *optionsMergeOptionValues(List *old_options, List > > > *new_options); +static bytea *optionsValuesToBytea(List *options, > > > options_spec_set * spec_set); +List *optionsTextArrayToRawValues(Datum > > > array_datum); > > > +List *optionsParseRawValues(List *raw_values, options_spec_set * > > > spec_set, > > > + options_parse_mode mode); > > > + > > > + > > > +/* > > > + * Options spec_set functions > > > + */ > > > + > > > +/* > > > + * Options catalog describes options available for certain object. > > > Catalog has + * all necessary information for parsing transforming and > > > validating options + * for an object. All > > > parsing/validation/transformation functions should not + * know any > > > details of option implementation for certain object, all this + * > > > information should be stored in catalog instead and interpreted by + * > > > pars/valid/transf functions blindly. > > > + * > > > + * The heart of the option catalog is an array of option definitions. > > > Options + * definition specifies name of option, type, range of > > > acceptable values, and + * default value. > > > + * > > > + * Options values can be one of the following types: bool, int, real, > > > enum, + * string. For more info see "option_type" and > > > "optionsCatalogAddItemYyyy" + * functions. > > > + * > > > + * Option definition flags allows to define parser behavior for special > > > (or not + * so special) cases. See option_spec_flags for more info. > > > + * > > > + * Options and Lock levels: > > > + * > > > + * The default choice for any new option should be AccessExclusiveLock. > > > + * In some cases the lock level can be reduced from there, but the lock > > > + * level chosen should always conflict with itself to ensure that > > > multiple > > > + * changes aren't lost when we attempt concurrent changes. > > > + * The choice of lock level depends completely upon how that parameter > > > + * is used within the server, not upon how and when you'd like to change > > > it. + * Safety first. Existing choices are documented here, and elsewhere > > > in + * backend code where the parameters are used. > > > + * > > > + * In general, anything that affects the results obtained from a SELECT > > > must be + * protected by AccessExclusiveLock. > > > + * > > > + * Autovacuum related parameters can be set at ShareUpdateExclusiveLock > > > + * since they are only used by the AV procs and don't change anything > > > + * currently executing. > > > + * > > > + * Fillfactor can be set because it applies only to subsequent changes > > > made to + * data blocks, as documented in heapio.c > > > + * > > > + * n_distinct options can be set at ShareUpdateExclusiveLock because they > > > + * are only used during ANALYZE, which uses a ShareUpdateExclusiveLock, > > > + * so the ANALYZE will not be affected by in-flight changes. Changing > > > those + * values has no affect until the next ANALYZE, so no need for > > > stronger lock. + * > > > + * Planner-related parameters can be set with ShareUpdateExclusiveLock > > > because + * they only affect planning and not the correctness of the > > > execution. Plans + * cannot be changed in mid-flight, so changes here > > > could not easily result in + * new improved plans in any case. So we > > > allow existing queries to continue + * and existing plans to survive, a > > > small price to pay for allowing better + * plans to be introduced > > > concurrently without interfering with users. + * > > > + * Setting parallel_workers is safe, since it acts the same as > > > + * max_parallel_workers_per_gather which is a USERSET parameter that > > > doesn't + * affect existing plans or queries. > > > +*/ > > > + > > > +/* > > > + * allocateOptionsSpecSet > > > + * Creates new Option Spec Set object: Allocates memory and > initializes > > > + * structure members. > > > + * > > > + * Spec Set items can be add via allocateOptionSpec and > > > optionSpecSetAddItem functions + * or by calling directly any of > > > optionsSpecSetAdd* function (preferable way) + * > > > + * namespace - Spec Set can be bind to certain namespace (E.g. > > > + * namespace.option=value). Options from other namespaces will be ignored > > > while + * processing. If set to NULL, no namespace will be used at all. > > > + * > > > + * size_of_bytea - size of target structure of Bytea options > > > represenation > > > + * > > > + * num_items_expected - if you know expected number of Spec Set items set > > > it here. + * Set to -1 in other cases. num_items_expected will be used > > > for preallocating memory + * and will trigger error, if you try to add > > > more items than you expected. + */ > > > + > > > +options_spec_set * > > > +allocateOptionsSpecSet(const char *namespace, int size_of_bytea, int > > > num_items_expected) +{ > > > + MemoryContext oldcxt; > > > + options_spec_set *spec_set; > > > + > > > + oldcxt = MemoryContextSwitchTo(TopMemoryContext); > > > + spec_set = palloc(sizeof(options_spec_set)); > > > + if (namespace) > > > + { > > > + spec_set->namespace = palloc(strlen(namespace) + 1); > > > + strcpy(spec_set->namespace, namespace); > > > + } > > > + else > > > + spec_set->namespace = NULL; > > > + if (num_items_expected > 0) > > > + { > > > + spec_set->num_allocated = num_items_expected; > > > + spec_set->forbid_realloc = true; > > > + spec_set->definitions = palloc( > > > + spec_set->num_allocated * > sizeof(option_spec_basic *)); > > > + } > > > + else > > > + { > > > + spec_set->num_allocated = 0; > > > + spec_set->forbid_realloc = false; > > > + spec_set->definitions = NULL; > > > + } > > > + spec_set->num = 0; > > > + spec_set->struct_size = size_of_bytea; > > > + spec_set->postprocess_fun = NULL; > > > + MemoryContextSwitchTo(oldcxt); > > > + return spec_set; > > > +} > > > + > > > +/* > > > + * allocateOptionSpec > > > + * Allocates a new Option Specifiation object of desired type > and > > > + * initialize the type-independent fields > > > + */ > > > +static option_spec_basic * > > > +allocateOptionSpec(int type, const char *name, const char *desc, LOCKMODE > > > lockmode, + option_spec_flags > flags, int struct_offset) > > > +{ > > > + MemoryContext oldcxt; > > > + size_t size; > > > + option_spec_basic *newoption; > > > + > > > + oldcxt = MemoryContextSwitchTo(TopMemoryContext); > > > + > > > + switch (type) > > > + { > > > + case OPTION_TYPE_BOOL: > > > + size = sizeof(option_spec_bool); > > > + break; > > > + case OPTION_TYPE_INT: > > > + size = sizeof(option_spec_int); > > > + break; > > > + case OPTION_TYPE_REAL: > > > + size = sizeof(option_spec_real); > > > + break; > > > + case OPTION_TYPE_ENUM: > > > + size = sizeof(option_spec_enum); > > > + break; > > > + case OPTION_TYPE_STRING: > > > + size = sizeof(option_spec_string); > > > + break; > > > + default: > > > + elog(ERROR, "unsupported reloption type %d", type); > > > + return NULL; /* keep compiler quiet */ > > > + } > > > + > > > + newoption = palloc(size); > > > + > > > + newoption->name = pstrdup(name); > > > + if (desc) > > > + newoption->desc = pstrdup(desc); > > > + else > > > + newoption->desc = NULL; > > > + newoption->type = type; > > > + newoption->lockmode = lockmode; > > > + newoption->flags = flags; > > > + newoption->struct_offset = struct_offset; > > > + > > > + MemoryContextSwitchTo(oldcxt); > > > + > > > + return newoption; > > > +} > > > + > > > +/* > > > + * optionSpecSetAddItem > > > + * Adds pre-created Option Specification objec to the Spec Set > > > + */ > > > +static void > > > +optionSpecSetAddItem(option_spec_basic * newoption, > > > + options_spec_set * spec_set) > > > +{ > > > + if (spec_set->num >= spec_set->num_allocated) > > > + { > > > + MemoryContext oldcxt; > > > + > > > + Assert(!spec_set->forbid_realloc); > > > + oldcxt = MemoryContextSwitchTo(TopMemoryContext); > > > + > > > + if (spec_set->num_allocated == 0) > > > + { > > > + spec_set->num_allocated = 8; > > > + spec_set->definitions = palloc( > > > + spec_set->num_allocated * > sizeof(option_spec_basic *)); > > > + } > > > + else > > > + { > > > + spec_set->num_allocated *= 2; > > > + spec_set->definitions = repalloc(spec_set->definitions, > > > + spec_set->num_allocated * > sizeof(option_spec_basic *)); > > > + } > > > + MemoryContextSwitchTo(oldcxt); > > > + } > > > + spec_set->definitions[spec_set->num] = newoption; > > > + spec_set->num++; > > > +} > > > + > > > + > > > +/* > > > + * optionsSpecSetAddBool > > > + * Adds boolean Option Specification entry to the Spec Set > > > + */ > > > +void > > > +optionsSpecSetAddBool(options_spec_set * spec_set, const char *name, > > > const char *desc, + > LOCKMODE lockmode, option_spec_flags flags, > > > + int struct_offset, bool > default_val) > > > +{ > > > + option_spec_bool *spec_set_item; > > > + > > > + spec_set_item = (option_spec_bool *) > > > + allocateOptionSpec(OPTION_TYPE_BOOL, name, desc, lockmode, > > > + flags, > struct_offset); > > > + > > > + spec_set_item->default_val = default_val; > > > + > > > + optionSpecSetAddItem((option_spec_basic *) spec_set_item, spec_set); > > > +} > > > + > > > +/* > > > + * optionsSpecSetAddInt > > > + * Adds integer Option Specification entry to the Spec Set > > > + */ > > > +void > > > +optionsSpecSetAddInt(options_spec_set * spec_set, const char *name, > > > + const char *desc, LOCKMODE lockmode, option_spec_flags flags, > > > + int struct_offset, int default_val, int > min_val, int max_val) > > > +{ > > > + option_spec_int *spec_set_item; > > > + > > > + spec_set_item = (option_spec_int *) > > > + allocateOptionSpec(OPTION_TYPE_INT, name, desc, lockmode, > > > + flags, > struct_offset); > > > + > > > + spec_set_item->default_val = default_val; > > > + spec_set_item->min = min_val; > > > + spec_set_item->max = max_val; > > > + > > > + optionSpecSetAddItem((option_spec_basic *) spec_set_item, spec_set); > > > +} > > > + > > > +/* > > > + * optionsSpecSetAddReal > > > + * Adds float Option Specification entry to the Spec Set > > > + */ > > > +void > > > +optionsSpecSetAddReal(options_spec_set * spec_set, const char *name, > > > const char *desc, + LOCKMODE lockmode, option_spec_flags > flags, int > > > struct_offset, + double > default_val, double min_val, double > > > max_val) > > > +{ > > > + option_spec_real *spec_set_item; > > > + > > > + spec_set_item = (option_spec_real *) > > > + allocateOptionSpec(OPTION_TYPE_REAL, name, desc, lockmode, > > > + flags, > struct_offset); > > > + > > > + spec_set_item->default_val = default_val; > > > + spec_set_item->min = min_val; > > > + spec_set_item->max = max_val; > > > + > > > + optionSpecSetAddItem((option_spec_basic *) spec_set_item, spec_set); > > > +} > > > + > > > +/* > > > + * optionsSpecSetAddEnum > > > + * Adds enum Option Specification entry to the Spec Set > > > + * > > > + * The members array must have a terminating NULL entry. > > > + * > > > + * The detailmsg is shown when unsupported values are passed, and has > > > this > > > + * form: "Valid values are \"foo\", \"bar\", and \"bar\"." > > > + * > > > + * The members array and detailmsg are not copied -- caller must ensure > > > that + * they are valid throughout the life of the process. > > > + */ > > > + > > > +void > > > +optionsSpecSetAddEnum(options_spec_set * spec_set, const char *name, > > > const char *desc, + LOCKMODE lockmode, option_spec_flags flags, > int > > > struct_offset, > > > + opt_enum_elt_def * members, int default_val, const char > *detailmsg) > > > +{ > > > + option_spec_enum *spec_set_item; > > > + > > > + spec_set_item = (option_spec_enum *) > > > + allocateOptionSpec(OPTION_TYPE_ENUM, name, desc, lockmode, > > > + flags, > struct_offset); > > > + > > > + spec_set_item->default_val = default_val; > > > + spec_set_item->members = members; > > > + spec_set_item->detailmsg = detailmsg; > > > + > > > + optionSpecSetAddItem((option_spec_basic *) spec_set_item, spec_set); > > > +} > > > + > > > +/* > > > + * optionsSpecSetAddString > > > + * Adds string Option Specification entry to the Spec Set > > > + * > > > + * "validator" is an optional function pointer that can be used to test > > > the + * validity of the values. It must elog(ERROR) when the argument > > > string is + * not acceptable for the variable. Note that the default > > > value must pass + * the validation. > > > + */ > > > +void > > > +optionsSpecSetAddString(options_spec_set * spec_set, const char *name, > > > const char *desc, + LOCKMODE lockmode, option_spec_flags > flags, int > > > struct_offset, + const char *default_val, > validate_string_option > > > validator) +{ > > > + option_spec_string *spec_set_item; > > > + > > > + /* make sure the validator/default combination is sane */ > > > + if (validator) > > > + (validator) (default_val); > > > + > > > + spec_set_item = (option_spec_string *) > > > + allocateOptionSpec(OPTION_TYPE_STRING, name, desc, lockmode, > > > + flags, > struct_offset); > > > + spec_set_item->validate_cb = validator; > > > + > > > + if (default_val) > > > + spec_set_item->default_val = > MemoryContextStrdup(TopMemoryContext, > > > + > default_val); > > > + else > > > + spec_set_item->default_val = NULL; > > > + optionSpecSetAddItem((option_spec_basic *) spec_set_item, spec_set); > > > +} > > > + > > > + > > > +/* > > > + * Options transform functions > > > + */ > > > + > > > +/* FIXME this comment should be updated > > > + * Option values exists in five representations: DefList, TextArray, > > > Values and + * Bytea: > > > + * > > > + * DefList: Is a List of DefElem structures, that comes from syntax > > > analyzer. + * It can be transformed to Values representation for further > > > parsing and + * validating > > > + * > > > + * Values: A List of option_value structures. Is divided into two > > > subclasses: + * RawValues, when values are already transformed from > > > DefList or TextArray, + * but not parsed yet. (In this case you should > > > use raw_name and raw_value + * structure members to see option content). > > > ParsedValues (or just simple + * Values) is crated after finding a > > > definition for this option in a spec_set + * and after parsing of the raw > > > value. For ParsedValues content is stored in + * values structure member, > > > and name can be taken from option definition in gen + * structure member. > > > Actually Value list can have both Raw and Parsed values, + * as we do > > > not validate options that came from database, and db option that + * does > > > not exist in spec_set is just ignored, and kept as RawValues + * > > > + * TextArray: The representation in which options for existing object > > > comes + * and goes from/to database; for example from > > > pg_class.reloptions. It is a + * plain TEXT[] db object with name=value > > > text inside. This representation can + * be transformed into Values for > > > further processing, using options spec_set. + * > > > + * Bytea: Is a binary representation of options. Each object that has > > > code that + * uses options, should create a C-structure for this options, > > > with varlen + * 4-byte header in front of the data; all items of options > > > spec_set should have + * an offset of a corresponding binary data in this > > > structure, so transform + * function can put this data in the correct > > > place. One can transform options + * data from values representation into > > > Bytea, using spec_set data, and then use + * it as a usual Datum object, > > > when needed. This Datum should be cached + * somewhere (for example in > > > rel->rd_options for relations) when object that + * has option is loaded > > > from db. > > > + */ > > > + > > > + > > > +/* optionsDefListToRawValues > > > + * Converts option values that came from syntax analyzer > (DefList) into > > > + * Values List. > > > + * > > > + * No parsing is done here except for checking that RESET syntax is > > > correct + * (syntax analyzer do not see difference between SET and RESET > > > cases, we + * should treat it here manually > > > + */ > > > +static List * > > > +optionsDefListToRawValues(List *defList, options_parse_mode parse_mode) > > > +{ > > > + ListCell *cell; > > > + List *result = NIL; > > > + > > > + foreach(cell, defList) > > > + { > > > + option_value *option_dst; > > > + DefElem *def = (DefElem *) lfirst(cell); > > > + char *value; > > > + > > > + option_dst = palloc(sizeof(option_value)); > > > + > > > + if (def->defnamespace) > > > + { > > > + option_dst->namespace = palloc(strlen(def- > >defnamespace) + 1); > > > + strcpy(option_dst->namespace, def->defnamespace); > > > + } > > > + else > > > + { > > > + option_dst->namespace = NULL; > > > + } > > > + option_dst->raw_name = palloc(strlen(def->defname) + 1); > > > + strcpy(option_dst->raw_name, def->defname); > > > + > > > + if (parse_mode & OPTIONS_PARSE_MODE_FOR_RESET) > > > + { > > > + /* > > > + * If this option came from RESET statement we should > throw error > > > + * it it brings us name=value data, as syntax > analyzer do not > > > + * prevent it > > > + */ > > > + if (def->arg != NULL) > > > + ereport(ERROR, > > > + > (errcode(ERRCODE_SYNTAX_ERROR), > > > + errmsg("RESET must not include values > for parameters"))); > > > + > > > + option_dst->status = OPTION_VALUE_STATUS_FOR_RESET; > > > + } > > > + else > > > + { > > > + /* > > > + * For SET statement we should treat (name) > expression as if it is > > > + * actually (name=true) so do it here manually. In > other cases > > > + * just use value as we should use it > > > + */ > > > + option_dst->status = OPTION_VALUE_STATUS_RAW; > > > + if (def->arg != NULL) > > > + value = defGetString(def); > > > + else > > > + value = "true"; > > > + option_dst->raw_value = palloc(strlen(value) + 1); > > > + strcpy(option_dst->raw_value, value); > > > + } > > > + > > > + result = lappend(result, option_dst); > > > + } > > > + return result; > > > +} > > > + > > > +/* > > > + * optionsValuesToTextArray > > > + * Converts List of option_values into TextArray > > > + * > > > + * Convertation is made to put options into database (e.g. in > > > + * pg_class.reloptions for all relation options) > > > + */ > > > + > > > +Datum > > > +optionsValuesToTextArray(List *options_values) > > > +{ > > > + ArrayBuildState *astate = NULL; > > > + ListCell *cell; > > > + Datum result; > > > + > > > + foreach(cell, options_values) > > > + { > > > + option_value *option = (option_value *) lfirst(cell); > > > + const char *name; > > > + char *value; > > > + text *t; > > > + int len; > > > + > > > + /* > > > + * Raw value were not cleared while parsing, so instead of > converting > > > + * it back, just use it to store value as text > > > + */ > > > + value = option->raw_value; > > > + > > > + Assert(option->status != OPTION_VALUE_STATUS_EMPTY); > > > + > > > + /* > > > + * Name will be taken from option definition, if option were > parsed or > > > + * from raw_name if option were not parsed for some reason > > > + */ > > > + if (option->status == OPTION_VALUE_STATUS_PARSED) > > > + name = option->gen->name; > > > + else > > > + name = option->raw_name; > > > + > > > + /* > > > + * Now build "name=value" string and append it to the array > > > + */ > > > + len = VARHDRSZ + strlen(name) + strlen(value) + 1; > > > + t = (text *) palloc(len + 1); > > > + SET_VARSIZE(t, len); > > > + sprintf(VARDATA(t), "%s=%s", name, value); > > > + astate = accumArrayResult(astate, PointerGetDatum(t), false, > > > + TEXTOID, > CurrentMemoryContext); > > > + } > > > + if (astate) > > > + result = makeArrayResult(astate, CurrentMemoryContext); > > > + else > > > + result = (Datum) 0; > > > + > > > + return result; > > > +} > > > + > > > +/* > > > + * optionsTextArrayToRawValues > > > + * Converts options from TextArray format into RawValues list. > > > + * > > > + * This function is used to convert options data that comes from > database > > > to + * List of option_values, for further parsing, and, in the case of > > > ALTER + * command, for merging with new option values. > > > + */ > > > +List * > > > +optionsTextArrayToRawValues(Datum array_datum) > > > +{ > > > + List *result = NIL; > > > + > > > + if (PointerIsValid(DatumGetPointer(array_datum))) > > > + { > > > + ArrayType *array = DatumGetArrayTypeP(array_datum); > > > + Datum *options; > > > + int noptions; > > > + int i; > > > + > > > + deconstruct_array(array, TEXTOID, -1, false, 'i', > > > + &options, NULL, &noptions); > > > + > > > + for (i = 0; i < noptions; i++) > > > + { > > > + option_value *option_dst; > > > + char *text_str = VARDATA(options[i]); > > > + int text_len = > VARSIZE(options[i]) - VARHDRSZ; > > > + int i; > > > + int name_len = -1; > > > + char *name; > > > + int raw_value_len; > > > + char *raw_value; > > > + > > > + /* > > > + * Find position of '=' sign and treat id as a > separator between > > > + * name and value in "name=value" item > > > + */ > > > + for (i = 0; i < text_len; i = i + pg_mblen(text_str)) > > > + { > > > + if (text_str[i] == '=') > > > + { > > > + name_len = i; > > > + break; > > > + } > > > + } > > > + Assert(name_len >= 1); /* Just in case > */ > > > + > > > + raw_value_len = text_len - name_len - 1; > > > + > > > + /* > > > + * Copy name from src > > > + */ > > > + name = palloc(name_len + 1); > > > + memcpy(name, text_str, name_len); > > > + name[name_len] = '\0'; > > > + > > > + /* > > > + * Copy value from src > > > + */ > > > + raw_value = palloc(raw_value_len + 1); > > > + memcpy(raw_value, text_str + name_len + 1, > raw_value_len); > > > + raw_value[raw_value_len] = '\0'; > > > + > > > + /* > > > + * Create new option_value item > > > + */ > > > + option_dst = palloc(sizeof(option_value)); > > > + option_dst->status = OPTION_VALUE_STATUS_RAW; > > > + option_dst->raw_name = name; > > > + option_dst->raw_value = raw_value; > > > + option_dst->namespace = NULL; > > > + > > > + result = lappend(result, option_dst); > > > + } > > > + } > > > + return result; > > > +} > > > + > > > +/* > > > + * optionsMergeOptionValues > > > + * Merges two lists of option_values into one list > > > + * > > > + * This function is used to merge two Values list into one. It is used > > > for all + * kinds of ALTER commands when existing options are > > > merged|replaced with new + * options list. This function also process > > > RESET variant of ALTER command. It + * merges two lists as usual, and > > > then removes all items with RESET flag on. + * > > > + * Both incoming lists will be destroyed while merging > > > + */ > > > +static List * > > > +optionsMergeOptionValues(List *old_options, List *new_options) > > > +{ > > > + List *result = NIL; > > > + ListCell *old_cell; > > > + ListCell *new_cell; > > > + > > > + /* > > > + * First add to result all old options that are not mentioned in new > > > list > > > + */ > > > + foreach(old_cell, old_options) > > > + { > > > + bool found; > > > + const char *old_name; > > > + option_value *old_option; > > > + > > > + old_option = (option_value *) lfirst(old_cell); > > > + if (old_option->status == OPTION_VALUE_STATUS_PARSED) > > > + old_name = old_option->gen->name; > > > + else > > > + old_name = old_option->raw_name; > > > + > > > + /* > > > + * Looking for a new option with same name > > > + */ > > > + found = false; > > > + foreach(new_cell, new_options) > > > + { > > > + option_value *new_option; > > > + const char *new_name; > > > + > > > + new_option = (option_value *) lfirst(new_cell); > > > + if (new_option->status == OPTION_VALUE_STATUS_PARSED) > > > + new_name = new_option->gen->name; > > > + else > > > + new_name = new_option->raw_name; > > > + > > > + if (strcmp(new_name, old_name) == 0) > > > + { > > > + found = true; > > > + break; > > > + } > > > + } > > > + if (!found) > > > + result = lappend(result, old_option); > > > + } > > > + /* > > > + * Now add all to result all new options that are not designated for > > > reset + */ > > > + foreach(new_cell, new_options) > > > + { > > > + option_value *new_option; > > > + new_option = (option_value *) lfirst(new_cell); > > > + > > > + if(new_option->status != OPTION_VALUE_STATUS_FOR_RESET) > > > + result = lappend(result, new_option); > > > + } > > > + return result; > > > +} > > > + > > > +/* > > > + * optionsDefListValdateNamespaces > > > + * Function checks that all options represented as DefList has > no > > > + * namespaces or have namespaces only from allowed list > > > + * > > > + * Function accept options as DefList and NULL terminated list of allowed > > > + * namespaces. It throws an error if not proper namespace was found. > > > + * > > > + * This function actually used only for tables with it's toast. namespace > > > + */ > > > +void > > > +optionsDefListValdateNamespaces(List *defList, char **allowed_namespaces) > > > +{ > > > + ListCell *cell; > > > + > > > + foreach(cell, defList) > > > + { > > > + DefElem *def = (DefElem *) lfirst(cell); > > > + > > > + /* > > > + * Checking namespace only for options that have namespaces. > Options > > > + * with no namespaces are always accepted > > > + */ > > > + if (def->defnamespace) > > > + { > > > + bool found = false; > > > + int i = 0; > > > + > > > + while (allowed_namespaces[i]) > > > + { > > > + if (strcmp(def->defnamespace, > > > + > allowed_namespaces[i]) == 0) > > > + { > > > + found = true; > > > + break; > > > + } > > > + i++; > > > + } > > > + if (!found) > > > + ereport(ERROR, > > > + > (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > + errmsg("unrecognized > parameter namespace \"%s\"", > > > + def- > >defnamespace))); > > > + } > > > + } > > > +} > > > + > > > +/* > > > + * optionsDefListFilterNamespaces > > > + * Iterates over DefList, choose items with specified namespace > and adds > > > + * them to a result List > > > + * > > > + * This function does not destroy source DefList but does not create > > > copies + * of List nodes. > > > + * It is actually used only for tables, in order to split toast and heap > > > + * reloptions, so each one can be stored in on it's own pg_class record > > > + */ > > > +List * > > > +optionsDefListFilterNamespaces(List *defList, const char *namespace) > > > +{ > > > + ListCell *cell; > > > + List *result = NIL; > > > + > > > + foreach(cell, defList) > > > + { > > > + DefElem *def = (DefElem *) lfirst(cell); > > > + > > > + if ((!namespace && !def->defnamespace) || > > > + (namespace && def->defnamespace && > > > + strcmp(namespace, def->defnamespace) == 0)) > > > + { > > > + result = lappend(result, def); > > > + } > > > + } > > > + return result; > > > +} > > > + > > > +/* > > > + * optionsTextArrayToDefList > > > + * Convert the text-array format of reloptions into a List of > DefElem. > > > + */ > > > +List * > > > +optionsTextArrayToDefList(Datum options) > > > +{ > > > + List *result = NIL; > > > + ArrayType *array; > > > + Datum *optiondatums; > > > + int noptions; > > > + int i; > > > + > > > + /* Nothing to do if no options */ > > > + if (!PointerIsValid(DatumGetPointer(options))) > > > + return result; > > > + > > > + array = DatumGetArrayTypeP(options); > > > + > > > + deconstruct_array(array, TEXTOID, -1, false, 'i', > > > + &optiondatums, NULL, &noptions); > > > + > > > + for (i = 0; i < noptions; i++) > > > + { > > > + char *s; > > > + char *p; > > > + Node *val = NULL; > > > + > > > + s = TextDatumGetCString(optiondatums[i]); > > > + p = strchr(s, '='); > > > + if (p) > > > + { > > > + *p++ = '\0'; > > > + val = (Node *) makeString(pstrdup(p)); > > > + } > > > + result = lappend(result, makeDefElem(pstrdup(s), val, -1)); > > > + } > > > + > > > + return result; > > > +} > > > + > > > +/* FIXME write comment here */ > > > + > > > +Datum > > > +optionsDefListToTextArray(List *defList) > > > +{ > > > + ListCell *cell; > > > + Datum result; > > > + ArrayBuildState *astate = NULL; > > > + > > > + foreach(cell, defList) > > > + { > > > + DefElem *def = (DefElem *) lfirst(cell); > > > + const char *name = def->defname; > > > + const char *value; > > > + text *t; > > > + int len; > > > + > > > + if (def->arg != NULL) > > > + value = defGetString(def); > > > + else > > > + value = "true"; > > > + > > > + if (def->defnamespace) > > > + { > > > + Assert(false); /* Should not get here */ > > > + /* This function is used for backward compatibility > in the place were > > > namespases are not allowed */ + return (Datum) 0; > > > + } > > > + len = VARHDRSZ + strlen(name) + strlen(value) + 1; > > > + t = (text *) palloc(len + 1); > > > + SET_VARSIZE(t, len); > > > + sprintf(VARDATA(t), "%s=%s", name, value); > > > + astate = accumArrayResult(astate, PointerGetDatum(t), false, > > > + TEXTOID, > CurrentMemoryContext); > > > + > > > + } > > > + if (astate) > > > + result = makeArrayResult(astate, CurrentMemoryContext); > > > + else > > > + result = (Datum) 0; > > > + return result; > > > +} > > > + > > > + > > > +/* > > > + * optionsParseRawValues > > > + * Parses and vlaidates (if proper flag is set) option_values. > As a > > > result + * caller will get the list of parsed (or partly > parsed) > > > option_values + * > > > + * This function is used in cases when caller gets raw values from db or > > > + * syntax and want to parse them. > > > + * This function uses option_spec_set to get information about how each > > > option + * should be parsed. > > > + * If validate mode is off, function found an option that do not have > > > proper + * option_spec_set entry, this option kept unparsed (if some > > > garbage came from + * the DB, we should put it back there) > > > + * > > > + * This function destroys incoming list. > > > + */ > > > +List * > > > +optionsParseRawValues(List *raw_values, options_spec_set * spec_set, > > > + options_parse_mode mode) > > > +{ > > > + ListCell *cell; > > > + List *result = NIL; > > > + bool *is_set; > > > + int i; > > > + bool validate = mode & OPTIONS_PARSE_MODE_VALIDATE; > > > + bool for_alter = mode & OPTIONS_PARSE_MODE_FOR_ALTER; > > > + > > > + > > > + is_set = palloc0(sizeof(bool) * spec_set->num); > > > + foreach(cell, raw_values) > > > + { > > > + option_value *option = (option_value *) lfirst(cell); > > > + bool found = false; > > > + bool skip = false; > > > + > > > + > > > + if (option->status == OPTION_VALUE_STATUS_PARSED) > > > + { > > > + /* > > > + * This can happen while ALTER, when new values were > already > > > + * parsed, but old values merged from DB are still > raw > > > + */ > > > + result = lappend(result, option); > > > + continue; > > > + } > > > + if (validate && option->namespace && (!spec_set->namespace || > > > + strcmp(spec_set->namespace, option- > >namespace) != 0)) > > > + { > > > + ereport(ERROR, > > > + > (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > + errmsg("unrecognized parameter > namespace \"%s\"", > > > + option->namespace))); > > > + } > > > + > > > + for (i = 0; i < spec_set->num; i++) > > > + { > > > + option_spec_basic *definition = spec_set- > >definitions[i]; > > > + > > > + if (strcmp(option->raw_name, > > > + definition->name) == > 0) > > > + { > > > + /* > > > + * Skip option with "ignore" flag, as it is > processed > > > + * somewhere else. (WITH OIDS special case) > > > + */ > > > + if (definition->flags & > OPTION_DEFINITION_FLAG_IGNORE) > > > + { > > > + found = true; > > > + skip = true; > > > + break; > > > + } > > > + > > > + /* > > > + * Reject option as if it was not in > spec_set. Needed for cases > > > + * when option should have default value, but > should not be > > > + * changed > > > + */ > > > + if (definition->flags & > OPTION_DEFINITION_FLAG_REJECT) > > > + { > > > + found = false; > > > + break; > > > + } > > > + > > > + if (validate && is_set[i]) > > > + { > > > + ereport(ERROR, > > > + > (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > + errmsg("parameter \"%s\" > specified more than once", > > > + option- > >raw_name))); > > > + } > > > + if ((for_alter) && > > > + (definition->flags & > OPTION_DEFINITION_FLAG_FORBID_ALTER)) > > > + { > > > + ereport(ERROR, > > > + > (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > + errmsg("changing parameter > \"%s\" is not allowed", > > > + definition- > >name))); > > > + } > > > + if (option->status == > OPTION_VALUE_STATUS_FOR_RESET) > > > + { > > > + /* > > > + * For RESET options do not need > further processing so > > > + * mark it found and stop searching > > > + */ > > > + found = true; > > > + break; > > > + } > > > + pfree(option->raw_name); > > > + option->raw_name = NULL; > > > + option->gen = definition; > > > + parse_one_option(option, NULL, -1, validate); > > > + is_set[i] = true; > > > + found = true; > > > + break; > > > + } > > > + } > > > + if (!found) > > > + { > > > + if (validate) > > > + { > > > + if (option->namespace) > > > + ereport(ERROR, > > > + > (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > + errmsg("unrecognized > parameter \"%s.%s\"", > > > + > option->namespace, option->raw_name))); > > > + else > > > + ereport(ERROR, > > > + > (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > + errmsg("unrecognized > parameter \"%s\"", > > > + > option->raw_name))); > > > + } else > > > + { > > > + /* RESET is always in non-validating mode, > unkown names should > > > + * be ignored. This is traditional behaviour > of postgres/ > > > + * FIXME may be it should be changed someday > > > + */ > > > + if (option->status == > OPTION_VALUE_STATUS_FOR_RESET) > > > + { > > > + skip = true; > > > + } > > > + } > > > + /* > > > + * In other cases, if we are parsing not in validate > mode, then > > > + * we should keep unknown node, because non-validate > mode is for > > > + * data that is already in the DB and should not be > changed after > > > + * altering another entries > > > + */ > > > + } > > > + if (!skip) > > > + result = lappend(result, option); > > > + } > > > + return result; > > > +} > > > + > > > +/* > > > + * parse_one_option > > > + * > > > + * Subroutine for optionsParseRawValues, to parse and validate > a > > > + * single option's value > > > + */ > > > +static void > > > +parse_one_option(option_value * option, const char *text_str, int > > > text_len, + bool validate) > > > +{ > > > + char *value; > > > + bool parsed; > > > + > > > + value = option->raw_value; > > > + > > > + switch (option->gen->type) > > > + { > > > + case OPTION_TYPE_BOOL: > > > + { > > > + parsed = parse_bool(value, &option- > >values.bool_val); > > > + if (validate && !parsed) > > > + ereport(ERROR, > > > + > (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > + errmsg("invalid value for > boolean option \"%s\": %s", > > > + option->gen->name, > value))); > > > + } > > > + break; > > > + case OPTION_TYPE_INT: > > > + { > > > + option_spec_int *optint = > > > + (option_spec_int *) option->gen; > > > + > > > + parsed = parse_int(value, &option- > >values.int_val, 0, NULL); > > > + if (validate && !parsed) > > > + ereport(ERROR, > > > + > (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > + errmsg("invalid value for > integer option \"%s\": %s", > > > + option->gen->name, > value))); > > > + if (validate && (option->values.int_val < > optint->min || > > > + option- > >values.int_val > optint->max)) > > > + ereport(ERROR, > > > + > (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > + errmsg("value %s out of > bounds for option \"%s\"", > > > + value, > option->gen->name), > > > + errdetail("Valid values are between > \"%d\" and \"%d\".", > > > + optint->min, > optint->max))); > > > + } > > > + break; > > > + case OPTION_TYPE_REAL: > > > + { > > > + option_spec_real *optreal = > > > + (option_spec_real *) option->gen; > > > + > > > + parsed = parse_real(value, &option- > >values.real_val, 0, NULL); > > > + if (validate && !parsed) > > > + ereport(ERROR, > > > + > (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > + errmsg("invalid > value for floating point option \"%s\": %s", > > > + > option->gen->name, value))); > > > + if (validate && (option->values.real_val < > optreal->min || > > > + option- > >values.real_val > optreal->max)) > > > + ereport(ERROR, > > > + > (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > + errmsg("value %s out of > bounds for option \"%s\"", > > > + value, > option->gen->name), > > > + errdetail("Valid values are between > \"%f\" and \"%f\".", > > > + optreal->min, > optreal->max))); > > > + } > > > + break; > > > + case OPTION_TYPE_ENUM: > > > + { > > > + option_spec_enum *optenum = > > > + > (option_spec_enum *) option->gen; > > > + opt_enum_elt_def *elt; > > > + parsed = false; > > > + for (elt = optenum->members; elt->string_val; > elt++) > > > + { > > > + if (strcmp(value, elt->string_val) == > 0) > > > + { > > > + option->values.enum_val = > elt->symbol_val; > > > + parsed = true; > > > + break; > > > + } > > > + } > > > + if (!parsed) > > > + { > > > + ereport(ERROR, > > > + > (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > + errmsg("invalid > value for enum option \"%s\": %s", > > > + > option->gen->name, value), > > > + optenum->detailmsg ? > > > + > errdetail_internal("%s", _(optenum->detailmsg)) : 0)); > > > + } > > > + } > > > + break; > > > + case OPTION_TYPE_STRING: > > > + { > > > + option_spec_string *optstring = > > > + (option_spec_string *) option->gen; > > > + > > > + option->values.string_val = value; > > > + if (validate && optstring->validate_cb) > > > + (optstring->validate_cb) (value); > > > + parsed = true; > > > + } > > > + break; > > > + default: > > > + elog(ERROR, "unsupported reloption type %d", option- > >gen->type); > > > + parsed = true; /* quiet compiler */ > > > + break; > > > + } > > > + > > > + if (parsed) > > > + option->status = OPTION_VALUE_STATUS_PARSED; > > > + > > > +} > > > + > > > +/* > > > + * optionsAllocateBytea > > > + * Allocates memory for bytea options representation > > > + * > > > + * Function allocates memory for byrea structure of an option, plus adds > > > space + * for values of string options. We should keep all data including > > > string + * values in the same memory chunk, because Cache code copies > > > bytea option + * data from one MemoryConext to another without knowing > > > about it's internal + * structure, so it would not be able to copy string > > > values if they are outside + * of bytea memory chunk. > > > + */ > > > +static void * > > > +optionsAllocateBytea(options_spec_set * spec_set, List *options) > > > +{ > > > + Size size; > > > + int i; > > > + ListCell *cell; > > > + int length; > > > + void *res; > > > + > > > + size = spec_set->struct_size; > > > + > > > + /* Calculate size needed to store all string values for this option > */ > > > + for (i = 0; i < spec_set->num; i++) > > > + { > > > + option_spec_basic *definition = spec_set->definitions[i]; > > > + bool found = false; > > > + option_value *option; > > > + > > > + /* Not interested in non-string options, skipping */ > > > + if (definition->type != OPTION_TYPE_STRING) > > > + continue; > > > + > > > + /* > > > + * Trying to find option_value that references definition > spec_set > > > + * entry > > > + */ > > > + foreach(cell, options) > > > + { > > > + option = (option_value *) lfirst(cell); > > > + if (option->status == OPTION_VALUE_STATUS_PARSED && > > > + strcmp(option->gen->name, definition->name) == > 0) > > > + { > > > + found = true; > > > + break; > > > + } > > > + } > > > + if (found) > > > + /* If found, it'value will be stored */ > > > + length = strlen(option->values.string_val) + 1; > > > + else > > > + /* If not found, then there would be default value > there */ > > > + if (((option_spec_string *) definition)->default_val) > > > + length = strlen( > > > + ((option_spec_string *) definition)- > >default_val) + 1; > > > + else > > > + length = 0; > > > + /* Add total length of all string values to basic size */ > > > + size += length; > > > + } > > > + > > > + res = palloc0(size); > > > + SET_VARSIZE(res, size); > > > + return res; > > > +} > > > + > > > +/* > > > + * optionsValuesToBytea > > > + * Converts options from List of option_values to binary bytea > structure > > > + * > > > + * Convertation goes according to options_spec_set: each spec_set item > > > + * has offset value, and option value in binary mode is written to the > > > + * structure with that offset. > > > + * > > > + * More special case is string values. Memory for bytea structure is > > > allocated + * by optionsAllocateBytea which adds some more space for > > > string values to + * the size of original structure. All string values > > > are copied there and + * inside the bytea structure an offset to that > > > value is kept. > > > + * > > > + */ > > > +static bytea * > > > +optionsValuesToBytea(List *options, options_spec_set * spec_set) > > > +{ > > > + char *data; > > > + char *string_values_buffer; > > > + int i; > > > + > > > + data = optionsAllocateBytea(spec_set, options); > > > + > > > + /* place for string data starts right after original structure */ > > > + string_values_buffer = data + spec_set->struct_size; > > > + > > > + for (i = 0; i < spec_set->num; i++) > > > + { > > > + option_value *found = NULL; > > > + ListCell *cell; > > > + char *item_pos; > > > + option_spec_basic *definition = spec_set->definitions[i]; > > > + > > > + if (definition->flags & OPTION_DEFINITION_FLAG_IGNORE) > > > + continue; > > > + > > > + /* Calculate the position of the item inside the structure */ > > > + item_pos = data + definition->struct_offset; > > > + > > > + /* Looking for the corresponding option from options list */ > > > + foreach(cell, options) > > > + { > > > + option_value *option = (option_value *) lfirst(cell); > > > + > > > + if (option->status == OPTION_VALUE_STATUS_RAW) > > > + continue; /* raw can come from db. > Just ignore them then */ > > > + Assert(option->status != OPTION_VALUE_STATUS_EMPTY); > > > + > > > + if (strcmp(definition->name, option->gen->name) == 0) > > > + { > > > + found = option; > > > + break; > > > + } > > > + } > > > + /* writing to the proper position either option value or > default val */ > > > + switch (definition->type) > > > + { > > > + case OPTION_TYPE_BOOL: > > > + *(bool *) item_pos = found ? > > > + found->values.bool_val : > > > + ((option_spec_bool *) definition)- > >default_val; > > > + break; > > > + case OPTION_TYPE_INT: > > > + *(int *) item_pos = found ? > > > + found->values.int_val : > > > + ((option_spec_int *) definition)- > >default_val; > > > + break; > > > + case OPTION_TYPE_REAL: > > > + *(double *) item_pos = found ? > > > + found->values.real_val : > > > + ((option_spec_real *) definition)- > >default_val; > > > + break; > > > + case OPTION_TYPE_ENUM: > > > + *(int *) item_pos = found ? > > > + found->values.enum_val : > > > + ((option_spec_enum *) definition)- > >default_val; > > > + break; > > > + > > > + case OPTION_TYPE_STRING: > > > + { > > > + /* > > > + * For string options: writing string > value at the string > > > + * buffer after the structure, and > storing and offset to > > > + * that value > > > + */ > > > + char *value = NULL; > > > + > > > + if (found) > > > + value = found- > >values.string_val; > > > + else > > > + value = ((option_spec_string > *) definition) > > > + ->default_val; > > > + *(int *) item_pos = value ? > > > + string_values_buffer - data : > > > + > OPTION_STRING_VALUE_NOT_SET_OFFSET; > > > + if (value) > > > + { > > > + strcpy(string_values_buffer, > value); > > > + string_values_buffer += > strlen(value) + 1; > > > + } > > > + } > > > + break; > > > + default: > > > + elog(ERROR, "unsupported reloption type %d", > > > + definition->type); > > > + break; > > > + } > > > + } > > > + return (void *) data; > > > +} > > > + > > > + > > > +/* > > > + * transformOptions > > > + * This function is used by src/backend/commands/Xxxx in order > to > > > process > > > + * new option values, merge them with existing values (in the > case of > > > + * ALTER command) and prepare to put them [back] into DB > > > + */ > > > + > > > +Datum > > > +transformOptions(options_spec_set * spec_set, Datum oldOptions, > > > + List *defList, options_parse_mode > parse_mode) > > > +{ > > > + Datum result; > > > + List *new_values; > > > + List *old_values; > > > + List *merged_values; > > > + > > > + /* > > > + * Parse and validate New values > > > + */ > > > + new_values = optionsDefListToRawValues(defList, parse_mode); > > > + if (! (parse_mode & OPTIONS_PARSE_MODE_FOR_RESET)) > > > + { > > > + /* FIXME: postgres usual behaviour vas not to vaidate names > that > > > + * came from RESET command. Once this behavious should be > changed, > > > + * I guess. But for now we keep it as it was. > > > + */ > > > + parse_mode|= OPTIONS_PARSE_MODE_VALIDATE; > > > + } > > > + new_values = optionsParseRawValues(new_values, spec_set, parse_mode); > > > + > > > + /* > > > + * Old values exists in case of ALTER commands. Transform them to raw > > > + * values and merge them with new_values, and parse it. > > > + */ > > > + if (PointerIsValid(DatumGetPointer(oldOptions))) > > > + { > > > + old_values = optionsTextArrayToRawValues(oldOptions); > > > + merged_values = optionsMergeOptionValues(old_values, > new_values); > > > + > > > + /* > > > + * Parse options only after merging in order not to parse > options that > > > + * would be removed by merging later > > > + */ > > > + merged_values = optionsParseRawValues(merged_values, > spec_set, 0); > > > + } > > > + else > > > + { > > > + merged_values = new_values; > > > + } > > > + > > > + /* > > > + * If we have postprocess_fun function defined in spec_set, then there > > > + * might be some custom options checks there, with error throwing. So > we > > > + * should do it here to throw these errors while CREATing or ALTERing > > > + * options > > > + */ > > > + if (spec_set->postprocess_fun) > > > + { > > > + bytea *data = optionsValuesToBytea(merged_values, > spec_set); > > > + > > > + spec_set->postprocess_fun(data, true); > > > + pfree(data); > > > + } > > > + > > > + /* > > > + * Convert options to TextArray format so caller can store them into > > > + * database > > > + */ > > > + result = optionsValuesToTextArray(merged_values); > > > + return result; > > > +} > > > + > > > + > > > +/* > > > + * optionsTextArrayToBytea > > > + * A meta-function that transforms options stored as TextArray > into > > > binary + * (bytea) representation. > > > + * > > > + * This function runs other transform functions that leads to the > desired > > > + * result in no-validation mode. This function is used by cache > > > mechanism, > > > + * in order to load and cache options when object itself is loaded and > > > cached + */ > > > +bytea * > > > +optionsTextArrayToBytea(options_spec_set * spec_set, Datum data, bool > > > validate) +{ > > > + List *values; > > > + bytea *options; > > > + > > > + values = optionsTextArrayToRawValues(data); > > > + values = optionsParseRawValues(values, spec_set, > > > + validate ? > OPTIONS_PARSE_MODE_VALIDATE : 0); > > > + options = optionsValuesToBytea(values, spec_set); > > > + > > > + if (spec_set->postprocess_fun) > > > + { > > > + spec_set->postprocess_fun(options, false); > > > + } > > > + return options; > > > +} > > > diff --git a/src/backend/access/common/relation.c > > > b/src/backend/access/common/relation.c index 632d13c..49ad197 100644 > > > --- a/src/backend/access/common/relation.c > > > +++ b/src/backend/access/common/relation.c > > > @@ -65,9 +65,13 @@ relation_open(Oid relationId, LOCKMODE lockmode) > > > > > > * If we didn't get the lock ourselves, assert that caller holds > one, > > > * except in bootstrap mode where no locks are used. > > > */ > > > > > > - Assert(lockmode != NoLock || > > > - IsBootstrapProcessingMode() || > > > - CheckRelationLockedByMe(r, AccessShareLock, true)); > > > + > > > +// FIXME We need NoLock mode to get AM data when choosing Lock for > > > +// attoptions is changed. See ProcessUtilitySlow problems comes from > > > there > > > +// This is a dirty hack, we need better solution for this case; > > > +// Assert(lockmode != NoLock || > > > +// IsBootstrapProcessingMode() || > > > +// CheckRelationLockedByMe(r, AccessShareLock, true)); > > > > > > /* Make note that we've accessed a temporary relation */ > > > if (RelationUsesLocalBuffers(r)) > > > > > > diff --git a/src/backend/access/common/reloptions.c > > > b/src/backend/access/common/reloptions.c index b5602f5..29ab98a 100644 > > > --- a/src/backend/access/common/reloptions.c > > > +++ b/src/backend/access/common/reloptions.c > > > @@ -1,7 +1,7 @@ > > > > > > /*----------------------------------------------------------------------- > > > -- > > > > > > * > > > * reloptions.c > > > > > > - * Core support for relation options (pg_class.reloptions) > > > + * Support for relation options (pg_class.reloptions) > > > > > > * > > > * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group > > > * Portions Copyright (c) 1994, Regents of the University of California > > > > > > @@ -17,13 +17,10 @@ > > > > > > #include <float.h> > > > > > > -#include "access/gist_private.h" > > > -#include "access/hash.h" > > > > > > #include "access/heaptoast.h" > > > #include "access/htup_details.h" > > > > > > -#include "access/nbtree.h" > > > > > > #include "access/reloptions.h" > > > > > > -#include "access/spgist_private.h" > > > +#include "access/options.h" > > > > > > #include "catalog/pg_type.h" > > > #include "commands/defrem.h" > > > #include "commands/tablespace.h" > > > > > > @@ -36,6 +33,7 @@ > > > > > > #include "utils/guc.h" > > > #include "utils/memutils.h" > > > #include "utils/rel.h" > > > > > > +#include "storage/bufmgr.h" > > > > > > /* > > > > > > * Contents of pg_class.reloptions > > > > > > @@ -93,380 +91,8 @@ > > > > > > * value has no effect until the next VACUUM, so no need for stronger > > > lock. > > > */ > > > > > > -static relopt_bool boolRelOpts[] = > > > -{ > > > - { > > > - { > > > - "autosummarize", > > > - "Enables automatic summarization on this BRIN > index", > > > - RELOPT_KIND_BRIN, > > > - AccessExclusiveLock > > > - }, > > > - false > > > - }, > > > - { > > > - { > > > - "autovacuum_enabled", > > > - "Enables autovacuum in this relation", > > > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > > - ShareUpdateExclusiveLock > > > - }, > > > - true > > > - }, > > > - { > > > - { > > > - "user_catalog_table", > > > - "Declare a table as an additional catalog table, > e.g. for the purpose > > > of logical replication", - RELOPT_KIND_HEAP, > > > - AccessExclusiveLock > > > - }, > > > - false > > > - }, > > > - { > > > - { > > > - "fastupdate", > > > - "Enables \"fast update\" feature for this GIN > index", > > > - RELOPT_KIND_GIN, > > > - AccessExclusiveLock > > > - }, > > > - true > > > - }, > > > - { > > > - { > > > - "security_barrier", > > > - "View acts as a row security barrier", > > > - RELOPT_KIND_VIEW, > > > - AccessExclusiveLock > > > - }, > > > - false > > > - }, > > > - { > > > - { > > > - "vacuum_truncate", > > > - "Enables vacuum to truncate empty pages at the end > of this table", > > > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > > - ShareUpdateExclusiveLock > > > - }, > > > - true > > > - }, > > > - { > > > - { > > > - "deduplicate_items", > > > - "Enables \"deduplicate items\" feature for this > btree index", > > > - RELOPT_KIND_BTREE, > > > - ShareUpdateExclusiveLock /* since it applies only > to later > > > - > * inserts */ > > > - }, > > > - true > > > - }, > > > - /* list terminator */ > > > - {{NULL}} > > > -}; > > > - > > > -static relopt_int intRelOpts[] = > > > -{ > > > - { > > > - { > > > - "fillfactor", > > > - "Packs table pages only to this percentage", > > > - RELOPT_KIND_HEAP, > > > - ShareUpdateExclusiveLock /* since it applies only > to later > > > - > * inserts */ > > > - }, > > > - HEAP_DEFAULT_FILLFACTOR, HEAP_MIN_FILLFACTOR, 100 > > > - }, > > > - { > > > - { > > > - "fillfactor", > > > - "Packs btree index pages only to this percentage", > > > - RELOPT_KIND_BTREE, > > > - ShareUpdateExclusiveLock /* since it applies only > to later > > > - > * inserts */ > > > - }, > > > - BTREE_DEFAULT_FILLFACTOR, BTREE_MIN_FILLFACTOR, 100 > > > - }, > > > - { > > > - { > > > - "fillfactor", > > > - "Packs hash index pages only to this percentage", > > > - RELOPT_KIND_HASH, > > > - ShareUpdateExclusiveLock /* since it applies only > to later > > > - > * inserts */ > > > - }, > > > - HASH_DEFAULT_FILLFACTOR, HASH_MIN_FILLFACTOR, 100 > > > - }, > > > - { > > > - { > > > - "fillfactor", > > > - "Packs gist index pages only to this percentage", > > > - RELOPT_KIND_GIST, > > > - ShareUpdateExclusiveLock /* since it applies only > to later > > > - > * inserts */ > > > - }, > > > - GIST_DEFAULT_FILLFACTOR, GIST_MIN_FILLFACTOR, 100 > > > - }, > > > - { > > > - { > > > - "fillfactor", > > > - "Packs spgist index pages only to this percentage", > > > - RELOPT_KIND_SPGIST, > > > - ShareUpdateExclusiveLock /* since it applies only > to later > > > - > * inserts */ > > > - }, > > > - SPGIST_DEFAULT_FILLFACTOR, SPGIST_MIN_FILLFACTOR, 100 > > > - }, > > > - { > > > - { > > > - "autovacuum_vacuum_threshold", > > > - "Minimum number of tuple updates or deletes prior to > vacuum", > > > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > > - ShareUpdateExclusiveLock > > > - }, > > > - -1, 0, INT_MAX > > > - }, > > > - { > > > - { > > > - "autovacuum_vacuum_insert_threshold", > > > - "Minimum number of tuple inserts prior to vacuum, or > -1 to disable > > > insert vacuums", - RELOPT_KIND_HEAP | > RELOPT_KIND_TOAST, > > > - ShareUpdateExclusiveLock > > > - }, > > > - -2, -1, INT_MAX > > > - }, > > > - { > > > - { > > > - "autovacuum_analyze_threshold", > > > - "Minimum number of tuple inserts, updates or deletes > prior to > > > analyze", > > > - RELOPT_KIND_HEAP, > > > - ShareUpdateExclusiveLock > > > - }, > > > - -1, 0, INT_MAX > > > - }, > > > - { > > > - { > > > - "autovacuum_vacuum_cost_limit", > > > - "Vacuum cost amount available before napping, for > autovacuum", > > > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > > - ShareUpdateExclusiveLock > > > - }, > > > - -1, 1, 10000 > > > - }, > > > - { > > > - { > > > - "autovacuum_freeze_min_age", > > > - "Minimum age at which VACUUM should freeze a table > row, for > > > autovacuum", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > > - ShareUpdateExclusiveLock > > > - }, > > > - -1, 0, 1000000000 > > > - }, > > > - { > > > - { > > > - "autovacuum_multixact_freeze_min_age", > > > - "Minimum multixact age at which VACUUM should freeze > a row > > > multixact's, for autovacuum", - RELOPT_KIND_HEAP | > RELOPT_KIND_TOAST, > > > - ShareUpdateExclusiveLock > > > - }, > > > - -1, 0, 1000000000 > > > - }, > > > - { > > > - { > > > - "autovacuum_freeze_max_age", > > > - "Age at which to autovacuum a table to prevent > transaction ID > > > wraparound", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > > - ShareUpdateExclusiveLock > > > - }, > > > - -1, 100000, 2000000000 > > > - }, > > > - { > > > - { > > > - "autovacuum_multixact_freeze_max_age", > > > - "Multixact age at which to autovacuum a table to > prevent multixact > > > wraparound", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > > - ShareUpdateExclusiveLock > > > - }, > > > - -1, 10000, 2000000000 > > > - }, > > > - { > > > - { > > > - "autovacuum_freeze_table_age", > > > - "Age at which VACUUM should perform a full table > sweep to freeze row > > > versions", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > > - ShareUpdateExclusiveLock > > > - }, -1, 0, 2000000000 > > > - }, > > > - { > > > - { > > > - "autovacuum_multixact_freeze_table_age", > > > - "Age of multixact at which VACUUM should perform a > full table sweep to > > > freeze row versions", - RELOPT_KIND_HEAP | > RELOPT_KIND_TOAST, > > > - ShareUpdateExclusiveLock > > > - }, -1, 0, 2000000000 > > > - }, > > > - { > > > - { > > > - "log_autovacuum_min_duration", > > > - "Sets the minimum execution time above which > autovacuum actions will > > > be logged", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > > - ShareUpdateExclusiveLock > > > - }, > > > - -1, -1, INT_MAX > > > - }, > > > - { > > > - { > > > - "toast_tuple_target", > > > - "Sets the target tuple length at which external > columns will be > > > toasted", - RELOPT_KIND_HEAP, > > > - ShareUpdateExclusiveLock > > > - }, > > > - TOAST_TUPLE_TARGET, 128, TOAST_TUPLE_TARGET_MAIN > > > - }, > > > - { > > > - { > > > - "pages_per_range", > > > - "Number of pages that each page range covers in a > BRIN index", > > > - RELOPT_KIND_BRIN, > > > - AccessExclusiveLock > > > - }, 128, 1, 131072 > > > - }, > > > - { > > > - { > > > - "gin_pending_list_limit", > > > - "Maximum size of the pending list for this GIN > index, in kilobytes.", > > > - RELOPT_KIND_GIN, > > > - AccessExclusiveLock > > > - }, > > > - -1, 64, MAX_KILOBYTES > > > - }, > > > - { > > > - { > > > - "effective_io_concurrency", > > > - "Number of simultaneous requests that can be handled > efficiently by > > > the disk subsystem.", - RELOPT_KIND_TABLESPACE, > > > - ShareUpdateExclusiveLock > > > - }, > > > -#ifdef USE_PREFETCH > > > - -1, 0, MAX_IO_CONCURRENCY > > > -#else > > > - 0, 0, 0 > > > -#endif > > > - }, > > > - { > > > - { > > > - "maintenance_io_concurrency", > > > - "Number of simultaneous requests that can be handled > efficiently by > > > the disk subsystem for maintenance work.", - > RELOPT_KIND_TABLESPACE, > > > - ShareUpdateExclusiveLock > > > - }, > > > -#ifdef USE_PREFETCH > > > - -1, 0, MAX_IO_CONCURRENCY > > > -#else > > > - 0, 0, 0 > > > -#endif > > > - }, > > > - { > > > - { > > > - "parallel_workers", > > > - "Number of parallel processes that can be used per > executor node for > > > this relation.", - RELOPT_KIND_HEAP, > > > - ShareUpdateExclusiveLock > > > - }, > > > - -1, 0, 1024 > > > - }, > > > - > > > - /* list terminator */ > > > - {{NULL}} > > > -}; > > > - > > > -static relopt_real realRelOpts[] = > > > -{ > > > - { > > > - { > > > - "autovacuum_vacuum_cost_delay", > > > - "Vacuum cost delay in milliseconds, for autovacuum", > > > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > > - ShareUpdateExclusiveLock > > > - }, > > > - -1, 0.0, 100.0 > > > - }, > > > - { > > > - { > > > - "autovacuum_vacuum_scale_factor", > > > - "Number of tuple updates or deletes prior to vacuum > as a fraction of > > > reltuples", - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > > - ShareUpdateExclusiveLock > > > - }, > > > - -1, 0.0, 100.0 > > > - }, > > > - { > > > - { > > > - "autovacuum_vacuum_insert_scale_factor", > > > - "Number of tuple inserts prior to vacuum as a > fraction of reltuples", > > > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > > - ShareUpdateExclusiveLock > > > - }, > > > - -1, 0.0, 100.0 > > > - }, > > > - { > > > - { > > > - "autovacuum_analyze_scale_factor", > > > - "Number of tuple inserts, updates or deletes prior > to analyze as a > > > fraction of reltuples", - RELOPT_KIND_HEAP, > > > - ShareUpdateExclusiveLock > > > - }, > > > - -1, 0.0, 100.0 > > > - }, > > > - { > > > - { > > > - "seq_page_cost", > > > - "Sets the planner's estimate of the cost of a > sequentially fetched > > > disk page.", - RELOPT_KIND_TABLESPACE, > > > - ShareUpdateExclusiveLock > > > - }, > > > - -1, 0.0, DBL_MAX > > > - }, > > > - { > > > - { > > > - "random_page_cost", > > > - "Sets the planner's estimate of the cost of a > nonsequentially fetched > > > disk page.", - RELOPT_KIND_TABLESPACE, > > > - ShareUpdateExclusiveLock > > > - }, > > > - -1, 0.0, DBL_MAX > > > - }, > > > - { > > > - { > > > - "n_distinct", > > > - "Sets the planner's estimate of the number of > distinct values > > > appearing in a column (excluding child relations).", > > > - RELOPT_KIND_ATTRIBUTE, > > > - ShareUpdateExclusiveLock > > > - }, > > > - 0, -1.0, DBL_MAX > > > - }, > > > - { > > > - { > > > - "n_distinct_inherited", > > > - "Sets the planner's estimate of the number of > distinct values > > > appearing in a column (including child relations).", > > > - RELOPT_KIND_ATTRIBUTE, > > > - ShareUpdateExclusiveLock > > > - }, > > > - 0, -1.0, DBL_MAX > > > - }, > > > - { > > > - { > > > - "vacuum_cleanup_index_scale_factor", > > > - "Deprecated B-Tree parameter.", > > > - RELOPT_KIND_BTREE, > > > - ShareUpdateExclusiveLock > > > - }, > > > - -1, 0.0, 1e10 > > > - }, > > > - /* list terminator */ > > > - {{NULL}} > > > -}; > > > - > > > > > > /* values from StdRdOptIndexCleanup */ > > > > > > -relopt_enum_elt_def StdRdOptIndexCleanupValues[] = > > > +opt_enum_elt_def StdRdOptIndexCleanupValues[] = > > > > > > { > > > > > > {"auto", STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO}, > > > {"on", STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON}, > > > > > > @@ -480,17 +106,8 @@ relopt_enum_elt_def StdRdOptIndexCleanupValues[] = > > > > > > {(const char *) NULL} /* list terminator */ > > > > > > }; > > > > > > -/* values from GistOptBufferingMode */ > > > -relopt_enum_elt_def gistBufferingOptValues[] = > > > -{ > > > - {"auto", GIST_OPTION_BUFFERING_AUTO}, > > > - {"on", GIST_OPTION_BUFFERING_ON}, > > > - {"off", GIST_OPTION_BUFFERING_OFF}, > > > - {(const char *) NULL} /* list terminator */ > > > -}; > > > - > > > > > > /* values from ViewOptCheckOption */ > > > > > > -relopt_enum_elt_def viewCheckOptValues[] = > > > +opt_enum_elt_def viewCheckOptValues[] = > > > > > > { > > > > > > /* no value for NOT_SET */ > > > {"local", VIEW_OPTION_CHECK_OPTION_LOCAL}, > > > > > > @@ -498,61 +115,8 @@ relopt_enum_elt_def viewCheckOptValues[] = > > > > > > {(const char *) NULL} /* list terminator */ > > > > > > }; > > > > > > -static relopt_enum enumRelOpts[] = > > > -{ > > > - { > > > - { > > > - "vacuum_index_cleanup", > > > - "Controls index vacuuming and index cleanup", > > > - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST, > > > - ShareUpdateExclusiveLock > > > - }, > > > - StdRdOptIndexCleanupValues, > > > - STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO, > > > - gettext_noop("Valid values are \"on\", \"off\", and > \"auto\".") > > > - }, > > > - { > > > - { > > > - "buffering", > > > - "Enables buffering build for this GiST index", > > > - RELOPT_KIND_GIST, > > > - AccessExclusiveLock > > > - }, > > > - gistBufferingOptValues, > > > - GIST_OPTION_BUFFERING_AUTO, > > > - gettext_noop("Valid values are \"on\", \"off\", and > \"auto\".") > > > - }, > > > - { > > > - { > > > - "check_option", > > > - "View has WITH CHECK OPTION defined (local or > cascaded).", > > > - RELOPT_KIND_VIEW, > > > - AccessExclusiveLock > > > - }, > > > - viewCheckOptValues, > > > - VIEW_OPTION_CHECK_OPTION_NOT_SET, > > > - gettext_noop("Valid values are \"local\" and \"cascaded\".") > > > - }, > > > - /* list terminator */ > > > - {{NULL}} > > > -}; > > > - > > > -static relopt_string stringRelOpts[] = > > > -{ > > > - /* list terminator */ > > > - {{NULL}} > > > -}; > > > - > > > -static relopt_gen **relOpts = NULL; > > > -static bits32 last_assigned_kind = RELOPT_KIND_LAST_DEFAULT; > > > - > > > -static int num_custom_options = 0; > > > -static relopt_gen **custom_options = NULL; > > > -static bool need_initialization = true; > > > > > > -static void initialize_reloptions(void); > > > -static void parse_one_reloption(relopt_value *option, char *text_str, > > > - int > text_len, bool validate); > > > +options_spec_set *get_stdrd_relopt_spec_set(relopt_kind kind); > > > > > > /* > > > > > > * Get the length of a string reloption (either default or the > > > user-defined > > > > > > @@ -563,160 +127,6 @@ static void parse_one_reloption(relopt_value > > > *option, char *text_str,> > > > ((option).isset ? strlen((option).values.string_val) : \ > > > > > > ((relopt_string *) (option).gen)->default_len) > > > > > > -/* > > > - * initialize_reloptions > > > - * initialization routine, must be called before parsing > > > - * > > > - * Initialize the relOpts array and fill each variable's type and name > > > length. - */ > > > -static void > > > -initialize_reloptions(void) > > > -{ > > > - int i; > > > - int j; > > > - > > > - j = 0; > > > - for (i = 0; boolRelOpts[i].gen.name; i++) > > > - { > > > - Assert(DoLockModesConflict(boolRelOpts[i].gen.lockmode, > > > - > boolRelOpts[i].gen.lockmode)); > > > - j++; > > > - } > > > - for (i = 0; intRelOpts[i].gen.name; i++) > > > - { > > > - Assert(DoLockModesConflict(intRelOpts[i].gen.lockmode, > > > - > intRelOpts[i].gen.lockmode)); > > > - j++; > > > - } > > > - for (i = 0; realRelOpts[i].gen.name; i++) > > > - { > > > - Assert(DoLockModesConflict(realRelOpts[i].gen.lockmode, > > > - > realRelOpts[i].gen.lockmode)); > > > - j++; > > > - } > > > - for (i = 0; enumRelOpts[i].gen.name; i++) > > > - { > > > - Assert(DoLockModesConflict(enumRelOpts[i].gen.lockmode, > > > - > enumRelOpts[i].gen.lockmode)); > > > - j++; > > > - } > > > - for (i = 0; stringRelOpts[i].gen.name; i++) > > > - { > > > - Assert(DoLockModesConflict(stringRelOpts[i].gen.lockmode, > > > - > stringRelOpts[i].gen.lockmode)); > > > - j++; > > > - } > > > - j += num_custom_options; > > > - > > > - if (relOpts) > > > - pfree(relOpts); > > > - relOpts = MemoryContextAlloc(TopMemoryContext, > > > - (j + 1) * > sizeof(relopt_gen *)); > > > - > > > - j = 0; > > > - for (i = 0; boolRelOpts[i].gen.name; i++) > > > - { > > > - relOpts[j] = &boolRelOpts[i].gen; > > > - relOpts[j]->type = RELOPT_TYPE_BOOL; > > > - relOpts[j]->namelen = strlen(relOpts[j]->name); > > > - j++; > > > - } > > > - > > > - for (i = 0; intRelOpts[i].gen.name; i++) > > > - { > > > - relOpts[j] = &intRelOpts[i].gen; > > > - relOpts[j]->type = RELOPT_TYPE_INT; > > > - relOpts[j]->namelen = strlen(relOpts[j]->name); > > > - j++; > > > - } > > > - > > > - for (i = 0; realRelOpts[i].gen.name; i++) > > > - { > > > - relOpts[j] = &realRelOpts[i].gen; > > > - relOpts[j]->type = RELOPT_TYPE_REAL; > > > - relOpts[j]->namelen = strlen(relOpts[j]->name); > > > - j++; > > > - } > > > - > > > - for (i = 0; enumRelOpts[i].gen.name; i++) > > > - { > > > - relOpts[j] = &enumRelOpts[i].gen; > > > - relOpts[j]->type = RELOPT_TYPE_ENUM; > > > - relOpts[j]->namelen = strlen(relOpts[j]->name); > > > - j++; > > > - } > > > - > > > - for (i = 0; stringRelOpts[i].gen.name; i++) > > > - { > > > - relOpts[j] = &stringRelOpts[i].gen; > > > - relOpts[j]->type = RELOPT_TYPE_STRING; > > > - relOpts[j]->namelen = strlen(relOpts[j]->name); > > > - j++; > > > - } > > > - > > > - for (i = 0; i < num_custom_options; i++) > > > - { > > > - relOpts[j] = custom_options[i]; > > > - j++; > > > - } > > > - > > > - /* add a list terminator */ > > > - relOpts[j] = NULL; > > > - > > > - /* flag the work is complete */ > > > - need_initialization = false; > > > -} > > > - > > > -/* > > > - * add_reloption_kind > > > - * Create a new relopt_kind value, to be used in custom > reloptions by > > > - * user-defined AMs. > > > - */ > > > -relopt_kind > > > -add_reloption_kind(void) > > > -{ > > > - /* don't hand out the last bit so that the enum's behavior is > portable > > > */ > > > - if (last_assigned_kind >= RELOPT_KIND_MAX) > > > - ereport(ERROR, > > > - (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), > > > - errmsg("user-defined relation parameter > types limit exceeded"))); > > > - last_assigned_kind <<= 1; > > > - return (relopt_kind) last_assigned_kind; > > > -} > > > - > > > -/* > > > - * add_reloption > > > - * Add an already-created custom reloption to the list, and > recompute > > > the > > > - * main parser table. > > > - */ > > > -static void > > > -add_reloption(relopt_gen *newoption) > > > -{ > > > - static int max_custom_options = 0; > > > - > > > - if (num_custom_options >= max_custom_options) > > > - { > > > - MemoryContext oldcxt; > > > - > > > - oldcxt = MemoryContextSwitchTo(TopMemoryContext); > > > - > > > - if (max_custom_options == 0) > > > - { > > > - max_custom_options = 8; > > > - custom_options = palloc(max_custom_options * > sizeof(relopt_gen *)); > > > - } > > > - else > > > - { > > > - max_custom_options *= 2; > > > - custom_options = repalloc(custom_options, > > > - > max_custom_options * sizeof(relopt_gen *)); > > > - } > > > - MemoryContextSwitchTo(oldcxt); > > > - } > > > - custom_options[num_custom_options++] = newoption; > > > - > > > - need_initialization = true; > > > -} > > > > > > /* > > > > > > * init_local_reloptions > > > > > > @@ -729,6 +139,7 @@ init_local_reloptions(local_relopts *opts, Size > > > relopt_struct_size)> > > > opts->options = NIL; > > > opts->validators = NIL; > > > opts->relopt_struct_size = relopt_struct_size; > > > > > > + opts->spec_set = allocateOptionsSpecSet(NULL, relopt_struct_size, 0); > > > > > > } > > > > > > /* > > > > > > @@ -743,112 +154,6 @@ register_reloptions_validator(local_relopts *opts, > > > relopts_validator validator)> > > > } > > > > > > /* > > > > > > - * add_local_reloption > > > - * Add an already-created custom reloption to the local list. > > > - */ > > > -static void > > > -add_local_reloption(local_relopts *relopts, relopt_gen *newoption, int > > > offset) -{ > > > - local_relopt *opt = palloc(sizeof(*opt)); > > > - > > > - Assert(offset < relopts->relopt_struct_size); > > > - > > > - opt->option = newoption; > > > - opt->offset = offset; > > > - > > > - relopts->options = lappend(relopts->options, opt); > > > -} > > > - > > > -/* > > > - * allocate_reloption > > > - * Allocate a new reloption and initialize the type-agnostic > fields > > > - * (for types other than string) > > > - */ > > > -static relopt_gen * > > > -allocate_reloption(bits32 kinds, int type, const char *name, const char > > > *desc, - LOCKMODE lockmode) > > > -{ > > > - MemoryContext oldcxt; > > > - size_t size; > > > - relopt_gen *newoption; > > > - > > > - if (kinds != RELOPT_KIND_LOCAL) > > > - oldcxt = MemoryContextSwitchTo(TopMemoryContext); > > > - else > > > - oldcxt = NULL; > > > - > > > - switch (type) > > > - { > > > - case RELOPT_TYPE_BOOL: > > > - size = sizeof(relopt_bool); > > > - break; > > > - case RELOPT_TYPE_INT: > > > - size = sizeof(relopt_int); > > > - break; > > > - case RELOPT_TYPE_REAL: > > > - size = sizeof(relopt_real); > > > - break; > > > - case RELOPT_TYPE_ENUM: > > > - size = sizeof(relopt_enum); > > > - break; > > > - case RELOPT_TYPE_STRING: > > > - size = sizeof(relopt_string); > > > - break; > > > - default: > > > - elog(ERROR, "unsupported reloption type %d", type); > > > - return NULL; /* keep compiler quiet */ > > > - } > > > - > > > - newoption = palloc(size); > > > - > > > - newoption->name = pstrdup(name); > > > - if (desc) > > > - newoption->desc = pstrdup(desc); > > > - else > > > - newoption->desc = NULL; > > > - newoption->kinds = kinds; > > > - newoption->namelen = strlen(name); > > > - newoption->type = type; > > > - newoption->lockmode = lockmode; > > > - > > > - if (oldcxt != NULL) > > > - MemoryContextSwitchTo(oldcxt); > > > - > > > - return newoption; > > > -} > > > - > > > -/* > > > - * init_bool_reloption > > > - * Allocate and initialize a new boolean reloption > > > - */ > > > -static relopt_bool * > > > -init_bool_reloption(bits32 kinds, const char *name, const char *desc, > > > - bool default_val, LOCKMODE lockmode) > > > -{ > > > - relopt_bool *newoption; > > > - > > > - newoption = (relopt_bool *) allocate_reloption(kinds, > RELOPT_TYPE_BOOL, > > > - > name, desc, lockmode); > > > - newoption->default_val = default_val; > > > - > > > - return newoption; > > > -} > > > - > > > -/* > > > - * add_bool_reloption > > > - * Add a new boolean reloption > > > - */ > > > -void > > > -add_bool_reloption(bits32 kinds, const char *name, const char *desc, > > > - bool default_val, LOCKMODE lockmode) > > > -{ > > > - relopt_bool *newoption = init_bool_reloption(kinds, name, desc, > > > - > default_val, lockmode); > > > - > > > - add_reloption((relopt_gen *) newoption); > > > -} > > > - > > > -/* > > > > > > * add_local_bool_reloption > > > * Add a new boolean local reloption > > > * > > > > > > @@ -858,47 +163,8 @@ void > > > > > > add_local_bool_reloption(local_relopts *relopts, const char *name, > > > > > > const char *desc, bool > default_val, int offset) > > > > > > { > > > > > > - relopt_bool *newoption = init_bool_reloption(RELOPT_KIND_LOCAL, > > > - > name, desc, > > > - > default_val, 0); > > > - > > > - add_local_reloption(relopts, (relopt_gen *) newoption, offset); > > > -} > > > - > > > - > > > -/* > > > - * init_real_reloption > > > - * Allocate and initialize a new integer reloption > > > - */ > > > -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) > > > -{ > > > - relopt_int *newoption; > > > - > > > - newoption = (relopt_int *) allocate_reloption(kinds, > RELOPT_TYPE_INT, > > > - > name, desc, lockmode); > > > - newoption->default_val = default_val; > > > - newoption->min = min_val; > > > - newoption->max = max_val; > > > - > > > - return newoption; > > > -} > > > - > > > -/* > > > - * add_int_reloption > > > - * Add a new integer reloption > > > - */ > > > -void > > > -add_int_reloption(bits32 kinds, const char *name, const char *desc, int > > > default_val, - int min_val, int max_val, > LOCKMODE lockmode) > > > -{ > > > - relopt_int *newoption = init_int_reloption(kinds, name, desc, > > > - > default_val, min_val, > > > - > max_val, lockmode); > > > - > > > - add_reloption((relopt_gen *) newoption); > > > + optionsSpecSetAddBool(relopts->spec_set, name, desc, NoLock, 0, > offset, > > > + > default_val); > > > > > > } > > > > > > /* > > > > > > @@ -912,47 +178,8 @@ add_local_int_reloption(local_relopts *relopts, const > > > char *name,> > > > const char *desc, int > default_val, int min_val, > > > int max_val, int offset) > > > > > > { > > > > > > - relopt_int *newoption = init_int_reloption(RELOPT_KIND_LOCAL, > > > - > name, desc, default_val, > > > - > min_val, max_val, 0); > > > - > > > - add_local_reloption(relopts, (relopt_gen *) newoption, offset); > > > -} > > > - > > > -/* > > > - * init_real_reloption > > > - * Allocate and initialize a new real reloption > > > - */ > > > -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) > > > -{ > > > - relopt_real *newoption; > > > - > > > - newoption = (relopt_real *) allocate_reloption(kinds, > RELOPT_TYPE_REAL, > > > - > name, desc, lockmode); > > > - newoption->default_val = default_val; > > > - newoption->min = min_val; > > > - newoption->max = max_val; > > > - > > > - return newoption; > > > -} > > > - > > > -/* > > > - * add_real_reloption > > > - * Add a new float reloption > > > - */ > > > -void > > > -add_real_reloption(bits32 kinds, const char *name, const char *desc, > > > - double default_val, double min_val, > double max_val, > > > - LOCKMODE lockmode) > > > -{ > > > - relopt_real *newoption = init_real_reloption(kinds, name, desc, > > > - > default_val, min_val, > > > - > max_val, lockmode); > > > - > > > - add_reloption((relopt_gen *) newoption); > > > + optionsSpecSetAddInt(relopts->spec_set, name, desc, NoLock, 0, offset, > > > + > default_val, min_val, max_val); > > > > > > } > > > > > > /* > > > > > > @@ -966,57 +193,9 @@ add_local_real_reloption(local_relopts *relopts, > > > const char *name,> > > > const char *desc, double > default_val, > > > double min_val, double > max_val, int offset) > > > > > > { > > > > > > - relopt_real *newoption = init_real_reloption(RELOPT_KIND_LOCAL, > > > - > name, desc, > > > - > default_val, min_val, > > > - > max_val, 0); > > > - > > > - add_local_reloption(relopts, (relopt_gen *) newoption, offset); > > > -} > > > - > > > -/* > > > - * init_enum_reloption > > > - * Allocate and initialize a new enum reloption > > > - */ > > > -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) > > > -{ > > > - relopt_enum *newoption; > > > - > > > - newoption = (relopt_enum *) allocate_reloption(kinds, > RELOPT_TYPE_ENUM, > > > - > name, desc, lockmode); > > > - newoption->members = members; > > > - newoption->default_val = default_val; > > > - newoption->detailmsg = detailmsg; > > > - > > > - return newoption; > > > -} > > > - > > > - > > > -/* > > > - * add_enum_reloption > > > - * Add a new enum reloption > > > - * > > > - * The members array must have a terminating NULL entry. > > > - * > > > - * The detailmsg is shown when unsupported values are passed, and has > > > this > > > - * form: "Valid values are \"foo\", \"bar\", and \"bar\"." > > > - * > > > - * The members array and detailmsg are not copied -- caller must ensure > > > that - * they are valid throughout the life of the process. > > > - */ > > > -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) > > > -{ > > > - relopt_enum *newoption = init_enum_reloption(kinds, name, desc, > > > - > members, default_val, > > > - > detailmsg, lockmode); > > > + optionsSpecSetAddReal(relopts->spec_set, name, desc, NoLock, 0, > offset, > > > + > default_val, min_val, max_val); > > > > > > - add_reloption((relopt_gen *) newoption); > > > > > > } > > > > > > /* > > > > > > @@ -1027,77 +206,11 @@ add_enum_reloption(bits32 kinds, const char *name, > > > const char *desc,> > > > */ > > > > > > void > > > add_local_enum_reloption(local_relopts *relopts, const char *name, > > > > > > - const char *desc, > relopt_enum_elt_def *members, > > > + const char *desc, > opt_enum_elt_def *members, > > > > > > int default_val, const char > *detailmsg, int offset) > > > > > > { > > > > > > - relopt_enum *newoption = init_enum_reloption(RELOPT_KIND_LOCAL, > > > - > name, desc, > > > - > members, default_val, > > > - > detailmsg, 0); > > > - > > > - add_local_reloption(relopts, (relopt_gen *) newoption, offset); > > > -} > > > - > > > -/* > > > - * init_string_reloption > > > - * Allocate and initialize a new string reloption > > > - */ > > > -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) > > > -{ > > > - relopt_string *newoption; > > > - > > > - /* make sure the validator/default combination is sane */ > > > - if (validator) > > > - (validator) (default_val); > > > - > > > - newoption = (relopt_string *) allocate_reloption(kinds, > > > RELOPT_TYPE_STRING, - > name, desc, lockmode); > > > - newoption->validate_cb = validator; > > > - newoption->fill_cb = filler; > > > - if (default_val) > > > - { > > > - if (kinds == RELOPT_KIND_LOCAL) > > > - newoption->default_val = strdup(default_val); > > > - else > > > - newoption->default_val = > MemoryContextStrdup(TopMemoryContext, > > > default_val); - newoption->default_len = strlen(default_val); > > > - newoption->default_isnull = false; > > > - } > > > - else > > > - { > > > - newoption->default_val = ""; > > > - newoption->default_len = 0; > > > - newoption->default_isnull = true; > > > - } > > > - > > > - return newoption; > > > -} > > > - > > > -/* > > > - * add_string_reloption > > > - * Add a new string reloption > > > - * > > > - * "validator" is an optional function pointer that can be used to test > > > the - * validity of the values. It must elog(ERROR) when the argument > > > string is - * not acceptable for the variable. Note that the default > > > value must pass - * the validation. > > > - */ > > > -void > > > -add_string_reloption(bits32 kinds, const char *name, const char *desc, > > > - const char *default_val, > validate_string_relopt validator, > > > - LOCKMODE lockmode) > > > -{ > > > - relopt_string *newoption = init_string_reloption(kinds, name, desc, > > > - > default_val, > > > - > validator, NULL, > > > - > lockmode); > > > - > > > - add_reloption((relopt_gen *) newoption); > > > + optionsSpecSetAddEnum(relopts->spec_set, name, desc, NoLock, 0, > offset, > > > + > members, default_val, detailmsg); > > > > > > } > > > > > > /* > > > > > > @@ -1113,249 +226,9 @@ add_local_string_reloption(local_relopts *relopts, > > > const char *name,> > > > validate_string_relopt > validator, > > > fill_string_relopt filler, > int offset) > > > > > > { > > > > > > - relopt_string *newoption = init_string_reloption(RELOPT_KIND_LOCAL, > > > - > name, desc, > > > - > default_val, > > > - > validator, filler, > > > - > 0); > > > - > > > - add_local_reloption(relopts, (relopt_gen *) newoption, offset); > > > -} > > > - > > > -/* > > > - * Transform a relation options list (list of DefElem) into the text > > > array > > > - * format that is kept in pg_class.reloptions, including only those > > > options - * that are in the passed namespace. The output values do not > > > include the - * namespace. > > > - * > > > - * This is used for three cases: CREATE TABLE/INDEX, ALTER TABLE SET, and > > > - * ALTER TABLE RESET. In the ALTER cases, oldOptions is the existing > > > - * reloptions value (possibly NULL), and we replace or remove entries > > > - * as needed. > > > - * > > > - * If acceptOidsOff is true, then we allow oids = false, but throw error > > > when - * on. This is solely needed for backwards compatibility. > > > - * > > > - * Note that this is not responsible for determining whether the options > > > - * are valid, but it does check that namespaces for all the options given > > > are - * listed in validnsps. The NULL namespace is always valid and need > > > not be - * explicitly listed. Passing a NULL pointer means that only the > > > NULL - * namespace is valid. > > > - * > > > - * Both oldOptions and the result are text arrays (or NULL for > > > "default"), > > > - * but we declare them as Datums to avoid including array.h in > > > reloptions.h. - */ > > > -Datum > > > -transformRelOptions(Datum oldOptions, List *defList, const char > > > *namspace, > > > - char *validnsps[], bool > acceptOidsOff, bool isReset) > > > -{ > > > - Datum result; > > > - ArrayBuildState *astate; > > > - ListCell *cell; > > > - > > > - /* no change if empty list */ > > > - if (defList == NIL) > > > - return oldOptions; > > > - > > > - /* We build new array using accumArrayResult */ > > > - astate = NULL; > > > - > > > - /* Copy any oldOptions that aren't to be replaced */ > > > - if (PointerIsValid(DatumGetPointer(oldOptions))) > > > - { > > > - ArrayType *array = DatumGetArrayTypeP(oldOptions); > > > - Datum *oldoptions; > > > - int noldoptions; > > > - int i; > > > - > > > - deconstruct_array(array, TEXTOID, -1, false, TYPALIGN_INT, > > > - &oldoptions, NULL, > &noldoptions); > > > - > > > - for (i = 0; i < noldoptions; i++) > > > - { > > > - char *text_str = VARDATA(oldoptions[i]); > > > - int text_len = > VARSIZE(oldoptions[i]) - VARHDRSZ; > > > - > > > - /* Search for a match in defList */ > > > - foreach(cell, defList) > > > - { > > > - DefElem *def = (DefElem *) lfirst(cell); > > > - int kw_len; > > > - > > > - /* ignore if not in the same namespace */ > > > - if (namspace == NULL) > > > - { > > > - if (def->defnamespace != NULL) > > > - continue; > > > - } > > > - else if (def->defnamespace == NULL) > > > - continue; > > > - else if (strcmp(def->defnamespace, namspace) > != 0) > > > - continue; > > > - > > > - kw_len = strlen(def->defname); > > > - if (text_len > kw_len && text_str[kw_len] == > '=' && > > > - strncmp(text_str, def->defname, > kw_len) == 0) > > > - break; > > > - } > > > - if (!cell) > > > - { > > > - /* No match, so keep old option */ > > > - astate = accumArrayResult(astate, > oldoptions[i], > > > - > false, TEXTOID, > > > - > CurrentMemoryContext); > > > - } > > > - } > > > - } > > > - > > > - /* > > > - * If CREATE/SET, add new options to array; if RESET, just check > that > > > the > > > - * user didn't say RESET (option=val). (Must do this because the > > > grammar > > > - * doesn't enforce it.) > > > - */ > > > - foreach(cell, defList) > > > - { > > > - DefElem *def = (DefElem *) lfirst(cell); > > > - > > > - if (isReset) > > > - { > > > - if (def->arg != NULL) > > > - ereport(ERROR, > > > - > (errcode(ERRCODE_SYNTAX_ERROR), > > > - errmsg("RESET must not > include values for parameters"))); > > > - } > > > - else > > > - { > > > - text *t; > > > - const char *value; > > > - Size len; > > > - > > > - /* > > > - * Error out if the namespace is not valid. A NULL > namespace is > > > - * always valid. > > > - */ > > > - if (def->defnamespace != NULL) > > > - { > > > - bool valid = false; > > > - int i; > > > - > > > - if (validnsps) > > > - { > > > - for (i = 0; validnsps[i]; i++) > > > - { > > > - if (strcmp(def- > >defnamespace, validnsps[i]) == 0) > > > - { > > > - valid = true; > > > - break; > > > - } > > > - } > > > - } > > > - > > > - if (!valid) > > > - ereport(ERROR, > > > - > (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > - > errmsg("unrecognized parameter namespace \"%s\"", > > > - def- > >defnamespace))); > > > - } > > > - > > > - /* ignore if not in the same namespace */ > > > - if (namspace == NULL) > > > - { > > > - if (def->defnamespace != NULL) > > > - continue; > > > - } > > > - else if (def->defnamespace == NULL) > > > - continue; > > > - else if (strcmp(def->defnamespace, namspace) != 0) > > > - continue; > > > - > > > - /* > > > - * Flatten the DefElem into a text string like > "name=arg". If we > > > - * have just "name", assume "name=true" is meant. > Note: the > > > - * namespace is not output. > > > - */ > > > - if (def->arg != NULL) > > > - value = defGetString(def); > > > - else > > > - value = "true"; > > > - > > > - /* > > > - * This is not a great place for this test, but > there's no other > > > - * convenient place to filter the option out. As WITH > (oids = > > > - * false) will be removed someday, this seems like > an acceptable > > > - * amount of ugly. > > > - */ > > > - if (acceptOidsOff && def->defnamespace == NULL && > > > - strcmp(def->defname, "oids") == 0) > > > - { > > > - if (defGetBoolean(def)) > > > - ereport(ERROR, > > > - > (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), > > > - errmsg("tables > declared WITH OIDS are not supported"))); > > > - /* skip over option, reloptions machinery > doesn't know it */ > > > - continue; > > > - } > > > - > > > - len = VARHDRSZ + strlen(def->defname) + 1 + > strlen(value); > > > - /* +1 leaves room for sprintf's trailing null */ > > > - t = (text *) palloc(len + 1); > > > - SET_VARSIZE(t, len); > > > - sprintf(VARDATA(t), "%s=%s", def->defname, value); > > > - > > > - astate = accumArrayResult(astate, > PointerGetDatum(t), > > > - > false, TEXTOID, > > > - > CurrentMemoryContext); > > > - } > > > - } > > > - > > > - if (astate) > > > - result = makeArrayResult(astate, CurrentMemoryContext); > > > - else > > > - result = (Datum) 0; > > > - > > > - return result; > > > -} > > > - > > > - > > > -/* > > > - * Convert the text-array format of reloptions into a List of DefElem. > > > - * This is the inverse of transformRelOptions(). > > > - */ > > > -List * > > > -untransformRelOptions(Datum options) > > > -{ > > > - List *result = NIL; > > > - ArrayType *array; > > > - Datum *optiondatums; > > > - int noptions; > > > - int i; > > > - > > > - /* Nothing to do if no options */ > > > - if (!PointerIsValid(DatumGetPointer(options))) > > > - return result; > > > - > > > - array = DatumGetArrayTypeP(options); > > > - > > > - deconstruct_array(array, TEXTOID, -1, false, TYPALIGN_INT, > > > - &optiondatums, NULL, &noptions); > > > - > > > - for (i = 0; i < noptions; i++) > > > - { > > > - char *s; > > > - char *p; > > > - Node *val = NULL; > > > - > > > - s = TextDatumGetCString(optiondatums[i]); > > > - p = strchr(s, '='); > > > - if (p) > > > - { > > > - *p++ = '\0'; > > > - val = (Node *) makeString(pstrdup(p)); > > > - } > > > - result = lappend(result, makeDefElem(pstrdup(s), val, -1)); > > > - } > > > - > > > - return result; > > > + optionsSpecSetAddString(relopts->spec_set, name, desc, NoLock, 0, > > > offset, > > > + > default_val, validator); > > > +/* FIXME solve mistery with filler option! */ > > > > > > } > > > > > > /* > > > > > > @@ -1372,12 +245,13 @@ untransformRelOptions(Datum options) > > > > > > */ > > > > > > bytea * > > > extractRelOptions(HeapTuple tuple, TupleDesc tupdesc, > > > > > > - amoptions_function amoptions) > > > + amreloptspecset_function > amoptionsspecsetfn) > > > > > > { > > > > > > bytea *options; > > > bool isnull; > > > Datum datum; > > > Form_pg_class classForm; > > > > > > + options_spec_set *spec_set; > > > > > > datum = fastgetattr(tuple, > > > > > > Anum_pg_class_reloptions, > > > > > > @@ -1394,702 +268,341 @@ extractRelOptions(HeapTuple tuple, TupleDesc > > > tupdesc,> > > > case RELKIND_RELATION: > > > case RELKIND_TOASTVALUE: > > > > > > case RELKIND_MATVIEW: > > > - options = heap_reloptions(classForm->relkind, datum, > false); > > > + spec_set = get_heap_relopt_spec_set(); > > > > > > break; > > > > > > case RELKIND_PARTITIONED_TABLE: > > > - options = partitioned_table_reloptions(datum, > false); > > > + spec_set = get_partitioned_relopt_spec_set(); > > > > > > break; > > > > > > case RELKIND_VIEW: > > > - options = view_reloptions(datum, false); > > > + spec_set = get_view_relopt_spec_set(); > > > > > > break; > > > > > > case RELKIND_INDEX: > > > > > > case RELKIND_PARTITIONED_INDEX: > > > - options = index_reloptions(amoptions, datum, false); > > > + if (amoptionsspecsetfn) > > > + spec_set = amoptionsspecsetfn(); > > > + else > > > + spec_set = NULL; > > > > > > break; > > > > > > case RELKIND_FOREIGN_TABLE: > > > - options = NULL; > > > + spec_set = NULL; > > > > > > break; > > > > > > default: > > > Assert(false); /* can't get here */ > > > > > > - options = NULL; /* keep compiler quiet */ > > > + spec_set = NULL; /* keep compiler quiet */ > > > > > > break; > > > > > > } > > > > > > + if (spec_set) > > > + options = optionsTextArrayToBytea(spec_set, datum, 0); > > > + else > > > + options = NULL; > > > > > > return options; > > > > > > } > > > > > > -static void > > > -parseRelOptionsInternal(Datum options, bool validate, > > > - relopt_value *reloptions, > int numoptions) > > > -{ > > > - ArrayType *array = DatumGetArrayTypeP(options); > > > - Datum *optiondatums; > > > - int noptions; > > > - int i; > > > - > > > - deconstruct_array(array, TEXTOID, -1, false, TYPALIGN_INT, > > > - &optiondatums, NULL, &noptions); > > > +options_spec_set * > > > +get_stdrd_relopt_spec_set(relopt_kind kind) > > > +{ > > > + bool is_for_toast = (kind == RELOPT_KIND_TOAST); > > > + > > > + options_spec_set * stdrd_relopt_spec_set = allocateOptionsSpecSet( > > > + is_for_toast ? "toast" : NULL, > sizeof(StdRdOptions), 0); //FIXME > > > change 0 to actual value (may be) > > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, "fillfactor", > > > + "Packs table > pages only to this percentag", > > > + > ShareUpdateExclusiveLock, /* since it applies only > > > + > * to later inserts */ > > > + is_for_toast > ? OPTION_DEFINITION_FLAG_REJECT : 0, > > > + > offsetof(StdRdOptions, fillfactor), > > > + HEAP_DEFAULT_FILLFACTOR, > HEAP_MIN_FILLFACTOR, 100); > > > + optionsSpecSetAddBool(stdrd_relopt_spec_set, "autovacuum_enabled", > > > + "Enables autovacuum > in this relation", > > > + > ShareUpdateExclusiveLock, 0, > > > + offsetof(StdRdOptions, autovacuum) + > offsetof(AutoVacOpts, enabled), > > > + true); > > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, > > > "autovacuum_vacuum_threshold", + "Minimum number > of tuple updates or > > > deletes prior to vacuum", + > ShareUpdateExclusiveLock, > > > + 0, offsetof(StdRdOptions, autovacuum) > + offsetof(AutoVacOpts, > > > vacuum_threshold), + > -1, 0, INT_MAX); > > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, > > > "autovacuum_analyze_threshold", + "Minimum number > of tuple updates or > > > deletes prior to vacuum", + > ShareUpdateExclusiveLock, > > > + is_for_toast ? > OPTION_DEFINITION_FLAG_REJECT : 0, > > > + offsetof(StdRdOptions, autovacuum) + > offsetof(AutoVacOpts, > > > analyze_threshold), + > -1, 0, INT_MAX); > > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, > > > "autovacuum_vacuum_cost_limit", + "Vacuum cost amount > available > > > before napping, for autovacuum", + > ShareUpdateExclusiveLock, > > > + 0, offsetof(StdRdOptions, autovacuum) + > offsetof(AutoVacOpts, > > > vacuum_cost_limit), + > -1, 0, 10000); > > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, > "autovacuum_freeze_min_age", > > > + "Minimum age at which VACUUM should freeze a table row, for > > > autovacuum", > > > + > ShareUpdateExclusiveLock, > > > + 0, offsetof(StdRdOptions, > autovacuum) + offsetof(AutoVacOpts, > > > freeze_min_age), + > -1, 0, 1000000000); > > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, > "autovacuum_freeze_max_age", > > > + "Age at which to autovacuum a table to prevent transaction ID > > > wraparound", + > ShareUpdateExclusiveLock, > > > + 0, offsetof(StdRdOptions, > autovacuum) + offsetof(AutoVacOpts, > > > freeze_max_age), + > -1, 100000, 2000000000); > > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, > > > "autovacuum_freeze_table_age", + > "Age at which VACUUM should > > > perform a full table sweep to freeze row versions", + > > > > ShareUpdateExclusiveLock, > > > + 0, offsetof(StdRdOptions, autovacuum) > + offsetof(AutoVacOpts, > > > freeze_table_age), + > -1, 0, 2000000000); > > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, > > > "autovacuum_multixact_freeze_min_age", + > "Minimum multixact age at > > > which VACUUM should freeze a row multixact's, for autovacuum", + > > > > ShareUpdateExclusiveLock, > > > + 0, offsetof(StdRdOptions, autovacuum) + > offsetof(AutoVacOpts, > > > multixact_freeze_min_age), + > -1, 0, 1000000000); > > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, > > > "autovacuum_multixact_freeze_max_age", + > "Multixact age at which > > > to autovacuum a table to prevent multixact wraparound", + > > > > ShareUpdateExclusiveLock, > > > + 0, offsetof(StdRdOptions, autovacuum) + > offsetof(AutoVacOpts, > > > multixact_freeze_max_age), + > -1, 10000, 2000000000); > > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, > > > "autovacuum_multixact_freeze_table_age", + > "Age of multixact at > > > which VACUUM should perform a full table sweep to freeze row versions", > > > + > ShareUpdateExclusiveLock, > > > + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > > multixact_freeze_table_age), + > -1, 0, 2000000000); > > > + > optionsSpecSetAddInt(stdrd_relopt_spec_set,"log_autovacuum_min_duration" > > > , > > > + "Sets the minimum > execution time above which autovacuum actions > > > will be logged", + > ShareUpdateExclusiveLock, > > > + 0, offsetof(StdRdOptions, autovacuum) > + offsetof(AutoVacOpts, > > > log_min_duration), + > -1, -1, INT_MAX); > > > + optionsSpecSetAddReal(stdrd_relopt_spec_set, > > > "autovacuum_vacuum_cost_delay", + > "Vacuum cost delay in > > > milliseconds, for autovacuum", > > > + > ShareUpdateExclusiveLock, > > > + 0, offsetof(StdRdOptions, autovacuum) + > offsetof(AutoVacOpts, > > > vacuum_cost_delay), + > -1, 0.0, 100.0); > > > + optionsSpecSetAddReal(stdrd_relopt_spec_set, > > > "autovacuum_vacuum_scale_factor", + > "Number of tuple updates or > > > deletes prior to vacuum as a fraction of reltuples", + > > > > ShareUpdateExclusiveLock, > > > + 0, offsetof(StdRdOptions, autovacuum) + > offsetof(AutoVacOpts, > > > vacuum_scale_factor), + > -1, 0.0, 100.0); > > > + > > > + optionsSpecSetAddReal(stdrd_relopt_spec_set, > > > "autovacuum_vacuum_insert_scale_factor", + > "Number of tuple > > > inserts prior to vacuum as a fraction of reltuples", + > > > > ShareUpdateExclusiveLock, > > > + 0, offsetof(StdRdOptions, autovacuum) + > offsetof(AutoVacOpts, > > > vacuum_ins_scale_factor), + > -1, 0.0, 100.0); > > > + > > > + optionsSpecSetAddReal(stdrd_relopt_spec_set, > > > "autovacuum_analyze_scale_factor", + > "Number of tuple inserts, > > > updates or deletes prior to analyze as a fraction of reltuples", + > > > > ShareUpdateExclusiveLock, > > > + is_for_toast ? > OPTION_DEFINITION_FLAG_REJECT : 0, > > > + offsetof(StdRdOptions, autovacuum) + > offsetof(AutoVacOpts, > > > analyze_scale_factor), + > -1, 0.0, 100.0); > > > + > > > + > > > + > > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, "toast_tuple_target", > > > + "Sets the > target tuple length at which external columns will be > > > toasted", + > ShareUpdateExclusiveLock, > > > + is_for_toast > ? OPTION_DEFINITION_FLAG_REJECT : 0, > > > + > offsetof(StdRdOptions, toast_tuple_target), > > > + TOAST_TUPLE_TARGET, 128, > TOAST_TUPLE_TARGET_MAIN); > > > + > > > + optionsSpecSetAddBool(stdrd_relopt_spec_set, "user_catalog_table", > > > + "Declare a > table as an additional catalog table, e.g. for the > > > purpose of logical replication", + > AccessExclusiveLock, > > > + is_for_toast > ? OPTION_DEFINITION_FLAG_REJECT : 0, > > > + > offsetof(StdRdOptions, user_catalog_table), > > > + false); > > > + > > > + optionsSpecSetAddInt(stdrd_relopt_spec_set, "parallel_workers", > > > + "Number of > parallel processes that can be used per executor node > > > for this relation.", + > ShareUpdateExclusiveLock, > > > + is_for_toast > ? OPTION_DEFINITION_FLAG_REJECT : 0, > > > + > offsetof(StdRdOptions, parallel_workers), > > > + -1, 0, 1024); > > > + > > > + optionsSpecSetAddEnum(stdrd_relopt_spec_set, "vacuum_index_cleanup", > > > + "Controls > index vacuuming and index cleanup", > > > + > ShareUpdateExclusiveLock, 0, > > > + > offsetof(StdRdOptions, vacuum_index_cleanup), > > > + > StdRdOptIndexCleanupValues, > > > + > STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO, > > > + > gettext_noop("Valid values are \"on\", \"off\", and \"auto\".")); > > > + > > > + optionsSpecSetAddBool(stdrd_relopt_spec_set, "vacuum_truncate", > > > + "Enables > vacuum to truncate empty pages at the end of this > > > table", > > > + > ShareUpdateExclusiveLock, 0, > > > + > offsetof(StdRdOptions, vacuum_truncate), > > > + true); > > > + > > > +// FIXME Do something with OIDS > > > + > > > + return stdrd_relopt_spec_set; > > > +} > > > + > > > + > > > +static options_spec_set *heap_relopt_spec_set = NULL; > > > + > > > +options_spec_set * > > > +get_heap_relopt_spec_set(void) > > > +{ > > > + if (heap_relopt_spec_set) > > > + return heap_relopt_spec_set; > > > + heap_relopt_spec_set = get_stdrd_relopt_spec_set(RELOPT_KIND_HEAP); > > > + return heap_relopt_spec_set; > > > +} > > > + > > > +static options_spec_set *toast_relopt_spec_set = NULL; > > > + > > > +options_spec_set * > > > +get_toast_relopt_spec_set(void) > > > +{ > > > + if (toast_relopt_spec_set) > > > + return toast_relopt_spec_set; > > > + toast_relopt_spec_set = get_stdrd_relopt_spec_set(RELOPT_KIND_TOAST); > > > + return toast_relopt_spec_set; > > > +} > > > + > > > +static options_spec_set *partitioned_relopt_spec_set = NULL; > > > > > > - for (i = 0; i < noptions; i++) > > > - { > > > - char *text_str = VARDATA(optiondatums[i]); > > > - int text_len = VARSIZE(optiondatums[i]) > - VARHDRSZ; > > > - int j; > > > - > > > - /* Search for a match in reloptions */ > > > - for (j = 0; j < numoptions; j++) > > > - { > > > - int kw_len = reloptions[j].gen- > >namelen; > > > - > > > - if (text_len > kw_len && text_str[kw_len] == '=' && > > > - strncmp(text_str, reloptions[j].gen->name, > kw_len) == 0) > > > - { > > > - parse_one_reloption(&reloptions[j], > text_str, text_len, > > > - > validate); > > > - break; > > > - } > > > - } > > > - > > > - if (j >= numoptions && validate) > > > - { > > > - char *s; > > > - char *p; > > > - > > > - s = TextDatumGetCString(optiondatums[i]); > > > - p = strchr(s, '='); > > > - if (p) > > > - *p = '\0'; > > > - ereport(ERROR, > > > - > (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > - errmsg("unrecognized parameter > \"%s\"", s))); > > > - } > > > - } > > > - > > > - /* It's worth avoiding memory leaks in this function */ > > > - pfree(optiondatums); > > > +options_spec_set * > > > +get_partitioned_relopt_spec_set(void) > > > +{ > > > + if (partitioned_relopt_spec_set) > > > + return partitioned_relopt_spec_set; > > > + partitioned_relopt_spec_set = allocateOptionsSpecSet( > > > + NULL, sizeof(StdRdOptions), 0); > > > + /* No options for now, so spec set is empty */ > > > > > > - if (((void *) array) != DatumGetPointer(options)) > > > - pfree(array); > > > + return partitioned_relopt_spec_set; > > > > > > } > > > > > > /* > > > > > > - * Interpret reloptions that are given in text-array format. > > > - * > > > - * options is a reloption text array as constructed by > > > transformRelOptions. - * kind specifies the family of options to be > > > processed. > > > - * > > > - * The return value is a relopt_value * array on which the options > > > actually - * set in the options array are marked with isset=true. The > > > length of this - * array is returned in *numrelopts. Options not set are > > > also present in the - * array; this is so that the caller can easily > > > locate the default values. - * > > > - * If there are no options of the given kind, numrelopts is set to 0 and > > > NULL - * is returned (unless options are illegally supplied despite none > > > being - * defined, in which case an error occurs). > > > - * > > > - * Note: values of type int, bool and real are allocated as part of the > > > - * returned array. Values of type string are allocated separately and > > > must - * be freed by the caller. > > > + * Parse local options, allocate a bytea struct that's of the specified > > > + * 'base_size' plus any extra space that's needed for string variables, > > > + * fill its option's fields located at the given offsets and return it. > > > > > > */ > > > > > > -static relopt_value * > > > -parseRelOptions(Datum options, bool validate, relopt_kind kind, > > > - int *numrelopts) > > > -{ > > > - relopt_value *reloptions = NULL; > > > - int numoptions = 0; > > > - int i; > > > - int j; > > > - > > > - if (need_initialization) > > > - initialize_reloptions(); > > > - > > > - /* Build a list of expected options, based on kind */ > > > - > > > - for (i = 0; relOpts[i]; i++) > > > - if (relOpts[i]->kinds & kind) > > > - numoptions++; > > > - > > > - if (numoptions > 0) > > > - { > > > - reloptions = palloc(numoptions * sizeof(relopt_value)); > > > - > > > - for (i = 0, j = 0; relOpts[i]; i++) > > > - { > > > - if (relOpts[i]->kinds & kind) > > > - { > > > - reloptions[j].gen = relOpts[i]; > > > - reloptions[j].isset = false; > > > - j++; > > > - } > > > - } > > > - } > > > - > > > - /* Done if no options */ > > > - if (PointerIsValid(DatumGetPointer(options))) > > > - parseRelOptionsInternal(options, validate, reloptions, > numoptions); > > > - > > > - *numrelopts = numoptions; > > > - return reloptions; > > > -} > > > - > > > -/* Parse local unregistered options. */ > > > -static relopt_value * > > > -parseLocalRelOptions(local_relopts *relopts, Datum options, bool > > > validate) > > > +void * > > > +build_local_reloptions(local_relopts *relopts, Datum options, bool > > > validate)> > > > { > > > > > > - int nopts = list_length(relopts->options); > > > - relopt_value *values = palloc(sizeof(*values) * nopts); > > > + void *opts; > > > > > > ListCell *lc; > > > > > > - int i = 0; > > > - > > > - foreach(lc, relopts->options) > > > - { > > > - local_relopt *opt = lfirst(lc); > > > - > > > - values[i].gen = opt->option; > > > - values[i].isset = false; > > > - > > > - i++; > > > - } > > > - > > > - if (options != (Datum) 0) > > > - parseRelOptionsInternal(options, validate, values, nopts); > > > + opts = (void *) optionsTextArrayToBytea(relopts->spec_set, options, > > > validate); > > > > > > - return values; > > > -} > > > - > > > -/* > > > - * Subroutine for parseRelOptions, to parse and validate a single > > > option's > > > - * value > > > - */ > > > -static void > > > -parse_one_reloption(relopt_value *option, char *text_str, int text_len, > > > - bool validate) > > > -{ > > > - char *value; > > > - int value_len; > > > - bool parsed; > > > - bool nofree = false; > > > - > > > - if (option->isset && validate) > > > - ereport(ERROR, > > > - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > - errmsg("parameter \"%s\" specified more than > once", > > > - option->gen->name))); > > > - > > > - value_len = text_len - option->gen->namelen - 1; > > > - value = (char *) palloc(value_len + 1); > > > - memcpy(value, text_str + option->gen->namelen + 1, value_len); > > > - value[value_len] = '\0'; > > > - > > > - switch (option->gen->type) > > > - { > > > - case RELOPT_TYPE_BOOL: > > > - { > > > - parsed = parse_bool(value, &option- > >values.bool_val); > > > - if (validate && !parsed) > > > - ereport(ERROR, > > > - > (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > - errmsg("invalid > value for boolean option \"%s\": %s", > > > - > option->gen->name, value))); > > > - } > > > - break; > > > - case RELOPT_TYPE_INT: > > > - { > > > - relopt_int *optint = (relopt_int *) option- > >gen; > > > - > > > - parsed = parse_int(value, &option- > >values.int_val, 0, NULL); > > > - if (validate && !parsed) > > > - ereport(ERROR, > > > - > (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > - errmsg("invalid > value for integer option \"%s\": %s", > > > - > option->gen->name, value))); > > > - if (validate && (option->values.int_val < > optint->min || > > > - option- > >values.int_val > optint->max)) > > > - ereport(ERROR, > > > - > (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > - errmsg("value %s > out of bounds for option \"%s\"", > > > - > value, option->gen->name), > > > - errdetail("Valid > values are between \"%d\" and \"%d\".", > > > - > optint->min, optint->max))); > > > - } > > > - break; > > > - case RELOPT_TYPE_REAL: > > > - { > > > - relopt_real *optreal = (relopt_real *) > option->gen; > > > - > > > - parsed = parse_real(value, &option- > >values.real_val, 0, NULL); > > > - if (validate && !parsed) > > > - ereport(ERROR, > > > - > (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > - errmsg("invalid > value for floating point option \"%s\": %s", > > > - > option->gen->name, value))); > > > - if (validate && (option->values.real_val < > optreal->min || > > > - option- > >values.real_val > optreal->max)) > > > - ereport(ERROR, > > > - > (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > - errmsg("value %s > out of bounds for option \"%s\"", > > > - > value, option->gen->name), > > > - errdetail("Valid > values are between \"%f\" and \"%f\".", > > > - > optreal->min, optreal->max))); > > > - } > > > - break; > > > - case RELOPT_TYPE_ENUM: > > > - { > > > - relopt_enum *optenum = (relopt_enum *) > option->gen; > > > - relopt_enum_elt_def *elt; > > > - > > > - parsed = false; > > > - for (elt = optenum->members; elt- > >string_val; elt++) > > > - { > > > - if (pg_strcasecmp(value, elt- > >string_val) == 0) > > > - { > > > - option->values.enum_val = > elt->symbol_val; > > > - parsed = true; > > > - break; > > > - } > > > - } > > > - if (validate && !parsed) > > > - ereport(ERROR, > > > - > (errcode(ERRCODE_INVALID_PARAMETER_VALUE), > > > - errmsg("invalid > value for enum option \"%s\": %s", > > > - > option->gen->name, value), > > > - optenum->detailmsg > ? > > > - > errdetail_internal("%s", _(optenum->detailmsg)) : 0)); > > > - > > > - /* > > > - * If value is not among the allowed string > values, but we are > > > - * not asked to validate, just use the > default numeric value. > > > - */ > > > - if (!parsed) > > > - option->values.enum_val = optenum- > >default_val; > > > - } > > > - break; > > > - case RELOPT_TYPE_STRING: > > > - { > > > - relopt_string *optstring = (relopt_string *) > option->gen; > > > - > > > - option->values.string_val = value; > > > - nofree = true; > > > - if (validate && optstring->validate_cb) > > > - (optstring->validate_cb) (value); > > > - parsed = true; > > > - } > > > - break; > > > - default: > > > - elog(ERROR, "unsupported reloption type %d", option- > >gen->type); > > > - parsed = true; /* quiet compiler */ > > > - break; > > > - } > > > + foreach(lc, relopts->validators) > > > + ((relopts_validator) lfirst(lc)) (opts, NULL, 0); > > > +// ((relopts_validator) lfirst(lc)) (opts, vals, noptions); > > > +// FIXME solve problem with validation of separate option values; > > > + return opts; > > > > > > - if (parsed) > > > - option->isset = true; > > > - if (!nofree) > > > - pfree(value); > > > > > > } > > > > > > /* > > > > > > - * Given the result from parseRelOptions, allocate a struct that's of the > > > - * specified base size plus any extra space that's needed for string > > > variables. - * > > > - * "base" should be sizeof(struct) of the reloptions struct (StdRdOptions > > > or - * equivalent). > > > + * get_view_relopt_spec_set > > > + * Returns an options catalog for view relation. > > > > > > */ > > > > > > -static void * > > > -allocateReloptStruct(Size base, relopt_value *options, int numoptions) > > > -{ > > > - Size size = base; > > > - int i; > > > - > > > - for (i = 0; i < numoptions; i++) > > > - { > > > - relopt_value *optval = &options[i]; > > > - > > > - if (optval->gen->type == RELOPT_TYPE_STRING) > > > - { > > > - relopt_string *optstr = (relopt_string *) optval- > >gen; > > > - > > > - if (optstr->fill_cb) > > > - { > > > - const char *val = optval->isset ? optval- > >values.string_val : > > > - optstr->default_isnull ? NULL : optstr- > >default_val; > > > - > > > - size += optstr->fill_cb(val, NULL); > > > - } > > > - else > > > - size += GET_STRING_RELOPTION_LEN(*optval) + > 1; > > > - } > > > - } > > > - > > > - return palloc0(size); > > > -} > > > +static options_spec_set *view_relopt_spec_set = NULL; > > > > > > -/* > > > - * Given the result of parseRelOptions and a parsing table, fill in the > > > - * struct (previously allocated with allocateReloptStruct) with the > > > parsed > > > - * values. > > > - * > > > - * rdopts is the pointer to the allocated struct to be filled. > > > - * basesize is the sizeof(struct) that was passed to > > > allocateReloptStruct. > > > - * options, of length numoptions, is parseRelOptions' output. > > > - * elems, of length numelems, is the table describing the allowed > > > options. > > > - * When validate is true, it is expected that all options appear in > > > elems. > > > - */ > > > -static void > > > -fillRelOptions(void *rdopts, Size basesize, > > > - relopt_value *options, int numoptions, > > > - bool validate, > > > - const relopt_parse_elt *elems, int numelems) > > > +options_spec_set * > > > +get_view_relopt_spec_set(void) > > > > > > { > > > > > > - int i; > > > - int offset = basesize; > > > + if (view_relopt_spec_set) > > > + return view_relopt_spec_set; > > > > > > - for (i = 0; i < numoptions; i++) > > > - { > > > - int j; > > > - bool found = false; > > > + view_relopt_spec_set = allocateOptionsSpecSet(NULL, > > > + > sizeof(ViewOptions), 2); > > > > > > - for (j = 0; j < numelems; j++) > > > - { > > > - if (strcmp(options[i].gen->name, elems[j].optname) > == 0) > > > - { > > > - relopt_string *optstring; > > > - char *itempos = ((char *) rdopts) + > elems[j].offset; > > > - char *string_val; > > > - > > > - switch (options[i].gen->type) > > > - { > > > - case RELOPT_TYPE_BOOL: > > > - *(bool *) itempos = > options[i].isset ? > > > - > options[i].values.bool_val : > > > - ((relopt_bool *) > options[i].gen)->default_val; > > > - break; > > > - case RELOPT_TYPE_INT: > > > - *(int *) itempos = > options[i].isset ? > > > - > options[i].values.int_val : > > > - ((relopt_int *) > options[i].gen)->default_val; > > > - break; > > > - case RELOPT_TYPE_REAL: > > > - *(double *) itempos = > options[i].isset ? > > > - > options[i].values.real_val : > > > - ((relopt_real *) > options[i].gen)->default_val; > > > - break; > > > - case RELOPT_TYPE_ENUM: > > > - *(int *) itempos = > options[i].isset ? > > > - > options[i].values.enum_val : > > > - ((relopt_enum *) > options[i].gen)->default_val; > > > - break; > > > - case RELOPT_TYPE_STRING: > > > - optstring = (relopt_string > *) options[i].gen; > > > - if (options[i].isset) > > > - string_val = > options[i].values.string_val; > > > - else if (!optstring- > >default_isnull) > > > - string_val = > optstring->default_val; > > > - else > > > - string_val = NULL; > > > - > > > - if (optstring->fill_cb) > > > - { > > > - Size > size = > > > - optstring- > >fill_cb(string_val, > > > - > (char *) rdopts + offset); > > > - > > > - if (size) > > > - { > > > - *(int *) > itempos = offset; > > > - offset += > size; > > > - } > > > - else > > > - *(int *) > itempos = 0; > > > - } > > > - else if (string_val == NULL) > > > - *(int *) itempos = > 0; > > > - else > > > - { > > > - strcpy((char *) > rdopts + offset, string_val); > > > - *(int *) itempos = > offset; > > > - offset += > strlen(string_val) + 1; > > > - } > > > - break; > > > - default: > > > - elog(ERROR, "unsupported > reloption type %d", > > > - options[i].gen- > >type); > > > - break; > > > - } > > > - found = true; > > > - break; > > > - } > > > - } > > > - if (validate && !found) > > > - elog(ERROR, "reloption \"%s\" not found in parse > table", > > > - options[i].gen->name); > > > - } > > > - SET_VARSIZE(rdopts, offset); > > > -} > > > + optionsSpecSetAddBool(view_relopt_spec_set, "security_barrier", > > > + "View acts as a row > security barrier", > > > + > AccessExclusiveLock, > > > + 0, offsetof(ViewOptions, > security_barrier), false); > > > > > > + optionsSpecSetAddEnum(view_relopt_spec_set, "check_option", > > > + "View has WITH CHECK > OPTION defined (local or cascaded)", > > > + > AccessExclusiveLock, 0, > > > + > offsetof(ViewOptions, check_option), > > > + viewCheckOptValues, > > > + > VIEW_OPTION_CHECK_OPTION_NOT_SET, > > > + gettext_noop("Valid > values are \"local\" and \"cascaded\".")); > > > > > > -/* > > > - * Option parser for anything that uses StdRdOptions. > > > - */ > > > -bytea * > > > -default_reloptions(Datum reloptions, bool validate, relopt_kind kind) > > > -{ > > > - static const relopt_parse_elt tab[] = { > > > - {"fillfactor", RELOPT_TYPE_INT, offsetof(StdRdOptions, > fillfactor)}, > > > - {"autovacuum_enabled", RELOPT_TYPE_BOOL, > > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > enabled)}, > > > - {"autovacuum_vacuum_threshold", RELOPT_TYPE_INT, > > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > > vacuum_threshold)}, - {"autovacuum_vacuum_insert_threshold", > > > RELOPT_TYPE_INT, > > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > > vacuum_ins_threshold)}, - {"autovacuum_analyze_threshold", > > > RELOPT_TYPE_INT, > > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > > analyze_threshold)}, - {"autovacuum_vacuum_cost_limit", > RELOPT_TYPE_INT, > > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > > vacuum_cost_limit)}, - {"autovacuum_freeze_min_age", > RELOPT_TYPE_INT, > > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > > freeze_min_age)}, - {"autovacuum_freeze_max_age", > RELOPT_TYPE_INT, > > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > > freeze_max_age)}, - {"autovacuum_freeze_table_age", > RELOPT_TYPE_INT, > > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > > freeze_table_age)}, - {"autovacuum_multixact_freeze_min_age", > > > RELOPT_TYPE_INT, > > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > > multixact_freeze_min_age)}, - > {"autovacuum_multixact_freeze_max_age", > > > RELOPT_TYPE_INT, > > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > > multixact_freeze_max_age)}, - > {"autovacuum_multixact_freeze_table_age", > > > RELOPT_TYPE_INT, > > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > > multixact_freeze_table_age)}, - > {"log_autovacuum_min_duration", > > > RELOPT_TYPE_INT, > > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > > log_min_duration)}, - {"toast_tuple_target", RELOPT_TYPE_INT, > > > - offsetof(StdRdOptions, toast_tuple_target)}, > > > - {"autovacuum_vacuum_cost_delay", RELOPT_TYPE_REAL, > > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > > vacuum_cost_delay)}, - {"autovacuum_vacuum_scale_factor", > > > RELOPT_TYPE_REAL, > > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > > vacuum_scale_factor)}, - > {"autovacuum_vacuum_insert_scale_factor", > > > RELOPT_TYPE_REAL, > > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > > vacuum_ins_scale_factor)}, - > {"autovacuum_analyze_scale_factor", > > > RELOPT_TYPE_REAL, > > > - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, > > > analyze_scale_factor)}, - {"user_catalog_table", > RELOPT_TYPE_BOOL, > > > - offsetof(StdRdOptions, user_catalog_table)}, > > > - {"parallel_workers", RELOPT_TYPE_INT, > > > - offsetof(StdRdOptions, parallel_workers)}, > > > - {"vacuum_index_cleanup", RELOPT_TYPE_ENUM, > > > - offsetof(StdRdOptions, vacuum_index_cleanup)}, > > > - {"vacuum_truncate", RELOPT_TYPE_BOOL, > > > - offsetof(StdRdOptions, vacuum_truncate)} > > > - }; > > > - > > > - return (bytea *) build_reloptions(reloptions, validate, kind, > > > - > sizeof(StdRdOptions), > > > - > tab, lengthof(tab)); > > > + return view_relopt_spec_set; > > > > > > } > > > > > > /* > > > > > > - * build_reloptions > > > - * > > > - * Parses "reloptions" provided by the caller, returning them in a > > > - * structure containing the parsed options. The parsing is done with > > > - * the help of a parsing table describing the allowed options, defined > > > - * by "relopt_elems" of length "num_relopt_elems". > > > - * > > > - * "validate" must be true if reloptions value is freshly built by > > > - * transformRelOptions(), as opposed to being read from the catalog, in > > > which - * case the values contained in it must already be valid. > > > - * > > > - * NULL is returned if the passed-in options did not match any of the > > > options - * in the parsing table, unless validate is true in which case > > > an error would - * be reported. > > > + * get_attribute_options_spec_set > > > + * Returns an options spec det for heap attributes > > > > > > */ > > > > > > -void * > > > -build_reloptions(Datum reloptions, bool validate, > > > - relopt_kind kind, > > > - Size relopt_struct_size, > > > - const relopt_parse_elt *relopt_elems, > > > - int num_relopt_elems) > > > -{ > > > - int numoptions; > > > - relopt_value *options; > > > - void *rdopts; > > > - > > > - /* parse options specific to given relation option kind */ > > > - options = parseRelOptions(reloptions, validate, kind, &numoptions); > > > - Assert(numoptions <= num_relopt_elems); > > > - > > > - /* if none set, we're done */ > > > - if (numoptions == 0) > > > - { > > > - Assert(options == NULL); > > > - return NULL; > > > - } > > > - > > > - /* allocate and fill the structure */ > > > - rdopts = allocateReloptStruct(relopt_struct_size, options, > numoptions); > > > - fillRelOptions(rdopts, relopt_struct_size, options, numoptions, > > > - validate, relopt_elems, > num_relopt_elems); > > > +static options_spec_set *attribute_options_spec_set = NULL; > > > > > > - pfree(options); > > > - > > > - return rdopts; > > > -} > > > - > > > -/* > > > - * Parse local options, allocate a bytea struct that's of the specified > > > - * 'base_size' plus any extra space that's needed for string variables, > > > - * fill its option's fields located at the given offsets and return it. > > > - */ > > > -void * > > > -build_local_reloptions(local_relopts *relopts, Datum options, bool > > > validate) +options_spec_set * > > > +get_attribute_options_spec_set(void) > > > > > > { > > > > > > - int noptions = list_length(relopts->options); > > > - relopt_parse_elt *elems = palloc(sizeof(*elems) * noptions); > > > - relopt_value *vals; > > > - void *opts; > > > - int i = 0; > > > - ListCell *lc; > > > + if (attribute_options_spec_set) > > > + return attribute_options_spec_set; > > > > > > - foreach(lc, relopts->options) > > > - { > > > - local_relopt *opt = lfirst(lc); > > > - > > > - elems[i].optname = opt->option->name; > > > - elems[i].opttype = opt->option->type; > > > - elems[i].offset = opt->offset; > > > - > > > - i++; > > > - } > > > + attribute_options_spec_set = allocateOptionsSpecSet(NULL, > > > + > sizeof(AttributeOpts), 2); > > > > > > - vals = parseLocalRelOptions(relopts, options, validate); > > > - opts = allocateReloptStruct(relopts->relopt_struct_size, vals, > > > noptions); > > > - fillRelOptions(opts, relopts->relopt_struct_size, vals, noptions, > > > validate, - elems, noptions); > > > + optionsSpecSetAddReal(attribute_options_spec_set, "n_distinct", > > > + "Sets the planner's > estimate of the number of distinct values > > > appearing in a column (excluding child relations).", + > > > > ShareUpdateExclusiveLock, > > > + 0, offsetof(AttributeOpts, n_distinct), 0, -1.0, > DBL_MAX); > > > > > > - foreach(lc, relopts->validators) > > > - ((relopts_validator) lfirst(lc)) (opts, vals, noptions); > > > - > > > - if (elems) > > > - pfree(elems); > > > + optionsSpecSetAddReal(attribute_options_spec_set, > > > + "n_distinct_inherited", > > > + "Sets the planner's > estimate of the number of distinct values > > > appearing in a column (including child relations).", + > > > > ShareUpdateExclusiveLock, > > > + 0, offsetof(AttributeOpts, n_distinct_inherited), 0, -1.0, DBL_MAX); > > > > > > - return opts; > > > + return attribute_options_spec_set; > > > > > > } > > > > > > -/* > > > - * Option parser for partitioned tables > > > - */ > > > -bytea * > > > -partitioned_table_reloptions(Datum reloptions, bool validate) > > > -{ > > > - /* > > > - * There are no options for partitioned tables yet, but this is able > to > > > do - * some validation. > > > - */ > > > - return (bytea *) build_reloptions(reloptions, validate, > > > - > RELOPT_KIND_PARTITIONED, > > > - 0, > NULL, 0); > > > -} > > > > > > /* > > > > > > - * Option parser for views > > > - */ > > > -bytea * > > > -view_reloptions(Datum reloptions, bool validate) > > > -{ > > > - static const relopt_parse_elt tab[] = { > > > - {"security_barrier", RELOPT_TYPE_BOOL, > > > - offsetof(ViewOptions, security_barrier)}, > > > - {"check_option", RELOPT_TYPE_ENUM, > > > - offsetof(ViewOptions, check_option)} > > > - }; > > > - > > > - return (bytea *) build_reloptions(reloptions, validate, > > > - > RELOPT_KIND_VIEW, > > > - > sizeof(ViewOptions), > > > - > tab, lengthof(tab)); > > > -} > > > + * get_tablespace_options_spec_set > > > + * Returns an options spec set for tablespaces > > > +*/ > > > +static options_spec_set *tablespace_options_spec_set = NULL; > > > > > > -/* > > > - * Parse options for heaps, views and toast tables. > > > - */ > > > -bytea * > > > -heap_reloptions(char relkind, Datum reloptions, bool validate) > > > +options_spec_set * > > > +get_tablespace_options_spec_set(void) > > > > > > { > > > > > > - StdRdOptions *rdopts; > > > - > > > - switch (relkind) > > > + if (!tablespace_options_spec_set) > > > > > > { > > > > > > - case RELKIND_TOASTVALUE: > > > - rdopts = (StdRdOptions *) > > > - default_reloptions(reloptions, validate, > RELOPT_KIND_TOAST); > > > - if (rdopts != NULL) > > > - { > > > - /* adjust default-only parameters for TOAST > relations */ > > > - rdopts->fillfactor = 100; > > > - rdopts->autovacuum.analyze_threshold = -1; > > > - rdopts->autovacuum.analyze_scale_factor = > -1; > > > - } > > > - return (bytea *) rdopts; > > > - case RELKIND_RELATION: > > > - case RELKIND_MATVIEW: > > > - return default_reloptions(reloptions, validate, > RELOPT_KIND_HEAP); > > > - default: > > > - /* other relkinds are not supported */ > > > - return NULL; > > > - } > > > -} > > > - > > > - > > > -/* > > > - * Parse options for indexes. > > > - * > > > - * amoptions index AM's option parser function > > > - * reloptions options as text[] datum > > > - * validate error flag > > > - */ > > > -bytea * > > > -index_reloptions(amoptions_function amoptions, Datum reloptions, bool > > > validate) -{ > > > - Assert(amoptions != NULL); > > > + tablespace_options_spec_set = allocateOptionsSpecSet(NULL, > > > + > sizeof(TableSpaceOpts), 4); > > > > > > - /* Assume function is strict */ > > > - if (!PointerIsValid(DatumGetPointer(reloptions))) > > > - return NULL; > > > + optionsSpecSetAddReal(tablespace_options_spec_set, > > > + > "random_page_cost", > > > + "Sets the > planner's estimate of the cost of a nonsequentially > > > fetched disk page", + > ShareUpdateExclusiveLock, > > > + 0, offsetof(TableSpaceOpts, random_page_cost), -1, > 0.0, DBL_MAX); > > > > > > - return amoptions(reloptions, validate); > > > -} > > > + optionsSpecSetAddReal(tablespace_options_spec_set, > "seq_page_cost", > > > + "Sets the > planner's estimate of the cost of a sequentially > > > fetched disk page", + > ShareUpdateExclusiveLock, > > > + 0, offsetof(TableSpaceOpts, seq_page_cost), -1, > 0.0, DBL_MAX); > > > > > > -/* > > > - * Option parser for attribute reloptions > > > - */ > > > -bytea * > > > -attribute_reloptions(Datum reloptions, bool validate) > > > -{ > > > - static const relopt_parse_elt tab[] = { > > > - {"n_distinct", RELOPT_TYPE_REAL, offsetof(AttributeOpts, > n_distinct)}, > > > - {"n_distinct_inherited", RELOPT_TYPE_REAL, > offsetof(AttributeOpts, > > > n_distinct_inherited)} - }; > > > - > > > - return (bytea *) build_reloptions(reloptions, validate, > > > - > RELOPT_KIND_ATTRIBUTE, > > > - > sizeof(AttributeOpts), > > > - > tab, lengthof(tab)); > > > -} > > > + optionsSpecSetAddInt(tablespace_options_spec_set, > > > + > "effective_io_concurrency", > > > + "Number of > simultaneous requests that can be handled efficiently > > > by the disk subsystem", + > ShareUpdateExclusiveLock, > > > + 0, offsetof(TableSpaceOpts, > effective_io_concurrency), > > > +#ifdef USE_PREFETCH > > > + -1, 0, > MAX_IO_CONCURRENCY > > > +#else > > > + 0, 0, 0 > > > +#endif > > > + ); > > > > > > -/* > > > - * Option parser for tablespace reloptions > > > - */ > > > -bytea * > > > -tablespace_reloptions(Datum reloptions, bool validate) > > > -{ > > > - static const relopt_parse_elt tab[] = { > > > - {"random_page_cost", RELOPT_TYPE_REAL, > offsetof(TableSpaceOpts, > > > random_page_cost)}, - {"seq_page_cost", RELOPT_TYPE_REAL, > > > offsetof(TableSpaceOpts, seq_page_cost)}, - > {"effective_io_concurrency", > > > RELOPT_TYPE_INT, offsetof(TableSpaceOpts, effective_io_concurrency)}, > > > - {"maintenance_io_concurrency", RELOPT_TYPE_INT, > > > offsetof(TableSpaceOpts, maintenance_io_concurrency)} - }; > > > - > > > - return (bytea *) build_reloptions(reloptions, validate, > > > - > RELOPT_KIND_TABLESPACE, > > > - > sizeof(TableSpaceOpts), > > > - > tab, lengthof(tab)); > > > + optionsSpecSetAddInt(tablespace_options_spec_set, > > > + > "maintenance_io_concurrency", > > > + "Number of > simultaneous requests that can be handled efficiently > > > by the disk subsystem for maintenance work.", + > > > > ShareUpdateExclusiveLock, > > > + 0, offsetof(TableSpaceOpts, > maintenance_io_concurrency), > > > +#ifdef USE_PREFETCH > > > + -1, 0, > MAX_IO_CONCURRENCY > > > +#else > > > + 0, 0, 0 > > > +#endif > > > + ); > > > + } > > > + return tablespace_options_spec_set; > > > > > > } > > > > > > /* > > > > > > @@ -2099,33 +612,55 @@ tablespace_reloptions(Datum reloptions, bool > > > validate)> > > > * for a longer explanation of how this works. > > > */ > > > > > > LOCKMODE > > > > > > -AlterTableGetRelOptionsLockLevel(List *defList) > > > +AlterTableGetRelOptionsLockLevel(Relation rel, List *defList) > > > > > > { > > > > > > LOCKMODE lockmode = NoLock; > > > ListCell *cell; > > > > > > + options_spec_set *spec_set = NULL; > > > > > > if (defList == NIL) > > > > > > return AccessExclusiveLock; > > > > > > - if (need_initialization) > > > - initialize_reloptions(); > > > + switch (rel->rd_rel->relkind) > > > + { > > > + case RELKIND_TOASTVALUE: > > > + spec_set = get_toast_relopt_spec_set(); > > > + break; > > > + case RELKIND_RELATION: > > > + case RELKIND_MATVIEW: > > > + spec_set = get_heap_relopt_spec_set(); > > > + break; > > > + case RELKIND_INDEX: > > > + spec_set = rel->rd_indam->amreloptspecset(); > > > + break; > > > + case RELKIND_VIEW: > > > + spec_set = get_view_relopt_spec_set(); > > > + break; > > > + case RELKIND_PARTITIONED_TABLE: > > > + spec_set = get_partitioned_relopt_spec_set(); > > > + break; > > > + default: > > > + Assert(false); /* can't get here */ > > > + break; > > > + } > > > + Assert(spec_set); /* No spec set - no reloption > change. Should > > > + * never get > here */ > > > > > > foreach(cell, defList) > > > { > > > > > > DefElem *def = (DefElem *) lfirst(cell); > > > > > > + > > > > > > int i; > > > > > > - for (i = 0; relOpts[i]; i++) > > > + for (i = 0; i < spec_set->num; i++) > > > > > > { > > > > > > - if (strncmp(relOpts[i]->name, > > > - def->defname, > > > - relOpts[i]->namelen + 1) == > 0) > > > - { > > > - if (lockmode < relOpts[i]->lockmode) > > > - lockmode = relOpts[i]->lockmode; > > > - } > > > + option_spec_basic *gen = spec_set->definitions[i]; > > > + > > > + if (pg_strcasecmp(gen->name, > > > + def->defname) == 0) > > > + if (lockmode < gen->lockmode) > > > + lockmode = gen->lockmode; > > > > > > } > > > > > > } > > > > > > - > > > > > > return lockmode; > > > > > > -} > > > +} > > > \ No newline at end of file > > > diff --git a/src/backend/access/gin/gininsert.c > > > b/src/backend/access/gin/gininsert.c index 0e8672c..0cbffad 100644 > > > --- a/src/backend/access/gin/gininsert.c > > > +++ b/src/backend/access/gin/gininsert.c > > > @@ -512,6 +512,8 @@ gininsert(Relation index, Datum *values, bool *isnull, > > > > > > oldCtx = MemoryContextSwitchTo(insertCtx); > > > > > > +// elog(WARNING, "GinGetUseFastUpdate = %i", GinGetUseFastUpdate(index)); > > > + > > > > > > if (GinGetUseFastUpdate(index)) > > > { > > > > > > GinTupleCollector collector; > > > > > > diff --git a/src/backend/access/gin/ginutil.c > > > b/src/backend/access/gin/ginutil.c index 6d2d71b..d1fa3a0 100644 > > > --- a/src/backend/access/gin/ginutil.c > > > +++ b/src/backend/access/gin/ginutil.c > > > @@ -16,7 +16,7 @@ > > > > > > #include "access/gin_private.h" > > > #include "access/ginxlog.h" > > > > > > -#include "access/reloptions.h" > > > +#include "access/options.h" > > > > > > #include "access/xloginsert.h" > > > #include "catalog/pg_collation.h" > > > #include "catalog/pg_type.h" > > > > > > @@ -28,6 +28,7 @@ > > > > > > #include "utils/builtins.h" > > > #include "utils/index_selfuncs.h" > > > #include "utils/typcache.h" > > > > > > +#include "utils/guc.h" > > > > > > /* > > > > > > @@ -67,7 +68,6 @@ ginhandler(PG_FUNCTION_ARGS) > > > > > > amroutine->amvacuumcleanup = ginvacuumcleanup; > > > amroutine->amcanreturn = NULL; > > > amroutine->amcostestimate = gincostestimate; > > > > > > - amroutine->amoptions = ginoptions; > > > > > > amroutine->amproperty = NULL; > > > amroutine->ambuildphasename = NULL; > > > amroutine->amvalidate = ginvalidate; > > > > > > @@ -82,6 +82,7 @@ ginhandler(PG_FUNCTION_ARGS) > > > > > > amroutine->amestimateparallelscan = NULL; > > > amroutine->aminitparallelscan = NULL; > > > amroutine->amparallelrescan = NULL; > > > > > > + amroutine->amreloptspecset = gingetreloptspecset; > > > > > > PG_RETURN_POINTER(amroutine); > > > > > > } > > > > > > @@ -604,6 +605,7 @@ ginExtractEntries(GinState *ginstate, OffsetNumber > > > attnum,> > > > return entries; > > > > > > } > > > > > > +/* > > > > > > bytea * > > > ginoptions(Datum reloptions, bool validate) > > > { > > > > > > @@ -618,6 +620,7 @@ ginoptions(Datum reloptions, bool validate) > > > > > > > sizeof(GinOptions), > > > > tab, lengthof(tab)); > > > > > > } > > > > > > +*/ > > > > > > /* > > > > > > * Fetch index's statistical data into *stats > > > > > > @@ -705,3 +708,31 @@ ginUpdateStats(Relation index, const GinStatsData > > > *stats, bool is_build)> > > > END_CRIT_SECTION(); > > > > > > } > > > > > > + > > > +static options_spec_set *gin_relopt_specset = NULL; > > > + > > > +void * > > > +gingetreloptspecset(void) > > > +{ > > > + if (gin_relopt_specset) > > > + return gin_relopt_specset; > > > + > > > + gin_relopt_specset = allocateOptionsSpecSet(NULL, > > > + > sizeof(GinOptions), 2); > > > + > > > + optionsSpecSetAddBool(gin_relopt_specset, "fastupdate", > > > + "Enables \"fast update\" > feature for this GIN index", > > > + > AccessExclusiveLock, > > > + 0, > > > + offsetof(GinOptions, > useFastUpdate), > > > + > GIN_DEFAULT_USE_FASTUPDATE); > > > + > > > + optionsSpecSetAddInt(gin_relopt_specset, "gin_pending_list_limit", > > > + "Maximum size of the pending list for this GIN index, in > kilobytes", > > > + AccessExclusiveLock, > > > + 0, > > > + offsetof(GinOptions, > pendingListCleanupSize), > > > + -1, 64, > MAX_KILOBYTES); > > > + > > > + return gin_relopt_specset; > > > +} > > > diff --git a/src/backend/access/gist/gist.c > > > b/src/backend/access/gist/gist.c index 0683f42..cbbc6a5 100644 > > > --- a/src/backend/access/gist/gist.c > > > +++ b/src/backend/access/gist/gist.c > > > @@ -88,7 +88,6 @@ gisthandler(PG_FUNCTION_ARGS) > > > > > > amroutine->amvacuumcleanup = gistvacuumcleanup; > > > amroutine->amcanreturn = gistcanreturn; > > > amroutine->amcostestimate = gistcostestimate; > > > > > > - amroutine->amoptions = gistoptions; > > > > > > amroutine->amproperty = gistproperty; > > > amroutine->ambuildphasename = NULL; > > > amroutine->amvalidate = gistvalidate; > > > > > > @@ -103,6 +102,7 @@ gisthandler(PG_FUNCTION_ARGS) > > > > > > amroutine->amestimateparallelscan = NULL; > > > amroutine->aminitparallelscan = NULL; > > > amroutine->amparallelrescan = NULL; > > > > > > + amroutine->amreloptspecset = gistgetreloptspecset; > > > > > > PG_RETURN_POINTER(amroutine); > > > > > > } > > > > > > diff --git a/src/backend/access/gist/gistbuild.c > > > b/src/backend/access/gist/gistbuild.c index baad28c..931d249 100644 > > > --- a/src/backend/access/gist/gistbuild.c > > > +++ b/src/backend/access/gist/gistbuild.c > > > @@ -215,6 +215,7 @@ gistbuild(Relation heap, Relation index, IndexInfo > > > *indexInfo)> > > > buildstate.buildMode = GIST_BUFFERING_DISABLED; > > > > > > else /* must be "auto" > */ > > > > > > buildstate.buildMode = GIST_BUFFERING_AUTO; > > > > > > +//elog(WARNING, "biffering_mode = %i", options->buffering_mode); > > > > > > } > > > else > > > { > > > > > > diff --git a/src/backend/access/gist/gistutil.c > > > b/src/backend/access/gist/gistutil.c index 43ba03b..0391915 100644 > > > --- a/src/backend/access/gist/gistutil.c > > > +++ b/src/backend/access/gist/gistutil.c > > > @@ -17,7 +17,7 @@ > > > > > > #include "access/gist_private.h" > > > #include "access/htup_details.h" > > > > > > -#include "access/reloptions.h" > > > +#include "access/options.h" > > > > > > #include "catalog/pg_opclass.h" > > > #include "storage/indexfsm.h" > > > #include "storage/lmgr.h" > > > > > > @@ -916,20 +916,6 @@ gistPageRecyclable(Page page) > > > > > > return false; > > > > > > } > > > > > > -bytea * > > > -gistoptions(Datum reloptions, bool validate) > > > -{ > > > - static const relopt_parse_elt tab[] = { > > > - {"fillfactor", RELOPT_TYPE_INT, offsetof(GiSTOptions, > fillfactor)}, > > > - {"buffering", RELOPT_TYPE_ENUM, offsetof(GiSTOptions, > buffering_mode)} > > > - }; > > > - > > > - return (bytea *) build_reloptions(reloptions, validate, > > > - > RELOPT_KIND_GIST, > > > - > sizeof(GiSTOptions), > > > - > tab, lengthof(tab)); > > > -} > > > - > > > > > > /* > > > > > > * gistproperty() -- Check boolean properties of indexes. > > > * > > > > > > @@ -1064,3 +1050,42 @@ gistGetFakeLSN(Relation rel) > > > > > > return GetFakeLSNForUnloggedRel(); > > > > > > } > > > > > > } > > > > > > + > > > +/* values from GistOptBufferingMode */ > > > +opt_enum_elt_def gistBufferingOptValues[] = > > > +{ > > > + {"auto", GIST_OPTION_BUFFERING_AUTO}, > > > + {"on", GIST_OPTION_BUFFERING_ON}, > > > + {"off", GIST_OPTION_BUFFERING_OFF}, > > > + {(const char *) NULL} /* list terminator */ > > > +}; > > > + > > > +static options_spec_set *gist_relopt_specset = NULL; > > > + > > > +void * > > > +gistgetreloptspecset(void) > > > +{ > > > + if (gist_relopt_specset) > > > + return gist_relopt_specset; > > > + > > > + gist_relopt_specset = allocateOptionsSpecSet(NULL, > > > + > sizeof(GiSTOptions), 2); > > > + > > > + optionsSpecSetAddInt(gist_relopt_specset, "fillfactor", > > > + "Packs gist index pages only > to this percentage", > > > + NoLock, /* > No ALTER, no lock */ > > > + 0, > > > + offsetof(GiSTOptions, > fillfactor), > > > + > GIST_DEFAULT_FILLFACTOR, > > > + GIST_MIN_FILLFACTOR, > 100); > > > + > > > + optionsSpecSetAddEnum(gist_relopt_specset, "buffering", > > > + "Enables buffering build > for this GiST index", > > > + NoLock, /* > No ALTER, no lock */ > > > + 0, > > > + > offsetof(GiSTOptions, buffering_mode), > > > + > gistBufferingOptValues, > > > + > GIST_OPTION_BUFFERING_AUTO, > > > + gettext_noop("Valid > values are \"on\", \"off\", and > > > \"auto\".")); > > > + return gist_relopt_specset; > > > +} > > > diff --git a/src/backend/access/hash/hash.c > > > b/src/backend/access/hash/hash.c index eb38104..8dc4ca7 100644 > > > --- a/src/backend/access/hash/hash.c > > > +++ b/src/backend/access/hash/hash.c > > > @@ -85,7 +85,6 @@ hashhandler(PG_FUNCTION_ARGS) > > > > > > amroutine->amvacuumcleanup = hashvacuumcleanup; > > > amroutine->amcanreturn = NULL; > > > amroutine->amcostestimate = hashcostestimate; > > > > > > - amroutine->amoptions = hashoptions; > > > > > > amroutine->amproperty = NULL; > > > amroutine->ambuildphasename = NULL; > > > amroutine->amvalidate = hashvalidate; > > > > > > @@ -100,6 +99,7 @@ hashhandler(PG_FUNCTION_ARGS) > > > > > > amroutine->amestimateparallelscan = NULL; > > > amroutine->aminitparallelscan = NULL; > > > amroutine->amparallelrescan = NULL; > > > > > > + amroutine->amreloptspecset = hashgetreloptspecset; > > > > > > PG_RETURN_POINTER(amroutine); > > > > > > } > > > > > > diff --git a/src/backend/access/hash/hashpage.c > > > b/src/backend/access/hash/hashpage.c index 159646c..38f64ef 100644 > > > --- a/src/backend/access/hash/hashpage.c > > > +++ b/src/backend/access/hash/hashpage.c > > > @@ -359,6 +359,8 @@ _hash_init(Relation rel, double num_tuples, ForkNumber > > > forkNum)> > > > data_width = sizeof(uint32); > > > item_width = MAXALIGN(sizeof(IndexTupleData)) + MAXALIGN(data_width) > + > > > > > > sizeof(ItemIdData); /* include the line pointer */ > > > > > > +//elog(WARNING, "fillfactor = %i", HashGetFillFactor(rel)); > > > + > > > > > > ffactor = HashGetTargetPageUsage(rel) / item_width; > > > /* keep to a sane range */ > > > if (ffactor < 10) > > > > > > diff --git a/src/backend/access/hash/hashutil.c > > > b/src/backend/access/hash/hashutil.c index 5198728..826beab 100644 > > > --- a/src/backend/access/hash/hashutil.c > > > +++ b/src/backend/access/hash/hashutil.c > > > @@ -15,7 +15,7 @@ > > > > > > #include "postgres.h" > > > > > > #include "access/hash.h" > > > > > > -#include "access/reloptions.h" > > > +#include "access/options.h" > > > > > > #include "access/relscan.h" > > > #include "port/pg_bitutils.h" > > > #include "storage/buf_internals.h" > > > > > > @@ -272,19 +272,6 @@ _hash_checkpage(Relation rel, Buffer buf, int flags) > > > > > > } > > > > > > } > > > > > > -bytea * > > > -hashoptions(Datum reloptions, bool validate) > > > -{ > > > - static const relopt_parse_elt tab[] = { > > > - {"fillfactor", RELOPT_TYPE_INT, offsetof(HashOptions, > fillfactor)}, > > > - }; > > > - > > > - return (bytea *) build_reloptions(reloptions, validate, > > > - > RELOPT_KIND_HASH, > > > - > sizeof(HashOptions), > > > - > tab, lengthof(tab)); > > > -} > > > - > > > > > > /* > > > > > > * _hash_get_indextuple_hashkey - get the hash index tuple's hash key > > > value > > > */ > > > > > > @@ -620,3 +607,24 @@ _hash_kill_items(IndexScanDesc scan) > > > > > > else > > > > > > _hash_relbuf(rel, buf); > > > > > > } > > > > > > + > > > +static options_spec_set *hash_relopt_specset = NULL; > > > + > > > +void * > > > +hashgetreloptspecset(void) > > > +{ > > > + if (hash_relopt_specset) > > > + return hash_relopt_specset; > > > + > > > + hash_relopt_specset = allocateOptionsSpecSet(NULL, > > > + > sizeof(HashOptions), 1); > > > + optionsSpecSetAddInt(hash_relopt_specset, "fillfactor", > > > + "Packs hash index pages only > to this percentage", > > > + NoLock, /* > No ALTER -- no lock */ > > > + 0, > > > + offsetof(HashOptions, > fillfactor), > > > + > HASH_DEFAULT_FILLFACTOR, > > > + HASH_MIN_FILLFACTOR, > 100); > > > + > > > + return hash_relopt_specset; > > > +} > > > diff --git a/src/backend/access/nbtree/nbtinsert.c > > > b/src/backend/access/nbtree/nbtinsert.c index 7355e1d..f7b117e 100644 > > > --- a/src/backend/access/nbtree/nbtinsert.c > > > +++ b/src/backend/access/nbtree/nbtinsert.c > > > @@ -2745,6 +2745,8 @@ _bt_delete_or_dedup_one_page(Relation rel, Relation > > > heapRel,> > > > _bt_bottomupdel_pass(rel, buffer, heapRel, insertstate- > >itemsz)) > > > return; > > > > > > +// elog(WARNING, "Deduplicate_items = %i", BTGetDeduplicateItems(rel)); > > > + > > > > > > /* Perform deduplication pass (when enabled and index-is- > allequalimage) > > > */ > > > if (BTGetDeduplicateItems(rel) && itup_key->allequalimage) > > > > > > _bt_dedup_pass(rel, buffer, heapRel, insertstate->itup, > > > > > > diff --git a/src/backend/access/nbtree/nbtree.c > > > b/src/backend/access/nbtree/nbtree.c index 40ad095..f171c54 100644 > > > --- a/src/backend/access/nbtree/nbtree.c > > > +++ b/src/backend/access/nbtree/nbtree.c > > > @@ -22,6 +22,7 @@ > > > > > > #include "access/nbtxlog.h" > > > #include "access/relscan.h" > > > #include "access/xlog.h" > > > > > > +#include "access/options.h" > > > > > > #include "commands/progress.h" > > > #include "commands/vacuum.h" > > > #include "miscadmin.h" > > > > > > @@ -124,7 +125,6 @@ bthandler(PG_FUNCTION_ARGS) > > > > > > amroutine->amvacuumcleanup = btvacuumcleanup; > > > amroutine->amcanreturn = btcanreturn; > > > amroutine->amcostestimate = btcostestimate; > > > > > > - amroutine->amoptions = btoptions; > > > > > > amroutine->amproperty = btproperty; > > > amroutine->ambuildphasename = btbuildphasename; > > > amroutine->amvalidate = btvalidate; > > > > > > @@ -139,6 +139,7 @@ bthandler(PG_FUNCTION_ARGS) > > > > > > amroutine->amestimateparallelscan = btestimateparallelscan; > > > amroutine->aminitparallelscan = btinitparallelscan; > > > amroutine->amparallelrescan = btparallelrescan; > > > > > > + amroutine->amreloptspecset = btgetreloptspecset; > > > > > > PG_RETURN_POINTER(amroutine); > > > > > > } > > > > > > @@ -1418,3 +1419,37 @@ btcanreturn(Relation index, int attno) > > > > > > { > > > > > > return true; > > > > > > } > > > > > > + > > > +static options_spec_set *bt_relopt_specset = NULL; > > > + > > > +void * > > > +btgetreloptspecset(void) > > > +{ > > > + if (bt_relopt_specset) > > > + return bt_relopt_specset; > > > + > > > + bt_relopt_specset = allocateOptionsSpecSet(NULL, > > > + > sizeof(BTOptions), 3); > > > + > > > + optionsSpecSetAddInt( > > > + bt_relopt_specset, "fillfactor", > > > + "Packs btree index pages only to this percentage", > > > + ShareUpdateExclusiveLock, /* since it applies only to later > inserts */ > > > + 0, offsetof(BTOptions, fillfactor), > > > + BTREE_DEFAULT_FILLFACTOR, BTREE_MIN_FILLFACTOR, 100 > > > + ); > > > + optionsSpecSetAddReal( > > > + bt_relopt_specset, "vacuum_cleanup_index_scale_factor", > > > + "Number of tuple inserts prior to index cleanup as a fraction > of > > > reltuples", + ShareUpdateExclusiveLock, > > > + 0, offsetof(BTOptions,vacuum_cleanup_index_scale_factor), > > > + -1, 0.0, 1e10 > > > + ); > > > + optionsSpecSetAddBool( > > > + bt_relopt_specset, "deduplicate_items", > > > + "Enables \"deduplicate items\" feature for this btree index", > > > + ShareUpdateExclusiveLock, /* since it applies only to later > inserts */ > > > + 0, offsetof(BTOptions,deduplicate_items), true > > > + ); > > > + return bt_relopt_specset; > > > +} > > > diff --git a/src/backend/access/nbtree/nbtutils.c > > > b/src/backend/access/nbtree/nbtutils.c index c72b456..2588a30 100644 > > > --- a/src/backend/access/nbtree/nbtutils.c > > > +++ b/src/backend/access/nbtree/nbtutils.c > > > @@ -18,7 +18,7 @@ > > > > > > #include <time.h> > > > > > > #include "access/nbtree.h" > > > > > > -#include "access/reloptions.h" > > > +#include "storage/lock.h" > > > > > > #include "access/relscan.h" > > > #include "catalog/catalog.h" > > > #include "commands/progress.h" > > > > > > @@ -2100,25 +2100,6 @@ BTreeShmemInit(void) > > > > > > Assert(found); > > > > > > } > > > > > > -bytea * > > > -btoptions(Datum reloptions, bool validate) > > > -{ > > > - static const relopt_parse_elt tab[] = { > > > - {"fillfactor", RELOPT_TYPE_INT, offsetof(BTOptions, > fillfactor)}, > > > - {"vacuum_cleanup_index_scale_factor", RELOPT_TYPE_REAL, > > > - offsetof(BTOptions, vacuum_cleanup_index_scale_factor)}, > > > - {"deduplicate_items", RELOPT_TYPE_BOOL, > > > - offsetof(BTOptions, deduplicate_items)} > > > - > > > - }; > > > - > > > - return (bytea *) build_reloptions(reloptions, validate, > > > - > RELOPT_KIND_BTREE, > > > - > sizeof(BTOptions), > > > - > tab, lengthof(tab)); > > > - > > > -} > > > - > > > > > > /* > > > > > > * btproperty() -- Check boolean properties of indexes. > > > * > > > > > > diff --git a/src/backend/access/spgist/spgutils.c > > > b/src/backend/access/spgist/spgutils.c index 03a9cd3..14429ad 100644 > > > --- a/src/backend/access/spgist/spgutils.c > > > +++ b/src/backend/access/spgist/spgutils.c > > > @@ -17,7 +17,7 @@ > > > > > > #include "access/amvalidate.h" > > > #include "access/htup_details.h" > > > > > > -#include "access/reloptions.h" > > > +#include "access/options.h" > > > > > > #include "access/spgist_private.h" > > > #include "access/toast_compression.h" > > > #include "access/transam.h" > > > > > > @@ -72,7 +72,6 @@ spghandler(PG_FUNCTION_ARGS) > > > > > > amroutine->amvacuumcleanup = spgvacuumcleanup; > > > amroutine->amcanreturn = spgcanreturn; > > > amroutine->amcostestimate = spgcostestimate; > > > > > > - amroutine->amoptions = spgoptions; > > > > > > amroutine->amproperty = spgproperty; > > > amroutine->ambuildphasename = NULL; > > > amroutine->amvalidate = spgvalidate; > > > > > > @@ -87,6 +86,7 @@ spghandler(PG_FUNCTION_ARGS) > > > > > > amroutine->amestimateparallelscan = NULL; > > > amroutine->aminitparallelscan = NULL; > > > amroutine->amparallelrescan = NULL; > > > > > > + amroutine->amreloptspecset = spggetreloptspecset; > > > > > > PG_RETURN_POINTER(amroutine); > > > > > > } > > > > > > @@ -550,6 +550,7 @@ SpGistGetBuffer(Relation index, int flags, int > > > needSpace, bool *isNew)> > > > * related to the ones already on it. But fillfactor mustn't cause > an > > > * error for requests that would otherwise be legal. > > > */ > > > > > > +//elog(WARNING, "fillfactor = %i", SpGistGetFillFactor(index)); > > > > > > needSpace += SpGistGetTargetPageFreeSpace(index); > > > needSpace = Min(needSpace, SPGIST_PAGE_CAPACITY); > > > > > > @@ -721,23 +722,6 @@ SpGistInitMetapage(Page page) > > > > > > } > > > > > > /* > > > > > > - * reloptions processing for SPGiST > > > - */ > > > -bytea * > > > -spgoptions(Datum reloptions, bool validate) > > > -{ > > > - static const relopt_parse_elt tab[] = { > > > - {"fillfactor", RELOPT_TYPE_INT, offsetof(SpGistOptions, > fillfactor)}, > > > - }; > > > - > > > - return (bytea *) build_reloptions(reloptions, validate, > > > - > RELOPT_KIND_SPGIST, > > > - > sizeof(SpGistOptions), > > > - > tab, lengthof(tab)); > > > - > > > -} > > > - > > > -/* > > > > > > * Get the space needed to store a non-null datum of the indicated type > > > * in an inner tuple (that is, as a prefix or node label). > > > * Note the result is already rounded up to a MAXALIGN boundary. > > > > > > @@ -1336,3 +1320,25 @@ spgproperty(Oid index_oid, int attno, > > > > > > return true; > > > > > > } > > > > > > + > > > +static options_spec_set *spgist_relopt_specset = NULL; > > > + > > > +void * > > > +spggetreloptspecset(void) > > > +{ > > > + if (!spgist_relopt_specset) > > > + { > > > + spgist_relopt_specset = allocateOptionsSpecSet(NULL, > > > + > sizeof(SpGistOptions), 1); > > > + > > > + optionsSpecSetAddInt(spgist_relopt_specset, "fillfactor", > > > + "Packs spgist index pages > only to this percentage", > > > + > ShareUpdateExclusiveLock, /* since it applies only > > > + > * to later inserts */ > > > + 0, > > > + > offsetof(SpGistOptions, fillfactor), > > > + > SPGIST_DEFAULT_FILLFACTOR, > > > + > SPGIST_MIN_FILLFACTOR, 100); > > > + } > > > + return spgist_relopt_specset; > > > +} > > > diff --git a/src/backend/commands/createas.c > > > b/src/backend/commands/createas.c index 0982851..4f3dbb8 100644 > > > --- a/src/backend/commands/createas.c > > > +++ b/src/backend/commands/createas.c > > > @@ -90,6 +90,7 @@ create_ctas_internal(List *attrList, IntoClause *into) > > > > > > Datum toast_options; > > > static char *validnsps[] = HEAP_RELOPT_NAMESPACES; > > > ObjectAddress intoRelationAddr; > > > > > > + List *toastDefList; > > > > > > /* This code supports both CREATE TABLE AS and CREATE MATERIALIZED > VIEW > > > */ > > > is_matview = (into->viewQuery != NULL); > > > > > > @@ -124,14 +125,12 @@ create_ctas_internal(List *attrList, IntoClause > > > *into)> > > > CommandCounterIncrement(); > > > > > > /* parse and validate reloptions for the toast table */ > > > > > > - toast_options = transformRelOptions((Datum) 0, > > > - > create->options, > > > - > "toast", > > > - > validnsps, > > > - > true, false); > > > > > > - (void) heap_reloptions(RELKIND_TOASTVALUE, toast_options, true); > > > + optionsDefListValdateNamespaces(create->options, validnsps); > > > + toastDefList = optionsDefListFilterNamespaces(create->options, > "toast"); > > > > > > + toast_options = transformOptions(get_toast_relopt_spec_set(), (Datum) > 0, > > > + > toastDefList, 0); > > > > > > NewRelationCreateToastTable(intoRelationAddr.objectId, > toast_options); > > > > > > /* Create the "view" part of a materialized view. */ > > > > > > diff --git a/src/backend/commands/foreigncmds.c > > > b/src/backend/commands/foreigncmds.c index 146fa57..758ca34 100644 > > > --- a/src/backend/commands/foreigncmds.c > > > +++ b/src/backend/commands/foreigncmds.c > > > @@ -112,7 +112,7 @@ transformGenericOptions(Oid catalogId, > > > > > > List *options, > > > Oid fdwvalidator) > > > > > > { > > > > > > - List *resultOptions = untransformRelOptions(oldOptions); > > > + List *resultOptions = optionsTextArrayToDefList(oldOptions); > > > > > > ListCell *optcell; > > > Datum result; > > > > > > diff --git a/src/backend/commands/indexcmds.c > > > b/src/backend/commands/indexcmds.c index c14ca27..96d465a 100644 > > > --- a/src/backend/commands/indexcmds.c > > > +++ b/src/backend/commands/indexcmds.c > > > @@ -19,6 +19,7 @@ > > > > > > #include "access/heapam.h" > > > #include "access/htup_details.h" > > > #include "access/reloptions.h" > > > > > > +#include "access/options.h" > > > > > > #include "access/sysattr.h" > > > #include "access/tableam.h" > > > #include "access/xact.h" > > > > > > @@ -531,7 +532,7 @@ DefineIndex(Oid relationId, > > > > > > Form_pg_am accessMethodForm; > > > IndexAmRoutine *amRoutine; > > > bool amcanorder; > > > > > > - amoptions_function amoptions; > > > + amreloptspecset_function amreloptspecsetfn; > > > > > > bool partitioned; > > > bool safe_index; > > > Datum reloptions; > > > > > > @@ -837,7 +838,7 @@ DefineIndex(Oid relationId, > > > > > > accessMethodName))); > > > > > > amcanorder = amRoutine->amcanorder; > > > > > > - amoptions = amRoutine->amoptions; > > > + amreloptspecsetfn = amRoutine->amreloptspecset; > > > > > > pfree(amRoutine); > > > ReleaseSysCache(tuple); > > > > > > @@ -851,10 +852,19 @@ DefineIndex(Oid relationId, > > > > > > /* > > > > > > * Parse AM-specific options, convert to text array form, validate. > > > */ > > > > > > - reloptions = transformRelOptions((Datum) 0, stmt->options, > > > - > NULL, NULL, false, false); > > > > > > - (void) index_reloptions(amoptions, reloptions, true); > > > + if (amreloptspecsetfn) > > > + { > > > + reloptions = transformOptions(amreloptspecsetfn(), > > > + > (Datum) 0, stmt->options, 0); > > > + } > > > + else > > > + { > > > + ereport(ERROR, > > > + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), > > > + errmsg("access method %s does not support > options", > > > + accessMethodName))); > > > + } > > > > > > /* > > > > > > * Prepare arguments for index_create, primarily an IndexInfo > structure. > > > > > > @@ -1986,8 +1996,7 @@ ComputeIndexAttrs(IndexInfo *indexInfo, > > > > > > palloc0(sizeof(Datum) * indexInfo- > >ii_NumIndexAttrs); > > > > > > indexInfo->ii_OpclassOptions[attn] = > > > > > > - transformRelOptions((Datum) 0, attribute- > >opclassopts, > > > - > NULL, NULL, false, false); > > > + optionsDefListToTextArray(attribute- > >opclassopts); > > > > > > } > > > > > > attn++; > > > > > > diff --git a/src/backend/commands/tablecmds.c > > > b/src/backend/commands/tablecmds.c index 1c2ebe1..7f3004f 100644 > > > --- a/src/backend/commands/tablecmds.c > > > +++ b/src/backend/commands/tablecmds.c > > > @@ -20,6 +20,7 @@ > > > > > > #include "access/heapam_xlog.h" > > > #include "access/multixact.h" > > > #include "access/reloptions.h" > > > > > > +#include "access/options.h" > > > > > > #include "access/relscan.h" > > > #include "access/sysattr.h" > > > #include "access/tableam.h" > > > > > > @@ -641,7 +642,6 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid > > > ownerId,> > > > ListCell *listptr; > > > AttrNumber attnum; > > > bool partitioned; > > > > > > - static char *validnsps[] = HEAP_RELOPT_NAMESPACES; > > > > > > Oid ofTypeId; > > > ObjectAddress address; > > > LOCKMODE parentLockmode; > > > > > > @@ -789,19 +789,37 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid > > > ownerId,> > > > /* > > > > > > * Parse and validate reloptions, if any. > > > */ > > > > > > - reloptions = transformRelOptions((Datum) 0, stmt->options, NULL, > > > validnsps, - > true, false); > > > > > > switch (relkind) > > > { > > > > > > case RELKIND_VIEW: > > > - (void) view_reloptions(reloptions, true); > > > + reloptions = transformOptions( > > > + > get_view_relopt_spec_set(), > > > + > (Datum) 0, stmt->options, 0); > > > > > > break; > > > > > > case RELKIND_PARTITIONED_TABLE: > > > - (void) partitioned_table_reloptions(reloptions, > true); > > > + { > > > + /* If it is not all listed above, then it if heap */ > > > + char *namespaces[] = HEAP_RELOPT_NAMESPACES; > > > + List *heapDefList; > > > + > > > + optionsDefListValdateNamespaces(stmt->options, > namespaces); > > > + heapDefList = optionsDefListFilterNamespaces(stmt- > >options, NULL); > > > + reloptions = > transformOptions(get_partitioned_relopt_spec_set(), > > > + > (Datum) 0, heapDefList, 0); > > > > > > break; > > > > > > + } > > > > > > default: > > > - (void) heap_reloptions(relkind, reloptions, true); > > > + { > > > + /* If it is not all listed above, then it if heap */ > > > + char *namespaces[] = HEAP_RELOPT_NAMESPACES; > > > + List *heapDefList; > > > + > > > + optionsDefListValdateNamespaces(stmt->options, > namespaces); > > > + heapDefList = optionsDefListFilterNamespaces(stmt- > >options, NULL); > > > + reloptions = > transformOptions(get_heap_relopt_spec_set(), > > > + > (Datum) 0, heapDefList, 0); > > > + } > > > > > > } > > > > > > if (stmt->ofTypename) > > > > > > @@ -4022,7 +4040,7 @@ void > > > > > > AlterTableInternal(Oid relid, List *cmds, bool recurse) > > > { > > > > > > Relation rel; > > > > > > - LOCKMODE lockmode = AlterTableGetLockLevel(cmds); > > > + LOCKMODE lockmode = AlterTableGetLockLevel(relid, cmds); > > > > > > rel = relation_open(relid, lockmode); > > > > > > @@ -4064,7 +4082,7 @@ AlterTableInternal(Oid relid, List *cmds, bool > > > recurse)> > > > * otherwise we might end up with an inconsistent dump that can't > > > restore. > > > */ > > > > > > LOCKMODE > > > > > > -AlterTableGetLockLevel(List *cmds) > > > +AlterTableGetLockLevel(Oid relid, List *cmds) > > > > > > { > > > > > > /* > > > > > > * This only works if we read catalog tables using MVCC snapshots. > > > > > > @@ -4285,9 +4303,13 @@ AlterTableGetLockLevel(List *cmds) > > > > > > * > getTables() */ > > > > > > case AT_ResetRelOptions: /* Uses MVCC in > getIndexes() and > > > > > > > * getTables() */ > > > > > > - cmd_lockmode = > AlterTableGetRelOptionsLockLevel((List *) cmd->def); > > > - break; > > > - > > > + { > > > + Relation rel = relation_open(relid, > NoLock); // FIXME I am not sure > > > how wise it is + cmd_lockmode = > AlterTableGetRelOptionsLockLevel(rel, > > > + > castNode(List, cmd->def)); > > > + relation_close(rel,NoLock); > > > + break; > > > + } > > > > > > case AT_AttachPartition: > > > cmd_lockmode = ShareUpdateExclusiveLock; > > > break; > > > > > > @@ -8062,11 +8084,11 @@ ATExecSetOptions(Relation rel, const char > > > *colName, Node *options,> > > > /* Generate new proposed attoptions (text array) */ > > > datum = SysCacheGetAttr(ATTNAME, tuple, > Anum_pg_attribute_attoptions, > > > > > > &isnull); > > > > > > - newOptions = transformRelOptions(isnull ? (Datum) 0 : datum, > > > - > castNode(List, options), NULL, NULL, > > > - > false, isReset); > > > - /* Validate new options */ > > > - (void) attribute_reloptions(newOptions, true); > > > + > > > + newOptions = transformOptions(get_attribute_options_spec_set(), > > > + isnull ? > (Datum) 0 : datum, > > > + castNode(List, options), > OPTIONS_PARSE_MODE_FOR_ALTER | > > > + (isReset ? > OPTIONS_PARSE_MODE_FOR_RESET : 0)); > > > > > > /* Build new tuple. */ > > > memset(repl_null, false, sizeof(repl_null)); > > > > > > @@ -13704,7 +13726,8 @@ ATExecSetRelOptions(Relation rel, List *defList, > > > AlterTableType operation,> > > > Datum repl_val[Natts_pg_class]; > > > bool repl_null[Natts_pg_class]; > > > bool repl_repl[Natts_pg_class]; > > > > > > - static char *validnsps[] = HEAP_RELOPT_NAMESPACES; > > > + List *toastDefList; > > > + options_parse_mode parse_mode; > > > > > > if (defList == NIL && operation != AT_ReplaceRelOptions) > > > > > > return; /* nothing to do > */ > > > > > > @@ -13734,27 +13757,68 @@ ATExecSetRelOptions(Relation rel, List *defList, > > > AlterTableType operation,> > > > } > > > > > > /* Generate new proposed reloptions (text array) */ > > > > > > - newOptions = transformRelOptions(isnull ? (Datum) 0 : datum, > > > - > defList, NULL, validnsps, false, > > > - > operation == AT_ResetRelOptions); > > > > > > /* Validate */ > > > > > > + parse_mode = OPTIONS_PARSE_MODE_FOR_ALTER; > > > + if (operation == AT_ResetRelOptions) > > > + parse_mode |= OPTIONS_PARSE_MODE_FOR_RESET; > > > + > > > > > > switch (rel->rd_rel->relkind) > > > { > > > > > > case RELKIND_RELATION: > > > - case RELKIND_TOASTVALUE: > > > + case RELKIND_TOASTVALUE: // FIXME why it is here??? > > > > > > case RELKIND_MATVIEW: > > > - (void) heap_reloptions(rel->rd_rel->relkind, > newOptions, true); > > > + { > > > + char *namespaces[] = > HEAP_RELOPT_NAMESPACES; > > > + List *heapDefList; > > > + > > > + optionsDefListValdateNamespaces(defList, > namespaces); > > > + heapDefList = optionsDefListFilterNamespaces( > > > + > defList, NULL); > > > + newOptions = > transformOptions(get_heap_relopt_spec_set(), > > > + > isnull ? (Datum) 0 : datum, > > > + > heapDefList, parse_mode); > > > + } > > > > > > break; > > > > > > + > > > > > > case RELKIND_PARTITIONED_TABLE: > > > - (void) partitioned_table_reloptions(newOptions, > true); > > > - break; > > > + { > > > + char *namespaces[] = > HEAP_RELOPT_NAMESPACES; > > > + List *heapDefList; > > > + > > > + optionsDefListValdateNamespaces(defList, > namespaces); > > > + heapDefList = optionsDefListFilterNamespaces( > > > + > defList, NULL); > > > + newOptions = > transformOptions(get_partitioned_relopt_spec_set(), > > > + > isnull ? (Datum) 0 : datum, > > > + > heapDefList, parse_mode); > > > + break; > > > + } > > > > > > case RELKIND_VIEW: > > > - (void) view_reloptions(newOptions, true); > > > - break; > > > + { > > > + > > > + newOptions = transformOptions( > > > + > get_view_relopt_spec_set(), > > > + > datum, defList, parse_mode); > > > + break; > > > + } > > > > > > case RELKIND_INDEX: > > > > > > case RELKIND_PARTITIONED_INDEX: > > > - (void) index_reloptions(rel->rd_indam->amoptions, > newOptions, true); > > > + if (! rel->rd_indam->amreloptspecset) > > > + { > > > + ereport(ERROR, > > > + > (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), > > > + errmsg("index %s does not > support options", > > > + > RelationGetRelationName(rel)))); > > > + break; > > > + } > > > + parse_mode = OPTIONS_PARSE_MODE_FOR_ALTER; > > > + if (operation == AT_ResetRelOptions) > > > + parse_mode |= OPTIONS_PARSE_MODE_FOR_RESET; > > > + newOptions = transformOptions( > > > + rel- > >rd_indam->amreloptspecset(), > > > + > isnull ? (Datum) 0 : datum, > > > + > defList, parse_mode); > > > > > > break; > > > > > > default: > > > ereport(ERROR, > > > > > > @@ -13769,7 +13833,7 @@ ATExecSetRelOptions(Relation rel, List *defList, > > > AlterTableType operation,> > > > if (rel->rd_rel->relkind == RELKIND_VIEW) > > > { > > > > > > Query *view_query = get_view_query(rel); > > > > > > - List *view_options = > untransformRelOptions(newOptions); > > > + List *view_options = > optionsTextArrayToDefList(newOptions); > > > > > > ListCell *cell; > > > bool check_option = false; > > > > > > @@ -13853,11 +13917,15 @@ ATExecSetRelOptions(Relation rel, List *defList, > > > AlterTableType operation,> > > > > &isnull); > > > > > > } > > > > > > - newOptions = transformRelOptions(isnull ? (Datum) 0 : datum, > > > - > defList, "toast", validnsps, false, > > > - > operation == AT_ResetRelOptions); > > > + parse_mode = OPTIONS_PARSE_MODE_FOR_ALTER; > > > + if (operation == AT_ResetRelOptions) > > > + parse_mode |= OPTIONS_PARSE_MODE_FOR_RESET; > > > + > > > + toastDefList = optionsDefListFilterNamespaces(defList, > "toast"); > > > > > > - (void) heap_reloptions(RELKIND_TOASTVALUE, newOptions, > true); > > > + newOptions = transformOptions(get_toast_relopt_spec_set(), > > > + > isnull ? (Datum) 0 : datum, > > > + > toastDefList, parse_mode); > > > > > > memset(repl_val, 0, sizeof(repl_val)); > > > memset(repl_null, false, sizeof(repl_null)); > > > > > > diff --git a/src/backend/commands/tablespace.c > > > b/src/backend/commands/tablespace.c index 4b96eec..912699b 100644 > > > --- a/src/backend/commands/tablespace.c > > > +++ b/src/backend/commands/tablespace.c > > > @@ -345,10 +345,9 @@ CreateTableSpace(CreateTableSpaceStmt *stmt) > > > > > > nulls[Anum_pg_tablespace_spcacl - 1] = true; > > > > > > /* Generate new proposed spcoptions (text array) */ > > > > > > - newOptions = transformRelOptions((Datum) 0, > > > - > stmt->options, > > > - > NULL, NULL, false, false); > > > - (void) tablespace_reloptions(newOptions, true); > > > + newOptions = transformOptions(get_tablespace_options_spec_set(), > > > + > (Datum) 0, stmt->options, 0); > > > + > > > > > > if (newOptions != (Datum) 0) > > > > > > values[Anum_pg_tablespace_spcoptions - 1] = newOptions; > > > > > > else > > > > > > @@ -1053,10 +1052,11 @@ AlterTableSpaceOptions(AlterTableSpaceOptionsStmt > > > *stmt)> > > > /* Generate new proposed spcoptions (text array) */ > > > datum = heap_getattr(tup, Anum_pg_tablespace_spcoptions, > > > > > > RelationGetDescr(rel), > &isnull); > > > > > > - newOptions = transformRelOptions(isnull ? (Datum) 0 : datum, > > > - > stmt->options, NULL, NULL, false, > > > - > stmt->isReset); > > > - (void) tablespace_reloptions(newOptions, true); > > > + newOptions = transformOptions(get_tablespace_options_spec_set(), > > > + isnull ? > (Datum) 0 : datum, > > > + stmt- > >options, > > > + > OPTIONS_PARSE_MODE_FOR_ALTER | > > > + (stmt->isReset ? > OPTIONS_PARSE_MODE_FOR_RESET : 0)); > > > > > > /* Build new tuple. */ > > > memset(repl_null, false, sizeof(repl_null)); > > > > > > diff --git a/src/backend/foreign/foreign.c b/src/backend/foreign/foreign.c > > > index 5564dc3..0370be7 100644 > > > --- a/src/backend/foreign/foreign.c > > > +++ b/src/backend/foreign/foreign.c > > > @@ -78,7 +78,7 @@ GetForeignDataWrapperExtended(Oid fdwid, bits16 flags) > > > > > > if (isnull) > > > > > > fdw->options = NIL; > > > > > > else > > > > > > - fdw->options = untransformRelOptions(datum); > > > + fdw->options = optionsTextArrayToDefList(datum); > > > > > > ReleaseSysCache(tp); > > > > > > @@ -165,7 +165,7 @@ GetForeignServerExtended(Oid serverid, bits16 flags) > > > > > > if (isnull) > > > > > > server->options = NIL; > > > > > > else > > > > > > - server->options = untransformRelOptions(datum); > > > + server->options = optionsTextArrayToDefList(datum); > > > > > > ReleaseSysCache(tp); > > > > > > @@ -233,7 +233,7 @@ GetUserMapping(Oid userid, Oid serverid) > > > > > > if (isnull) > > > > > > um->options = NIL; > > > > > > else > > > > > > - um->options = untransformRelOptions(datum); > > > + um->options = optionsTextArrayToDefList(datum); > > > > > > ReleaseSysCache(tp); > > > > > > @@ -270,7 +270,7 @@ GetForeignTable(Oid relid) > > > > > > if (isnull) > > > > > > ft->options = NIL; > > > > > > else > > > > > > - ft->options = untransformRelOptions(datum); > > > + ft->options = optionsTextArrayToDefList(datum); > > > > > > ReleaseSysCache(tp); > > > > > > @@ -303,7 +303,7 @@ GetForeignColumnOptions(Oid relid, AttrNumber attnum) > > > > > > if (isnull) > > > > > > options = NIL; > > > > > > else > > > > > > - options = untransformRelOptions(datum); > > > + options = optionsTextArrayToDefList(datum); > > > > > > ReleaseSysCache(tp); > > > > > > @@ -572,7 +572,7 @@ pg_options_to_table(PG_FUNCTION_ARGS) > > > > > > Datum array = PG_GETARG_DATUM(0); > > > > > > deflist_to_tuplestore((ReturnSetInfo *) fcinfo->resultinfo, > > > > > > - > untransformRelOptions(array)); > > > + > optionsTextArrayToDefList(array)); > > > > > > return (Datum) 0; > > > > > > } > > > > > > @@ -643,7 +643,7 @@ is_conninfo_option(const char *option, Oid context) > > > > > > Datum > > > postgresql_fdw_validator(PG_FUNCTION_ARGS) > > > { > > > > > > - List *options_list = > untransformRelOptions(PG_GETARG_DATUM(0)); > > > + List *options_list = > optionsTextArrayToDefList(PG_GETARG_DATUM(0)); > > > > > > Oid catalog = PG_GETARG_OID(1); > > > > > > ListCell *cell; > > > > > > diff --git a/src/backend/parser/parse_utilcmd.c > > > b/src/backend/parser/parse_utilcmd.c index 313d7b6..1fe41b4 100644 > > > --- a/src/backend/parser/parse_utilcmd.c > > > +++ b/src/backend/parser/parse_utilcmd.c > > > @@ -1757,7 +1757,7 @@ generateClonedIndexStmt(RangeVar *heapRel, Relation > > > source_idx,> > > > /* Add the operator class name, if non-default */ > > > iparam->opclass = get_opclass(indclass->values[keyno], > keycoltype); > > > iparam->opclassopts = > > > > > > - untransformRelOptions(get_attoptions(source_relid, > keyno + 1)); > > > + > optionsTextArrayToDefList(get_attoptions(source_relid, keyno + 1)); > > > > > > iparam->ordering = SORTBY_DEFAULT; > > > iparam->nulls_ordering = SORTBY_NULLS_DEFAULT; > > > > > > @@ -1821,7 +1821,7 @@ generateClonedIndexStmt(RangeVar *heapRel, Relation > > > source_idx,> > > > datum = SysCacheGetAttr(RELOID, ht_idxrel, > > > > > > > Anum_pg_class_reloptions, &isnull); > > > > > > if (!isnull) > > > > > > - index->options = untransformRelOptions(datum); > > > + index->options = optionsTextArrayToDefList(datum); > > > > > > /* If it's a partial index, decompile and append the predicate */ > > > datum = SysCacheGetAttr(INDEXRELID, ht_idx, > > > > > > diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c > > > index bf085aa..d12ab1a 100644 > > > --- a/src/backend/tcop/utility.c > > > +++ b/src/backend/tcop/utility.c > > > @@ -1155,6 +1155,7 @@ ProcessUtilitySlow(ParseState *pstate, > > > > > > CreateStmt *cstmt = > (CreateStmt *) stmt; > > > Datum > toast_options; > > > static char > *validnsps[] = HEAP_RELOPT_NAMESPACES; > > > > > > + List > *toastDefList; > > > > > > /* Remember > transformed RangeVar for LIKE */ > > > table_rv = cstmt- > >relation; > > > > > > @@ -1178,15 +1179,17 @@ ProcessUtilitySlow(ParseState *pstate, > > > > > > * parse and > validate reloptions for the toast > > > * table > > > */ > > > > > > - toast_options = > transformRelOptions((Datum) 0, > > > - > cstmt->options, > > > - > "toast", > > > - > validnsps, > > > - > true, > > > - > false); > > > - (void) > heap_reloptions(RELKIND_TOASTVALUE, > > > - > toast_options, > > > - > true); > > > + > > > + > optionsDefListValdateNamespaces( > > > + > ((CreateStmt *) stmt)->options, > > > + > validnsps); > > > + > > > + toastDefList = > optionsDefListFilterNamespaces( > > > + > ((CreateStmt *) stmt)->options, "toast"); > > > + > > > + toast_options = > transformOptions( > > > + > get_toast_relopt_spec_set(), (Datum) 0, > > > + > toastDefList, 0); > > > > > > > NewRelationCreateToastTable(address.objectId, > > > > > > > toast_options); > > > > > > @@ -1295,9 +1298,12 @@ ProcessUtilitySlow(ParseState *pstate, > > > > > > * lock on (for example) a relation > on which we have no > > > * permissions. > > > */ > > > > > > - lockmode = > AlterTableGetLockLevel(atstmt->cmds); > > > - relid = > AlterTableLookupRelation(atstmt, lockmode); > > > - > > > + relid = > AlterTableLookupRelation(atstmt, NoLock); // FIXME! > > > + if (OidIsValid(relid)) > > > + { > > > + lockmode = > AlterTableGetLockLevel(relid, atstmt->cmds); > > > + relid = > AlterTableLookupRelation(atstmt, lockmode); > > > + } > > > > > > if (OidIsValid(relid)) > > > { > > > > > > AlterTableUtilityContext > atcontext; > > > > > > diff --git a/src/backend/utils/cache/attoptcache.c > > > b/src/backend/utils/cache/attoptcache.c index 72d89cb..f651129 100644 > > > --- a/src/backend/utils/cache/attoptcache.c > > > +++ b/src/backend/utils/cache/attoptcache.c > > > @@ -16,6 +16,7 @@ > > > > > > */ > > > > > > #include "postgres.h" > > > > > > +#include "access/options.h" > > > > > > #include "access/reloptions.h" > > > #include "utils/attoptcache.h" > > > #include "utils/catcache.h" > > > > > > @@ -148,7 +149,8 @@ get_attribute_options(Oid attrelid, int attnum) > > > > > > opts = NULL; > > > > > > else > > > { > > > > > > - bytea *bytea_opts = > attribute_reloptions(datum, false); > > > + bytea *bytea_opts = > optionsTextArrayToBytea( > > > + > get_attribute_options_spec_set(), datum, 0); > > > > > > opts = > MemoryContextAlloc(CacheMemoryContext, > > > > > > > VARSIZE(bytea_opts)); > > > > > > diff --git a/src/backend/utils/cache/relcache.c > > > b/src/backend/utils/cache/relcache.c index 13d9994..f22c2d9 100644 > > > --- a/src/backend/utils/cache/relcache.c > > > +++ b/src/backend/utils/cache/relcache.c > > > @@ -441,7 +441,7 @@ static void > > > > > > RelationParseRelOptions(Relation relation, HeapTuple tuple) > > > { > > > > > > bytea *options; > > > > > > - amoptions_function amoptsfn; > > > + amreloptspecset_function amoptspecsetfn; > > > > > > relation->rd_options = NULL; > > > > > > @@ -456,11 +456,11 @@ RelationParseRelOptions(Relation relation, HeapTuple > > > tuple)> > > > case RELKIND_VIEW: > > > case RELKIND_MATVIEW: > > > > > > case RELKIND_PARTITIONED_TABLE: > > > - amoptsfn = NULL; > > > + amoptspecsetfn = NULL; > > > > > > break; > > > > > > case RELKIND_INDEX: > > > > > > case RELKIND_PARTITIONED_INDEX: > > > - amoptsfn = relation->rd_indam->amoptions; > > > + amoptspecsetfn = relation->rd_indam->amreloptspecset; > > > > > > break; > > > > > > default: > > > return; > > > > > > @@ -471,7 +471,7 @@ RelationParseRelOptions(Relation relation, HeapTuple > > > tuple)> > > > * we might not have any other for pg_class yet (consider executing > this > > > * code for pg_class itself) > > > */ > > > > > > - options = extractRelOptions(tuple, GetPgClassDescriptor(), > amoptsfn); > > > + options = extractRelOptions(tuple, GetPgClassDescriptor(), > > > amoptspecsetfn);> > > > /* > > > > > > * Copy parsed data into CacheMemoryContext. To guard against the > > > > > > diff --git a/src/backend/utils/cache/spccache.c > > > b/src/backend/utils/cache/spccache.c index 5870f43..87f2fa5 100644 > > > --- a/src/backend/utils/cache/spccache.c > > > +++ b/src/backend/utils/cache/spccache.c > > > @@ -148,7 +148,8 @@ get_tablespace(Oid spcid) > > > > > > opts = NULL; > > > > > > else > > > { > > > > > > - bytea *bytea_opts = > tablespace_reloptions(datum, false); > > > + bytea *bytea_opts = optionsTextArrayToBytea( > > > + > get_tablespace_options_spec_set(), datum, 0); > > > > > > opts = MemoryContextAlloc(CacheMemoryContext, > VARSIZE(bytea_opts)); > > > memcpy(opts, bytea_opts, VARSIZE(bytea_opts)); > > > > > > diff --git a/src/include/access/amapi.h b/src/include/access/amapi.h > > > index d357ebb..b8fb6b9 100644 > > > --- a/src/include/access/amapi.h > > > +++ b/src/include/access/amapi.h > > > @@ -136,10 +136,6 @@ typedef void (*amcostestimate_function) (struct > > > PlannerInfo *root,> > > > > double *indexCorrelation, > > > > double *indexPages); > > > > > > -/* parse index reloptions */ > > > -typedef bytea *(*amoptions_function) (Datum reloptions, > > > - > bool validate); > > > - > > > > > > /* report AM, index, or index column property */ > > > typedef bool (*amproperty_function) (Oid index_oid, int attno, > > > > > > > IndexAMProperty prop, const char *propname, > > > > > > @@ -186,6 +182,9 @@ typedef void (*ammarkpos_function) (IndexScanDesc > > > scan);> > > > /* restore marked scan position */ > > > typedef void (*amrestrpos_function) (IndexScanDesc scan); > > > > > > +/* get catalog of reloptions definitions */ > > > +typedef void *(*amreloptspecset_function) (); > > > + > > > > > > /* > > > > > > * Callback function signatures - for parallel index scans. > > > */ > > > > > > @@ -263,7 +262,6 @@ typedef struct IndexAmRoutine > > > > > > amvacuumcleanup_function amvacuumcleanup; > > > amcanreturn_function amcanreturn; /* can be NULL */ > > > amcostestimate_function amcostestimate; > > > > > > - amoptions_function amoptions; > > > > > > amproperty_function amproperty; /* can be NULL */ > > > ambuildphasename_function ambuildphasename; /* can be NULL */ > > > amvalidate_function amvalidate; > > > > > > @@ -275,6 +273,7 @@ typedef struct IndexAmRoutine > > > > > > amendscan_function amendscan; > > > ammarkpos_function ammarkpos; /* can be NULL */ > > > amrestrpos_function amrestrpos; /* can be NULL */ > > > > > > + amreloptspecset_function amreloptspecset; /* can be NULL */ > > > > > > /* interface functions to support parallel index scans */ > > > amestimateparallelscan_function amestimateparallelscan; /* can be > NULL > > > */ > > > > > > diff --git a/src/include/access/brin.h b/src/include/access/brin.h > > > index 4e2be13..25b3456 100644 > > > --- a/src/include/access/brin.h > > > +++ b/src/include/access/brin.h > > > @@ -36,6 +36,8 @@ typedef struct BrinStatsData > > > > > > #define BRIN_DEFAULT_PAGES_PER_RANGE 128 > > > > > > +#define BRIN_MIN_PAGES_PER_RANGE 1 > > > +#define BRIN_MAX_PAGES_PER_RANGE 131072 > > > > > > #define BrinGetPagesPerRange(relation) \ > > > > > > (AssertMacro(relation->rd_rel->relkind == RELKIND_INDEX && \ > > > > > > relation->rd_rel->relam == BRIN_AM_OID), \ > > > > > > diff --git a/src/include/access/brin_internal.h > > > b/src/include/access/brin_internal.h index 79440eb..a798a96 100644 > > > --- a/src/include/access/brin_internal.h > > > +++ b/src/include/access/brin_internal.h > > > @@ -14,6 +14,7 @@ > > > > > > #include "access/amapi.h" > > > #include "storage/bufpage.h" > > > #include "utils/typcache.h" > > > > > > +#include "access/options.h" > > > > > > /* > > > > > > @@ -108,6 +109,7 @@ extern IndexBulkDeleteResult > > > *brinbulkdelete(IndexVacuumInfo *info,> > > > extern IndexBulkDeleteResult *brinvacuumcleanup(IndexVacuumInfo *info, > > > > > > > IndexBulkDeleteResult *stats); > > > > > > extern bytea *brinoptions(Datum reloptions, bool validate); > > > > > > +extern void * bringetreloptspecset (void); > > > > > > /* brin_validate.c */ > > > extern bool brinvalidate(Oid opclassoid); > > > > > > diff --git a/src/include/access/gin_private.h > > > b/src/include/access/gin_private.h index 670a40b..2b7c25c 100644 > > > --- a/src/include/access/gin_private.h > > > +++ b/src/include/access/gin_private.h > > > @@ -108,6 +108,7 @@ extern Datum *ginExtractEntries(GinState *ginstate, > > > OffsetNumber attnum,> > > > extern OffsetNumber gintuple_get_attrnum(GinState *ginstate, IndexTuple > > > tuple); extern Datum gintuple_get_key(GinState *ginstate, IndexTuple > > > tuple,> > > > GinNullCategory > *category); > > > > > > +extern void *gingetreloptspecset(void); > > > > > > /* gininsert.c */ > > > extern IndexBuildResult *ginbuild(Relation heap, Relation index, > > > > > > diff --git a/src/include/access/gist_private.h > > > b/src/include/access/gist_private.h index 553d364..015b75a 100644 > > > --- a/src/include/access/gist_private.h > > > +++ b/src/include/access/gist_private.h > > > @@ -22,6 +22,7 @@ > > > > > > #include "storage/buffile.h" > > > #include "utils/hsearch.h" > > > #include "access/genam.h" > > > > > > +#include "access/reloptions.h" //FIXME! should be replaced with options.h > > > finally> > > > /* > > > > > > * Maximum number of "halves" a page can be split into in one operation. > > > > > > @@ -388,6 +389,7 @@ typedef enum GistOptBufferingMode > > > > > > GIST_OPTION_BUFFERING_OFF > > > > > > } GistOptBufferingMode; > > > > > > + > > > > > > /* > > > > > > * Storage type for GiST's reloptions > > > */ > > > > > > @@ -478,7 +480,7 @@ extern void gistadjustmembers(Oid opfamilyoid, > > > > > > #define GIST_MIN_FILLFACTOR 10 > > > #define GIST_DEFAULT_FILLFACTOR 90 > > > > > > -extern bytea *gistoptions(Datum reloptions, bool validate); > > > +extern void *gistgetreloptspecset(void); > > > > > > extern bool gistproperty(Oid index_oid, int attno, > > > > > > IndexAMProperty prop, const > char *propname, > > > bool *res, bool *isnull); > > > > > > diff --git a/src/include/access/hash.h b/src/include/access/hash.h > > > index 1cce865..91922ef 100644 > > > --- a/src/include/access/hash.h > > > +++ b/src/include/access/hash.h > > > @@ -378,7 +378,6 @@ extern IndexBulkDeleteResult > > > *hashbulkdelete(IndexVacuumInfo *info,> > > > > void *callback_state); > > > > > > extern IndexBulkDeleteResult *hashvacuumcleanup(IndexVacuumInfo *info, > > > > > > > IndexBulkDeleteResult *stats); > > > > > > -extern bytea *hashoptions(Datum reloptions, bool validate); > > > > > > extern bool hashvalidate(Oid opclassoid); > > > extern void hashadjustmembers(Oid opfamilyoid, > > > > > > Oid opclassoid, > > > > > > @@ -470,6 +469,7 @@ extern BlockNumber > > > _hash_get_newblock_from_oldbucket(Relation rel, Bucket old_bu> > > > extern Bucket _hash_get_newbucket_from_oldbucket(Relation rel, Bucket > > > old_bucket,> > > > > uint32 lowmask, uint32 maxbucket); > > > > > > extern void _hash_kill_items(IndexScanDesc scan); > > > > > > +extern void *hashgetreloptspecset(void); > > > > > > /* hash.c */ > > > extern void hashbucketcleanup(Relation rel, Bucket cur_bucket, > > > > > > diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h > > > index 30a216e..1fcb5f5 100644 > > > --- a/src/include/access/nbtree.h > > > +++ b/src/include/access/nbtree.h > > > @@ -1252,7 +1252,7 @@ extern void _bt_end_vacuum(Relation rel); > > > > > > extern void _bt_end_vacuum_callback(int code, Datum arg); > > > extern Size BTreeShmemSize(void); > > > extern void BTreeShmemInit(void); > > > > > > -extern bytea *btoptions(Datum reloptions, bool validate); > > > +extern void * btgetreloptspecset (void); > > > > > > extern bool btproperty(Oid index_oid, int attno, > > > > > > IndexAMProperty prop, const char > *propname, > > > bool *res, bool *isnull); > > > > > > diff --git a/src/include/access/options.h b/src/include/access/options.h > > > new file mode 100644 > > > index 0000000..34e2917 > > > --- /dev/null > > > +++ b/src/include/access/options.h > > > @@ -0,0 +1,245 @@ > > > +/*----------------------------------------------------------------------- > > > -- + * > > > + * options.h > > > + * Core support for relation and tablespace options > > > (pg_class.reloptions > > > + * and pg_tablespace.spcoptions) > > > + * > > > + * Note: the functions dealing with text-array options values declare > > > + * them as Datum, not ArrayType *, to avoid needing to include array.h > > > + * into a lot of low-level code. > > > + * > > > + * > > > + * Portions Copyright (c) 1996-2016, PostgreSQL Global Development Group > > > + * Portions Copyright (c) 1994, Regents of the University of California > > > + * > > > + * src/include/access/options.h > > > + * > > > + > > > *------------------------------------------------------------------------ > > > - + */ > > > +#ifndef OPTIONS_H > > > +#define OPTIONS_H > > > + > > > +#include "storage/lock.h" > > > +#include "nodes/pg_list.h" > > > + > > > + > > > +/* supported option types */ > > > +typedef enum option_type > > > +{ > > > + OPTION_TYPE_BOOL, > > > + OPTION_TYPE_INT, > > > + OPTION_TYPE_REAL, > > > + OPTION_TYPE_ENUM, > > > + OPTION_TYPE_STRING > > > +} option_type; > > > + > > > + > > > +typedef enum option_value_status > > > +{ > > > + OPTION_VALUE_STATUS_EMPTY, /* Option was just initialized */ > > > + OPTION_VALUE_STATUS_RAW, /* Option just came from syntax analyzer in > > > + * has name, > and raw (unparsed) value */ > > > + OPTION_VALUE_STATUS_PARSED, /* Option was parsed and has link to > catalog > > > + * entry and > proper value */ > > > + OPTION_VALUE_STATUS_FOR_RESET /* This option came from > ALTER xxx > > > + > * RESET */ > > > +} option_value_status; > > > + > > > +/* flags for reloptinon definition */ > > > +typedef enum option_spec_flags > > > +{ > > > + OPTION_DEFINITION_FLAG_FORBID_ALTER = (1 << 0), /* > Altering this option > > > + > * is forbidden */ > > > + OPTION_DEFINITION_FLAG_IGNORE = (1 << 1), /* Skip this option while > > > + > * parsing. Used for WITH OIDS > > > + > * special case */ > > > + OPTION_DEFINITION_FLAG_REJECT = (1 << 2) /* Option will be > rejected > > > + > * when comes from syntax > > > + > * analyzer, but still have > > > + > * default value and offset */ > > > +} option_spec_flags; > > > + > > > +/* flags that tells reloption parser how to parse*/ > > > +typedef enum options_parse_mode > > > +{ > > > + OPTIONS_PARSE_MODE_VALIDATE = (1 << 0), > > > + OPTIONS_PARSE_MODE_FOR_ALTER = (1 << 1), > > > + OPTIONS_PARSE_MODE_FOR_RESET = (1 << 2) > > > +} options_parse_mode; > > > + > > > + > > > + > > > +/* > > > + * opt_enum_elt_def -- One member of the array of acceptable values > > > + * of an enum reloption. > > > + */ > > > +typedef struct opt_enum_elt_def > > > +{ > > > + const char *string_val; > > > + int symbol_val; > > > +} opt_enum_elt_def; > > > + > > > + > > > +/* generic structure to store Option Spec information */ > > > +typedef struct option_spec_basic > > > +{ > > > + const char *name; /* must be first (used as list > termination > > > + * marker) */ > > > + const char *desc; > > > + LOCKMODE lockmode; > > > + option_spec_flags flags; > > > + option_type type; > > > + int struct_offset; /* offset of the value in > Bytea representation */ > > > +} option_spec_basic; > > > + > > > + > > > +/* reloptions records for specific variable types */ > > > +typedef struct option_spec_bool > > > +{ > > > + option_spec_basic base; > > > + bool default_val; > > > +} option_spec_bool; > > > + > > > +typedef struct option_spec_int > > > +{ > > > + option_spec_basic base; > > > + int default_val; > > > + int min; > > > + int max; > > > +} option_spec_int; > > > + > > > +typedef struct option_spec_real > > > +{ > > > + option_spec_basic base; > > > + double default_val; > > > + double min; > > > + double max; > > > +} option_spec_real; > > > + > > > +typedef struct option_spec_enum > > > +{ > > > + option_spec_basic base; > > > + opt_enum_elt_def *members;/* FIXME rewrite. Null terminated array of > > > allowed values for + > * the option */ > > > + int default_val; /* Number of item of > allowed_values array */ > > > + const char *detailmsg; > > > +} option_spec_enum; > > > + > > > +/* validation routines for strings */ > > > +typedef void (*validate_string_option) (const char *value); > > > + > > > +/* > > > + * When storing sting reloptions, we shoud deal with special case when > > > + * option value is not set. For fixed length options, we just copy > > > default > > > + * option value into the binary structure. For varlen value, there can be > > > + * "not set" special case, with no default value offered. > > > + * In this case we will set offset value to -1, so code that use > > > relptions > > > + * can deal this case. For better readability it was defined as a > > > constant. + */ > > > +#define OPTION_STRING_VALUE_NOT_SET_OFFSET -1 > > > + > > > +typedef struct option_spec_string > > > +{ > > > + option_spec_basic base; > > > + validate_string_option validate_cb; > > > + char *default_val; > > > +} option_spec_string; > > > + > > > +typedef void (*postprocess_bytea_options_function) (void *data, bool > > > validate); + > > > +typedef struct options_spec_set > > > +{ > > > + option_spec_basic **definitions; > > > + int num; /* Number of > spec_set items in use */ > > > + int num_allocated; /* Number of spec_set > items allocated */ > > > + bool forbid_realloc; /* If number of items of the > spec_set were > > > + * strictly > set to certain value do no allow > > > + * adding > more idems */ > > > + Size struct_size; /* Size of a structure for > options in binary > > > + * > representation */ > > > + postprocess_bytea_options_function postprocess_fun; /* This function > is > > > + > * called after options > > > + > * were converted in > > > + > * Bytea represenation. > > > + > * Can be used for extra > > > + > * validation and so on */ > > > + char *namespace; /* spec_set is used for options > from this > > > + * namespase > */ > > > +} options_spec_set; > > > + > > > + > > > +/* holds an option value parsed or unparsed */ > > > +typedef struct option_value > > > +{ > > > + option_spec_basic *gen; > > > + char *namespace; > > > + option_value_status status; > > > + char *raw_value; /* allocated separately */ > > > + char *raw_name; > > > + union > > > + { > > > + bool bool_val; > > > + int int_val; > > > + double real_val; > > > + int enum_val; > > > + char *string_val; /* allocated separately */ > > > + } values; > > > +} option_value; > > > + > > > + > > > + > > > + > > > +/* > > > + * Options spec_set related functions > > > + */ > > > +extern options_spec_set *allocateOptionsSpecSet(const char *namespace, > > > + int > size_of_bytea, int num_items_expected); > > > +extern void optionsSpecSetAddBool(options_spec_set * spec_set, const char > > > *name, + const char *desc, LOCKMODE > lockmode, option_spec_flags > > > flags, + > int struct_offset, bool default_val); > > > +extern void optionsSpecSetAddInt(options_spec_set * spec_set, const char > > > *name, + const char *desc, LOCKMODE > lockmode, option_spec_flags > > > flags, + int struct_offset, int > default_val, int min_val, int > > > max_val); +extern void optionsSpecSetAddReal(options_spec_set * spec_set, > > > const char *name, + const char *desc, LOCKMODE lockmode, > > > option_spec_flags flags, + int struct_offset, double default_val, > > > double min_val, double max_val); +extern void > > > optionsSpecSetAddEnum(options_spec_set * spec_set, > > > + const char *name, const > char *desc, LOCKMODE lockmode, > > > option_spec_flags flags, + int struct_offset, > opt_enum_elt_def* > > > members, int default_val, const char *detailmsg); +extern void > > > optionsSpecSetAddString(options_spec_set * spec_set, const char *name, > > > + const char *desc, LOCKMODE lockmode, option_spec_flags flags, > +int > > > struct_offset, const char *default_val, validate_string_option > > > validator); + > > > + > > > +/* > > > + * This macro allows to get string option value from bytea > > > representation. > > > + * "optstruct" - is a structure that is stored in bytea options > > > representation + * "member" - member of this structure that has string > > > option value + * (actually string values are stored in bytea after the > > > structure, and + * and "member" will contain an offset to this value. > > > This macro do all + * the math > > > + */ > > > +#define GET_STRING_OPTION(optstruct, member) \ > > > + ((optstruct)->member == OPTION_STRING_VALUE_NOT_SET_OFFSET ? NULL : \ > > > + (char *)(optstruct) + (optstruct)->member) > > > + > > > +/* > > > + * Functions related to option convertation, parsing, manipulation > > > + * and validation > > > + */ > > > +extern void optionsDefListValdateNamespaces(List *defList, > > > + char > **allowed_namespaces); > > > +extern List *optionsDefListFilterNamespaces(List *defList, const char > > > *namespace); +extern List *optionsTextArrayToDefList(Datum options); > > > +extern Datum optionsDefListToTextArray(List *defList); > > > +/* > > > + * Meta functions that uses functions above to get options for relations, > > > + * tablespaces, views and so on > > > + */ > > > + > > > +extern bytea *optionsTextArrayToBytea(options_spec_set * spec_set, Datum > > > data, + > bool validate); > > > +extern Datum transformOptions(options_spec_set * spec_set, Datum > > > oldOptions, + List *defList, options_parse_mode > parse_mode); > > > + > > > +#endif /* OPTIONS_H */ > > > diff --git a/src/include/access/reloptions.h > > > b/src/include/access/reloptions.h index 7c5fbeb..21b91df 100644 > > > --- a/src/include/access/reloptions.h > > > +++ b/src/include/access/reloptions.h > > > @@ -22,6 +22,7 @@ > > > > > > #include "access/amapi.h" > > > #include "access/htup.h" > > > #include "access/tupdesc.h" > > > > > > +#include "access/options.h" > > > > > > #include "nodes/pg_list.h" > > > #include "storage/lock.h" > > > > > > @@ -110,20 +111,10 @@ typedef struct relopt_real > > > > > > double max; > > > > > > } relopt_real; > > > > > > -/* > > > - * relopt_enum_elt_def -- One member of the array of acceptable values > > > - * of an enum reloption. > > > - */ > > > -typedef struct relopt_enum_elt_def > > > -{ > > > - const char *string_val; > > > - int symbol_val; > > > -} relopt_enum_elt_def; > > > - > > > > > > typedef struct relopt_enum > > > { > > > > > > relopt_gen gen; > > > > > > - relopt_enum_elt_def *members; > > > + opt_enum_elt_def *members; > > > > > > int default_val; > > > const char *detailmsg; > > > /* null-terminated array of members */ > > > > > > @@ -167,6 +158,7 @@ typedef struct local_relopts > > > > > > List *options; /* list of local_relopt > definitions */ > > > List *validators; /* list of relopts_validator > callbacks */ > > > Size relopt_struct_size; /* size of parsed bytea > structure */ > > > > > > + options_spec_set * spec_set; /* FIXME */ > > > > > > } local_relopts; > > > > > > /* > > > > > > @@ -179,21 +171,6 @@ typedef struct local_relopts > > > > > > ((optstruct)->member == 0 ? NULL : \ > > > > > > (char *)(optstruct) + (optstruct)->member) > > > > > > -extern relopt_kind add_reloption_kind(void); > > > -extern void add_bool_reloption(bits32 kinds, const char *name, const char > > > *desc, - bool > default_val, LOCKMODE lockmode); > > > -extern void add_int_reloption(bits32 kinds, const char *name, const char > > > *desc, - int > default_val, int min_val, int max_val, > > > - LOCKMODE > lockmode); > > > -extern void add_real_reloption(bits32 kinds, const char *name, const char > > > *desc, - double > default_val, double min_val, double max_val, > > > - LOCKMODE > lockmode); > > > -extern 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); > > > -extern void add_string_reloption(bits32 kinds, const char *name, const > > > char *desc, - > const char *default_val, validate_string_relopt > > > validator, - > LOCKMODE lockmode); > > > > > > extern void init_local_reloptions(local_relopts *opts, Size > > > relopt_struct_size); extern void > > > register_reloptions_validator(local_relopts *opts, > > > > > > @@ -210,7 +187,7 @@ extern void add_local_real_reloption(local_relopts > > > *opts, const char *name,> > > > int > offset); > > > > > > extern void add_local_enum_reloption(local_relopts *relopts, > > > > > > > const char *name, const char *desc, > > > > > > - > relopt_enum_elt_def *members, > > > + > opt_enum_elt_def *members, > > > > > > int > default_val, const char *detailmsg, > > > int > offset); > > > > > > extern void add_local_string_reloption(local_relopts *opts, const char > > > *name,> > > > @@ -219,29 +196,17 @@ extern void add_local_string_reloption(local_relopts > > > *opts, const char *name,> > > > > validate_string_relopt validator, > > > > fill_string_relopt filler, int offset); > > > > > > -extern Datum transformRelOptions(Datum oldOptions, List *defList, > > > - const char > *namspace, char *validnsps[], > > > - bool > acceptOidsOff, bool isReset); > > > -extern List *untransformRelOptions(Datum options); > > > > > > extern bytea *extractRelOptions(HeapTuple tuple, TupleDesc tupdesc, > > > > > > - > amoptions_function amoptions); > > > -extern void *build_reloptions(Datum reloptions, bool validate, > > > - relopt_kind kind, > > > - Size > relopt_struct_size, > > > - const > relopt_parse_elt *relopt_elems, > > > - int > num_relopt_elems); > > > + > amreloptspecset_function amoptions_def_set); > > > > > > extern void *build_local_reloptions(local_relopts *relopts, Datum > > > options, > > > > > > bool > validate); > > > > > > -extern bytea *default_reloptions(Datum reloptions, bool validate, > > > - relopt_kind > kind); > > > -extern bytea *heap_reloptions(char relkind, Datum reloptions, bool > > > validate); -extern bytea *view_reloptions(Datum reloptions, bool > > > validate); > > > -extern bytea *partitioned_table_reloptions(Datum reloptions, bool > > > validate); -extern bytea *index_reloptions(amoptions_function amoptions, > > > Datum reloptions, - > bool validate); > > > -extern bytea *attribute_reloptions(Datum reloptions, bool validate); > > > -extern bytea *tablespace_reloptions(Datum reloptions, bool validate); > > > -extern LOCKMODE AlterTableGetRelOptionsLockLevel(List *defList); > > > +options_spec_set *get_heap_relopt_spec_set(void); > > > +options_spec_set *get_toast_relopt_spec_set(void); > > > +options_spec_set *get_partitioned_relopt_spec_set(void); > > > +options_spec_set *get_view_relopt_spec_set(void); > > > +options_spec_set *get_attribute_options_spec_set(void); > > > +options_spec_set *get_tablespace_options_spec_set(void); > > > +extern LOCKMODE AlterTableGetRelOptionsLockLevel(Relation rel, List > > > *defList);> > > > #endif /* > RELOPTIONS_H */ > > > > > > diff --git a/src/include/access/spgist.h b/src/include/access/spgist.h > > > index 2eb2f42..d9a9b2d 100644 > > > --- a/src/include/access/spgist.h > > > +++ b/src/include/access/spgist.h > > > @@ -189,9 +189,6 @@ typedef struct spgLeafConsistentOut > > > > > > } spgLeafConsistentOut; > > > > > > -/* spgutils.c */ > > > -extern bytea *spgoptions(Datum reloptions, bool validate); > > > - > > > > > > /* spginsert.c */ > > > extern IndexBuildResult *spgbuild(Relation heap, Relation index, > > > > > > struct > IndexInfo *indexInfo); > > > > > > diff --git a/src/include/access/spgist_private.h > > > b/src/include/access/spgist_private.h index 40d3b71..dd9a05a 100644 > > > --- a/src/include/access/spgist_private.h > > > +++ b/src/include/access/spgist_private.h > > > @@ -529,6 +529,7 @@ extern OffsetNumber SpGistPageAddNewItem(SpGistState > > > *state, Page page,> > > > extern bool spgproperty(Oid index_oid, int attno, > > > > > > IndexAMProperty prop, const > char *propname, > > > bool *res, bool *isnull); > > > > > > +extern void *spggetreloptspecset(void); > > > > > > /* spgdoinsert.c */ > > > extern void spgUpdateNodeLink(SpGistInnerTuple tup, int nodeN, > > > > > > diff --git a/src/include/commands/tablecmds.h > > > b/src/include/commands/tablecmds.h index 336549c..3f87f98 100644 > > > --- a/src/include/commands/tablecmds.h > > > +++ b/src/include/commands/tablecmds.h > > > @@ -34,7 +34,7 @@ extern Oid AlterTableLookupRelation(AlterTableStmt > > > *stmt, LOCKMODE lockmode);> > > > extern void AlterTable(AlterTableStmt *stmt, LOCKMODE lockmode, > > > > > > struct AlterTableUtilityContext > *context); > > > > > > -extern LOCKMODE AlterTableGetLockLevel(List *cmds); > > > +extern LOCKMODE AlterTableGetLockLevel(Oid relid, List *cmds); > > > > > > extern void ATExecChangeOwner(Oid relationOid, Oid newOwnerId, bool > > > recursing, LOCKMODE lockmode);> > > > diff --git a/src/test/modules/dummy_index_am/dummy_index_am.c > > > b/src/test/modules/dummy_index_am/dummy_index_am.c index > > > 5365b063..80b39e8 100644 > > > --- a/src/test/modules/dummy_index_am/dummy_index_am.c > > > +++ b/src/test/modules/dummy_index_am/dummy_index_am.c > > > @@ -14,7 +14,7 @@ > > > > > > #include "postgres.h" > > > > > > #include "access/amapi.h" > > > > > > -#include "access/reloptions.h" > > > +#include "access/options.h" > > > > > > #include "catalog/index.h" > > > #include "commands/vacuum.h" > > > #include "nodes/pathnodes.h" > > > > > > @@ -25,12 +25,6 @@ PG_MODULE_MAGIC; > > > > > > void _PG_init(void); > > > > > > -/* parse table for fillRelOptions */ > > > -relopt_parse_elt di_relopt_tab[6]; > > > - > > > -/* Kind of relation options for dummy index */ > > > -relopt_kind di_relopt_kind; > > > - > > > > > > typedef enum DummyAmEnum > > > { > > > > > > DUMMY_AM_ENUM_ONE, > > > > > > @@ -49,7 +43,7 @@ typedef struct DummyIndexOptions > > > > > > int option_string_null_offset; > > > > > > } DummyIndexOptions; > > > > > > -relopt_enum_elt_def dummyAmEnumValues[] = > > > +opt_enum_elt_def dummyAmEnumValues[] = > > > > > > { > > > > > > {"one", DUMMY_AM_ENUM_ONE}, > > > {"two", DUMMY_AM_ENUM_TWO}, > > > > > > @@ -63,77 +57,85 @@ PG_FUNCTION_INFO_V1(dihandler); > > > > > > * Validation function for string relation options. > > > */ > > > > > > static void > > > > > > -validate_string_option(const char *value) > > > +divalidate_string_option(const char *value) > > > > > > { > > > > > > ereport(NOTICE, > > > > > > (errmsg("new option value for string parameter %s", > > > > > > value ? value : "NULL"))); > > > > > > } > > > > > > -/* > > > - * This function creates a full set of relation option types, > > > - * with various patterns. > > > - */ > > > -static void > > > -create_reloptions_table(void) > > > +static options_spec_set *di_relopt_specset = NULL; > > > +void * digetreloptspecset(void); > > > + > > > +void * > > > +digetreloptspecset(void) > > > > > > { > > > > > > - di_relopt_kind = add_reloption_kind(); > > > - > > > - add_int_reloption(di_relopt_kind, "option_int", > > > - "Integer option for > dummy_index_am", > > > - 10, -10, 100, > AccessExclusiveLock); > > > - di_relopt_tab[0].optname = "option_int"; > > > - di_relopt_tab[0].opttype = RELOPT_TYPE_INT; > > > - di_relopt_tab[0].offset = offsetof(DummyIndexOptions, option_int); > > > - > > > - add_real_reloption(di_relopt_kind, "option_real", > > > - "Real option for dummy_index_am", > > > - 3.1415, -10, 100, > AccessExclusiveLock); > > > - di_relopt_tab[1].optname = "option_real"; > > > - di_relopt_tab[1].opttype = RELOPT_TYPE_REAL; > > > - di_relopt_tab[1].offset = offsetof(DummyIndexOptions, option_real); > > > - > > > - add_bool_reloption(di_relopt_kind, "option_bool", > > > - "Boolean option for > dummy_index_am", > > > - true, AccessExclusiveLock); > > > - di_relopt_tab[2].optname = "option_bool"; > > > - di_relopt_tab[2].opttype = RELOPT_TYPE_BOOL; > > > - di_relopt_tab[2].offset = offsetof(DummyIndexOptions, option_bool); > > > - > > > - add_enum_reloption(di_relopt_kind, "option_enum", > > > - "Enum option for dummy_index_am", > > > - dummyAmEnumValues, > > > - DUMMY_AM_ENUM_ONE, > > > - "Valid values are \"one\" and > \"two\".", > > > - AccessExclusiveLock); > > > - di_relopt_tab[3].optname = "option_enum"; > > > - di_relopt_tab[3].opttype = RELOPT_TYPE_ENUM; > > > - di_relopt_tab[3].offset = offsetof(DummyIndexOptions, option_enum); > > > - > > > - add_string_reloption(di_relopt_kind, "option_string_val", > > > - "String option for > dummy_index_am with non-NULL default", > > > - "DefaultValue", > &validate_string_option, > > > - AccessExclusiveLock); > > > - di_relopt_tab[4].optname = "option_string_val"; > > > - di_relopt_tab[4].opttype = RELOPT_TYPE_STRING; > > > - di_relopt_tab[4].offset = offsetof(DummyIndexOptions, > > > - > option_string_val_offset); > > > + if (di_relopt_specset) > > > + return di_relopt_specset; > > > + > > > + di_relopt_specset = allocateOptionsSpecSet(NULL, > > > + > sizeof(DummyIndexOptions), 6); > > > + > > > + optionsSpecSetAddInt( > > > + di_relopt_specset, "option_int", > > > + "Integer option for dummy_index_am", > > > + AccessExclusiveLock, > > > + 0, offsetof(DummyIndexOptions, option_int), > > > + 10, -10, 100 > > > + ); > > > + > > > + > > > + optionsSpecSetAddReal( > > > + di_relopt_specset, "option_real", > > > + "Real option for dummy_index_am", > > > + AccessExclusiveLock, > > > + 0, offsetof(DummyIndexOptions, option_real), > > > + 3.1415, -10, 100 > > > + ); > > > + > > > + optionsSpecSetAddBool( > > > + di_relopt_specset, "option_bool", > > > + "Boolean option for dummy_index_am", > > > + AccessExclusiveLock, > > > + 0, offsetof(DummyIndexOptions, option_bool), true > > > + ); > > > + > > > + optionsSpecSetAddEnum(di_relopt_specset, "option_enum", > > > + "Enum option for dummy_index_am", > > > + AccessExclusiveLock, > > > + 0, > > > + offsetof(DummyIndexOptions, option_enum), > > > + dummyAmEnumValues, > > > + DUMMY_AM_ENUM_ONE, > > > + "Valid values are \"one\" and \"two\"." > > > + ); > > > + > > > + optionsSpecSetAddString(di_relopt_specset, "option_string_val", > > > + "String option for dummy_index_am with non-NULL default", > > > + AccessExclusiveLock, > > > + 0, > > > + offsetof(DummyIndexOptions, option_string_val_offset), > > > + "DefaultValue", &divalidate_string_option > > > + ); > > > > > > /* > > > > > > * String option for dummy_index_am with NULL default, and without > > > * description. > > > */ > > > > > > - add_string_reloption(di_relopt_kind, "option_string_null", > > > - NULL, /* description */ > > > - NULL, > &validate_string_option, > > > - AccessExclusiveLock); > > > - di_relopt_tab[5].optname = "option_string_null"; > > > - di_relopt_tab[5].opttype = RELOPT_TYPE_STRING; > > > - di_relopt_tab[5].offset = offsetof(DummyIndexOptions, > > > - > option_string_null_offset); > > > + > > > + optionsSpecSetAddString(di_relopt_specset, "option_string_null", > > > + NULL, /* description */ > > > + AccessExclusiveLock, > > > + 0, > > > + offsetof(DummyIndexOptions, option_string_null_offset), > > > + NULL, &divalidate_string_option > > > + ); > > > + > > > + return di_relopt_specset; > > > > > > } > > > > > > + > > > > > > /* > > > > > > * Build a new index. > > > */ > > > > > > @@ -219,19 +221,6 @@ dicostestimate(PlannerInfo *root, IndexPath *path, > > > double loop_count,> > > > } > > > > > > /* > > > > > > - * Parse relation options for index AM, returning a DummyIndexOptions > > > - * structure filled with option values. > > > - */ > > > -static bytea * > > > -dioptions(Datum reloptions, bool validate) > > > -{ > > > - return (bytea *) build_reloptions(reloptions, validate, > > > - > di_relopt_kind, > > > - > sizeof(DummyIndexOptions), > > > - > di_relopt_tab, lengthof(di_relopt_tab)); > > > -} > > > - > > > -/* > > > > > > * Validator for index AM. > > > */ > > > > > > static bool > > > > > > @@ -308,7 +297,6 @@ dihandler(PG_FUNCTION_ARGS) > > > > > > amroutine->amvacuumcleanup = divacuumcleanup; > > > amroutine->amcanreturn = NULL; > > > amroutine->amcostestimate = dicostestimate; > > > > > > - amroutine->amoptions = dioptions; > > > > > > amroutine->amproperty = NULL; > > > amroutine->ambuildphasename = NULL; > > > amroutine->amvalidate = divalidate; > > > > > > @@ -322,12 +310,7 @@ dihandler(PG_FUNCTION_ARGS) > > > > > > amroutine->amestimateparallelscan = NULL; > > > amroutine->aminitparallelscan = NULL; > > > amroutine->amparallelrescan = NULL; > > > > > > + amroutine->amreloptspecset = digetreloptspecset; > > > > > > PG_RETURN_POINTER(amroutine); > > > > > > } > > > > > > - > > > -void > > > -_PG_init(void) > > > -{ > > > - create_reloptions_table(); > > > -} > > > > -- Bruce Momjian <bruce@momjian.us> https://momjian.us EDB https://enterprisedb.com If only the physical world exists, free will is an illusion.