Re: Suggestion: Unified options API. Need help from core team - Mailing list pgsql-hackers
| From | Nikolay Shaplov |
|---|---|
| Subject | Re: Suggestion: Unified options API. Need help from core team |
| Date | |
| Msg-id | 1649585.qvZ8LAfTsV@thinkpad-pgpro Whole thread Raw |
| In response to | Re: Suggestion: Unified options API. Need help from core team (Bruce Momjian <bruce@momjian.us>) |
| Responses |
Re: Suggestion: Unified options API. Need help from core team
|
| List | pgsql-hackers |
В письме от вторник, 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(); > > -}
pgsql-hackers by date: