Re: Suggestion: Unified options API. Need help from core team

Uh, the core team does not get involved in development issues, unless
there is a issue that clearly cannot be resolved by discussion on the
hackers list.

---------------------------------------------------------------------------

On Mon, Oct 18, 2021 at 04:24:23PM +0300, Nikolay Shaplov wrote:
> Hi!
>
> I am still hoping to finish my work on reloptions I've started some years ago.
>
> I've renewed my patch and I think I need help from core team to finish it.
>
> General idea of the patch: Now we have three ways to define options for
> different objects, with more or less different code used for it. It wold be
> better to have unified context independent API for processing options, instead.
>
> Long story short:
>
> There is Option Specification object, that has all information about single
> option, how it should be parsed and validated.
>
> There is Option Specification Set object, an array of Option Specs, that defines
> all options available for certain object (am of some index for example).
>
> When some object (relation, opclass, etc) wants to have an options, it
> creates an Option Spec Set for there options, and uses it for converting
> options between different representations (to get is from SQL, to store it in
> pg_class, to pass it to the core code as bytea etc)
>
> For indexes Option Spec Set is available via Access Method API.
>
> For non-index relations all Option Spec Sets are left in reloption.c file, and
> should be moved to heap AM later. (They are not in AM now so will not change
> it now)
>
> Main problem:
>
> There are LockModes. LockModes for options is also stored in Option Spec Set.
> For indexes Option Spec Sec is accessable via AM. So to get LockMode for
> option of an index you need to have access for it's relation object (so you
> can call proper AM method to fetch spec set). So you need "Relation rel" in
> AlterTableGetRelOptionsLockLevel where Lock Level is determinated (src/
> backend/access/common/reloptions.c)
> AlterTableGetRelOptionsLockLevel is called from AlterTableGetLockLevel (src/
> backend/commands/tablecmds.c) so we need "Relation rel" there too.
> AlterTableGetLockLevel is called from AlterTableInternal (/src/backend/
> commands/tablecmds.c) There we have "Oid relid" so we can try to open relation
> like this
>
> Relation rel = relation_open(relid, NoLock);
> cmd_lockmode = AlterTableGetRelOptionsLockLevel(rel,
> castNode(List, cmd->def));
> relation_close(rel,NoLock);
> break;
>
> but this will trigger the assertion
>
> Assert(lockmode != NoLock ||
> IsBootstrapProcessingMode() ||
> CheckRelationLockedByMe(r, c, true));
>
> in relation_open (b/src/backend/access/common/relation.c)
>
> For now I've commented this assertion out. I've tried to open relation with
> AccessShareLock but this caused one test to fail, and I am not sure this
> solution is better.
>
> What I have done here I consider a hack, so I need a help of core-team here to
> do it in right way.
>
> General problems:
>
> I guess I need a coauthor, or supervisor from core team, to finish this patch.
> The amount of code is big, and I guess there are parts that can be made more
> in postgres way, then I did them. And I would need an advice there, and I
> guess it would be better to do if before sending it to commitfest.
>
>
> Current patch status:
>
> 1. It is Beta. Some minor issues and FIXMEs are not solved. Some code comments
> needs revising, but in general it do what it is intended to do.
>
> 2. This patch does not intend to change postgres behavior at all, all should
> work as before, all changes are internal only.
>
> The only exception is error message for unexciting option name in toast
> namespace
>
> CREATE TABLE reloptions_test2 (i int) WITH (toast.not_existing_option = 42);
> -ERROR: unrecognized parameter "not_existing_option"
> +ERROR: unrecognized parameter "toast.not_existing_option"
>
> New message is better I guess, though I can change it back if needed.
>
> 3. I am doing my development in this blanch https://gitlab.com/dhyannataraj/
> postgres/-/tree/new_options_take_two I am making changes every day, so last
> version will be available there
>
> Would be glad to hear from coreteam before I finish with this patch and made it
> ready for commit-fest.
>
>

> diff --git a/contrib/bloom/bloom.h b/contrib/bloom/bloom.h
> index a22a6df..8f2d5e7 100644
> --- a/contrib/bloom/bloom.h
> +++ b/contrib/bloom/bloom.h
> @@ -17,6 +17,7 @@
> #include "access/generic_xlog.h"
> #include "access/itup.h"
> #include "access/xlog.h"
> +#include "access/options.h"
> #include "fmgr.h"
> #include "nodes/pathnodes.h"
>
> @@ -207,7 +208,8 @@ extern IndexBulkDeleteResult *blbulkdelete(IndexVacuumInfo *info,
> void *callback_state);
> extern IndexBulkDeleteResult *blvacuumcleanup(IndexVacuumInfo *info,
> IndexBulkDeleteResult *stats);
> -extern bytea *bloptions(Datum reloptions, bool validate);
> +extern void *blrelopt_specset(void);
> +extern void blReloptionPostprocess(void *, bool validate);
> extern void blcostestimate(PlannerInfo *root, IndexPath *path,
> double loop_count, Cost *indexStartupCost,
> Cost *indexTotalCost, Selectivity *indexSelectivity,
> diff --git a/contrib/bloom/blutils.c b/contrib/bloom/blutils.c
> index 754de00..54dad16 100644
> --- a/contrib/bloom/blutils.c
> +++ b/contrib/bloom/blutils.c
> @@ -15,7 +15,7 @@
>
> #include "access/amapi.h"
> #include "access/generic_xlog.h"
> -#include "access/reloptions.h"
> +#include "access/options.h"
> #include "bloom.h"
> #include "catalog/index.h"
> #include "commands/vacuum.h"
> @@ -34,53 +34,13 @@
>
> PG_FUNCTION_INFO_V1(blhandler);
>
> -/* Kind of relation options for bloom index */
> -static relopt_kind bl_relopt_kind;
> -
> -/* parse table for fillRelOptions */
> -static relopt_parse_elt bl_relopt_tab[INDEX_MAX_KEYS + 1];
> +/* Catalog of relation options for bloom index */
> +static options_spec_set *bl_relopt_specset;
>
> static int32 myRand(void);
> static void mySrand(uint32 seed);
>
> /*
> - * Module initialize function: initialize info about Bloom relation options.
> - *
> - * Note: keep this in sync with makeDefaultBloomOptions().
> - */
> -void
> -_PG_init(void)
> -{
> - int i;
> - char buf[16];
> -
> - bl_relopt_kind = add_reloption_kind();
> -
> - /* Option for length of signature */
> - add_int_reloption(bl_relopt_kind, "length",
> - "Length of signature in bits",
> - DEFAULT_BLOOM_LENGTH, 1, MAX_BLOOM_LENGTH,
> - AccessExclusiveLock);
> - bl_relopt_tab[0].optname = "length";
> - bl_relopt_tab[0].opttype = RELOPT_TYPE_INT;
> - bl_relopt_tab[0].offset = offsetof(BloomOptions, bloomLength);
> -
> - /* Number of bits for each possible index column: col1, col2, ... */
> - for (i = 0; i < INDEX_MAX_KEYS; i++)
> - {
> - snprintf(buf, sizeof(buf), "col%d", i + 1);
> - add_int_reloption(bl_relopt_kind, buf,
> - "Number of bits generated for each index column",
> - DEFAULT_BLOOM_BITS, 1, MAX_BLOOM_BITS,
> - AccessExclusiveLock);
> - bl_relopt_tab[i + 1].optname = MemoryContextStrdup(TopMemoryContext,
> - buf);
> - bl_relopt_tab[i + 1].opttype = RELOPT_TYPE_INT;
> - bl_relopt_tab[i + 1].offset = offsetof(BloomOptions, bitSize[0]) + sizeof(int) * i;
> - }
> -}
> -
> -/*
> * Construct a default set of Bloom options.
> */
> static BloomOptions *
> @@ -135,7 +95,7 @@ blhandler(PG_FUNCTION_ARGS)
> amroutine->amvacuumcleanup = blvacuumcleanup;
> amroutine->amcanreturn = NULL;
> amroutine->amcostestimate = blcostestimate;
> - amroutine->amoptions = bloptions;
> + amroutine->amreloptspecset = blrelopt_specset;
> amroutine->amproperty = NULL;
> amroutine->ambuildphasename = NULL;
> amroutine->amvalidate = blvalidate;
> @@ -154,6 +114,28 @@ blhandler(PG_FUNCTION_ARGS)
> PG_RETURN_POINTER(amroutine);
> }
>
> +void
> +blReloptionPostprocess(void *data, bool validate)
> +{
> + BloomOptions *opts = (BloomOptions *) data;
> + int i;
> +
> + if (validate)
> + for (i = 0; i < INDEX_MAX_KEYS; i++)
> + {
> + if (opts->bitSize[i] >= opts->bloomLength)
> + {
> + ereport(ERROR,
> + (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> + errmsg("col%i should not be grater than length", i)));
> + }
> + }
> +
> + /* Convert signature length from # of bits to # to words, rounding up */
> + opts->bloomLength = (opts->bloomLength + SIGNWORDBITS - 1) / SIGNWORDBITS;
> +}
> +
> +
> /*
> * Fill BloomState structure for particular index.
> */
> @@ -474,24 +456,39 @@ BloomInitMetapage(Relation index)
> UnlockReleaseBuffer(metaBuffer);
> }
>
> -/*
> - * Parse reloptions for bloom index, producing a BloomOptions struct.
> - */
> -bytea *
> -bloptions(Datum reloptions, bool validate)
> +void *
> +blrelopt_specset(void)
> {
> - BloomOptions *rdopts;
> + int i;
> + char buf[16];
>
> - /* Parse the user-given reloptions */
> - rdopts = (BloomOptions *) build_reloptions(reloptions, validate,
> - bl_relopt_kind,
> - sizeof(BloomOptions),
> - bl_relopt_tab,
> - lengthof(bl_relopt_tab));
> + if (bl_relopt_specset)
> + return bl_relopt_specset;
>
> - /* Convert signature length from # of bits to # to words, rounding up */
> - if (rdopts)
> - rdopts->bloomLength = (rdopts->bloomLength + SIGNWORDBITS - 1) / SIGNWORDBITS;
>
> - return (bytea *) rdopts;
> + bl_relopt_specset = allocateOptionsSpecSet(NULL,
> + sizeof(BloomOptions), INDEX_MAX_KEYS + 1);
> + bl_relopt_specset->postprocess_fun = blReloptionPostprocess;
> +
> + optionsSpecSetAddInt(bl_relopt_specset, "length",
> + "Length of signature in bits",
> + NoLock, /* No lock as far as ALTER is
> + * forbidden */
> + 0,
> + offsetof(BloomOptions, bloomLength),
> + DEFAULT_BLOOM_LENGTH, 1, MAX_BLOOM_LENGTH);
> +
> + /* Number of bits for each possible index column: col1, col2, ... */
> + for (i = 0; i < INDEX_MAX_KEYS; i++)
> + {
> + snprintf(buf, 16, "col%d", i + 1);
> + optionsSpecSetAddInt(bl_relopt_specset, buf,
> + "Number of bits for corresponding column",
> + NoLock, /* No lock as far as ALTER is
> + * forbidden */
> + 0,
> + offsetof(BloomOptions, bitSize[i]),
> + DEFAULT_BLOOM_BITS, 1, MAX_BLOOM_BITS);
> + }
> + return bl_relopt_specset;
> }
> diff --git a/contrib/bloom/expected/bloom.out b/contrib/bloom/expected/bloom.out
> index dae12a7..e79456d 100644
> --- a/contrib/bloom/expected/bloom.out
> +++ b/contrib/bloom/expected/bloom.out
> @@ -228,3 +228,6 @@ CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH (length=0);
> ERROR: value 0 out of bounds for option "length"
> CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH (col1=0);
> ERROR: value 0 out of bounds for option "col1"
> +-- check post_validate for colN<lengh
> +CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH (length=10,col1=11);
> +ERROR: col0 should not be grater than length
> diff --git a/contrib/bloom/sql/bloom.sql b/contrib/bloom/sql/bloom.sql
> index 4733e1e..0bfc767 100644
> --- a/contrib/bloom/sql/bloom.sql
> +++ b/contrib/bloom/sql/bloom.sql
> @@ -93,3 +93,6 @@ SELECT reloptions FROM pg_class WHERE oid = 'bloomidx'::regclass;
> \set VERBOSITY terse
> CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH (length=0);
> CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH (col1=0);
> +
> +-- check post_validate for colN<lengh
> +CREATE INDEX bloomidx2 ON tst USING bloom (i, t) WITH (length=10,col1=11);
> diff --git a/contrib/dblink/dblink.c b/contrib/dblink/dblink.c
> index 3a0beaa..a15a10b 100644
> --- a/contrib/dblink/dblink.c
> +++ b/contrib/dblink/dblink.c
> @@ -2005,7 +2005,7 @@ PG_FUNCTION_INFO_V1(dblink_fdw_validator);
> Datum
> dblink_fdw_validator(PG_FUNCTION_ARGS)
> {
> - List *options_list = untransformRelOptions(PG_GETARG_DATUM(0));
> + List *options_list = optionsTextArrayToDefList(PG_GETARG_DATUM(0));
> Oid context = PG_GETARG_OID(1);
> ListCell *cell;
>
> diff --git a/contrib/file_fdw/file_fdw.c b/contrib/file_fdw/file_fdw.c
> index 2c2f149..1194747 100644
> --- a/contrib/file_fdw/file_fdw.c
> +++ b/contrib/file_fdw/file_fdw.c
> @@ -195,7 +195,7 @@ file_fdw_handler(PG_FUNCTION_ARGS)
> Datum
> file_fdw_validator(PG_FUNCTION_ARGS)
> {
> - List *options_list = untransformRelOptions(PG_GETARG_DATUM(0));
> + List *options_list = optionsTextArrayToDefList(PG_GETARG_DATUM(0));
> Oid catalog = PG_GETARG_OID(1);
> char *filename = NULL;
> DefElem *force_not_null = NULL;
> diff --git a/contrib/postgres_fdw/option.c b/contrib/postgres_fdw/option.c
> index 5bb1af4..bbd4167 100644
> --- a/contrib/postgres_fdw/option.c
> +++ b/contrib/postgres_fdw/option.c
> @@ -72,7 +72,7 @@ PG_FUNCTION_INFO_V1(postgres_fdw_validator);
> Datum
> postgres_fdw_validator(PG_FUNCTION_ARGS)
> {
> - List *options_list = untransformRelOptions(PG_GETARG_DATUM(0));
> + List *options_list = optionsTextArrayToDefList(PG_GETARG_DATUM(0));
> Oid catalog = PG_GETARG_OID(1);
> ListCell *cell;
>
> diff --git a/src/backend/access/brin/brin.c b/src/backend/access/brin/brin.c
> index ccc9fa0..5dd52a4 100644
> --- a/src/backend/access/brin/brin.c
> +++ b/src/backend/access/brin/brin.c
> @@ -20,7 +20,6 @@
> #include "access/brin_pageops.h"
> #include "access/brin_xlog.h"
> #include "access/relation.h"
> -#include "access/reloptions.h"
> #include "access/relscan.h"
> #include "access/table.h"
> #include "access/tableam.h"
> @@ -40,7 +39,6 @@
> #include "utils/memutils.h"
> #include "utils/rel.h"
>
> -
> /*
> * We use a BrinBuildState during initial construction of a BRIN index.
> * The running state is kept in a BrinMemTuple.
> @@ -119,7 +117,6 @@ brinhandler(PG_FUNCTION_ARGS)
> amroutine->amvacuumcleanup = brinvacuumcleanup;
> amroutine->amcanreturn = NULL;
> amroutine->amcostestimate = brincostestimate;
> - amroutine->amoptions = brinoptions;
> amroutine->amproperty = NULL;
> amroutine->ambuildphasename = NULL;
> amroutine->amvalidate = brinvalidate;
> @@ -134,6 +131,7 @@ brinhandler(PG_FUNCTION_ARGS)
> amroutine->amestimateparallelscan = NULL;
> amroutine->aminitparallelscan = NULL;
> amroutine->amparallelrescan = NULL;
> + amroutine->amreloptspecset = bringetreloptspecset;
>
> PG_RETURN_POINTER(amroutine);
> }
> @@ -963,23 +961,6 @@ brinvacuumcleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *stats)
> }
>
> /*
> - * reloptions processor for BRIN indexes
> - */
> -bytea *
> -brinoptions(Datum reloptions, bool validate)
> -{
> - static const relopt_parse_elt tab[] = {
> - {"pages_per_range", RELOPT_TYPE_INT, offsetof(BrinOptions, pagesPerRange)},
> - {"autosummarize", RELOPT_TYPE_BOOL, offsetof(BrinOptions, autosummarize)}
> - };
> -
> - return (bytea *) build_reloptions(reloptions, validate,
> - RELOPT_KIND_BRIN,
> - sizeof(BrinOptions),
> - tab, lengthof(tab));
> -}
> -
> -/*
> * SQL-callable function to scan through an index and summarize all ranges
> * that are not currently summarized.
> */
> @@ -1765,3 +1746,32 @@ check_null_keys(BrinValues *bval, ScanKey *nullkeys, int nnullkeys)
>
> return true;
> }
> +
> +static options_spec_set *brin_relopt_specset = NULL;
> +
> +void *
> +bringetreloptspecset(void)
> +{
> + if (brin_relopt_specset)
> + return brin_relopt_specset;
> + brin_relopt_specset = allocateOptionsSpecSet(NULL,
> + sizeof(BrinOptions), 2);
> +
> + optionsSpecSetAddInt(brin_relopt_specset, "pages_per_range",
> + "Number of pages that each page range covers in a BRIN index",
> + NoLock, /* since ALTER is not allowed
> + * no lock needed */
> + 0,
> + offsetof(BrinOptions, pagesPerRange),
> + BRIN_DEFAULT_PAGES_PER_RANGE,
> + BRIN_MIN_PAGES_PER_RANGE,
> + BRIN_MAX_PAGES_PER_RANGE);
> + optionsSpecSetAddBool(brin_relopt_specset, "autosummarize",
> + "Enables automatic summarization on this BRIN index",
> + AccessExclusiveLock,
> + 0,
> + offsetof(BrinOptions, autosummarize),
> + false);
> + return brin_relopt_specset;
> +}
> +
> diff --git a/src/backend/access/brin/brin_pageops.c b/src/backend/access/brin/brin_pageops.c
> index df9ffc2..1940b3d 100644
> --- a/src/backend/access/brin/brin_pageops.c
> +++ b/src/backend/access/brin/brin_pageops.c
> @@ -420,6 +420,9 @@ brin_doinsert(Relation idxrel, BlockNumber pagesPerRange,
> freespace = br_page_get_freespace(page);
>
> ItemPointerSet(&tid, blk, off);
> +
> +//elog(WARNING, "pages_per_range = %i", pagesPerRange);
> +
> brinSetHeapBlockItemptr(revmapbuf, pagesPerRange, heapBlk, tid);
> MarkBufferDirty(revmapbuf);
>
> diff --git a/src/backend/access/common/Makefile b/src/backend/access/common/Makefile
> index b9aff0c..78c9c5a 100644
> --- a/src/backend/access/common/Makefile
> +++ b/src/backend/access/common/Makefile
> @@ -18,6 +18,7 @@ OBJS = \
> detoast.o \
> heaptuple.o \
> indextuple.o \
> + options.o \
> printsimple.o \
> printtup.o \
> relation.o \
> diff --git a/src/backend/access/common/options.c b/src/backend/access/common/options.c
> new file mode 100644
> index 0000000..752cddc
> --- /dev/null
> +++ b/src/backend/access/common/options.c
> @@ -0,0 +1,1468 @@
> +/*-------------------------------------------------------------------------
> + *
> + * options.c
> + * An unifom, context-free API for processing name=value options. Used
> + * to process relation optons (reloptions), attribute options, opclass
> + * options, etc.
> + *
> + * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
> + * Portions Copyright (c) 1994, Regents of the University of California
> + *
> + *
> + * IDENTIFICATION
> + * src/backend/access/common/options.c
> + *
> + *-------------------------------------------------------------------------
> + */
> +
> +#include "postgres.h"
> +
> +#include "access/options.h"
> +#include "catalog/pg_type.h"
> +#include "commands/defrem.h"
> +#include "nodes/makefuncs.h"
> +#include "utils/builtins.h"
> +#include "utils/guc.h"
> +#include "utils/memutils.h"
> +#include "mb/pg_wchar.h"
> +
> +
> +/*
> + * OPTIONS SPECIFICATION and OPTION SPECIFICATION SET
> + *
> + * Each option is defined via Option Specification object (Option Spec).
> + * Option Spec should have all information that is needed for processing
> + * (parsing, validating, converting) of a single option. Implemented via set of
> + * option_spec_* structures.
> + *
> + * A set of Option Specs (Options Spec Set), defines all options available for
> + * certain object (certain relation kind for example). It is a list of
> + * Options Specs, plus validation functions that can be used to validate whole
> + * option set, if needed. Implemenred via options_spec_set structure and set of
> + * optionsSpecSetAdd* functions that are used for adding Option Specs items to
> + * a Set.
> + *
> + * NOTE: we choose therm "sepcification" instead of "definition" because therm
> + * "definition" is used for objects that came from lexer. So to avoud confusion
> + * here we have Option Specifications, and all "definitions" are from lexer.
> + */
> +
> +/*
> + * OPTION VALUES REPRESENTATIONS
> + *
> + * Option values usually came from lexer in form of defList obect, stored in
> + * pg_catalog as text array, and used when they are stored in memory as
> + * C-structure. These are different option values representations. Here goes
> + * brief description of all representations used in the code.
> + *
> + * Values
> + *
> + * Values are an internal representation that is used while converting
> + * Values between other representation. Value is called "parsed",
> + * when Value's value is converted to a proper type and validated, or is called
> + * "unparsed", when Value's value is stored as raw string that was obtained
> + * from the source without any cheks. In convertation funcion names first case
> + * is refered as Values, second case is refered as RawValues. Values is
> + * implemented as List of option_value C-structures.
> + *
> + * defList
> + *
> + * Options in form of definition List that comes from lexer. (For reloptions it
> + * is a part of SQL query that goes after WITH, SET or RESET keywords). Can be
> + * converted to and from Values using optionsDefListToRawValues and
> + * optionsTextArrayToRawValues functions.
> + *
> + * TEXT[]
> + *
> + * Options in form suitable for storig in TEXT[] field in DB. (E.g. reloptions
> + * are stores in pg_catalog.pg_class table in reloptions field). Can be converted
> + * to and from Values using optionsValuesToTextArray and optionsTextArrayToRawValues
> + * functions.
> + *
> + * Bytea
> + *
> + * Option data stored in C-structure with varlena header in the beginning of the
> + * structure. This representation is used to pass option values to the core
> + * postgres. It is fast to read, it can be cached and so on. Bytea rpresentation
> + * can be obtained from Vales using optionsValuesToBytea function, and can't be
> + * converted back.
> + */
> +
> +static option_spec_basic *allocateOptionSpec(int type, const char *name,
> + const char *desc, LOCKMODE lockmode,
> + option_spec_flags flags, int struct_offset);
> +
> +static void parse_one_option(option_value * option, const char *text_str,
> + int text_len, bool validate);
> +static void *optionsAllocateBytea(options_spec_set * spec_set, List *options);
> +
> +
> +static List *
> +optionsDefListToRawValues(List *defList, options_parse_mode
> + parse_mode);
> +static Datum optionsValuesToTextArray(List *options_values);
> +static List *optionsMergeOptionValues(List *old_options, List *new_options);
> +static bytea *optionsValuesToBytea(List *options, options_spec_set * spec_set);
> +List *optionsTextArrayToRawValues(Datum array_datum);
> +List *optionsParseRawValues(List *raw_values, options_spec_set * spec_set,
> + options_parse_mode mode);
> +
> +
> +/*
> + * Options spec_set functions
> + */
> +
> +/*
> + * Options catalog describes options available for certain object. Catalog has
> + * all necessary information for parsing transforming and validating options
> + * for an object. All parsing/validation/transformation functions should not
> + * know any details of option implementation for certain object, all this
> + * information should be stored in catalog instead and interpreted by
> + * pars/valid/transf functions blindly.
> + *
> + * The heart of the option catalog is an array of option definitions. Options
> + * definition specifies name of option, type, range of acceptable values, and
> + * default value.
> + *
> + * Options values can be one of the following types: bool, int, real, enum,
> + * string. For more info see "option_type" and "optionsCatalogAddItemYyyy"
> + * functions.
> + *
> + * Option definition flags allows to define parser behavior for special (or not
> + * so special) cases. See option_spec_flags for more info.
> + *
> + * Options and Lock levels:
> + *
> + * The default choice for any new option should be AccessExclusiveLock.
> + * In some cases the lock level can be reduced from there, but the lock
> + * level chosen should always conflict with itself to ensure that multiple
> + * changes aren't lost when we attempt concurrent changes.
> + * The choice of lock level depends completely upon how that parameter
> + * is used within the server, not upon how and when you'd like to change it.
> + * Safety first. Existing choices are documented here, and elsewhere in
> + * backend code where the parameters are used.
> + *
> + * In general, anything that affects the results obtained from a SELECT must be
> + * protected by AccessExclusiveLock.
> + *
> + * Autovacuum related parameters can be set at ShareUpdateExclusiveLock
> + * since they are only used by the AV procs and don't change anything
> + * currently executing.
> + *
> + * Fillfactor can be set because it applies only to subsequent changes made to
> + * data blocks, as documented in heapio.c
> + *
> + * n_distinct options can be set at ShareUpdateExclusiveLock because they
> + * are only used during ANALYZE, which uses a ShareUpdateExclusiveLock,
> + * so the ANALYZE will not be affected by in-flight changes. Changing those
> + * values has no affect until the next ANALYZE, so no need for stronger lock.
> + *
> + * Planner-related parameters can be set with ShareUpdateExclusiveLock because
> + * they only affect planning and not the correctness of the execution. Plans
> + * cannot be changed in mid-flight, so changes here could not easily result in
> + * new improved plans in any case. So we allow existing queries to continue
> + * and existing plans to survive, a small price to pay for allowing better
> + * plans to be introduced concurrently without interfering with users.
> + *
> + * Setting parallel_workers is safe, since it acts the same as
> + * max_parallel_workers_per_gather which is a USERSET parameter that doesn't
> + * affect existing plans or queries.
> +*/
> +
> +/*
> + * allocateOptionsSpecSet
> + * Creates new Option Spec Set object: Allocates memory and initializes
> + * structure members.
> + *
> + * Spec Set items can be add via allocateOptionSpec and optionSpecSetAddItem functions
> + * or by calling directly any of optionsSpecSetAdd* function (preferable way)
> + *
> + * namespace - Spec Set can be bind to certain namespace (E.g.
> + * namespace.option=value). Options from other namespaces will be ignored while
> + * processing. If set to NULL, no namespace will be used at all.
> + *
> + * size_of_bytea - size of target structure of Bytea options represenation
> + *
> + * num_items_expected - if you know expected number of Spec Set items set it here.
> + * Set to -1 in other cases. num_items_expected will be used for preallocating memory
> + * and will trigger error, if you try to add more items than you expected.
> + */
> +
> +options_spec_set *
> +allocateOptionsSpecSet(const char *namespace, int size_of_bytea, int num_items_expected)
> +{
> + MemoryContext oldcxt;
> + options_spec_set *spec_set;
> +
> + oldcxt = MemoryContextSwitchTo(TopMemoryContext);
> + spec_set = palloc(sizeof(options_spec_set));
> + if (namespace)
> + {
> + spec_set->namespace = palloc(strlen(namespace) + 1);
> + strcpy(spec_set->namespace, namespace);
> + }
> + else
> + spec_set->namespace = NULL;
> + if (num_items_expected > 0)
> + {
> + spec_set->num_allocated = num_items_expected;
> + spec_set->forbid_realloc = true;
> + spec_set->definitions = palloc(
> + spec_set->num_allocated * sizeof(option_spec_basic *));
> + }
> + else
> + {
> + spec_set->num_allocated = 0;
> + spec_set->forbid_realloc = false;
> + spec_set->definitions = NULL;
> + }
> + spec_set->num = 0;
> + spec_set->struct_size = size_of_bytea;
> + spec_set->postprocess_fun = NULL;
> + MemoryContextSwitchTo(oldcxt);
> + return spec_set;
> +}
> +
> +/*
> + * allocateOptionSpec
> + * Allocates a new Option Specifiation object of desired type and
> + * initialize the type-independent fields
> + */
> +static option_spec_basic *
> +allocateOptionSpec(int type, const char *name, const char *desc, LOCKMODE lockmode,
> + option_spec_flags flags, int struct_offset)
> +{
> + MemoryContext oldcxt;
> + size_t size;
> + option_spec_basic *newoption;
> +
> + oldcxt = MemoryContextSwitchTo(TopMemoryContext);
> +
> + switch (type)
> + {
> + case OPTION_TYPE_BOOL:
> + size = sizeof(option_spec_bool);
> + break;
> + case OPTION_TYPE_INT:
> + size = sizeof(option_spec_int);
> + break;
> + case OPTION_TYPE_REAL:
> + size = sizeof(option_spec_real);
> + break;
> + case OPTION_TYPE_ENUM:
> + size = sizeof(option_spec_enum);
> + break;
> + case OPTION_TYPE_STRING:
> + size = sizeof(option_spec_string);
> + break;
> + default:
> + elog(ERROR, "unsupported reloption type %d", type);
> + return NULL; /* keep compiler quiet */
> + }
> +
> + newoption = palloc(size);
> +
> + newoption->name = pstrdup(name);
> + if (desc)
> + newoption->desc = pstrdup(desc);
> + else
> + newoption->desc = NULL;
> + newoption->type = type;
> + newoption->lockmode = lockmode;
> + newoption->flags = flags;
> + newoption->struct_offset = struct_offset;
> +
> + MemoryContextSwitchTo(oldcxt);
> +
> + return newoption;
> +}
> +
> +/*
> + * optionSpecSetAddItem
> + * Adds pre-created Option Specification objec to the Spec Set
> + */
> +static void
> +optionSpecSetAddItem(option_spec_basic * newoption,
> + options_spec_set * spec_set)
> +{
> + if (spec_set->num >= spec_set->num_allocated)
> + {
> + MemoryContext oldcxt;
> +
> + Assert(!spec_set->forbid_realloc);
> + oldcxt = MemoryContextSwitchTo(TopMemoryContext);
> +
> + if (spec_set->num_allocated == 0)
> + {
> + spec_set->num_allocated = 8;
> + spec_set->definitions = palloc(
> + spec_set->num_allocated * sizeof(option_spec_basic *));
> + }
> + else
> + {
> + spec_set->num_allocated *= 2;
> + spec_set->definitions = repalloc(spec_set->definitions,
> + spec_set->num_allocated * sizeof(option_spec_basic *));
> + }
> + MemoryContextSwitchTo(oldcxt);
> + }
> + spec_set->definitions[spec_set->num] = newoption;
> + spec_set->num++;
> +}
> +
> +
> +/*
> + * optionsSpecSetAddBool
> + * Adds boolean Option Specification entry to the Spec Set
> + */
> +void
> +optionsSpecSetAddBool(options_spec_set * spec_set, const char *name, const char *desc,
> + LOCKMODE lockmode, option_spec_flags flags,
> + int struct_offset, bool default_val)
> +{
> + option_spec_bool *spec_set_item;
> +
> + spec_set_item = (option_spec_bool *)
> + allocateOptionSpec(OPTION_TYPE_BOOL, name, desc, lockmode,
> + flags, struct_offset);
> +
> + spec_set_item->default_val = default_val;
> +
> + optionSpecSetAddItem((option_spec_basic *) spec_set_item, spec_set);
> +}
> +
> +/*
> + * optionsSpecSetAddInt
> + * Adds integer Option Specification entry to the Spec Set
> + */
> +void
> +optionsSpecSetAddInt(options_spec_set * spec_set, const char *name,
> + const char *desc, LOCKMODE lockmode, option_spec_flags flags,
> + int struct_offset, int default_val, int min_val, int max_val)
> +{
> + option_spec_int *spec_set_item;
> +
> + spec_set_item = (option_spec_int *)
> + allocateOptionSpec(OPTION_TYPE_INT, name, desc, lockmode,
> + flags, struct_offset);
> +
> + spec_set_item->default_val = default_val;
> + spec_set_item->min = min_val;
> + spec_set_item->max = max_val;
> +
> + optionSpecSetAddItem((option_spec_basic *) spec_set_item, spec_set);
> +}
> +
> +/*
> + * optionsSpecSetAddReal
> + * Adds float Option Specification entry to the Spec Set
> + */
> +void
> +optionsSpecSetAddReal(options_spec_set * spec_set, const char *name, const char *desc,
> + LOCKMODE lockmode, option_spec_flags flags, int struct_offset,
> + double default_val, double min_val, double max_val)
> +{
> + option_spec_real *spec_set_item;
> +
> + spec_set_item = (option_spec_real *)
> + allocateOptionSpec(OPTION_TYPE_REAL, name, desc, lockmode,
> + flags, struct_offset);
> +
> + spec_set_item->default_val = default_val;
> + spec_set_item->min = min_val;
> + spec_set_item->max = max_val;
> +
> + optionSpecSetAddItem((option_spec_basic *) spec_set_item, spec_set);
> +}
> +
> +/*
> + * optionsSpecSetAddEnum
> + * Adds enum Option Specification entry to the Spec Set
> + *
> + * The members array must have a terminating NULL entry.
> + *
> + * The detailmsg is shown when unsupported values are passed, and has this
> + * form: "Valid values are \"foo\", \"bar\", and \"bar\"."
> + *
> + * The members array and detailmsg are not copied -- caller must ensure that
> + * they are valid throughout the life of the process.
> + */
> +
> +void
> +optionsSpecSetAddEnum(options_spec_set * spec_set, const char *name, const char *desc,
> + LOCKMODE lockmode, option_spec_flags flags, int struct_offset,
> + opt_enum_elt_def * members, int default_val, const char *detailmsg)
> +{
> + option_spec_enum *spec_set_item;
> +
> + spec_set_item = (option_spec_enum *)
> + allocateOptionSpec(OPTION_TYPE_ENUM, name, desc, lockmode,
> + flags, struct_offset);
> +
> + spec_set_item->default_val = default_val;
> + spec_set_item->members = members;
> + spec_set_item->detailmsg = detailmsg;
> +
> + optionSpecSetAddItem((option_spec_basic *) spec_set_item, spec_set);
> +}
> +
> +/*
> + * optionsSpecSetAddString
> + * Adds string Option Specification entry to the Spec Set
> + *
> + * "validator" is an optional function pointer that can be used to test the
> + * validity of the values. It must elog(ERROR) when the argument string is
> + * not acceptable for the variable. Note that the default value must pass
> + * the validation.
> + */
> +void
> +optionsSpecSetAddString(options_spec_set * spec_set, const char *name, const char *desc,
> + LOCKMODE lockmode, option_spec_flags flags, int struct_offset,
> + const char *default_val, validate_string_option validator)
> +{
> + option_spec_string *spec_set_item;
> +
> + /* make sure the validator/default combination is sane */
> + if (validator)
> + (validator) (default_val);
> +
> + spec_set_item = (option_spec_string *)
> + allocateOptionSpec(OPTION_TYPE_STRING, name, desc, lockmode,
> + flags, struct_offset);
> + spec_set_item->validate_cb = validator;
> +
> + if (default_val)
> + spec_set_item->default_val = MemoryContextStrdup(TopMemoryContext,
> + default_val);
> + else
> + spec_set_item->default_val = NULL;
> + optionSpecSetAddItem((option_spec_basic *) spec_set_item, spec_set);
> +}
> +
> +
> +/*
> + * Options transform functions
> + */
> +
> +/* FIXME this comment should be updated
> + * Option values exists in five representations: DefList, TextArray, Values and
> + * Bytea:
> + *
> + * DefList: Is a List of DefElem structures, that comes from syntax analyzer.
> + * It can be transformed to Values representation for further parsing and
> + * validating
> + *
> + * Values: A List of option_value structures. Is divided into two subclasses:
> + * RawValues, when values are already transformed from DefList or TextArray,
> + * but not parsed yet. (In this case you should use raw_name and raw_value
> + * structure members to see option content). ParsedValues (or just simple
> + * Values) is crated after finding a definition for this option in a spec_set
> + * and after parsing of the raw value. For ParsedValues content is stored in
> + * values structure member, and name can be taken from option definition in gen
> + * structure member. Actually Value list can have both Raw and Parsed values,
> + * as we do not validate options that came from database, and db option that
> + * does not exist in spec_set is just ignored, and kept as RawValues
> + *
> + * TextArray: The representation in which options for existing object comes
> + * and goes from/to database; for example from pg_class.reloptions. It is a
> + * plain TEXT[] db object with name=value text inside. This representation can
> + * be transformed into Values for further processing, using options spec_set.
> + *
> + * Bytea: Is a binary representation of options. Each object that has code that
> + * uses options, should create a C-structure for this options, with varlen
> + * 4-byte header in front of the data; all items of options spec_set should have
> + * an offset of a corresponding binary data in this structure, so transform
> + * function can put this data in the correct place. One can transform options
> + * data from values representation into Bytea, using spec_set data, and then use
> + * it as a usual Datum object, when needed. This Datum should be cached
> + * somewhere (for example in rel->rd_options for relations) when object that
> + * has option is loaded from db.
> + */
> +
> +
> +/* optionsDefListToRawValues
> + * Converts option values that came from syntax analyzer (DefList) into
> + * Values List.
> + *
> + * No parsing is done here except for checking that RESET syntax is correct
> + * (syntax analyzer do not see difference between SET and RESET cases, we
> + * should treat it here manually
> + */
> +static List *
> +optionsDefListToRawValues(List *defList, options_parse_mode parse_mode)
> +{
> + ListCell *cell;
> + List *result = NIL;
> +
> + foreach(cell, defList)
> + {
> + option_value *option_dst;
> + DefElem *def = (DefElem *) lfirst(cell);
> + char *value;
> +
> + option_dst = palloc(sizeof(option_value));
> +
> + if (def->defnamespace)
> + {
> + option_dst->namespace = palloc(strlen(def->defnamespace) + 1);
> + strcpy(option_dst->namespace, def->defnamespace);
> + }
> + else
> + {
> + option_dst->namespace = NULL;
> + }
> + option_dst->raw_name = palloc(strlen(def->defname) + 1);
> + strcpy(option_dst->raw_name, def->defname);
> +
> + if (parse_mode & OPTIONS_PARSE_MODE_FOR_RESET)
> + {
> + /*
> + * If this option came from RESET statement we should throw error
> + * it it brings us name=value data, as syntax analyzer do not
> + * prevent it
> + */
> + if (def->arg != NULL)
> + ereport(ERROR,
> + (errcode(ERRCODE_SYNTAX_ERROR),
> + errmsg("RESET must not include values for parameters")));
> +
> + option_dst->status = OPTION_VALUE_STATUS_FOR_RESET;
> + }
> + else
> + {
> + /*
> + * For SET statement we should treat (name) expression as if it is
> + * actually (name=true) so do it here manually. In other cases
> + * just use value as we should use it
> + */
> + option_dst->status = OPTION_VALUE_STATUS_RAW;
> + if (def->arg != NULL)
> + value = defGetString(def);
> + else
> + value = "true";
> + option_dst->raw_value = palloc(strlen(value) + 1);
> + strcpy(option_dst->raw_value, value);
> + }
> +
> + result = lappend(result, option_dst);
> + }
> + return result;
> +}
> +
> +/*
> + * optionsValuesToTextArray
> + * Converts List of option_values into TextArray
> + *
> + * Convertation is made to put options into database (e.g. in
> + * pg_class.reloptions for all relation options)
> + */
> +
> +Datum
> +optionsValuesToTextArray(List *options_values)
> +{
> + ArrayBuildState *astate = NULL;
> + ListCell *cell;
> + Datum result;
> +
> + foreach(cell, options_values)
> + {
> + option_value *option = (option_value *) lfirst(cell);
> + const char *name;
> + char *value;
> + text *t;
> + int len;
> +
> + /*
> + * Raw value were not cleared while parsing, so instead of converting
> + * it back, just use it to store value as text
> + */
> + value = option->raw_value;
> +
> + Assert(option->status != OPTION_VALUE_STATUS_EMPTY);
> +
> + /*
> + * Name will be taken from option definition, if option were parsed or
> + * from raw_name if option were not parsed for some reason
> + */
> + if (option->status == OPTION_VALUE_STATUS_PARSED)
> + name = option->gen->name;
> + else
> + name = option->raw_name;
> +
> + /*
> + * Now build "name=value" string and append it to the array
> + */
> + len = VARHDRSZ + strlen(name) + strlen(value) + 1;
> + t = (text *) palloc(len + 1);
> + SET_VARSIZE(t, len);
> + sprintf(VARDATA(t), "%s=%s", name, value);
> + astate = accumArrayResult(astate, PointerGetDatum(t), false,
> + TEXTOID, CurrentMemoryContext);
> + }
> + if (astate)
> + result = makeArrayResult(astate, CurrentMemoryContext);
> + else
> + result = (Datum) 0;
> +
> + return result;
> +}
> +
> +/*
> + * optionsTextArrayToRawValues
> + * Converts options from TextArray format into RawValues list.
> + *
> + * This function is used to convert options data that comes from database to
> + * List of option_values, for further parsing, and, in the case of ALTER
> + * command, for merging with new option values.
> + */
> +List *
> +optionsTextArrayToRawValues(Datum array_datum)
> +{
> + List *result = NIL;
> +
> + if (PointerIsValid(DatumGetPointer(array_datum)))
> + {
> + ArrayType *array = DatumGetArrayTypeP(array_datum);
> + Datum *options;
> + int noptions;
> + int i;
> +
> + deconstruct_array(array, TEXTOID, -1, false, 'i',
> + &options, NULL, &noptions);
> +
> + for (i = 0; i < noptions; i++)
> + {
> + option_value *option_dst;
> + char *text_str = VARDATA(options[i]);
> + int text_len = VARSIZE(options[i]) - VARHDRSZ;
> + int i;
> + int name_len = -1;
> + char *name;
> + int raw_value_len;
> + char *raw_value;
> +
> + /*
> + * Find position of '=' sign and treat id as a separator between
> + * name and value in "name=value" item
> + */
> + for (i = 0; i < text_len; i = i + pg_mblen(text_str))
> + {
> + if (text_str[i] == '=')
> + {
> + name_len = i;
> + break;
> + }
> + }
> + Assert(name_len >= 1); /* Just in case */
> +
> + raw_value_len = text_len - name_len - 1;
> +
> + /*
> + * Copy name from src
> + */
> + name = palloc(name_len + 1);
> + memcpy(name, text_str, name_len);
> + name[name_len] = '\0';
> +
> + /*
> + * Copy value from src
> + */
> + raw_value = palloc(raw_value_len + 1);
> + memcpy(raw_value, text_str + name_len + 1, raw_value_len);
> + raw_value[raw_value_len] = '\0';
> +
> + /*
> + * Create new option_value item
> + */
> + option_dst = palloc(sizeof(option_value));
> + option_dst->status = OPTION_VALUE_STATUS_RAW;
> + option_dst->raw_name = name;
> + option_dst->raw_value = raw_value;
> + option_dst->namespace = NULL;
> +
> + result = lappend(result, option_dst);
> + }
> + }
> + return result;
> +}
> +
> +/*
> + * optionsMergeOptionValues
> + * Merges two lists of option_values into one list
> + *
> + * This function is used to merge two Values list into one. It is used for all
> + * kinds of ALTER commands when existing options are merged|replaced with new
> + * options list. This function also process RESET variant of ALTER command. It
> + * merges two lists as usual, and then removes all items with RESET flag on.
> + *
> + * Both incoming lists will be destroyed while merging
> + */
> +static List *
> +optionsMergeOptionValues(List *old_options, List *new_options)
> +{
> + List *result = NIL;
> + ListCell *old_cell;
> + ListCell *new_cell;
> +
> + /*
> + * First add to result all old options that are not mentioned in new list
> + */
> + foreach(old_cell, old_options)
> + {
> + bool found;
> + const char *old_name;
> + option_value *old_option;
> +
> + old_option = (option_value *) lfirst(old_cell);
> + if (old_option->status == OPTION_VALUE_STATUS_PARSED)
> + old_name = old_option->gen->name;
> + else
> + old_name = old_option->raw_name;
> +
> + /*
> + * Looking for a new option with same name
> + */
> + found = false;
> + foreach(new_cell, new_options)
> + {
> + option_value *new_option;
> + const char *new_name;
> +
> + new_option = (option_value *) lfirst(new_cell);
> + if (new_option->status == OPTION_VALUE_STATUS_PARSED)
> + new_name = new_option->gen->name;
> + else
> + new_name = new_option->raw_name;
> +
> + if (strcmp(new_name, old_name) == 0)
> + {
> + found = true;
> + break;
> + }
> + }
> + if (!found)
> + result = lappend(result, old_option);
> + }
> + /*
> + * Now add all to result all new options that are not designated for reset
> + */
> + foreach(new_cell, new_options)
> + {
> + option_value *new_option;
> + new_option = (option_value *) lfirst(new_cell);
> +
> + if(new_option->status != OPTION_VALUE_STATUS_FOR_RESET)
> + result = lappend(result, new_option);
> + }
> + return result;
> +}
> +
> +/*
> + * optionsDefListValdateNamespaces
> + * Function checks that all options represented as DefList has no
> + * namespaces or have namespaces only from allowed list
> + *
> + * Function accept options as DefList and NULL terminated list of allowed
> + * namespaces. It throws an error if not proper namespace was found.
> + *
> + * This function actually used only for tables with it's toast. namespace
> + */
> +void
> +optionsDefListValdateNamespaces(List *defList, char **allowed_namespaces)
> +{
> + ListCell *cell;
> +
> + foreach(cell, defList)
> + {
> + DefElem *def = (DefElem *) lfirst(cell);
> +
> + /*
> + * Checking namespace only for options that have namespaces. Options
> + * with no namespaces are always accepted
> + */
> + if (def->defnamespace)
> + {
> + bool found = false;
> + int i = 0;
> +
> + while (allowed_namespaces[i])
> + {
> + if (strcmp(def->defnamespace,
> + allowed_namespaces[i]) == 0)
> + {
> + found = true;
> + break;
> + }
> + i++;
> + }
> + if (!found)
> + ereport(ERROR,
> + (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> + errmsg("unrecognized parameter namespace \"%s\"",
> + def->defnamespace)));
> + }
> + }
> +}
> +
> +/*
> + * optionsDefListFilterNamespaces
> + * Iterates over DefList, choose items with specified namespace and adds
> + * them to a result List
> + *
> + * This function does not destroy source DefList but does not create copies
> + * of List nodes.
> + * It is actually used only for tables, in order to split toast and heap
> + * reloptions, so each one can be stored in on it's own pg_class record
> + */
> +List *
> +optionsDefListFilterNamespaces(List *defList, const char *namespace)
> +{
> + ListCell *cell;
> + List *result = NIL;
> +
> + foreach(cell, defList)
> + {
> + DefElem *def = (DefElem *) lfirst(cell);
> +
> + if ((!namespace && !def->defnamespace) ||
> + (namespace && def->defnamespace &&
> + strcmp(namespace, def->defnamespace) == 0))
> + {
> + result = lappend(result, def);
> + }
> + }
> + return result;
> +}
> +
> +/*
> + * optionsTextArrayToDefList
> + * Convert the text-array format of reloptions into a List of DefElem.
> + */
> +List *
> +optionsTextArrayToDefList(Datum options)
> +{
> + List *result = NIL;
> + ArrayType *array;
> + Datum *optiondatums;
> + int noptions;
> + int i;
> +
> + /* Nothing to do if no options */
> + if (!PointerIsValid(DatumGetPointer(options)))
> + return result;
> +
> + array = DatumGetArrayTypeP(options);
> +
> + deconstruct_array(array, TEXTOID, -1, false, 'i',
> + &optiondatums, NULL, &noptions);
> +
> + for (i = 0; i < noptions; i++)
> + {
> + char *s;
> + char *p;
> + Node *val = NULL;
> +
> + s = TextDatumGetCString(optiondatums[i]);
> + p = strchr(s, '=');
> + if (p)
> + {
> + *p++ = '\0';
> + val = (Node *) makeString(pstrdup(p));
> + }
> + result = lappend(result, makeDefElem(pstrdup(s), val, -1));
> + }
> +
> + return result;
> +}
> +
> +/* FIXME write comment here */
> +
> +Datum
> +optionsDefListToTextArray(List *defList)
> +{
> + ListCell *cell;
> + Datum result;
> + ArrayBuildState *astate = NULL;
> +
> + foreach(cell, defList)
> + {
> + DefElem *def = (DefElem *) lfirst(cell);
> + const char *name = def->defname;
> + const char *value;
> + text *t;
> + int len;
> +
> + if (def->arg != NULL)
> + value = defGetString(def);
> + else
> + value = "true";
> +
> + if (def->defnamespace)
> + {
> + Assert(false); /* Should not get here */
> + /* This function is used for backward compatibility in the place were namespases are not allowed */
> + return (Datum) 0;
> + }
> + len = VARHDRSZ + strlen(name) + strlen(value) + 1;
> + t = (text *) palloc(len + 1);
> + SET_VARSIZE(t, len);
> + sprintf(VARDATA(t), "%s=%s", name, value);
> + astate = accumArrayResult(astate, PointerGetDatum(t), false,
> + TEXTOID, CurrentMemoryContext);
> +
> + }
> + if (astate)
> + result = makeArrayResult(astate, CurrentMemoryContext);
> + else
> + result = (Datum) 0;
> + return result;
> +}
> +
> +
> +/*
> + * optionsParseRawValues
> + * Parses and vlaidates (if proper flag is set) option_values. As a result
> + * caller will get the list of parsed (or partly parsed) option_values
> + *
> + * This function is used in cases when caller gets raw values from db or
> + * syntax and want to parse them.
> + * This function uses option_spec_set to get information about how each option
> + * should be parsed.
> + * If validate mode is off, function found an option that do not have proper
> + * option_spec_set entry, this option kept unparsed (if some garbage came from
> + * the DB, we should put it back there)
> + *
> + * This function destroys incoming list.
> + */
> +List *
> +optionsParseRawValues(List *raw_values, options_spec_set * spec_set,
> + options_parse_mode mode)
> +{
> + ListCell *cell;
> + List *result = NIL;
> + bool *is_set;
> + int i;
> + bool validate = mode & OPTIONS_PARSE_MODE_VALIDATE;
> + bool for_alter = mode & OPTIONS_PARSE_MODE_FOR_ALTER;
> +
> +
> + is_set = palloc0(sizeof(bool) * spec_set->num);
> + foreach(cell, raw_values)
> + {
> + option_value *option = (option_value *) lfirst(cell);
> + bool found = false;
> + bool skip = false;
> +
> +
> + if (option->status == OPTION_VALUE_STATUS_PARSED)
> + {
> + /*
> + * This can happen while ALTER, when new values were already
> + * parsed, but old values merged from DB are still raw
> + */
> + result = lappend(result, option);
> + continue;
> + }
> + if (validate && option->namespace && (!spec_set->namespace ||
> + strcmp(spec_set->namespace, option->namespace) != 0))
> + {
> + ereport(ERROR,
> + (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> + errmsg("unrecognized parameter namespace \"%s\"",
> + option->namespace)));
> + }
> +
> + for (i = 0; i < spec_set->num; i++)
> + {
> + option_spec_basic *definition = spec_set->definitions[i];
> +
> + if (strcmp(option->raw_name,
> + definition->name) == 0)
> + {
> + /*
> + * Skip option with "ignore" flag, as it is processed
> + * somewhere else. (WITH OIDS special case)
> + */
> + if (definition->flags & OPTION_DEFINITION_FLAG_IGNORE)
> + {
> + found = true;
> + skip = true;
> + break;
> + }
> +
> + /*
> + * Reject option as if it was not in spec_set. Needed for cases
> + * when option should have default value, but should not be
> + * changed
> + */
> + if (definition->flags & OPTION_DEFINITION_FLAG_REJECT)
> + {
> + found = false;
> + break;
> + }
> +
> + if (validate && is_set[i])
> + {
> + ereport(ERROR,
> + (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> + errmsg("parameter \"%s\" specified more than once",
> + option->raw_name)));
> + }
> + if ((for_alter) &&
> + (definition->flags & OPTION_DEFINITION_FLAG_FORBID_ALTER))
> + {
> + ereport(ERROR,
> + (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> + errmsg("changing parameter \"%s\" is not allowed",
> + definition->name)));
> + }
> + if (option->status == OPTION_VALUE_STATUS_FOR_RESET)
> + {
> + /*
> + * For RESET options do not need further processing so
> + * mark it found and stop searching
> + */
> + found = true;
> + break;
> + }
> + pfree(option->raw_name);
> + option->raw_name = NULL;
> + option->gen = definition;
> + parse_one_option(option, NULL, -1, validate);
> + is_set[i] = true;
> + found = true;
> + break;
> + }
> + }
> + if (!found)
> + {
> + if (validate)
> + {
> + if (option->namespace)
> + ereport(ERROR,
> + (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> + errmsg("unrecognized parameter \"%s.%s\"",
> + option->namespace, option->raw_name)));
> + else
> + ereport(ERROR,
> + (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> + errmsg("unrecognized parameter \"%s\"",
> + option->raw_name)));
> + } else
> + {
> + /* RESET is always in non-validating mode, unkown names should
> + * be ignored. This is traditional behaviour of postgres/
> + * FIXME may be it should be changed someday
> + */
> + if (option->status == OPTION_VALUE_STATUS_FOR_RESET)
> + {
> + skip = true;
> + }
> + }
> + /*
> + * In other cases, if we are parsing not in validate mode, then
> + * we should keep unknown node, because non-validate mode is for
> + * data that is already in the DB and should not be changed after
> + * altering another entries
> + */
> + }
> + if (!skip)
> + result = lappend(result, option);
> + }
> + return result;
> +}
> +
> +/*
> + * parse_one_option
> + *
> + * Subroutine for optionsParseRawValues, to parse and validate a
> + * single option's value
> + */
> +static void
> +parse_one_option(option_value * option, const char *text_str, int text_len,
> + bool validate)
> +{
> + char *value;
> + bool parsed;
> +
> + value = option->raw_value;
> +
> + switch (option->gen->type)
> + {
> + case OPTION_TYPE_BOOL:
> + {
> + parsed = parse_bool(value, &option->values.bool_val);
> + if (validate && !parsed)
> + ereport(ERROR,
> + (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> + errmsg("invalid value for boolean option \"%s\": %s",
> + option->gen->name, value)));
> + }
> + break;
> + case OPTION_TYPE_INT:
> + {
> + option_spec_int *optint =
> + (option_spec_int *) option->gen;
> +
> + parsed = parse_int(value, &option->values.int_val, 0, NULL);
> + if (validate && !parsed)
> + ereport(ERROR,
> + (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> + errmsg("invalid value for integer option \"%s\": %s",
> + option->gen->name, value)));
> + if (validate && (option->values.int_val < optint->min ||
> + option->values.int_val > optint->max))
> + ereport(ERROR,
> + (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> + errmsg("value %s out of bounds for option \"%s\"",
> + value, option->gen->name),
> + errdetail("Valid values are between \"%d\" and \"%d\".",
> + optint->min, optint->max)));
> + }
> + break;
> + case OPTION_TYPE_REAL:
> + {
> + option_spec_real *optreal =
> + (option_spec_real *) option->gen;
> +
> + parsed = parse_real(value, &option->values.real_val, 0, NULL);
> + if (validate && !parsed)
> + ereport(ERROR,
> + (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> + errmsg("invalid value for floating point option \"%s\": %s",
> + option->gen->name, value)));
> + if (validate && (option->values.real_val < optreal->min ||
> + option->values.real_val > optreal->max))
> + ereport(ERROR,
> + (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> + errmsg("value %s out of bounds for option \"%s\"",
> + value, option->gen->name),
> + errdetail("Valid values are between \"%f\" and \"%f\".",
> + optreal->min, optreal->max)));
> + }
> + break;
> + case OPTION_TYPE_ENUM:
> + {
> + option_spec_enum *optenum =
> + (option_spec_enum *) option->gen;
> + opt_enum_elt_def *elt;
> + parsed = false;
> + for (elt = optenum->members; elt->string_val; elt++)
> + {
> + if (strcmp(value, elt->string_val) == 0)
> + {
> + option->values.enum_val = elt->symbol_val;
> + parsed = true;
> + break;
> + }
> + }
> + if (!parsed)
> + {
> + ereport(ERROR,
> + (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> + errmsg("invalid value for enum option \"%s\": %s",
> + option->gen->name, value),
> + optenum->detailmsg ?
> + errdetail_internal("%s", _(optenum->detailmsg)) : 0));
> + }
> + }
> + break;
> + case OPTION_TYPE_STRING:
> + {
> + option_spec_string *optstring =
> + (option_spec_string *) option->gen;
> +
> + option->values.string_val = value;
> + if (validate && optstring->validate_cb)
> + (optstring->validate_cb) (value);
> + parsed = true;
> + }
> + break;
> + default:
> + elog(ERROR, "unsupported reloption type %d", option->gen->type);
> + parsed = true; /* quiet compiler */
> + break;
> + }
> +
> + if (parsed)
> + option->status = OPTION_VALUE_STATUS_PARSED;
> +
> +}
> +
> +/*
> + * optionsAllocateBytea
> + * Allocates memory for bytea options representation
> + *
> + * Function allocates memory for byrea structure of an option, plus adds space
> + * for values of string options. We should keep all data including string
> + * values in the same memory chunk, because Cache code copies bytea option
> + * data from one MemoryConext to another without knowing about it's internal
> + * structure, so it would not be able to copy string values if they are outside
> + * of bytea memory chunk.
> + */
> +static void *
> +optionsAllocateBytea(options_spec_set * spec_set, List *options)
> +{
> + Size size;
> + int i;
> + ListCell *cell;
> + int length;
> + void *res;
> +
> + size = spec_set->struct_size;
> +
> + /* Calculate size needed to store all string values for this option */
> + for (i = 0; i < spec_set->num; i++)
> + {
> + option_spec_basic *definition = spec_set->definitions[i];
> + bool found = false;
> + option_value *option;
> +
> + /* Not interested in non-string options, skipping */
> + if (definition->type != OPTION_TYPE_STRING)
> + continue;
> +
> + /*
> + * Trying to find option_value that references definition spec_set
> + * entry
> + */
> + foreach(cell, options)
> + {
> + option = (option_value *) lfirst(cell);
> + if (option->status == OPTION_VALUE_STATUS_PARSED &&
> + strcmp(option->gen->name, definition->name) == 0)
> + {
> + found = true;
> + break;
> + }
> + }
> + if (found)
> + /* If found, it'value will be stored */
> + length = strlen(option->values.string_val) + 1;
> + else
> + /* If not found, then there would be default value there */
> + if (((option_spec_string *) definition)->default_val)
> + length = strlen(
> + ((option_spec_string *) definition)->default_val) + 1;
> + else
> + length = 0;
> + /* Add total length of all string values to basic size */
> + size += length;
> + }
> +
> + res = palloc0(size);
> + SET_VARSIZE(res, size);
> + return res;
> +}
> +
> +/*
> + * optionsValuesToBytea
> + * Converts options from List of option_values to binary bytea structure
> + *
> + * Convertation goes according to options_spec_set: each spec_set item
> + * has offset value, and option value in binary mode is written to the
> + * structure with that offset.
> + *
> + * More special case is string values. Memory for bytea structure is allocated
> + * by optionsAllocateBytea which adds some more space for string values to
> + * the size of original structure. All string values are copied there and
> + * inside the bytea structure an offset to that value is kept.
> + *
> + */
> +static bytea *
> +optionsValuesToBytea(List *options, options_spec_set * spec_set)
> +{
> + char *data;
> + char *string_values_buffer;
> + int i;
> +
> + data = optionsAllocateBytea(spec_set, options);
> +
> + /* place for string data starts right after original structure */
> + string_values_buffer = data + spec_set->struct_size;
> +
> + for (i = 0; i < spec_set->num; i++)
> + {
> + option_value *found = NULL;
> + ListCell *cell;
> + char *item_pos;
> + option_spec_basic *definition = spec_set->definitions[i];
> +
> + if (definition->flags & OPTION_DEFINITION_FLAG_IGNORE)
> + continue;
> +
> + /* Calculate the position of the item inside the structure */
> + item_pos = data + definition->struct_offset;
> +
> + /* Looking for the corresponding option from options list */
> + foreach(cell, options)
> + {
> + option_value *option = (option_value *) lfirst(cell);
> +
> + if (option->status == OPTION_VALUE_STATUS_RAW)
> + continue; /* raw can come from db. Just ignore them then */
> + Assert(option->status != OPTION_VALUE_STATUS_EMPTY);
> +
> + if (strcmp(definition->name, option->gen->name) == 0)
> + {
> + found = option;
> + break;
> + }
> + }
> + /* writing to the proper position either option value or default val */
> + switch (definition->type)
> + {
> + case OPTION_TYPE_BOOL:
> + *(bool *) item_pos = found ?
> + found->values.bool_val :
> + ((option_spec_bool *) definition)->default_val;
> + break;
> + case OPTION_TYPE_INT:
> + *(int *) item_pos = found ?
> + found->values.int_val :
> + ((option_spec_int *) definition)->default_val;
> + break;
> + case OPTION_TYPE_REAL:
> + *(double *) item_pos = found ?
> + found->values.real_val :
> + ((option_spec_real *) definition)->default_val;
> + break;
> + case OPTION_TYPE_ENUM:
> + *(int *) item_pos = found ?
> + found->values.enum_val :
> + ((option_spec_enum *) definition)->default_val;
> + break;
> +
> + case OPTION_TYPE_STRING:
> + {
> + /*
> + * For string options: writing string value at the string
> + * buffer after the structure, and storing and offset to
> + * that value
> + */
> + char *value = NULL;
> +
> + if (found)
> + value = found->values.string_val;
> + else
> + value = ((option_spec_string *) definition)
> + ->default_val;
> + *(int *) item_pos = value ?
> + string_values_buffer - data :
> + OPTION_STRING_VALUE_NOT_SET_OFFSET;
> + if (value)
> + {
> + strcpy(string_values_buffer, value);
> + string_values_buffer += strlen(value) + 1;
> + }
> + }
> + break;
> + default:
> + elog(ERROR, "unsupported reloption type %d",
> + definition->type);
> + break;
> + }
> + }
> + return (void *) data;
> +}
> +
> +
> +/*
> + * transformOptions
> + * This function is used by src/backend/commands/Xxxx in order to process
> + * new option values, merge them with existing values (in the case of
> + * ALTER command) and prepare to put them [back] into DB
> + */
> +
> +Datum
> +transformOptions(options_spec_set * spec_set, Datum oldOptions,
> + List *defList, options_parse_mode parse_mode)
> +{
> + Datum result;
> + List *new_values;
> + List *old_values;
> + List *merged_values;
> +
> + /*
> + * Parse and validate New values
> + */
> + new_values = optionsDefListToRawValues(defList, parse_mode);
> + if (! (parse_mode & OPTIONS_PARSE_MODE_FOR_RESET))
> + {
> + /* FIXME: postgres usual behaviour vas not to vaidate names that
> + * came from RESET command. Once this behavious should be changed,
> + * I guess. But for now we keep it as it was.
> + */
> + parse_mode|= OPTIONS_PARSE_MODE_VALIDATE;
> + }
> + new_values = optionsParseRawValues(new_values, spec_set, parse_mode);
> +
> + /*
> + * Old values exists in case of ALTER commands. Transform them to raw
> + * values and merge them with new_values, and parse it.
> + */
> + if (PointerIsValid(DatumGetPointer(oldOptions)))
> + {
> + old_values = optionsTextArrayToRawValues(oldOptions);
> + merged_values = optionsMergeOptionValues(old_values, new_values);
> +
> + /*
> + * Parse options only after merging in order not to parse options that
> + * would be removed by merging later
> + */
> + merged_values = optionsParseRawValues(merged_values, spec_set, 0);
> + }
> + else
> + {
> + merged_values = new_values;
> + }
> +
> + /*
> + * If we have postprocess_fun function defined in spec_set, then there
> + * might be some custom options checks there, with error throwing. So we
> + * should do it here to throw these errors while CREATing or ALTERing
> + * options
> + */
> + if (spec_set->postprocess_fun)
> + {
> + bytea *data = optionsValuesToBytea(merged_values, spec_set);
> +
> + spec_set->postprocess_fun(data, true);
> + pfree(data);
> + }
> +
> + /*
> + * Convert options to TextArray format so caller can store them into
> + * database
> + */
> + result = optionsValuesToTextArray(merged_values);
> + return result;
> +}
> +
> +
> +/*
> + * optionsTextArrayToBytea
> + * A meta-function that transforms options stored as TextArray into binary
> + * (bytea) representation.
> + *
> + * This function runs other transform functions that leads to the desired
> + * result in no-validation mode. This function is used by cache mechanism,
> + * in order to load and cache options when object itself is loaded and cached
> + */
> +bytea *
> +optionsTextArrayToBytea(options_spec_set * spec_set, Datum data, bool validate)
> +{
> + List *values;
> + bytea *options;
> +
> + values = optionsTextArrayToRawValues(data);
> + values = optionsParseRawValues(values, spec_set,
> + validate ? OPTIONS_PARSE_MODE_VALIDATE : 0);
> + options = optionsValuesToBytea(values, spec_set);
> +
> + if (spec_set->postprocess_fun)
> + {
> + spec_set->postprocess_fun(options, false);
> + }
> + return options;
> +}
> diff --git a/src/backend/access/common/relation.c b/src/backend/access/common/relation.c
> index 632d13c..49ad197 100644
> --- a/src/backend/access/common/relation.c
> +++ b/src/backend/access/common/relation.c
> @@ -65,9 +65,13 @@ relation_open(Oid relationId, LOCKMODE lockmode)
> * If we didn't get the lock ourselves, assert that caller holds one,
> * except in bootstrap mode where no locks are used.
> */
> - Assert(lockmode != NoLock ||
> - IsBootstrapProcessingMode() ||
> - CheckRelationLockedByMe(r, AccessShareLock, true));
> +
> +// FIXME We need NoLock mode to get AM data when choosing Lock for
> +// attoptions is changed. See ProcessUtilitySlow problems comes from there
> +// This is a dirty hack, we need better solution for this case;
> +// Assert(lockmode != NoLock ||
> +// IsBootstrapProcessingMode() ||
> +// CheckRelationLockedByMe(r, AccessShareLock, true));
>
> /* Make note that we've accessed a temporary relation */
> if (RelationUsesLocalBuffers(r))
> diff --git a/src/backend/access/common/reloptions.c b/src/backend/access/common/reloptions.c
> index b5602f5..29ab98a 100644
> --- a/src/backend/access/common/reloptions.c
> +++ b/src/backend/access/common/reloptions.c
> @@ -1,7 +1,7 @@
> /*-------------------------------------------------------------------------
> *
> * reloptions.c
> - * Core support for relation options (pg_class.reloptions)
> + * Support for relation options (pg_class.reloptions)
> *
> * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
> * Portions Copyright (c) 1994, Regents of the University of California
> @@ -17,13 +17,10 @@
>
> #include <float.h>
>
> -#include "access/gist_private.h"
> -#include "access/hash.h"
> #include "access/heaptoast.h"
> #include "access/htup_details.h"
> -#include "access/nbtree.h"
> #include "access/reloptions.h"
> -#include "access/spgist_private.h"
> +#include "access/options.h"
> #include "catalog/pg_type.h"
> #include "commands/defrem.h"
> #include "commands/tablespace.h"
> @@ -36,6 +33,7 @@
> #include "utils/guc.h"
> #include "utils/memutils.h"
> #include "utils/rel.h"
> +#include "storage/bufmgr.h"
>
> /*
> * Contents of pg_class.reloptions
> @@ -93,380 +91,8 @@
> * value has no effect until the next VACUUM, so no need for stronger lock.
> */
>
> -static relopt_bool boolRelOpts[] =
> -{
> - {
> - {
> - "autosummarize",
> - "Enables automatic summarization on this BRIN index",
> - RELOPT_KIND_BRIN,
> - AccessExclusiveLock
> - },
> - false
> - },
> - {
> - {
> - "autovacuum_enabled",
> - "Enables autovacuum in this relation",
> - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
> - ShareUpdateExclusiveLock
> - },
> - true
> - },
> - {
> - {
> - "user_catalog_table",
> - "Declare a table as an additional catalog table, e.g. for the purpose of logical replication",
> - RELOPT_KIND_HEAP,
> - AccessExclusiveLock
> - },
> - false
> - },
> - {
> - {
> - "fastupdate",
> - "Enables \"fast update\" feature for this GIN index",
> - RELOPT_KIND_GIN,
> - AccessExclusiveLock
> - },
> - true
> - },
> - {
> - {
> - "security_barrier",
> - "View acts as a row security barrier",
> - RELOPT_KIND_VIEW,
> - AccessExclusiveLock
> - },
> - false
> - },
> - {
> - {
> - "vacuum_truncate",
> - "Enables vacuum to truncate empty pages at the end of this table",
> - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
> - ShareUpdateExclusiveLock
> - },
> - true
> - },
> - {
> - {
> - "deduplicate_items",
> - "Enables \"deduplicate items\" feature for this btree index",
> - RELOPT_KIND_BTREE,
> - ShareUpdateExclusiveLock /* since it applies only to later
> - * inserts */
> - },
> - true
> - },
> - /* list terminator */
> - {{NULL}}
> -};
> -
> -static relopt_int intRelOpts[] =
> -{
> - {
> - {
> - "fillfactor",
> - "Packs table pages only to this percentage",
> - RELOPT_KIND_HEAP,
> - ShareUpdateExclusiveLock /* since it applies only to later
> - * inserts */
> - },
> - HEAP_DEFAULT_FILLFACTOR, HEAP_MIN_FILLFACTOR, 100
> - },
> - {
> - {
> - "fillfactor",
> - "Packs btree index pages only to this percentage",
> - RELOPT_KIND_BTREE,
> - ShareUpdateExclusiveLock /* since it applies only to later
> - * inserts */
> - },
> - BTREE_DEFAULT_FILLFACTOR, BTREE_MIN_FILLFACTOR, 100
> - },
> - {
> - {
> - "fillfactor",
> - "Packs hash index pages only to this percentage",
> - RELOPT_KIND_HASH,
> - ShareUpdateExclusiveLock /* since it applies only to later
> - * inserts */
> - },
> - HASH_DEFAULT_FILLFACTOR, HASH_MIN_FILLFACTOR, 100
> - },
> - {
> - {
> - "fillfactor",
> - "Packs gist index pages only to this percentage",
> - RELOPT_KIND_GIST,
> - ShareUpdateExclusiveLock /* since it applies only to later
> - * inserts */
> - },
> - GIST_DEFAULT_FILLFACTOR, GIST_MIN_FILLFACTOR, 100
> - },
> - {
> - {
> - "fillfactor",
> - "Packs spgist index pages only to this percentage",
> - RELOPT_KIND_SPGIST,
> - ShareUpdateExclusiveLock /* since it applies only to later
> - * inserts */
> - },
> - SPGIST_DEFAULT_FILLFACTOR, SPGIST_MIN_FILLFACTOR, 100
> - },
> - {
> - {
> - "autovacuum_vacuum_threshold",
> - "Minimum number of tuple updates or deletes prior to vacuum",
> - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
> - ShareUpdateExclusiveLock
> - },
> - -1, 0, INT_MAX
> - },
> - {
> - {
> - "autovacuum_vacuum_insert_threshold",
> - "Minimum number of tuple inserts prior to vacuum, or -1 to disable insert vacuums",
> - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
> - ShareUpdateExclusiveLock
> - },
> - -2, -1, INT_MAX
> - },
> - {
> - {
> - "autovacuum_analyze_threshold",
> - "Minimum number of tuple inserts, updates or deletes prior to analyze",
> - RELOPT_KIND_HEAP,
> - ShareUpdateExclusiveLock
> - },
> - -1, 0, INT_MAX
> - },
> - {
> - {
> - "autovacuum_vacuum_cost_limit",
> - "Vacuum cost amount available before napping, for autovacuum",
> - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
> - ShareUpdateExclusiveLock
> - },
> - -1, 1, 10000
> - },
> - {
> - {
> - "autovacuum_freeze_min_age",
> - "Minimum age at which VACUUM should freeze a table row, for autovacuum",
> - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
> - ShareUpdateExclusiveLock
> - },
> - -1, 0, 1000000000
> - },
> - {
> - {
> - "autovacuum_multixact_freeze_min_age",
> - "Minimum multixact age at which VACUUM should freeze a row multixact's, for autovacuum",
> - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
> - ShareUpdateExclusiveLock
> - },
> - -1, 0, 1000000000
> - },
> - {
> - {
> - "autovacuum_freeze_max_age",
> - "Age at which to autovacuum a table to prevent transaction ID wraparound",
> - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
> - ShareUpdateExclusiveLock
> - },
> - -1, 100000, 2000000000
> - },
> - {
> - {
> - "autovacuum_multixact_freeze_max_age",
> - "Multixact age at which to autovacuum a table to prevent multixact wraparound",
> - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
> - ShareUpdateExclusiveLock
> - },
> - -1, 10000, 2000000000
> - },
> - {
> - {
> - "autovacuum_freeze_table_age",
> - "Age at which VACUUM should perform a full table sweep to freeze row versions",
> - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
> - ShareUpdateExclusiveLock
> - }, -1, 0, 2000000000
> - },
> - {
> - {
> - "autovacuum_multixact_freeze_table_age",
> - "Age of multixact at which VACUUM should perform a full table sweep to freeze row versions",
> - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
> - ShareUpdateExclusiveLock
> - }, -1, 0, 2000000000
> - },
> - {
> - {
> - "log_autovacuum_min_duration",
> - "Sets the minimum execution time above which autovacuum actions will be logged",
> - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
> - ShareUpdateExclusiveLock
> - },
> - -1, -1, INT_MAX
> - },
> - {
> - {
> - "toast_tuple_target",
> - "Sets the target tuple length at which external columns will be toasted",
> - RELOPT_KIND_HEAP,
> - ShareUpdateExclusiveLock
> - },
> - TOAST_TUPLE_TARGET, 128, TOAST_TUPLE_TARGET_MAIN
> - },
> - {
> - {
> - "pages_per_range",
> - "Number of pages that each page range covers in a BRIN index",
> - RELOPT_KIND_BRIN,
> - AccessExclusiveLock
> - }, 128, 1, 131072
> - },
> - {
> - {
> - "gin_pending_list_limit",
> - "Maximum size of the pending list for this GIN index, in kilobytes.",
> - RELOPT_KIND_GIN,
> - AccessExclusiveLock
> - },
> - -1, 64, MAX_KILOBYTES
> - },
> - {
> - {
> - "effective_io_concurrency",
> - "Number of simultaneous requests that can be handled efficiently by the disk subsystem.",
> - RELOPT_KIND_TABLESPACE,
> - ShareUpdateExclusiveLock
> - },
> -#ifdef USE_PREFETCH
> - -1, 0, MAX_IO_CONCURRENCY
> -#else
> - 0, 0, 0
> -#endif
> - },
> - {
> - {
> - "maintenance_io_concurrency",
> - "Number of simultaneous requests that can be handled efficiently by the disk subsystem for maintenance work.",
> - RELOPT_KIND_TABLESPACE,
> - ShareUpdateExclusiveLock
> - },
> -#ifdef USE_PREFETCH
> - -1, 0, MAX_IO_CONCURRENCY
> -#else
> - 0, 0, 0
> -#endif
> - },
> - {
> - {
> - "parallel_workers",
> - "Number of parallel processes that can be used per executor node for this relation.",
> - RELOPT_KIND_HEAP,
> - ShareUpdateExclusiveLock
> - },
> - -1, 0, 1024
> - },
> -
> - /* list terminator */
> - {{NULL}}
> -};
> -
> -static relopt_real realRelOpts[] =
> -{
> - {
> - {
> - "autovacuum_vacuum_cost_delay",
> - "Vacuum cost delay in milliseconds, for autovacuum",
> - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
> - ShareUpdateExclusiveLock
> - },
> - -1, 0.0, 100.0
> - },
> - {
> - {
> - "autovacuum_vacuum_scale_factor",
> - "Number of tuple updates or deletes prior to vacuum as a fraction of reltuples",
> - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
> - ShareUpdateExclusiveLock
> - },
> - -1, 0.0, 100.0
> - },
> - {
> - {
> - "autovacuum_vacuum_insert_scale_factor",
> - "Number of tuple inserts prior to vacuum as a fraction of reltuples",
> - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
> - ShareUpdateExclusiveLock
> - },
> - -1, 0.0, 100.0
> - },
> - {
> - {
> - "autovacuum_analyze_scale_factor",
> - "Number of tuple inserts, updates or deletes prior to analyze as a fraction of reltuples",
> - RELOPT_KIND_HEAP,
> - ShareUpdateExclusiveLock
> - },
> - -1, 0.0, 100.0
> - },
> - {
> - {
> - "seq_page_cost",
> - "Sets the planner's estimate of the cost of a sequentially fetched disk page.",
> - RELOPT_KIND_TABLESPACE,
> - ShareUpdateExclusiveLock
> - },
> - -1, 0.0, DBL_MAX
> - },
> - {
> - {
> - "random_page_cost",
> - "Sets the planner's estimate of the cost of a nonsequentially fetched disk page.",
> - RELOPT_KIND_TABLESPACE,
> - ShareUpdateExclusiveLock
> - },
> - -1, 0.0, DBL_MAX
> - },
> - {
> - {
> - "n_distinct",
> - "Sets the planner's estimate of the number of distinct values appearing in a column (excluding child relations).",
> - RELOPT_KIND_ATTRIBUTE,
> - ShareUpdateExclusiveLock
> - },
> - 0, -1.0, DBL_MAX
> - },
> - {
> - {
> - "n_distinct_inherited",
> - "Sets the planner's estimate of the number of distinct values appearing in a column (including child relations).",
> - RELOPT_KIND_ATTRIBUTE,
> - ShareUpdateExclusiveLock
> - },
> - 0, -1.0, DBL_MAX
> - },
> - {
> - {
> - "vacuum_cleanup_index_scale_factor",
> - "Deprecated B-Tree parameter.",
> - RELOPT_KIND_BTREE,
> - ShareUpdateExclusiveLock
> - },
> - -1, 0.0, 1e10
> - },
> - /* list terminator */
> - {{NULL}}
> -};
> -
> /* values from StdRdOptIndexCleanup */
> -relopt_enum_elt_def StdRdOptIndexCleanupValues[] =
> +opt_enum_elt_def StdRdOptIndexCleanupValues[] =
> {
> {"auto", STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO},
> {"on", STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON},
> @@ -480,17 +106,8 @@ relopt_enum_elt_def StdRdOptIndexCleanupValues[] =
> {(const char *) NULL} /* list terminator */
> };
>
> -/* values from GistOptBufferingMode */
> -relopt_enum_elt_def gistBufferingOptValues[] =
> -{
> - {"auto", GIST_OPTION_BUFFERING_AUTO},
> - {"on", GIST_OPTION_BUFFERING_ON},
> - {"off", GIST_OPTION_BUFFERING_OFF},
> - {(const char *) NULL} /* list terminator */
> -};
> -
> /* values from ViewOptCheckOption */
> -relopt_enum_elt_def viewCheckOptValues[] =
> +opt_enum_elt_def viewCheckOptValues[] =
> {
> /* no value for NOT_SET */
> {"local", VIEW_OPTION_CHECK_OPTION_LOCAL},
> @@ -498,61 +115,8 @@ relopt_enum_elt_def viewCheckOptValues[] =
> {(const char *) NULL} /* list terminator */
> };
>
> -static relopt_enum enumRelOpts[] =
> -{
> - {
> - {
> - "vacuum_index_cleanup",
> - "Controls index vacuuming and index cleanup",
> - RELOPT_KIND_HEAP | RELOPT_KIND_TOAST,
> - ShareUpdateExclusiveLock
> - },
> - StdRdOptIndexCleanupValues,
> - STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO,
> - gettext_noop("Valid values are \"on\", \"off\", and \"auto\".")
> - },
> - {
> - {
> - "buffering",
> - "Enables buffering build for this GiST index",
> - RELOPT_KIND_GIST,
> - AccessExclusiveLock
> - },
> - gistBufferingOptValues,
> - GIST_OPTION_BUFFERING_AUTO,
> - gettext_noop("Valid values are \"on\", \"off\", and \"auto\".")
> - },
> - {
> - {
> - "check_option",
> - "View has WITH CHECK OPTION defined (local or cascaded).",
> - RELOPT_KIND_VIEW,
> - AccessExclusiveLock
> - },
> - viewCheckOptValues,
> - VIEW_OPTION_CHECK_OPTION_NOT_SET,
> - gettext_noop("Valid values are \"local\" and \"cascaded\".")
> - },
> - /* list terminator */
> - {{NULL}}
> -};
> -
> -static relopt_string stringRelOpts[] =
> -{
> - /* list terminator */
> - {{NULL}}
> -};
> -
> -static relopt_gen **relOpts = NULL;
> -static bits32 last_assigned_kind = RELOPT_KIND_LAST_DEFAULT;
> -
> -static int num_custom_options = 0;
> -static relopt_gen **custom_options = NULL;
> -static bool need_initialization = true;
>
> -static void initialize_reloptions(void);
> -static void parse_one_reloption(relopt_value *option, char *text_str,
> - int text_len, bool validate);
> +options_spec_set *get_stdrd_relopt_spec_set(relopt_kind kind);
>
> /*
> * Get the length of a string reloption (either default or the user-defined
> @@ -563,160 +127,6 @@ static void parse_one_reloption(relopt_value *option, char *text_str,
> ((option).isset ? strlen((option).values.string_val) : \
> ((relopt_string *) (option).gen)->default_len)
>
> -/*
> - * initialize_reloptions
> - * initialization routine, must be called before parsing
> - *
> - * Initialize the relOpts array and fill each variable's type and name length.
> - */
> -static void
> -initialize_reloptions(void)
> -{
> - int i;
> - int j;
> -
> - j = 0;
> - for (i = 0; boolRelOpts[i].gen.name; i++)
> - {
> - Assert(DoLockModesConflict(boolRelOpts[i].gen.lockmode,
> - boolRelOpts[i].gen.lockmode));
> - j++;
> - }
> - for (i = 0; intRelOpts[i].gen.name; i++)
> - {
> - Assert(DoLockModesConflict(intRelOpts[i].gen.lockmode,
> - intRelOpts[i].gen.lockmode));
> - j++;
> - }
> - for (i = 0; realRelOpts[i].gen.name; i++)
> - {
> - Assert(DoLockModesConflict(realRelOpts[i].gen.lockmode,
> - realRelOpts[i].gen.lockmode));
> - j++;
> - }
> - for (i = 0; enumRelOpts[i].gen.name; i++)
> - {
> - Assert(DoLockModesConflict(enumRelOpts[i].gen.lockmode,
> - enumRelOpts[i].gen.lockmode));
> - j++;
> - }
> - for (i = 0; stringRelOpts[i].gen.name; i++)
> - {
> - Assert(DoLockModesConflict(stringRelOpts[i].gen.lockmode,
> - stringRelOpts[i].gen.lockmode));
> - j++;
> - }
> - j += num_custom_options;
> -
> - if (relOpts)
> - pfree(relOpts);
> - relOpts = MemoryContextAlloc(TopMemoryContext,
> - (j + 1) * sizeof(relopt_gen *));
> -
> - j = 0;
> - for (i = 0; boolRelOpts[i].gen.name; i++)
> - {
> - relOpts[j] = &boolRelOpts[i].gen;
> - relOpts[j]->type = RELOPT_TYPE_BOOL;
> - relOpts[j]->namelen = strlen(relOpts[j]->name);
> - j++;
> - }
> -
> - for (i = 0; intRelOpts[i].gen.name; i++)
> - {
> - relOpts[j] = &intRelOpts[i].gen;
> - relOpts[j]->type = RELOPT_TYPE_INT;
> - relOpts[j]->namelen = strlen(relOpts[j]->name);
> - j++;
> - }
> -
> - for (i = 0; realRelOpts[i].gen.name; i++)
> - {
> - relOpts[j] = &realRelOpts[i].gen;
> - relOpts[j]->type = RELOPT_TYPE_REAL;
> - relOpts[j]->namelen = strlen(relOpts[j]->name);
> - j++;
> - }
> -
> - for (i = 0; enumRelOpts[i].gen.name; i++)
> - {
> - relOpts[j] = &enumRelOpts[i].gen;
> - relOpts[j]->type = RELOPT_TYPE_ENUM;
> - relOpts[j]->namelen = strlen(relOpts[j]->name);
> - j++;
> - }
> -
> - for (i = 0; stringRelOpts[i].gen.name; i++)
> - {
> - relOpts[j] = &stringRelOpts[i].gen;
> - relOpts[j]->type = RELOPT_TYPE_STRING;
> - relOpts[j]->namelen = strlen(relOpts[j]->name);
> - j++;
> - }
> -
> - for (i = 0; i < num_custom_options; i++)
> - {
> - relOpts[j] = custom_options[i];
> - j++;
> - }
> -
> - /* add a list terminator */
> - relOpts[j] = NULL;
> -
> - /* flag the work is complete */
> - need_initialization = false;
> -}
> -
> -/*
> - * add_reloption_kind
> - * Create a new relopt_kind value, to be used in custom reloptions by
> - * user-defined AMs.
> - */
> -relopt_kind
> -add_reloption_kind(void)
> -{
> - /* don't hand out the last bit so that the enum's behavior is portable */
> - if (last_assigned_kind >= RELOPT_KIND_MAX)
> - ereport(ERROR,
> - (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
> - errmsg("user-defined relation parameter types limit exceeded")));
> - last_assigned_kind <<= 1;
> - return (relopt_kind) last_assigned_kind;
> -}
> -
> -/*
> - * add_reloption
> - * Add an already-created custom reloption to the list, and recompute the
> - * main parser table.
> - */
> -static void
> -add_reloption(relopt_gen *newoption)
> -{
> - static int max_custom_options = 0;
> -
> - if (num_custom_options >= max_custom_options)
> - {
> - MemoryContext oldcxt;
> -
> - oldcxt = MemoryContextSwitchTo(TopMemoryContext);
> -
> - if (max_custom_options == 0)
> - {
> - max_custom_options = 8;
> - custom_options = palloc(max_custom_options * sizeof(relopt_gen *));
> - }
> - else
> - {
> - max_custom_options *= 2;
> - custom_options = repalloc(custom_options,
> - max_custom_options * sizeof(relopt_gen *));
> - }
> - MemoryContextSwitchTo(oldcxt);
> - }
> - custom_options[num_custom_options++] = newoption;
> -
> - need_initialization = true;
> -}
>
> /*
> * init_local_reloptions
> @@ -729,6 +139,7 @@ init_local_reloptions(local_relopts *opts, Size relopt_struct_size)
> opts->options = NIL;
> opts->validators = NIL;
> opts->relopt_struct_size = relopt_struct_size;
> + opts->spec_set = allocateOptionsSpecSet(NULL, relopt_struct_size, 0);
> }
>
> /*
> @@ -743,112 +154,6 @@ register_reloptions_validator(local_relopts *opts, relopts_validator validator)
> }
>
> /*
> - * add_local_reloption
> - * Add an already-created custom reloption to the local list.
> - */
> -static void
> -add_local_reloption(local_relopts *relopts, relopt_gen *newoption, int offset)
> -{
> - local_relopt *opt = palloc(sizeof(*opt));
> -
> - Assert(offset < relopts->relopt_struct_size);
> -
> - opt->option = newoption;
> - opt->offset = offset;
> -
> - relopts->options = lappend(relopts->options, opt);
> -}
> -
> -/*
> - * allocate_reloption
> - * Allocate a new reloption and initialize the type-agnostic fields
> - * (for types other than string)
> - */
> -static relopt_gen *
> -allocate_reloption(bits32 kinds, int type, const char *name, const char *desc,
> - LOCKMODE lockmode)
> -{
> - MemoryContext oldcxt;
> - size_t size;
> - relopt_gen *newoption;
> -
> - if (kinds != RELOPT_KIND_LOCAL)
> - oldcxt = MemoryContextSwitchTo(TopMemoryContext);
> - else
> - oldcxt = NULL;
> -
> - switch (type)
> - {
> - case RELOPT_TYPE_BOOL:
> - size = sizeof(relopt_bool);
> - break;
> - case RELOPT_TYPE_INT:
> - size = sizeof(relopt_int);
> - break;
> - case RELOPT_TYPE_REAL:
> - size = sizeof(relopt_real);
> - break;
> - case RELOPT_TYPE_ENUM:
> - size = sizeof(relopt_enum);
> - break;
> - case RELOPT_TYPE_STRING:
> - size = sizeof(relopt_string);
> - break;
> - default:
> - elog(ERROR, "unsupported reloption type %d", type);
> - return NULL; /* keep compiler quiet */
> - }
> -
> - newoption = palloc(size);
> -
> - newoption->name = pstrdup(name);
> - if (desc)
> - newoption->desc = pstrdup(desc);
> - else
> - newoption->desc = NULL;
> - newoption->kinds = kinds;
> - newoption->namelen = strlen(name);
> - newoption->type = type;
> - newoption->lockmode = lockmode;
> -
> - if (oldcxt != NULL)
> - MemoryContextSwitchTo(oldcxt);
> -
> - return newoption;
> -}
> -
> -/*
> - * init_bool_reloption
> - * Allocate and initialize a new boolean reloption
> - */
> -static relopt_bool *
> -init_bool_reloption(bits32 kinds, const char *name, const char *desc,
> - bool default_val, LOCKMODE lockmode)
> -{
> - relopt_bool *newoption;
> -
> - newoption = (relopt_bool *) allocate_reloption(kinds, RELOPT_TYPE_BOOL,
> - name, desc, lockmode);
> - newoption->default_val = default_val;
> -
> - return newoption;
> -}
> -
> -/*
> - * add_bool_reloption
> - * Add a new boolean reloption
> - */
> -void
> -add_bool_reloption(bits32 kinds, const char *name, const char *desc,
> - bool default_val, LOCKMODE lockmode)
> -{
> - relopt_bool *newoption = init_bool_reloption(kinds, name, desc,
> - default_val, lockmode);
> -
> - add_reloption((relopt_gen *) newoption);
> -}
> -
> -/*
> * add_local_bool_reloption
> * Add a new boolean local reloption
> *
> @@ -858,47 +163,8 @@ void
> add_local_bool_reloption(local_relopts *relopts, const char *name,
> const char *desc, bool default_val, int offset)
> {
> - relopt_bool *newoption = init_bool_reloption(RELOPT_KIND_LOCAL,
> - name, desc,
> - default_val, 0);
> -
> - add_local_reloption(relopts, (relopt_gen *) newoption, offset);
> -}
> -
> -
> -/*
> - * init_real_reloption
> - * Allocate and initialize a new integer reloption
> - */
> -static relopt_int *
> -init_int_reloption(bits32 kinds, const char *name, const char *desc,
> - int default_val, int min_val, int max_val,
> - LOCKMODE lockmode)
> -{
> - relopt_int *newoption;
> -
> - newoption = (relopt_int *) allocate_reloption(kinds, RELOPT_TYPE_INT,
> - name, desc, lockmode);
> - newoption->default_val = default_val;
> - newoption->min = min_val;
> - newoption->max = max_val;
> -
> - return newoption;
> -}
> -
> -/*
> - * add_int_reloption
> - * Add a new integer reloption
> - */
> -void
> -add_int_reloption(bits32 kinds, const char *name, const char *desc, int default_val,
> - int min_val, int max_val, LOCKMODE lockmode)
> -{
> - relopt_int *newoption = init_int_reloption(kinds, name, desc,
> - default_val, min_val,
> - max_val, lockmode);
> -
> - add_reloption((relopt_gen *) newoption);
> + optionsSpecSetAddBool(relopts->spec_set, name, desc, NoLock, 0, offset,
> + default_val);
> }
>
> /*
> @@ -912,47 +178,8 @@ add_local_int_reloption(local_relopts *relopts, const char *name,
> const char *desc, int default_val, int min_val,
> int max_val, int offset)
> {
> - relopt_int *newoption = init_int_reloption(RELOPT_KIND_LOCAL,
> - name, desc, default_val,
> - min_val, max_val, 0);
> -
> - add_local_reloption(relopts, (relopt_gen *) newoption, offset);
> -}
> -
> -/*
> - * init_real_reloption
> - * Allocate and initialize a new real reloption
> - */
> -static relopt_real *
> -init_real_reloption(bits32 kinds, const char *name, const char *desc,
> - double default_val, double min_val, double max_val,
> - LOCKMODE lockmode)
> -{
> - relopt_real *newoption;
> -
> - newoption = (relopt_real *) allocate_reloption(kinds, RELOPT_TYPE_REAL,
> - name, desc, lockmode);
> - newoption->default_val = default_val;
> - newoption->min = min_val;
> - newoption->max = max_val;
> -
> - return newoption;
> -}
> -
> -/*
> - * add_real_reloption
> - * Add a new float reloption
> - */
> -void
> -add_real_reloption(bits32 kinds, const char *name, const char *desc,
> - double default_val, double min_val, double max_val,
> - LOCKMODE lockmode)
> -{
> - relopt_real *newoption = init_real_reloption(kinds, name, desc,
> - default_val, min_val,
> - max_val, lockmode);
> -
> - add_reloption((relopt_gen *) newoption);
> + optionsSpecSetAddInt(relopts->spec_set, name, desc, NoLock, 0, offset,
> + default_val, min_val, max_val);
> }
>
> /*
> @@ -966,57 +193,9 @@ add_local_real_reloption(local_relopts *relopts, const char *name,
> const char *desc, double default_val,
> double min_val, double max_val, int offset)
> {
> - relopt_real *newoption = init_real_reloption(RELOPT_KIND_LOCAL,
> - name, desc,
> - default_val, min_val,
> - max_val, 0);
> -
> - add_local_reloption(relopts, (relopt_gen *) newoption, offset);
> -}
> -
> -/*
> - * init_enum_reloption
> - * Allocate and initialize a new enum reloption
> - */
> -static relopt_enum *
> -init_enum_reloption(bits32 kinds, const char *name, const char *desc,
> - relopt_enum_elt_def *members, int default_val,
> - const char *detailmsg, LOCKMODE lockmode)
> -{
> - relopt_enum *newoption;
> -
> - newoption = (relopt_enum *) allocate_reloption(kinds, RELOPT_TYPE_ENUM,
> - name, desc, lockmode);
> - newoption->members = members;
> - newoption->default_val = default_val;
> - newoption->detailmsg = detailmsg;
> -
> - return newoption;
> -}
> -
> -
> -/*
> - * add_enum_reloption
> - * Add a new enum reloption
> - *
> - * The members array must have a terminating NULL entry.
> - *
> - * The detailmsg is shown when unsupported values are passed, and has this
> - * form: "Valid values are \"foo\", \"bar\", and \"bar\"."
> - *
> - * The members array and detailmsg are not copied -- caller must ensure that
> - * they are valid throughout the life of the process.
> - */
> -void
> -add_enum_reloption(bits32 kinds, const char *name, const char *desc,
> - relopt_enum_elt_def *members, int default_val,
> - const char *detailmsg, LOCKMODE lockmode)
> -{
> - relopt_enum *newoption = init_enum_reloption(kinds, name, desc,
> - members, default_val,
> - detailmsg, lockmode);
> + optionsSpecSetAddReal(relopts->spec_set, name, desc, NoLock, 0, offset,
> + default_val, min_val, max_val);
>
> - add_reloption((relopt_gen *) newoption);
> }
>
> /*
> @@ -1027,77 +206,11 @@ add_enum_reloption(bits32 kinds, const char *name, const char *desc,
> */
> void
> add_local_enum_reloption(local_relopts *relopts, const char *name,
> - const char *desc, relopt_enum_elt_def *members,
> + const char *desc, opt_enum_elt_def *members,
> int default_val, const char *detailmsg, int offset)
> {
> - relopt_enum *newoption = init_enum_reloption(RELOPT_KIND_LOCAL,
> - name, desc,
> - members, default_val,
> - detailmsg, 0);
> -
> - add_local_reloption(relopts, (relopt_gen *) newoption, offset);
> -}
> -
> -/*
> - * init_string_reloption
> - * Allocate and initialize a new string reloption
> - */
> -static relopt_string *
> -init_string_reloption(bits32 kinds, const char *name, const char *desc,
> - const char *default_val,
> - validate_string_relopt validator,
> - fill_string_relopt filler,
> - LOCKMODE lockmode)
> -{
> - relopt_string *newoption;
> -
> - /* make sure the validator/default combination is sane */
> - if (validator)
> - (validator) (default_val);
> -
> - newoption = (relopt_string *) allocate_reloption(kinds, RELOPT_TYPE_STRING,
> - name, desc, lockmode);
> - newoption->validate_cb = validator;
> - newoption->fill_cb = filler;
> - if (default_val)
> - {
> - if (kinds == RELOPT_KIND_LOCAL)
> - newoption->default_val = strdup(default_val);
> - else
> - newoption->default_val = MemoryContextStrdup(TopMemoryContext, default_val);
> - newoption->default_len = strlen(default_val);
> - newoption->default_isnull = false;
> - }
> - else
> - {
> - newoption->default_val = "";
> - newoption->default_len = 0;
> - newoption->default_isnull = true;
> - }
> -
> - return newoption;
> -}
> -
> -/*
> - * add_string_reloption
> - * Add a new string reloption
> - *
> - * "validator" is an optional function pointer that can be used to test the
> - * validity of the values. It must elog(ERROR) when the argument string is
> - * not acceptable for the variable. Note that the default value must pass
> - * the validation.
> - */
> -void
> -add_string_reloption(bits32 kinds, const char *name, const char *desc,
> - const char *default_val, validate_string_relopt validator,
> - LOCKMODE lockmode)
> -{
> - relopt_string *newoption = init_string_reloption(kinds, name, desc,
> - default_val,
> - validator, NULL,
> - lockmode);
> -
> - add_reloption((relopt_gen *) newoption);
> + optionsSpecSetAddEnum(relopts->spec_set, name, desc, NoLock, 0, offset,
> + members, default_val, detailmsg);
> }
>
> /*
> @@ -1113,249 +226,9 @@ add_local_string_reloption(local_relopts *relopts, const char *name,
> validate_string_relopt validator,
> fill_string_relopt filler, int offset)
> {
> - relopt_string *newoption = init_string_reloption(RELOPT_KIND_LOCAL,
> - name, desc,
> - default_val,
> - validator, filler,
> - 0);
> -
> - add_local_reloption(relopts, (relopt_gen *) newoption, offset);
> -}
> -
> -/*
> - * Transform a relation options list (list of DefElem) into the text array
> - * format that is kept in pg_class.reloptions, including only those options
> - * that are in the passed namespace. The output values do not include the
> - * namespace.
> - *
> - * This is used for three cases: CREATE TABLE/INDEX, ALTER TABLE SET, and
> - * ALTER TABLE RESET. In the ALTER cases, oldOptions is the existing
> - * reloptions value (possibly NULL), and we replace or remove entries
> - * as needed.
> - *
> - * If acceptOidsOff is true, then we allow oids = false, but throw error when
> - * on. This is solely needed for backwards compatibility.
> - *
> - * Note that this is not responsible for determining whether the options
> - * are valid, but it does check that namespaces for all the options given are
> - * listed in validnsps. The NULL namespace is always valid and need not be
> - * explicitly listed. Passing a NULL pointer means that only the NULL
> - * namespace is valid.
> - *
> - * Both oldOptions and the result are text arrays (or NULL for "default"),
> - * but we declare them as Datums to avoid including array.h in reloptions.h.
> - */
> -Datum
> -transformRelOptions(Datum oldOptions, List *defList, const char *namspace,
> - char *validnsps[], bool acceptOidsOff, bool isReset)
> -{
> - Datum result;
> - ArrayBuildState *astate;
> - ListCell *cell;
> -
> - /* no change if empty list */
> - if (defList == NIL)
> - return oldOptions;
> -
> - /* We build new array using accumArrayResult */
> - astate = NULL;
> -
> - /* Copy any oldOptions that aren't to be replaced */
> - if (PointerIsValid(DatumGetPointer(oldOptions)))
> - {
> - ArrayType *array = DatumGetArrayTypeP(oldOptions);
> - Datum *oldoptions;
> - int noldoptions;
> - int i;
> -
> - deconstruct_array(array, TEXTOID, -1, false, TYPALIGN_INT,
> - &oldoptions, NULL, &noldoptions);
> -
> - for (i = 0; i < noldoptions; i++)
> - {
> - char *text_str = VARDATA(oldoptions[i]);
> - int text_len = VARSIZE(oldoptions[i]) - VARHDRSZ;
> -
> - /* Search for a match in defList */
> - foreach(cell, defList)
> - {
> - DefElem *def = (DefElem *) lfirst(cell);
> - int kw_len;
> -
> - /* ignore if not in the same namespace */
> - if (namspace == NULL)
> - {
> - if (def->defnamespace != NULL)
> - continue;
> - }
> - else if (def->defnamespace == NULL)
> - continue;
> - else if (strcmp(def->defnamespace, namspace) != 0)
> - continue;
> -
> - kw_len = strlen(def->defname);
> - if (text_len > kw_len && text_str[kw_len] == '=' &&
> - strncmp(text_str, def->defname, kw_len) == 0)
> - break;
> - }
> - if (!cell)
> - {
> - /* No match, so keep old option */
> - astate = accumArrayResult(astate, oldoptions[i],
> - false, TEXTOID,
> - CurrentMemoryContext);
> - }
> - }
> - }
> -
> - /*
> - * If CREATE/SET, add new options to array; if RESET, just check that the
> - * user didn't say RESET (option=val). (Must do this because the grammar
> - * doesn't enforce it.)
> - */
> - foreach(cell, defList)
> - {
> - DefElem *def = (DefElem *) lfirst(cell);
> -
> - if (isReset)
> - {
> - if (def->arg != NULL)
> - ereport(ERROR,
> - (errcode(ERRCODE_SYNTAX_ERROR),
> - errmsg("RESET must not include values for parameters")));
> - }
> - else
> - {
> - text *t;
> - const char *value;
> - Size len;
> -
> - /*
> - * Error out if the namespace is not valid. A NULL namespace is
> - * always valid.
> - */
> - if (def->defnamespace != NULL)
> - {
> - bool valid = false;
> - int i;
> -
> - if (validnsps)
> - {
> - for (i = 0; validnsps[i]; i++)
> - {
> - if (strcmp(def->defnamespace, validnsps[i]) == 0)
> - {
> - valid = true;
> - break;
> - }
> - }
> - }
> -
> - if (!valid)
> - ereport(ERROR,
> - (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> - errmsg("unrecognized parameter namespace \"%s\"",
> - def->defnamespace)));
> - }
> -
> - /* ignore if not in the same namespace */
> - if (namspace == NULL)
> - {
> - if (def->defnamespace != NULL)
> - continue;
> - }
> - else if (def->defnamespace == NULL)
> - continue;
> - else if (strcmp(def->defnamespace, namspace) != 0)
> - continue;
> -
> - /*
> - * Flatten the DefElem into a text string like "name=arg". If we
> - * have just "name", assume "name=true" is meant. Note: the
> - * namespace is not output.
> - */
> - if (def->arg != NULL)
> - value = defGetString(def);
> - else
> - value = "true";
> -
> - /*
> - * This is not a great place for this test, but there's no other
> - * convenient place to filter the option out. As WITH (oids =
> - * false) will be removed someday, this seems like an acceptable
> - * amount of ugly.
> - */
> - if (acceptOidsOff && def->defnamespace == NULL &&
> - strcmp(def->defname, "oids") == 0)
> - {
> - if (defGetBoolean(def))
> - ereport(ERROR,
> - (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
> - errmsg("tables declared WITH OIDS are not supported")));
> - /* skip over option, reloptions machinery doesn't know it */
> - continue;
> - }
> -
> - len = VARHDRSZ + strlen(def->defname) + 1 + strlen(value);
> - /* +1 leaves room for sprintf's trailing null */
> - t = (text *) palloc(len + 1);
> - SET_VARSIZE(t, len);
> - sprintf(VARDATA(t), "%s=%s", def->defname, value);
> -
> - astate = accumArrayResult(astate, PointerGetDatum(t),
> - false, TEXTOID,
> - CurrentMemoryContext);
> - }
> - }
> -
> - if (astate)
> - result = makeArrayResult(astate, CurrentMemoryContext);
> - else
> - result = (Datum) 0;
> -
> - return result;
> -}
> -
> -
> -/*
> - * Convert the text-array format of reloptions into a List of DefElem.
> - * This is the inverse of transformRelOptions().
> - */
> -List *
> -untransformRelOptions(Datum options)
> -{
> - List *result = NIL;
> - ArrayType *array;
> - Datum *optiondatums;
> - int noptions;
> - int i;
> -
> - /* Nothing to do if no options */
> - if (!PointerIsValid(DatumGetPointer(options)))
> - return result;
> -
> - array = DatumGetArrayTypeP(options);
> -
> - deconstruct_array(array, TEXTOID, -1, false, TYPALIGN_INT,
> - &optiondatums, NULL, &noptions);
> -
> - for (i = 0; i < noptions; i++)
> - {
> - char *s;
> - char *p;
> - Node *val = NULL;
> -
> - s = TextDatumGetCString(optiondatums[i]);
> - p = strchr(s, '=');
> - if (p)
> - {
> - *p++ = '\0';
> - val = (Node *) makeString(pstrdup(p));
> - }
> - result = lappend(result, makeDefElem(pstrdup(s), val, -1));
> - }
> -
> - return result;
> + optionsSpecSetAddString(relopts->spec_set, name, desc, NoLock, 0, offset,
> + default_val, validator);
> +/* FIXME solve mistery with filler option! */
> }
>
> /*
> @@ -1372,12 +245,13 @@ untransformRelOptions(Datum options)
> */
> bytea *
> extractRelOptions(HeapTuple tuple, TupleDesc tupdesc,
> - amoptions_function amoptions)
> + amreloptspecset_function amoptionsspecsetfn)
> {
> bytea *options;
> bool isnull;
> Datum datum;
> Form_pg_class classForm;
> + options_spec_set *spec_set;
>
> datum = fastgetattr(tuple,
> Anum_pg_class_reloptions,
> @@ -1394,702 +268,341 @@ extractRelOptions(HeapTuple tuple, TupleDesc tupdesc,
> case RELKIND_RELATION:
> case RELKIND_TOASTVALUE:
> case RELKIND_MATVIEW:
> - options = heap_reloptions(classForm->relkind, datum, false);
> + spec_set = get_heap_relopt_spec_set();
> break;
> case RELKIND_PARTITIONED_TABLE:
> - options = partitioned_table_reloptions(datum, false);
> + spec_set = get_partitioned_relopt_spec_set();
> break;
> case RELKIND_VIEW:
> - options = view_reloptions(datum, false);
> + spec_set = get_view_relopt_spec_set();
> break;
> case RELKIND_INDEX:
> case RELKIND_PARTITIONED_INDEX:
> - options = index_reloptions(amoptions, datum, false);
> + if (amoptionsspecsetfn)
> + spec_set = amoptionsspecsetfn();
> + else
> + spec_set = NULL;
> break;
> case RELKIND_FOREIGN_TABLE:
> - options = NULL;
> + spec_set = NULL;
> break;
> default:
> Assert(false); /* can't get here */
> - options = NULL; /* keep compiler quiet */
> + spec_set = NULL; /* keep compiler quiet */
> break;
> }
> + if (spec_set)
> + options = optionsTextArrayToBytea(spec_set, datum, 0);
> + else
> + options = NULL;
>
> return options;
> }
>
> -static void
> -parseRelOptionsInternal(Datum options, bool validate,
> - relopt_value *reloptions, int numoptions)
> -{
> - ArrayType *array = DatumGetArrayTypeP(options);
> - Datum *optiondatums;
> - int noptions;
> - int i;
> -
> - deconstruct_array(array, TEXTOID, -1, false, TYPALIGN_INT,
> - &optiondatums, NULL, &noptions);
> +options_spec_set *
> +get_stdrd_relopt_spec_set(relopt_kind kind)
> +{
> + bool is_for_toast = (kind == RELOPT_KIND_TOAST);
> +
> + options_spec_set * stdrd_relopt_spec_set = allocateOptionsSpecSet(
> + is_for_toast ? "toast" : NULL, sizeof(StdRdOptions), 0); //FIXME change 0 to actual value (may be)
> + optionsSpecSetAddInt(stdrd_relopt_spec_set, "fillfactor",
> + "Packs table pages only to this percentag",
> + ShareUpdateExclusiveLock, /* since it applies only
> + * to later inserts */
> + is_for_toast ? OPTION_DEFINITION_FLAG_REJECT : 0,
> + offsetof(StdRdOptions, fillfactor),
> + HEAP_DEFAULT_FILLFACTOR, HEAP_MIN_FILLFACTOR, 100);
> + optionsSpecSetAddBool(stdrd_relopt_spec_set, "autovacuum_enabled",
> + "Enables autovacuum in this relation",
> + ShareUpdateExclusiveLock, 0,
> + offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, enabled),
> + true);
> + optionsSpecSetAddInt(stdrd_relopt_spec_set, "autovacuum_vacuum_threshold",
> + "Minimum number of tuple updates or deletes prior to vacuum",
> + ShareUpdateExclusiveLock,
> + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_threshold),
> + -1, 0, INT_MAX);
> + optionsSpecSetAddInt(stdrd_relopt_spec_set, "autovacuum_analyze_threshold",
> + "Minimum number of tuple updates or deletes prior to vacuum",
> + ShareUpdateExclusiveLock,
> + is_for_toast ? OPTION_DEFINITION_FLAG_REJECT : 0,
> + offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_threshold),
> + -1, 0, INT_MAX);
> + optionsSpecSetAddInt(stdrd_relopt_spec_set, "autovacuum_vacuum_cost_limit",
> + "Vacuum cost amount available before napping, for autovacuum",
> + ShareUpdateExclusiveLock,
> + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_limit),
> + -1, 0, 10000);
> + optionsSpecSetAddInt(stdrd_relopt_spec_set, "autovacuum_freeze_min_age",
> + "Minimum age at which VACUUM should freeze a table row, for autovacuum",
> + ShareUpdateExclusiveLock,
> + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_min_age),
> + -1, 0, 1000000000);
> + optionsSpecSetAddInt(stdrd_relopt_spec_set, "autovacuum_freeze_max_age",
> + "Age at which to autovacuum a table to prevent transaction ID wraparound",
> + ShareUpdateExclusiveLock,
> + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_max_age),
> + -1, 100000, 2000000000);
> + optionsSpecSetAddInt(stdrd_relopt_spec_set, "autovacuum_freeze_table_age",
> + "Age at which VACUUM should perform a full table sweep to freeze row versions",
> + ShareUpdateExclusiveLock,
> + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_table_age),
> + -1, 0, 2000000000);
> + optionsSpecSetAddInt(stdrd_relopt_spec_set, "autovacuum_multixact_freeze_min_age",
> + "Minimum multixact age at which VACUUM should freeze a row multixact's, for autovacuum",
> + ShareUpdateExclusiveLock,
> + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_min_age),
> + -1, 0, 1000000000);
> + optionsSpecSetAddInt(stdrd_relopt_spec_set, "autovacuum_multixact_freeze_max_age",
> + "Multixact age at which to autovacuum a table to prevent multixact wraparound",
> + ShareUpdateExclusiveLock,
> + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_max_age),
> + -1, 10000, 2000000000);
> + optionsSpecSetAddInt(stdrd_relopt_spec_set, "autovacuum_multixact_freeze_table_age",
> + "Age of multixact at which VACUUM should perform a full table sweep to freeze row versions",
> + ShareUpdateExclusiveLock,
> + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_table_age),
> + -1, 0, 2000000000);
> + optionsSpecSetAddInt(stdrd_relopt_spec_set,"log_autovacuum_min_duration",
> + "Sets the minimum execution time above which autovacuum actions will be logged",
> + ShareUpdateExclusiveLock,
> + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, log_min_duration),
> + -1, -1, INT_MAX);
> + optionsSpecSetAddReal(stdrd_relopt_spec_set, "autovacuum_vacuum_cost_delay",
> + "Vacuum cost delay in milliseconds, for autovacuum",
> + ShareUpdateExclusiveLock,
> + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_delay),
> + -1, 0.0, 100.0);
> + optionsSpecSetAddReal(stdrd_relopt_spec_set, "autovacuum_vacuum_scale_factor",
> + "Number of tuple updates or deletes prior to vacuum as a fraction of reltuples",
> + ShareUpdateExclusiveLock,
> + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_scale_factor),
> + -1, 0.0, 100.0);
> +
> + optionsSpecSetAddReal(stdrd_relopt_spec_set, "autovacuum_vacuum_insert_scale_factor",
> + "Number of tuple inserts prior to vacuum as a fraction of reltuples",
> + ShareUpdateExclusiveLock,
> + 0, offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_ins_scale_factor),
> + -1, 0.0, 100.0);
> +
> + optionsSpecSetAddReal(stdrd_relopt_spec_set, "autovacuum_analyze_scale_factor",
> + "Number of tuple inserts, updates or deletes prior to analyze as a fraction of reltuples",
> + ShareUpdateExclusiveLock,
> + is_for_toast ? OPTION_DEFINITION_FLAG_REJECT : 0,
> + offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_scale_factor),
> + -1, 0.0, 100.0);
> +
> +
> +
> + optionsSpecSetAddInt(stdrd_relopt_spec_set, "toast_tuple_target",
> + "Sets the target tuple length at which external columns will be toasted",
> + ShareUpdateExclusiveLock,
> + is_for_toast ? OPTION_DEFINITION_FLAG_REJECT : 0,
> + offsetof(StdRdOptions, toast_tuple_target),
> + TOAST_TUPLE_TARGET, 128, TOAST_TUPLE_TARGET_MAIN);
> +
> + optionsSpecSetAddBool(stdrd_relopt_spec_set, "user_catalog_table",
> + "Declare a table as an additional catalog table, e.g. for the purpose of logical replication",
> + AccessExclusiveLock,
> + is_for_toast ? OPTION_DEFINITION_FLAG_REJECT : 0,
> + offsetof(StdRdOptions, user_catalog_table),
> + false);
> +
> + optionsSpecSetAddInt(stdrd_relopt_spec_set, "parallel_workers",
> + "Number of parallel processes that can be used per executor node for this relation.",
> + ShareUpdateExclusiveLock,
> + is_for_toast ? OPTION_DEFINITION_FLAG_REJECT : 0,
> + offsetof(StdRdOptions, parallel_workers),
> + -1, 0, 1024);
> +
> + optionsSpecSetAddEnum(stdrd_relopt_spec_set, "vacuum_index_cleanup",
> + "Controls index vacuuming and index cleanup",
> + ShareUpdateExclusiveLock, 0,
> + offsetof(StdRdOptions, vacuum_index_cleanup),
> + StdRdOptIndexCleanupValues,
> + STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO,
> + gettext_noop("Valid values are \"on\", \"off\", and \"auto\"."));
> +
> + optionsSpecSetAddBool(stdrd_relopt_spec_set, "vacuum_truncate",
> + "Enables vacuum to truncate empty pages at the end of this table",
> + ShareUpdateExclusiveLock, 0,
> + offsetof(StdRdOptions, vacuum_truncate),
> + true);
> +
> +// FIXME Do something with OIDS
> +
> + return stdrd_relopt_spec_set;
> +}
> +
> +
> +static options_spec_set *heap_relopt_spec_set = NULL;
> +
> +options_spec_set *
> +get_heap_relopt_spec_set(void)
> +{
> + if (heap_relopt_spec_set)
> + return heap_relopt_spec_set;
> + heap_relopt_spec_set = get_stdrd_relopt_spec_set(RELOPT_KIND_HEAP);
> + return heap_relopt_spec_set;
> +}
> +
> +static options_spec_set *toast_relopt_spec_set = NULL;
> +
> +options_spec_set *
> +get_toast_relopt_spec_set(void)
> +{
> + if (toast_relopt_spec_set)
> + return toast_relopt_spec_set;
> + toast_relopt_spec_set = get_stdrd_relopt_spec_set(RELOPT_KIND_TOAST);
> + return toast_relopt_spec_set;
> +}
> +
> +static options_spec_set *partitioned_relopt_spec_set = NULL;
>
> - for (i = 0; i < noptions; i++)
> - {
> - char *text_str = VARDATA(optiondatums[i]);
> - int text_len = VARSIZE(optiondatums[i]) - VARHDRSZ;
> - int j;
> -
> - /* Search for a match in reloptions */
> - for (j = 0; j < numoptions; j++)
> - {
> - int kw_len = reloptions[j].gen->namelen;
> -
> - if (text_len > kw_len && text_str[kw_len] == '=' &&
> - strncmp(text_str, reloptions[j].gen->name, kw_len) == 0)
> - {
> - parse_one_reloption(&reloptions[j], text_str, text_len,
> - validate);
> - break;
> - }
> - }
> -
> - if (j >= numoptions && validate)
> - {
> - char *s;
> - char *p;
> -
> - s = TextDatumGetCString(optiondatums[i]);
> - p = strchr(s, '=');
> - if (p)
> - *p = '\0';
> - ereport(ERROR,
> - (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> - errmsg("unrecognized parameter \"%s\"", s)));
> - }
> - }
> -
> - /* It's worth avoiding memory leaks in this function */
> - pfree(optiondatums);
> +options_spec_set *
> +get_partitioned_relopt_spec_set(void)
> +{
> + if (partitioned_relopt_spec_set)
> + return partitioned_relopt_spec_set;
> + partitioned_relopt_spec_set = allocateOptionsSpecSet(
> + NULL, sizeof(StdRdOptions), 0);
> + /* No options for now, so spec set is empty */
>
> - if (((void *) array) != DatumGetPointer(options))
> - pfree(array);
> + return partitioned_relopt_spec_set;
> }
>
> /*
> - * Interpret reloptions that are given in text-array format.
> - *
> - * options is a reloption text array as constructed by transformRelOptions.
> - * kind specifies the family of options to be processed.
> - *
> - * The return value is a relopt_value * array on which the options actually
> - * set in the options array are marked with isset=true. The length of this
> - * array is returned in *numrelopts. Options not set are also present in the
> - * array; this is so that the caller can easily locate the default values.
> - *
> - * If there are no options of the given kind, numrelopts is set to 0 and NULL
> - * is returned (unless options are illegally supplied despite none being
> - * defined, in which case an error occurs).
> - *
> - * Note: values of type int, bool and real are allocated as part of the
> - * returned array. Values of type string are allocated separately and must
> - * be freed by the caller.
> + * Parse local options, allocate a bytea struct that's of the specified
> + * 'base_size' plus any extra space that's needed for string variables,
> + * fill its option's fields located at the given offsets and return it.
> */
> -static relopt_value *
> -parseRelOptions(Datum options, bool validate, relopt_kind kind,
> - int *numrelopts)
> -{
> - relopt_value *reloptions = NULL;
> - int numoptions = 0;
> - int i;
> - int j;
> -
> - if (need_initialization)
> - initialize_reloptions();
> -
> - /* Build a list of expected options, based on kind */
> -
> - for (i = 0; relOpts[i]; i++)
> - if (relOpts[i]->kinds & kind)
> - numoptions++;
> -
> - if (numoptions > 0)
> - {
> - reloptions = palloc(numoptions * sizeof(relopt_value));
> -
> - for (i = 0, j = 0; relOpts[i]; i++)
> - {
> - if (relOpts[i]->kinds & kind)
> - {
> - reloptions[j].gen = relOpts[i];
> - reloptions[j].isset = false;
> - j++;
> - }
> - }
> - }
> -
> - /* Done if no options */
> - if (PointerIsValid(DatumGetPointer(options)))
> - parseRelOptionsInternal(options, validate, reloptions, numoptions);
> -
> - *numrelopts = numoptions;
> - return reloptions;
> -}
> -
> -/* Parse local unregistered options. */
> -static relopt_value *
> -parseLocalRelOptions(local_relopts *relopts, Datum options, bool validate)
> +void *
> +build_local_reloptions(local_relopts *relopts, Datum options, bool validate)
> {
> - int nopts = list_length(relopts->options);
> - relopt_value *values = palloc(sizeof(*values) * nopts);
> + void *opts;
> ListCell *lc;
> - int i = 0;
> -
> - foreach(lc, relopts->options)
> - {
> - local_relopt *opt = lfirst(lc);
> -
> - values[i].gen = opt->option;
> - values[i].isset = false;
> -
> - i++;
> - }
> -
> - if (options != (Datum) 0)
> - parseRelOptionsInternal(options, validate, values, nopts);
> + opts = (void *) optionsTextArrayToBytea(relopts->spec_set, options, validate);
>
> - return values;
> -}
> -
> -/*
> - * Subroutine for parseRelOptions, to parse and validate a single option's
> - * value
> - */
> -static void
> -parse_one_reloption(relopt_value *option, char *text_str, int text_len,
> - bool validate)
> -{
> - char *value;
> - int value_len;
> - bool parsed;
> - bool nofree = false;
> -
> - if (option->isset && validate)
> - ereport(ERROR,
> - (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> - errmsg("parameter \"%s\" specified more than once",
> - option->gen->name)));
> -
> - value_len = text_len - option->gen->namelen - 1;
> - value = (char *) palloc(value_len + 1);
> - memcpy(value, text_str + option->gen->namelen + 1, value_len);
> - value[value_len] = '\0';
> -
> - switch (option->gen->type)
> - {
> - case RELOPT_TYPE_BOOL:
> - {
> - parsed = parse_bool(value, &option->values.bool_val);
> - if (validate && !parsed)
> - ereport(ERROR,
> - (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> - errmsg("invalid value for boolean option \"%s\": %s",
> - option->gen->name, value)));
> - }
> - break;
> - case RELOPT_TYPE_INT:
> - {
> - relopt_int *optint = (relopt_int *) option->gen;
> -
> - parsed = parse_int(value, &option->values.int_val, 0, NULL);
> - if (validate && !parsed)
> - ereport(ERROR,
> - (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> - errmsg("invalid value for integer option \"%s\": %s",
> - option->gen->name, value)));
> - if (validate && (option->values.int_val < optint->min ||
> - option->values.int_val > optint->max))
> - ereport(ERROR,
> - (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> - errmsg("value %s out of bounds for option \"%s\"",
> - value, option->gen->name),
> - errdetail("Valid values are between \"%d\" and \"%d\".",
> - optint->min, optint->max)));
> - }
> - break;
> - case RELOPT_TYPE_REAL:
> - {
> - relopt_real *optreal = (relopt_real *) option->gen;
> -
> - parsed = parse_real(value, &option->values.real_val, 0, NULL);
> - if (validate && !parsed)
> - ereport(ERROR,
> - (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> - errmsg("invalid value for floating point option \"%s\": %s",
> - option->gen->name, value)));
> - if (validate && (option->values.real_val < optreal->min ||
> - option->values.real_val > optreal->max))
> - ereport(ERROR,
> - (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> - errmsg("value %s out of bounds for option \"%s\"",
> - value, option->gen->name),
> - errdetail("Valid values are between \"%f\" and \"%f\".",
> - optreal->min, optreal->max)));
> - }
> - break;
> - case RELOPT_TYPE_ENUM:
> - {
> - relopt_enum *optenum = (relopt_enum *) option->gen;
> - relopt_enum_elt_def *elt;
> -
> - parsed = false;
> - for (elt = optenum->members; elt->string_val; elt++)
> - {
> - if (pg_strcasecmp(value, elt->string_val) == 0)
> - {
> - option->values.enum_val = elt->symbol_val;
> - parsed = true;
> - break;
> - }
> - }
> - if (validate && !parsed)
> - ereport(ERROR,
> - (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
> - errmsg("invalid value for enum option \"%s\": %s",
> - option->gen->name, value),
> - optenum->detailmsg ?
> - errdetail_internal("%s", _(optenum->detailmsg)) : 0));
> -
> - /*
> - * If value is not among the allowed string values, but we are
> - * not asked to validate, just use the default numeric value.
> - */
> - if (!parsed)
> - option->values.enum_val = optenum->default_val;
> - }
> - break;
> - case RELOPT_TYPE_STRING:
> - {
> - relopt_string *optstring = (relopt_string *) option->gen;
> -
> - option->values.string_val = value;
> - nofree = true;
> - if (validate && optstring->validate_cb)
> - (optstring->validate_cb) (value);
> - parsed = true;
> - }
> - break;
> - default:
> - elog(ERROR, "unsupported reloption type %d", option->gen->type);
> - parsed = true; /* quiet compiler */
> - break;
> - }
> + foreach(lc, relopts->validators)
> + ((relopts_validator) lfirst(lc)) (opts, NULL, 0);
> +// ((relopts_validator) lfirst(lc)) (opts, vals, noptions);
> +// FIXME solve problem with validation of separate option values;
> + return opts;
>
> - if (parsed)
> - option->isset = true;
> - if (!nofree)
> - pfree(value);
> }
>
> /*
> - * Given the result from parseRelOptions, allocate a struct that's of the
> - * specified base size plus any extra space that's needed for string variables.
> - *
> - * "base" should be sizeof(struct) of the reloptions struct (StdRdOptions or
> - * equivalent).
> + * get_view_relopt_spec_set
> + * Returns an options catalog for view relation.
> */
> -static void *
> -allocateReloptStruct(Size base, relopt_value *options, int numoptions)
> -{
> - Size size = base;
> - int i;
> -
> - for (i = 0; i < numoptions; i++)
> - {
> - relopt_value *optval = &options[i];
> -
> - if (optval->gen->type == RELOPT_TYPE_STRING)
> - {
> - relopt_string *optstr = (relopt_string *) optval->gen;
> -
> - if (optstr->fill_cb)
> - {
> - const char *val = optval->isset ? optval->values.string_val :
> - optstr->default_isnull ? NULL : optstr->default_val;
> -
> - size += optstr->fill_cb(val, NULL);
> - }
> - else
> - size += GET_STRING_RELOPTION_LEN(*optval) + 1;
> - }
> - }
> -
> - return palloc0(size);
> -}
> +static options_spec_set *view_relopt_spec_set = NULL;
>
> -/*
> - * Given the result of parseRelOptions and a parsing table, fill in the
> - * struct (previously allocated with allocateReloptStruct) with the parsed
> - * values.
> - *
> - * rdopts is the pointer to the allocated struct to be filled.
> - * basesize is the sizeof(struct) that was passed to allocateReloptStruct.
> - * options, of length numoptions, is parseRelOptions' output.
> - * elems, of length numelems, is the table describing the allowed options.
> - * When validate is true, it is expected that all options appear in elems.
> - */
> -static void
> -fillRelOptions(void *rdopts, Size basesize,
> - relopt_value *options, int numoptions,
> - bool validate,
> - const relopt_parse_elt *elems, int numelems)
> +options_spec_set *
> +get_view_relopt_spec_set(void)
> {
> - int i;
> - int offset = basesize;
> + if (view_relopt_spec_set)
> + return view_relopt_spec_set;
>
> - for (i = 0; i < numoptions; i++)
> - {
> - int j;
> - bool found = false;
> + view_relopt_spec_set = allocateOptionsSpecSet(NULL,
> + sizeof(ViewOptions), 2);
>
> - for (j = 0; j < numelems; j++)
> - {
> - if (strcmp(options[i].gen->name, elems[j].optname) == 0)
> - {
> - relopt_string *optstring;
> - char *itempos = ((char *) rdopts) + elems[j].offset;
> - char *string_val;
> -
> - switch (options[i].gen->type)
> - {
> - case RELOPT_TYPE_BOOL:
> - *(bool *) itempos = options[i].isset ?
> - options[i].values.bool_val :
> - ((relopt_bool *) options[i].gen)->default_val;
> - break;
> - case RELOPT_TYPE_INT:
> - *(int *) itempos = options[i].isset ?
> - options[i].values.int_val :
> - ((relopt_int *) options[i].gen)->default_val;
> - break;
> - case RELOPT_TYPE_REAL:
> - *(double *) itempos = options[i].isset ?
> - options[i].values.real_val :
> - ((relopt_real *) options[i].gen)->default_val;
> - break;
> - case RELOPT_TYPE_ENUM:
> - *(int *) itempos = options[i].isset ?
> - options[i].values.enum_val :
> - ((relopt_enum *) options[i].gen)->default_val;
> - break;
> - case RELOPT_TYPE_STRING:
> - optstring = (relopt_string *) options[i].gen;
> - if (options[i].isset)
> - string_val = options[i].values.string_val;
> - else if (!optstring->default_isnull)
> - string_val = optstring->default_val;
> - else
> - string_val = NULL;
> -
> - if (optstring->fill_cb)
> - {
> - Size size =
> - optstring->fill_cb(string_val,
> - (char *) rdopts + offset);
> -
> - if (size)
> - {
> - *(int *) itempos = offset;
> - offset += size;
> - }
> - else
> - *(int *) itempos = 0;
> - }
> - else if (string_val == NULL)
> - *(int *) itempos = 0;
> - else
> - {
> - strcpy((char *) rdopts + offset, string_val);
> - *(int *) itempos = offset;
> - offset += strlen(string_val) + 1;
> - }
> - break;
> - default:
> - elog(ERROR, "unsupported reloption type %d",
> - options[i].gen->type);
> - break;
> - }
> - found = true;
> - break;
> - }
> - }
> - if (validate && !found)
> - elog(ERROR, "reloption \"%s\" not found in parse table",
> - options[i].gen->name);
> - }
> - SET_VARSIZE(rdopts, offset);
> -}
> + optionsSpecSetAddBool(view_relopt_spec_set, "security_barrier",
> + "View acts as a row security barrier",
> + AccessExclusiveLock,
> + 0, offsetof(ViewOptions, security_barrier), false);
>
> + optionsSpecSetAddEnum(view_relopt_spec_set, "check_option",
> + "View has WITH CHECK OPTION defined (local or cascaded)",
> + AccessExclusiveLock, 0,
> + offsetof(ViewOptions, check_option),
> + viewCheckOptValues,
> + VIEW_OPTION_CHECK_OPTION_NOT_SET,
> + gettext_noop("Valid values are \"local\" and \"cascaded\"."));
>
> -/*
> - * Option parser for anything that uses StdRdOptions.
> - */
> -bytea *
> -default_reloptions(Datum reloptions, bool validate, relopt_kind kind)
> -{
> - static const relopt_parse_elt tab[] = {
> - {"fillfactor", RELOPT_TYPE_INT, offsetof(StdRdOptions, fillfactor)},
> - {"autovacuum_enabled", RELOPT_TYPE_BOOL,
> - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, enabled)},
> - {"autovacuum_vacuum_threshold", RELOPT_TYPE_INT,
> - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_threshold)},
> - {"autovacuum_vacuum_insert_threshold", RELOPT_TYPE_INT,
> - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_ins_threshold)},
> - {"autovacuum_analyze_threshold", RELOPT_TYPE_INT,
> - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_threshold)},
> - {"autovacuum_vacuum_cost_limit", RELOPT_TYPE_INT,
> - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_limit)},
> - {"autovacuum_freeze_min_age", RELOPT_TYPE_INT,
> - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_min_age)},
> - {"autovacuum_freeze_max_age", RELOPT_TYPE_INT,
> - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_max_age)},
> - {"autovacuum_freeze_table_age", RELOPT_TYPE_INT,
> - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_table_age)},
> - {"autovacuum_multixact_freeze_min_age", RELOPT_TYPE_INT,
> - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_min_age)},
> - {"autovacuum_multixact_freeze_max_age", RELOPT_TYPE_INT,
> - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_max_age)},
> - {"autovacuum_multixact_freeze_table_age", RELOPT_TYPE_INT,
> - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_table_age)},
> - {"log_autovacuum_min_duration", RELOPT_TYPE_INT,
> - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, log_min_duration)},
> - {"toast_tuple_target", RELOPT_TYPE_INT,
> - offsetof(StdRdOptions, toast_tuple_target)},
> - {"autovacuum_vacuum_cost_delay", RELOPT_TYPE_REAL,
> - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_delay)},
> - {"autovacuum_vacuum_scale_factor", RELOPT_TYPE_REAL,
> - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_scale_factor)},
> - {"autovacuum_vacuum_insert_scale_factor", RELOPT_TYPE_REAL,
> - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_ins_scale_factor)},
> - {"autovacuum_analyze_scale_factor", RELOPT_TYPE_REAL,
> - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_scale_factor)},
> - {"user_catalog_table", RELOPT_TYPE_BOOL,
> - offsetof(StdRdOptions, user_catalog_table)},
> - {"parallel_workers", RELOPT_TYPE_INT,
> - offsetof(StdRdOptions, parallel_workers)},
> - {"vacuum_index_cleanup", RELOPT_TYPE_ENUM,
> - offsetof(StdRdOptions, vacuum_index_cleanup)},
> - {"vacuum_truncate", RELOPT_TYPE_BOOL,
> - offsetof(StdRdOptions, vacuum_truncate)}
> - };
> -
> - return (bytea *) build_reloptions(reloptions, validate, kind,
> - sizeof(StdRdOptions),
> - tab, lengthof(tab));
> + return view_relopt_spec_set;
> }
>
> /*
> - * build_reloptions
> - *
> - * Parses "reloptions" provided by the caller, returning them in a
> - * structure containing the parsed options. The parsing is done with
> - * the help of a parsing table describing the allowed options, defined
> - * by "relopt_elems" of length "num_relopt_elems".
> - *
> - * "validate" must be true if reloptions value is freshly built by
> - * transformRelOptions(), as opposed to being read from the catalog, in which
> - * case the values contained in it must already be valid.
> - *
> - * NULL is returned if the passed-in options did not match any of the options
> - * in the parsing table, unless validate is true in which case an error would
> - * be reported.
> + * get_attribute_options_spec_set
> + * Returns an options spec det for heap attributes
> */
> -void *
> -build_reloptions(Datum reloptions, bool validate,
> - relopt_kind kind,
> - Size relopt_struct_size,
> - const relopt_parse_elt *relopt_elems,
> - int num_relopt_elems)
> -{
> - int numoptions;
> - relopt_value *options;
> - void *rdopts;
> -
> - /* parse options specific to given relation option kind */
> - options = parseRelOptions(reloptions, validate, kind, &numoptions);
> - Assert(numoptions <= num_relopt_elems);
> -
> - /* if none set, we're done */
> - if (numoptions == 0)
> - {
> - Assert(options == NULL);
> - return NULL;
> - }
> -
> - /* allocate and fill the structure */
> - rdopts = allocateReloptStruct(relopt_struct_size, options, numoptions);
> - fillRelOptions(rdopts, relopt_struct_size, options, numoptions,
> - validate, relopt_elems, num_relopt_elems);
> +static options_spec_set *attribute_options_spec_set = NULL;
>
> - pfree(options);
> -
> - return rdopts;
> -}
> -
> -/*
> - * Parse local options, allocate a bytea struct that's of the specified
> - * 'base_size' plus any extra space that's needed for string variables,
> - * fill its option's fields located at the given offsets and return it.
> - */
> -void *
> -build_local_reloptions(local_relopts *relopts, Datum options, bool validate)
> +options_spec_set *
> +get_attribute_options_spec_set(void)
> {
> - int noptions = list_length(relopts->options);
> - relopt_parse_elt *elems = palloc(sizeof(*elems) * noptions);
> - relopt_value *vals;
> - void *opts;
> - int i = 0;
> - ListCell *lc;
> + if (attribute_options_spec_set)
> + return attribute_options_spec_set;
>
> - foreach(lc, relopts->options)
> - {
> - local_relopt *opt = lfirst(lc);
> -
> - elems[i].optname = opt->option->name;
> - elems[i].opttype = opt->option->type;
> - elems[i].offset = opt->offset;
> -
> - i++;
> - }
> + attribute_options_spec_set = allocateOptionsSpecSet(NULL,
> + sizeof(AttributeOpts), 2);
>
> - vals = parseLocalRelOptions(relopts, options, validate);
> - opts = allocateReloptStruct(relopts->relopt_struct_size, vals, noptions);
> - fillRelOptions(opts, relopts->relopt_struct_size, vals, noptions, validate,
> - elems, noptions);
> + optionsSpecSetAddReal(attribute_options_spec_set, "n_distinct",
> + "Sets the planner's estimate of the number of distinct values appearing in a column (excluding child relations).",
> + ShareUpdateExclusiveLock,
> + 0, offsetof(AttributeOpts, n_distinct), 0, -1.0, DBL_MAX);
>
> - foreach(lc, relopts->validators)
> - ((relopts_validator) lfirst(lc)) (opts, vals, noptions);
> -
> - if (elems)
> - pfree(elems);
> + optionsSpecSetAddReal(attribute_options_spec_set,
> + "n_distinct_inherited",
> + "Sets the planner's estimate of the number of distinct values appearing in a column (including child relations).",
> + ShareUpdateExclusiveLock,
> + 0, offsetof(AttributeOpts, n_distinct_inherited), 0, -1.0, DBL_MAX);
>
> - return opts;
> + return attribute_options_spec_set;
> }
>
> -/*
> - * Option parser for partitioned tables
> - */
> -bytea *
> -partitioned_table_reloptions(Datum reloptions, bool validate)
> -{
> - /*
> - * There are no options for partitioned tables yet, but this is able to do
> - * some validation.
> - */
> - return (bytea *) build_reloptions(reloptions, validate,
> - RELOPT_KIND_PARTITIONED,
> - 0, NULL, 0);
> -}
>
> /*
> - * Option parser for views
> - */
> -bytea *
> -view_reloptions(Datum reloptions, bool validate)
> -{
> - static const relopt_parse_elt tab[] = {
> - {"security_barrier", RELOPT_TYPE_BOOL,
> - offsetof(ViewOptions, security_barrier)},
> - {"check_option", RELOPT_TYPE_ENUM,
> - offsetof(ViewOptions, check_option)}
> - };
> -
> - return (bytea *) build_reloptions(reloptions, validate,
> - RELOPT_KIND_VIEW,
> - sizeof(ViewOptions),
> - tab, lengthof(tab));
> -}
> + * get_tablespace_options_spec_set
> + * Returns an options spec set for tablespaces
> +*/
> +static options_spec_set *tablespace_options_spec_set = NULL;
>
> -/*
> - * Parse options for heaps, views and toast tables.
> - */
> -bytea *
> -heap_reloptions(char relkind, Datum reloptions, bool validate)
> +options_spec_set *
> +get_tablespace_options_spec_set(void)
> {
> - StdRdOptions *rdopts;
> -
> - switch (relkind)
> + if (!tablespace_options_spec_set)
> {
> - case RELKIND_TOASTVALUE:
> - rdopts = (StdRdOptions *)
> - default_reloptions(reloptions, validate, RELOPT_KIND_TOAST);
> - if (rdopts != NULL)
> - {
> - /* adjust default-only parameters for TOAST relations */
> - rdopts->fillfactor = 100;
> - rdopts->autovacuum.analyze_threshold = -1;
> - rdopts->autovacuum.analyze_scale_factor = -1;
> - }
> - return (bytea *) rdopts;
> - case RELKIND_RELATION:
> - case RELKIND_MATVIEW:
> - return default_reloptions(reloptions, validate, RELOPT_KIND_HEAP);
> - default:
> - /* other relkinds are not supported */
> - return NULL;
> - }
> -}
> -
> -
> -/*
> - * Parse options for indexes.
> - *
> - * amoptions index AM's option parser function
> - * reloptions options as text[] datum
> - * validate error flag
> - */
> -bytea *
> -index_reloptions(amoptions_function amoptions, Datum reloptions, bool validate)
> -{
> - Assert(amoptions != NULL);
> + tablespace_options_spec_set = allocateOptionsSpecSet(NULL,
> + sizeof(TableSpaceOpts), 4);
>
> - /* Assume function is strict */
> - if (!PointerIsValid(DatumGetPointer(reloptions)))
> - return NULL;
> + optionsSpecSetAddReal(tablespace_options_spec_set,
> + "random_page_cost",
> + "Sets the planner's estimate of the cost of a nonsequentially fetched disk page",
> + ShareUpdateExclusiveLock,
> + 0, offsetof(TableSpaceOpts, random_page_cost), -1, 0.0, DBL_MAX);
>
> - return amoptions(reloptions, validate);
> -}
> + optionsSpecSetAddReal(tablespace_options_spec_set, "seq_page_cost",
> + "Sets the planner's estimate of the cost of a sequentially fetched disk page",
> + ShareUpdateExclusiveLock,
> + 0, offsetof(TableSpaceOpts, seq_page_cost), -1, 0.0, DBL_MAX);
>
> -/*
> - * Option parser for attribute reloptions
> - */
> -bytea *
> -attribute_reloptions(Datum reloptions, bool validate)
> -{
> - static const relopt_parse_elt tab[] = {
> - {"n_distinct", RELOPT_TYPE_REAL, offsetof(AttributeOpts, n_distinct)},
> - {"n_distinct_inherited", RELOPT_TYPE_REAL, offsetof(AttributeOpts, n_distinct_inherited)}
> - };
> -
> - return (bytea *) build_reloptions(reloptions, validate,
> - RELOPT_KIND_ATTRIBUTE,
> - sizeof(AttributeOpts),
> - tab, lengthof(tab));
> -}
> + optionsSpecSetAddInt(tablespace_options_spec_set,
> + "effective_io_concurrency",
> + "Number of simultaneous requests that can be handled efficiently by the disk subsystem",
> + ShareUpdateExclusiveLock,
> + 0, offsetof(TableSpaceOpts, effective_io_concurrency),
> +#ifdef USE_PREFETCH
> + -1, 0, MAX_IO_CONCURRENCY
> +#else
> + 0, 0, 0
> +#endif
> + );
>
> -/*
> - * Option parser for tablespace reloptions
> - */
> -bytea *
> -tablespace_reloptions(Datum reloptions, bool validate)
> -{
> - static const relopt_parse_elt tab[] = {
> - {"random_page_cost", RELOPT_TYPE_REAL, offsetof(TableSpaceOpts, random_page_cost)},
> - {"seq_page_cost", RELOPT_TYPE_REAL, offsetof(TableSpaceOpts, seq_page_cost)},
> - {"effective_io_concurrency", RELOPT_TYPE_INT, offsetof(TableSpaceOpts, effective_io_concurrency)},
> - {"maintenance_io_concurrency", RELOPT_TYPE_INT, offsetof(TableSpaceOpts, maintenance_io_concurrency)}
> - };
> -
> - return (bytea *) build_reloptions(reloptions, validate,
> - RELOPT_KIND_TABLESPACE,
> - sizeof(TableSpaceOpts),
> - tab, lengthof(tab));
> + optionsSpecSetAddInt(tablespace_options_spec_set,
> + "maintenance_io_concurrency",
> + "Number of simultaneous requests that can be handled efficiently by the disk subsystem for maintenance work.",
> + ShareUpdateExclusiveLock,
> + 0, offsetof(TableSpaceOpts, maintenance_io_concurrency),
> +#ifdef USE_PREFETCH
> + -1, 0, MAX_IO_CONCURRENCY
> +#else
> + 0, 0, 0
> +#endif
> + );
> + }
> + return tablespace_options_spec_set;
> }
>
> /*
> @@ -2099,33 +612,55 @@ tablespace_reloptions(Datum reloptions, bool validate)
> * for a longer explanation of how this works.
> */
> LOCKMODE
> -AlterTableGetRelOptionsLockLevel(List *defList)
> +AlterTableGetRelOptionsLockLevel(Relation rel, List *defList)
> {
> LOCKMODE lockmode = NoLock;
> ListCell *cell;
> + options_spec_set *spec_set = NULL;
>
> if (defList == NIL)
> return AccessExclusiveLock;
>
> - if (need_initialization)
> - initialize_reloptions();
> + switch (rel->rd_rel->relkind)
> + {
> + case RELKIND_TOASTVALUE:
> + spec_set = get_toast_relopt_spec_set();
> + break;
> + case RELKIND_RELATION:
> + case RELKIND_MATVIEW:
> + spec_set = get_heap_relopt_spec_set();
> + break;
> + case RELKIND_INDEX:
> + spec_set = rel->rd_indam->amreloptspecset();
> + break;
> + case RELKIND_VIEW:
> + spec_set = get_view_relopt_spec_set();
> + break;
> + case RELKIND_PARTITIONED_TABLE:
> + spec_set = get_partitioned_relopt_spec_set();
> + break;
> + default:
> + Assert(false); /* can't get here */
> + break;
> + }
> + Assert(spec_set); /* No spec set - no reloption change. Should
> + * never get here */
>
> foreach(cell, defList)
> {
> DefElem *def = (DefElem *) lfirst(cell);
> +
> int i;
>
> - for (i = 0; relOpts[i]; i++)
> + for (i = 0; i < spec_set->num; i++)
> {
> - if (strncmp(relOpts[i]->name,
> - def->defname,
> - relOpts[i]->namelen + 1) == 0)
> - {
> - if (lockmode < relOpts[i]->lockmode)
> - lockmode = relOpts[i]->lockmode;
> - }
> + option_spec_basic *gen = spec_set->definitions[i];
> +
> + if (pg_strcasecmp(gen->name,
> + def->defname) == 0)
> + if (lockmode < gen->lockmode)
> + lockmode = gen->lockmode;
> }
> }
> -
> return lockmode;
> -}
> +}
> \ No newline at end of file
> diff --git a/src/backend/access/gin/gininsert.c b/src/backend/access/gin/gininsert.c
> index 0e8672c..0cbffad 100644
> --- a/src/backend/access/gin/gininsert.c
> +++ b/src/backend/access/gin/gininsert.c
> @@ -512,6 +512,8 @@ gininsert(Relation index, Datum *values, bool *isnull,
>
> oldCtx = MemoryContextSwitchTo(insertCtx);
>
> +// elog(WARNING, "GinGetUseFastUpdate = %i", GinGetUseFastUpdate(index));
> +
> if (GinGetUseFastUpdate(index))
> {
> GinTupleCollector collector;
> diff --git a/src/backend/access/gin/ginutil.c b/src/backend/access/gin/ginutil.c
> index 6d2d71b..d1fa3a0 100644
> --- a/src/backend/access/gin/ginutil.c
> +++ b/src/backend/access/gin/ginutil.c
> @@ -16,7 +16,7 @@
>
> #include "access/gin_private.h"
> #include "access/ginxlog.h"
> -#include "access/reloptions.h"
> +#include "access/options.h"
> #include "access/xloginsert.h"
> #include "catalog/pg_collation.h"
> #include "catalog/pg_type.h"
> @@ -28,6 +28,7 @@
> #include "utils/builtins.h"
> #include "utils/index_selfuncs.h"
> #include "utils/typcache.h"
> +#include "utils/guc.h"
>
>
> /*
> @@ -67,7 +68,6 @@ ginhandler(PG_FUNCTION_ARGS)
> amroutine->amvacuumcleanup = ginvacuumcleanup;
> amroutine->amcanreturn = NULL;
> amroutine->amcostestimate = gincostestimate;
> - amroutine->amoptions = ginoptions;
> amroutine->amproperty = NULL;
> amroutine->ambuildphasename = NULL;
> amroutine->amvalidate = ginvalidate;
> @@ -82,6 +82,7 @@ ginhandler(PG_FUNCTION_ARGS)
> amroutine->amestimateparallelscan = NULL;
> amroutine->aminitparallelscan = NULL;
> amroutine->amparallelrescan = NULL;
> + amroutine->amreloptspecset = gingetreloptspecset;
>
> PG_RETURN_POINTER(amroutine);
> }
> @@ -604,6 +605,7 @@ ginExtractEntries(GinState *ginstate, OffsetNumber attnum,
> return entries;
> }
>
> +/*
> bytea *
> ginoptions(Datum reloptions, bool validate)
> {
> @@ -618,6 +620,7 @@ ginoptions(Datum reloptions, bool validate)
> sizeof(GinOptions),
> tab, lengthof(tab));
> }
> +*/
>
> /*
> * Fetch index's statistical data into *stats
> @@ -705,3 +708,31 @@ ginUpdateStats(Relation index, const GinStatsData *stats, bool is_build)
>
> END_CRIT_SECTION();
> }
> +
> +static options_spec_set *gin_relopt_specset = NULL;
> +
> +void *
> +gingetreloptspecset(void)
> +{
> + if (gin_relopt_specset)
> + return gin_relopt_specset;
> +
> + gin_relopt_specset = allocateOptionsSpecSet(NULL,
> + sizeof(GinOptions), 2);
> +
> + optionsSpecSetAddBool(gin_relopt_specset, "fastupdate",
> + "Enables \"fast update\" feature for this GIN index",
> + AccessExclusiveLock,
> + 0,
> + offsetof(GinOptions, useFastUpdate),
> + GIN_DEFAULT_USE_FASTUPDATE);
> +
> + optionsSpecSetAddInt(gin_relopt_specset, "gin_pending_list_limit",
> + "Maximum size of the pending list for this GIN index, in kilobytes",
> + AccessExclusiveLock,
> + 0,
> + offsetof(GinOptions, pendingListCleanupSize),
> + -1, 64, MAX_KILOBYTES);
> +
> + return gin_relopt_specset;
> +}
> diff --git a/src/backend/access/gist/gist.c b/src/backend/access/gist/gist.c
> index 0683f42..cbbc6a5 100644
> --- a/src/backend/access/gist/gist.c
> +++ b/src/backend/access/gist/gist.c
> @@ -88,7 +88,6 @@ gisthandler(PG_FUNCTION_ARGS)
> amroutine->amvacuumcleanup = gistvacuumcleanup;
> amroutine->amcanreturn = gistcanreturn;
> amroutine->amcostestimate = gistcostestimate;
> - amroutine->amoptions = gistoptions;
> amroutine->amproperty = gistproperty;
> amroutine->ambuildphasename = NULL;
> amroutine->amvalidate = gistvalidate;
> @@ -103,6 +102,7 @@ gisthandler(PG_FUNCTION_ARGS)
> amroutine->amestimateparallelscan = NULL;
> amroutine->aminitparallelscan = NULL;
> amroutine->amparallelrescan = NULL;
> + amroutine->amreloptspecset = gistgetreloptspecset;
>
> PG_RETURN_POINTER(amroutine);
> }
> diff --git a/src/backend/access/gist/gistbuild.c b/src/backend/access/gist/gistbuild.c
> index baad28c..931d249 100644
> --- a/src/backend/access/gist/gistbuild.c
> +++ b/src/backend/access/gist/gistbuild.c
> @@ -215,6 +215,7 @@ gistbuild(Relation heap, Relation index, IndexInfo *indexInfo)
> buildstate.buildMode = GIST_BUFFERING_DISABLED;
> else /* must be "auto" */
> buildstate.buildMode = GIST_BUFFERING_AUTO;
> +//elog(WARNING, "biffering_mode = %i", options->buffering_mode);
> }
> else
> {
> diff --git a/src/backend/access/gist/gistutil.c b/src/backend/access/gist/gistutil.c
> index 43ba03b..0391915 100644
> --- a/src/backend/access/gist/gistutil.c
> +++ b/src/backend/access/gist/gistutil.c
> @@ -17,7 +17,7 @@
>
> #include "access/gist_private.h"
> #include "access/htup_details.h"
> -#include "access/reloptions.h"
> +#include "access/options.h"
> #include "catalog/pg_opclass.h"
> #include "storage/indexfsm.h"
> #include "storage/lmgr.h"
> @@ -916,20 +916,6 @@ gistPageRecyclable(Page page)
> return false;
> }
>
> -bytea *
> -gistoptions(Datum reloptions, bool validate)
> -{
> - static const relopt_parse_elt tab[] = {
> - {"fillfactor", RELOPT_TYPE_INT, offsetof(GiSTOptions, fillfactor)},
> - {"buffering", RELOPT_TYPE_ENUM, offsetof(GiSTOptions, buffering_mode)}
> - };
> -
> - return (bytea *) build_reloptions(reloptions, validate,
> - RELOPT_KIND_GIST,
> - sizeof(GiSTOptions),
> - tab, lengthof(tab));
> -}
> -
> /*
> * gistproperty() -- Check boolean properties of indexes.
> *
> @@ -1064,3 +1050,42 @@ gistGetFakeLSN(Relation rel)
> return GetFakeLSNForUnloggedRel();
> }
> }
> +
> +/* values from GistOptBufferingMode */
> +opt_enum_elt_def gistBufferingOptValues[] =
> +{
> + {"auto", GIST_OPTION_BUFFERING_AUTO},
> + {"on", GIST_OPTION_BUFFERING_ON},
> + {"off", GIST_OPTION_BUFFERING_OFF},
> + {(const char *) NULL} /* list terminator */
> +};
> +
> +static options_spec_set *gist_relopt_specset = NULL;
> +
> +void *
> +gistgetreloptspecset(void)
> +{
> + if (gist_relopt_specset)
> + return gist_relopt_specset;
> +
> + gist_relopt_specset = allocateOptionsSpecSet(NULL,
> + sizeof(GiSTOptions), 2);
> +
> + optionsSpecSetAddInt(gist_relopt_specset, "fillfactor",
> + "Packs gist index pages only to this percentage",
> + NoLock, /* No ALTER, no lock */
> + 0,
> + offsetof(GiSTOptions, fillfactor),
> + GIST_DEFAULT_FILLFACTOR,
> + GIST_MIN_FILLFACTOR, 100);
> +
> + optionsSpecSetAddEnum(gist_relopt_specset, "buffering",
> + "Enables buffering build for this GiST index",
> + NoLock, /* No ALTER, no lock */
> + 0,
> + offsetof(GiSTOptions, buffering_mode),
> + gistBufferingOptValues,
> + GIST_OPTION_BUFFERING_AUTO,
> + gettext_noop("Valid values are \"on\", \"off\", and \"auto\"."));
> + return gist_relopt_specset;
> +}
> diff --git a/src/backend/access/hash/hash.c b/src/backend/access/hash/hash.c
> index eb38104..8dc4ca7 100644
> --- a/src/backend/access/hash/hash.c
> +++ b/src/backend/access/hash/hash.c
> @@ -85,7 +85,6 @@ hashhandler(PG_FUNCTION_ARGS)
> amroutine->amvacuumcleanup = hashvacuumcleanup;
> amroutine->amcanreturn = NULL;
> amroutine->amcostestimate = hashcostestimate;
> - amroutine->amoptions = hashoptions;
> amroutine->amproperty = NULL;
> amroutine->ambuildphasename = NULL;
> amroutine->amvalidate = hashvalidate;
> @@ -100,6 +99,7 @@ hashhandler(PG_FUNCTION_ARGS)
> amroutine->amestimateparallelscan = NULL;
> amroutine->aminitparallelscan = NULL;
> amroutine->amparallelrescan = NULL;
> + amroutine->amreloptspecset = hashgetreloptspecset;
>
> PG_RETURN_POINTER(amroutine);
> }
> diff --git a/src/backend/access/hash/hashpage.c b/src/backend/access/hash/hashpage.c
> index 159646c..38f64ef 100644
> --- a/src/backend/access/hash/hashpage.c
> +++ b/src/backend/access/hash/hashpage.c
> @@ -359,6 +359,8 @@ _hash_init(Relation rel, double num_tuples, ForkNumber forkNum)
> data_width = sizeof(uint32);
> item_width = MAXALIGN(sizeof(IndexTupleData)) + MAXALIGN(data_width) +
> sizeof(ItemIdData); /* include the line pointer */
> +//elog(WARNING, "fillfactor = %i", HashGetFillFactor(rel));
> +
> ffactor = HashGetTargetPageUsage(rel) / item_width;
> /* keep to a sane range */
> if (ffactor < 10)
> diff --git a/src/backend/access/hash/hashutil.c b/src/backend/access/hash/hashutil.c
> index 5198728..826beab 100644
> --- a/src/backend/access/hash/hashutil.c
> +++ b/src/backend/access/hash/hashutil.c
> @@ -15,7 +15,7 @@
> #include "postgres.h"
>
> #include "access/hash.h"
> -#include "access/reloptions.h"
> +#include "access/options.h"
> #include "access/relscan.h"
> #include "port/pg_bitutils.h"
> #include "storage/buf_internals.h"
> @@ -272,19 +272,6 @@ _hash_checkpage(Relation rel, Buffer buf, int flags)
> }
> }
>
> -bytea *
> -hashoptions(Datum reloptions, bool validate)
> -{
> - static const relopt_parse_elt tab[] = {
> - {"fillfactor", RELOPT_TYPE_INT, offsetof(HashOptions, fillfactor)},
> - };
> -
> - return (bytea *) build_reloptions(reloptions, validate,
> - RELOPT_KIND_HASH,
> - sizeof(HashOptions),
> - tab, lengthof(tab));
> -}
> -
> /*
> * _hash_get_indextuple_hashkey - get the hash index tuple's hash key value
> */
> @@ -620,3 +607,24 @@ _hash_kill_items(IndexScanDesc scan)
> else
> _hash_relbuf(rel, buf);
> }
> +
> +static options_spec_set *hash_relopt_specset = NULL;
> +
> +void *
> +hashgetreloptspecset(void)
> +{
> + if (hash_relopt_specset)
> + return hash_relopt_specset;
> +
> + hash_relopt_specset = allocateOptionsSpecSet(NULL,
> + sizeof(HashOptions), 1);
> + optionsSpecSetAddInt(hash_relopt_specset, "fillfactor",
> + "Packs hash index pages only to this percentage",
> + NoLock, /* No ALTER -- no lock */
> + 0,
> + offsetof(HashOptions, fillfactor),
> + HASH_DEFAULT_FILLFACTOR,
> + HASH_MIN_FILLFACTOR, 100);
> +
> + return hash_relopt_specset;
> +}
> diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
> index 7355e1d..f7b117e 100644
> --- a/src/backend/access/nbtree/nbtinsert.c
> +++ b/src/backend/access/nbtree/nbtinsert.c
> @@ -2745,6 +2745,8 @@ _bt_delete_or_dedup_one_page(Relation rel, Relation heapRel,
> _bt_bottomupdel_pass(rel, buffer, heapRel, insertstate->itemsz))
> return;
>
> +// elog(WARNING, "Deduplicate_items = %i", BTGetDeduplicateItems(rel));
> +
> /* Perform deduplication pass (when enabled and index-is-allequalimage) */
> if (BTGetDeduplicateItems(rel) && itup_key->allequalimage)
> _bt_dedup_pass(rel, buffer, heapRel, insertstate->itup,
> diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
> index 40ad095..f171c54 100644
> --- a/src/backend/access/nbtree/nbtree.c
> +++ b/src/backend/access/nbtree/nbtree.c
> @@ -22,6 +22,7 @@
> #include "access/nbtxlog.h"
> #include "access/relscan.h"
> #include "access/xlog.h"
> +#include "access/options.h"
> #include "commands/progress.h"
> #include "commands/vacuum.h"
> #include "miscadmin.h"
> @@ -124,7 +125,6 @@ bthandler(PG_FUNCTION_ARGS)
> amroutine->amvacuumcleanup = btvacuumcleanup;
> amroutine->amcanreturn = btcanreturn;
> amroutine->amcostestimate = btcostestimate;
> - amroutine->amoptions = btoptions;
> amroutine->amproperty = btproperty;
> amroutine->ambuildphasename = btbuildphasename;
> amroutine->amvalidate = btvalidate;
> @@ -139,6 +139,7 @@ bthandler(PG_FUNCTION_ARGS)
> amroutine->amestimateparallelscan = btestimateparallelscan;
> amroutine->aminitparallelscan = btinitparallelscan;
> amroutine->amparallelrescan = btparallelrescan;
> + amroutine->amreloptspecset = btgetreloptspecset;
>
> PG_RETURN_POINTER(amroutine);
> }
> @@ -1418,3 +1419,37 @@ btcanreturn(Relation index, int attno)
> {
> return true;
> }
> +
> +static options_spec_set *bt_relopt_specset = NULL;
> +
> +void *
> +btgetreloptspecset(void)
> +{
> + if (bt_relopt_specset)
> + return bt_relopt_specset;
> +
> + bt_relopt_specset = allocateOptionsSpecSet(NULL,
> + sizeof(BTOptions), 3);
> +
> + optionsSpecSetAddInt(
> + bt_relopt_specset, "fillfactor",
> + "Packs btree index pages only to this percentage",
> + ShareUpdateExclusiveLock, /* since it applies only to later inserts */
> + 0, offsetof(BTOptions, fillfactor),
> + BTREE_DEFAULT_FILLFACTOR, BTREE_MIN_FILLFACTOR, 100
> + );
> + optionsSpecSetAddReal(
> + bt_relopt_specset, "vacuum_cleanup_index_scale_factor",
> + "Number of tuple inserts prior to index cleanup as a fraction of reltuples",
> + ShareUpdateExclusiveLock,
> + 0, offsetof(BTOptions,vacuum_cleanup_index_scale_factor),
> + -1, 0.0, 1e10
> + );
> + optionsSpecSetAddBool(
> + bt_relopt_specset, "deduplicate_items",
> + "Enables \"deduplicate items\" feature for this btree index",
> + ShareUpdateExclusiveLock, /* since it applies only to later inserts */
> + 0, offsetof(BTOptions,deduplicate_items), true
> + );
> + return bt_relopt_specset;
> +}
> diff --git a/src/backend/access/nbtree/nbtutils.c b/src/backend/access/nbtree/nbtutils.c
> index c72b456..2588a30 100644
> --- a/src/backend/access/nbtree/nbtutils.c
> +++ b/src/backend/access/nbtree/nbtutils.c
> @@ -18,7 +18,7 @@
> #include <time.h>
>
> #include "access/nbtree.h"
> -#include "access/reloptions.h"
> +#include "storage/lock.h"
> #include "access/relscan.h"
> #include "catalog/catalog.h"
> #include "commands/progress.h"
> @@ -2100,25 +2100,6 @@ BTreeShmemInit(void)
> Assert(found);
> }
>
> -bytea *
> -btoptions(Datum reloptions, bool validate)
> -{
> - static const relopt_parse_elt tab[] = {
> - {"fillfactor", RELOPT_TYPE_INT, offsetof(BTOptions, fillfactor)},
> - {"vacuum_cleanup_index_scale_factor", RELOPT_TYPE_REAL,
> - offsetof(BTOptions, vacuum_cleanup_index_scale_factor)},
> - {"deduplicate_items", RELOPT_TYPE_BOOL,
> - offsetof(BTOptions, deduplicate_items)}
> -
> - };
> -
> - return (bytea *) build_reloptions(reloptions, validate,
> - RELOPT_KIND_BTREE,
> - sizeof(BTOptions),
> - tab, lengthof(tab));
> -
> -}
> -
> /*
> * btproperty() -- Check boolean properties of indexes.
> *
> diff --git a/src/backend/access/spgist/spgutils.c b/src/backend/access/spgist/spgutils.c
> index 03a9cd3..14429ad 100644
> --- a/src/backend/access/spgist/spgutils.c
> +++ b/src/backend/access/spgist/spgutils.c
> @@ -17,7 +17,7 @@
>
> #include "access/amvalidate.h"
> #include "access/htup_details.h"
> -#include "access/reloptions.h"
> +#include "access/options.h"
> #include "access/spgist_private.h"
> #include "access/toast_compression.h"
> #include "access/transam.h"
> @@ -72,7 +72,6 @@ spghandler(PG_FUNCTION_ARGS)
> amroutine->amvacuumcleanup = spgvacuumcleanup;
> amroutine->amcanreturn = spgcanreturn;
> amroutine->amcostestimate = spgcostestimate;
> - amroutine->amoptions = spgoptions;
> amroutine->amproperty = spgproperty;
> amroutine->ambuildphasename = NULL;
> amroutine->amvalidate = spgvalidate;
> @@ -87,6 +86,7 @@ spghandler(PG_FUNCTION_ARGS)
> amroutine->amestimateparallelscan = NULL;
> amroutine->aminitparallelscan = NULL;
> amroutine->amparallelrescan = NULL;
> + amroutine->amreloptspecset = spggetreloptspecset;
>
> PG_RETURN_POINTER(amroutine);
> }
> @@ -550,6 +550,7 @@ SpGistGetBuffer(Relation index, int flags, int needSpace, bool *isNew)
> * related to the ones already on it. But fillfactor mustn't cause an
> * error for requests that would otherwise be legal.
> */
> +//elog(WARNING, "fillfactor = %i", SpGistGetFillFactor(index));
> needSpace += SpGistGetTargetPageFreeSpace(index);
> needSpace = Min(needSpace, SPGIST_PAGE_CAPACITY);
>
> @@ -721,23 +722,6 @@ SpGistInitMetapage(Page page)
> }
>
> /*
> - * reloptions processing for SPGiST
> - */
> -bytea *
> -spgoptions(Datum reloptions, bool validate)
> -{
> - static const relopt_parse_elt tab[] = {
> - {"fillfactor", RELOPT_TYPE_INT, offsetof(SpGistOptions, fillfactor)},
> - };
> -
> - return (bytea *) build_reloptions(reloptions, validate,
> - RELOPT_KIND_SPGIST,
> - sizeof(SpGistOptions),
> - tab, lengthof(tab));
> -
> -}
> -
> -/*
> * Get the space needed to store a non-null datum of the indicated type
> * in an inner tuple (that is, as a prefix or node label).
> * Note the result is already rounded up to a MAXALIGN boundary.
> @@ -1336,3 +1320,25 @@ spgproperty(Oid index_oid, int attno,
>
> return true;
> }
> +
> +static options_spec_set *spgist_relopt_specset = NULL;
> +
> +void *
> +spggetreloptspecset(void)
> +{
> + if (!spgist_relopt_specset)
> + {
> + spgist_relopt_specset = allocateOptionsSpecSet(NULL,
> + sizeof(SpGistOptions), 1);
> +
> + optionsSpecSetAddInt(spgist_relopt_specset, "fillfactor",
> + "Packs spgist index pages only to this percentage",
> + ShareUpdateExclusiveLock, /* since it applies only
> + * to later inserts */
> + 0,
> + offsetof(SpGistOptions, fillfactor),
> + SPGIST_DEFAULT_FILLFACTOR,
> + SPGIST_MIN_FILLFACTOR, 100);
> + }
> + return spgist_relopt_specset;
> +}
> diff --git a/src/backend/commands/createas.c b/src/backend/commands/createas.c
> index 0982851..4f3dbb8 100644
> --- a/src/backend/commands/createas.c
> +++ b/src/backend/commands/createas.c
> @@ -90,6 +90,7 @@ create_ctas_internal(List *attrList, IntoClause *into)
> Datum toast_options;
> static char *validnsps[] = HEAP_RELOPT_NAMESPACES;
> ObjectAddress intoRelationAddr;
> + List *toastDefList;
>
> /* This code supports both CREATE TABLE AS and CREATE MATERIALIZED VIEW */
> is_matview = (into->viewQuery != NULL);
> @@ -124,14 +125,12 @@ create_ctas_internal(List *attrList, IntoClause *into)
> CommandCounterIncrement();
>
> /* parse and validate reloptions for the toast table */
> - toast_options = transformRelOptions((Datum) 0,
> - create->options,
> - "toast",
> - validnsps,
> - true, false);
>
> - (void) heap_reloptions(RELKIND_TOASTVALUE, toast_options, true);
> + optionsDefListValdateNamespaces(create->options, validnsps);
> + toastDefList = optionsDefListFilterNamespaces(create->options, "toast");
>
> + toast_options = transformOptions(get_toast_relopt_spec_set(), (Datum) 0,
> + toastDefList, 0);
> NewRelationCreateToastTable(intoRelationAddr.objectId, toast_options);
>
> /* Create the "view" part of a materialized view. */
> diff --git a/src/backend/commands/foreigncmds.c b/src/backend/commands/foreigncmds.c
> index 146fa57..758ca34 100644
> --- a/src/backend/commands/foreigncmds.c
> +++ b/src/backend/commands/foreigncmds.c
> @@ -112,7 +112,7 @@ transformGenericOptions(Oid catalogId,
> List *options,
> Oid fdwvalidator)
> {
> - List *resultOptions = untransformRelOptions(oldOptions);
> + List *resultOptions = optionsTextArrayToDefList(oldOptions);
> ListCell *optcell;
> Datum result;
>
> diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c
> index c14ca27..96d465a 100644
> --- a/src/backend/commands/indexcmds.c
> +++ b/src/backend/commands/indexcmds.c
> @@ -19,6 +19,7 @@
> #include "access/heapam.h"
> #include "access/htup_details.h"
> #include "access/reloptions.h"
> +#include "access/options.h"
> #include "access/sysattr.h"
> #include "access/tableam.h"
> #include "access/xact.h"
> @@ -531,7 +532,7 @@ DefineIndex(Oid relationId,
> Form_pg_am accessMethodForm;
> IndexAmRoutine *amRoutine;
> bool amcanorder;
> - amoptions_function amoptions;
> + amreloptspecset_function amreloptspecsetfn;
> bool partitioned;
> bool safe_index;
> Datum reloptions;
> @@ -837,7 +838,7 @@ DefineIndex(Oid relationId,
> accessMethodName)));
>
> amcanorder = amRoutine->amcanorder;
> - amoptions = amRoutine->amoptions;
> + amreloptspecsetfn = amRoutine->amreloptspecset;
>
> pfree(amRoutine);
> ReleaseSysCache(tuple);
> @@ -851,10 +852,19 @@ DefineIndex(Oid relationId,
> /*
> * Parse AM-specific options, convert to text array form, validate.
> */
> - reloptions = transformRelOptions((Datum) 0, stmt->options,
> - NULL, NULL, false, false);
>
> - (void) index_reloptions(amoptions, reloptions, true);
> + if (amreloptspecsetfn)
> + {
> + reloptions = transformOptions(amreloptspecsetfn(),
> + (Datum) 0, stmt->options, 0);
> + }
> + else
> + {
> + ereport(ERROR,
> + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
> + errmsg("access method %s does not support options",
> + accessMethodName)));
> + }
>
> /*
> * Prepare arguments for index_create, primarily an IndexInfo structure.
> @@ -1986,8 +1996,7 @@ ComputeIndexAttrs(IndexInfo *indexInfo,
> palloc0(sizeof(Datum) * indexInfo->ii_NumIndexAttrs);
>
> indexInfo->ii_OpclassOptions[attn] =
> - transformRelOptions((Datum) 0, attribute->opclassopts,
> - NULL, NULL, false, false);
> + optionsDefListToTextArray(attribute->opclassopts);
> }
>
> attn++;
> diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
> index 1c2ebe1..7f3004f 100644
> --- a/src/backend/commands/tablecmds.c
> +++ b/src/backend/commands/tablecmds.c
> @@ -20,6 +20,7 @@
> #include "access/heapam_xlog.h"
> #include "access/multixact.h"
> #include "access/reloptions.h"
> +#include "access/options.h"
> #include "access/relscan.h"
> #include "access/sysattr.h"
> #include "access/tableam.h"
> @@ -641,7 +642,6 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId,
> ListCell *listptr;
> AttrNumber attnum;
> bool partitioned;
> - static char *validnsps[] = HEAP_RELOPT_NAMESPACES;
> Oid ofTypeId;
> ObjectAddress address;
> LOCKMODE parentLockmode;
> @@ -789,19 +789,37 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId,
> /*
> * Parse and validate reloptions, if any.
> */
> - reloptions = transformRelOptions((Datum) 0, stmt->options, NULL, validnsps,
> - true, false);
>
> switch (relkind)
> {
> case RELKIND_VIEW:
> - (void) view_reloptions(reloptions, true);
> + reloptions = transformOptions(
> + get_view_relopt_spec_set(),
> + (Datum) 0, stmt->options, 0);
> break;
> case RELKIND_PARTITIONED_TABLE:
> - (void) partitioned_table_reloptions(reloptions, true);
> + {
> + /* If it is not all listed above, then it if heap */
> + char *namespaces[] = HEAP_RELOPT_NAMESPACES;
> + List *heapDefList;
> +
> + optionsDefListValdateNamespaces(stmt->options, namespaces);
> + heapDefList = optionsDefListFilterNamespaces(stmt->options, NULL);
> + reloptions = transformOptions(get_partitioned_relopt_spec_set(),
> + (Datum) 0, heapDefList, 0);
> break;
> + }
> default:
> - (void) heap_reloptions(relkind, reloptions, true);
> + {
> + /* If it is not all listed above, then it if heap */
> + char *namespaces[] = HEAP_RELOPT_NAMESPACES;
> + List *heapDefList;
> +
> + optionsDefListValdateNamespaces(stmt->options, namespaces);
> + heapDefList = optionsDefListFilterNamespaces(stmt->options, NULL);
> + reloptions = transformOptions(get_heap_relopt_spec_set(),
> + (Datum) 0, heapDefList, 0);
> + }
> }
>
> if (stmt->ofTypename)
> @@ -4022,7 +4040,7 @@ void
> AlterTableInternal(Oid relid, List *cmds, bool recurse)
> {
> Relation rel;
> - LOCKMODE lockmode = AlterTableGetLockLevel(cmds);
> + LOCKMODE lockmode = AlterTableGetLockLevel(relid, cmds);
>
> rel = relation_open(relid, lockmode);
>
> @@ -4064,7 +4082,7 @@ AlterTableInternal(Oid relid, List *cmds, bool recurse)
> * otherwise we might end up with an inconsistent dump that can't restore.
> */
> LOCKMODE
> -AlterTableGetLockLevel(List *cmds)
> +AlterTableGetLockLevel(Oid relid, List *cmds)
> {
> /*
> * This only works if we read catalog tables using MVCC snapshots.
> @@ -4285,9 +4303,13 @@ AlterTableGetLockLevel(List *cmds)
> * getTables() */
> case AT_ResetRelOptions: /* Uses MVCC in getIndexes() and
> * getTables() */
> - cmd_lockmode = AlterTableGetRelOptionsLockLevel((List *) cmd->def);
> - break;
> -
> + {
> + Relation rel = relation_open(relid, NoLock); // FIXME I am not sure how wise it is
> + cmd_lockmode = AlterTableGetRelOptionsLockLevel(rel,
> + castNode(List, cmd->def));
> + relation_close(rel,NoLock);
> + break;
> + }
> case AT_AttachPartition:
> cmd_lockmode = ShareUpdateExclusiveLock;
> break;
> @@ -8062,11 +8084,11 @@ ATExecSetOptions(Relation rel, const char *colName, Node *options,
> /* Generate new proposed attoptions (text array) */
> datum = SysCacheGetAttr(ATTNAME, tuple, Anum_pg_attribute_attoptions,
> &isnull);
> - newOptions = transformRelOptions(isnull ? (Datum) 0 : datum,
> - castNode(List, options), NULL, NULL,
> - false, isReset);
> - /* Validate new options */
> - (void) attribute_reloptions(newOptions, true);
> +
> + newOptions = transformOptions(get_attribute_options_spec_set(),
> + isnull ? (Datum) 0 : datum,
> + castNode(List, options), OPTIONS_PARSE_MODE_FOR_ALTER |
> + (isReset ? OPTIONS_PARSE_MODE_FOR_RESET : 0));
>
> /* Build new tuple. */
> memset(repl_null, false, sizeof(repl_null));
> @@ -13704,7 +13726,8 @@ ATExecSetRelOptions(Relation rel, List *defList, AlterTableType operation,
> Datum repl_val[Natts_pg_class];
> bool repl_null[Natts_pg_class];
> bool repl_repl[Natts_pg_class];
> - static char *validnsps[] = HEAP_RELOPT_NAMESPACES;
> + List *toastDefList;
> + options_parse_mode parse_mode;
>
> if (defList == NIL && operation != AT_ReplaceRelOptions)
> return; /* nothing to do */
> @@ -13734,27 +13757,68 @@ ATExecSetRelOptions(Relation rel, List *defList, AlterTableType operation,
> }
>
> /* Generate new proposed reloptions (text array) */
> - newOptions = transformRelOptions(isnull ? (Datum) 0 : datum,
> - defList, NULL, validnsps, false,
> - operation == AT_ResetRelOptions);
>
> /* Validate */
> + parse_mode = OPTIONS_PARSE_MODE_FOR_ALTER;
> + if (operation == AT_ResetRelOptions)
> + parse_mode |= OPTIONS_PARSE_MODE_FOR_RESET;
> +
> switch (rel->rd_rel->relkind)
> {
> case RELKIND_RELATION:
> - case RELKIND_TOASTVALUE:
> + case RELKIND_TOASTVALUE: // FIXME why it is here???
> case RELKIND_MATVIEW:
> - (void) heap_reloptions(rel->rd_rel->relkind, newOptions, true);
> + {
> + char *namespaces[] = HEAP_RELOPT_NAMESPACES;
> + List *heapDefList;
> +
> + optionsDefListValdateNamespaces(defList, namespaces);
> + heapDefList = optionsDefListFilterNamespaces(
> + defList, NULL);
> + newOptions = transformOptions(get_heap_relopt_spec_set(),
> + isnull ? (Datum) 0 : datum,
> + heapDefList, parse_mode);
> + }
> break;
> +
> case RELKIND_PARTITIONED_TABLE:
> - (void) partitioned_table_reloptions(newOptions, true);
> - break;
> + {
> + char *namespaces[] = HEAP_RELOPT_NAMESPACES;
> + List *heapDefList;
> +
> + optionsDefListValdateNamespaces(defList, namespaces);
> + heapDefList = optionsDefListFilterNamespaces(
> + defList, NULL);
> + newOptions = transformOptions(get_partitioned_relopt_spec_set(),
> + isnull ? (Datum) 0 : datum,
> + heapDefList, parse_mode);
> + break;
> + }
> case RELKIND_VIEW:
> - (void) view_reloptions(newOptions, true);
> - break;
> + {
> +
> + newOptions = transformOptions(
> + get_view_relopt_spec_set(),
> + datum, defList, parse_mode);
> + break;
> + }
> case RELKIND_INDEX:
> case RELKIND_PARTITIONED_INDEX:
> - (void) index_reloptions(rel->rd_indam->amoptions, newOptions, true);
> + if (! rel->rd_indam->amreloptspecset)
> + {
> + ereport(ERROR,
> + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
> + errmsg("index %s does not support options",
> + RelationGetRelationName(rel))));
> + break;
> + }
> + parse_mode = OPTIONS_PARSE_MODE_FOR_ALTER;
> + if (operation == AT_ResetRelOptions)
> + parse_mode |= OPTIONS_PARSE_MODE_FOR_RESET;
> + newOptions = transformOptions(
> + rel->rd_indam->amreloptspecset(),
> + isnull ? (Datum) 0 : datum,
> + defList, parse_mode);
> break;
> default:
> ereport(ERROR,
> @@ -13769,7 +13833,7 @@ ATExecSetRelOptions(Relation rel, List *defList, AlterTableType operation,
> if (rel->rd_rel->relkind == RELKIND_VIEW)
> {
> Query *view_query = get_view_query(rel);
> - List *view_options = untransformRelOptions(newOptions);
> + List *view_options = optionsTextArrayToDefList(newOptions);
> ListCell *cell;
> bool check_option = false;
>
> @@ -13853,11 +13917,15 @@ ATExecSetRelOptions(Relation rel, List *defList, AlterTableType operation,
> &isnull);
> }
>
> - newOptions = transformRelOptions(isnull ? (Datum) 0 : datum,
> - defList, "toast", validnsps, false,
> - operation == AT_ResetRelOptions);
> + parse_mode = OPTIONS_PARSE_MODE_FOR_ALTER;
> + if (operation == AT_ResetRelOptions)
> + parse_mode |= OPTIONS_PARSE_MODE_FOR_RESET;
> +
> + toastDefList = optionsDefListFilterNamespaces(defList, "toast");
>
> - (void) heap_reloptions(RELKIND_TOASTVALUE, newOptions, true);
> + newOptions = transformOptions(get_toast_relopt_spec_set(),
> + isnull ? (Datum) 0 : datum,
> + toastDefList, parse_mode);
>
> memset(repl_val, 0, sizeof(repl_val));
> memset(repl_null, false, sizeof(repl_null));
> diff --git a/src/backend/commands/tablespace.c b/src/backend/commands/tablespace.c
> index 4b96eec..912699b 100644
> --- a/src/backend/commands/tablespace.c
> +++ b/src/backend/commands/tablespace.c
> @@ -345,10 +345,9 @@ CreateTableSpace(CreateTableSpaceStmt *stmt)
> nulls[Anum_pg_tablespace_spcacl - 1] = true;
>
> /* Generate new proposed spcoptions (text array) */
> - newOptions = transformRelOptions((Datum) 0,
> - stmt->options,
> - NULL, NULL, false, false);
> - (void) tablespace_reloptions(newOptions, true);
> + newOptions = transformOptions(get_tablespace_options_spec_set(),
> + (Datum) 0, stmt->options, 0);
> +
> if (newOptions != (Datum) 0)
> values[Anum_pg_tablespace_spcoptions - 1] = newOptions;
> else
> @@ -1053,10 +1052,11 @@ AlterTableSpaceOptions(AlterTableSpaceOptionsStmt *stmt)
> /* Generate new proposed spcoptions (text array) */
> datum = heap_getattr(tup, Anum_pg_tablespace_spcoptions,
> RelationGetDescr(rel), &isnull);
> - newOptions = transformRelOptions(isnull ? (Datum) 0 : datum,
> - stmt->options, NULL, NULL, false,
> - stmt->isReset);
> - (void) tablespace_reloptions(newOptions, true);
> + newOptions = transformOptions(get_tablespace_options_spec_set(),
> + isnull ? (Datum) 0 : datum,
> + stmt->options,
> + OPTIONS_PARSE_MODE_FOR_ALTER |
> + (stmt->isReset ? OPTIONS_PARSE_MODE_FOR_RESET : 0));
>
> /* Build new tuple. */
> memset(repl_null, false, sizeof(repl_null));
> diff --git a/src/backend/foreign/foreign.c b/src/backend/foreign/foreign.c
> index 5564dc3..0370be7 100644
> --- a/src/backend/foreign/foreign.c
> +++ b/src/backend/foreign/foreign.c
> @@ -78,7 +78,7 @@ GetForeignDataWrapperExtended(Oid fdwid, bits16 flags)
> if (isnull)
> fdw->options = NIL;
> else
> - fdw->options = untransformRelOptions(datum);
> + fdw->options = optionsTextArrayToDefList(datum);
>
> ReleaseSysCache(tp);
>
> @@ -165,7 +165,7 @@ GetForeignServerExtended(Oid serverid, bits16 flags)
> if (isnull)
> server->options = NIL;
> else
> - server->options = untransformRelOptions(datum);
> + server->options = optionsTextArrayToDefList(datum);
>
> ReleaseSysCache(tp);
>
> @@ -233,7 +233,7 @@ GetUserMapping(Oid userid, Oid serverid)
> if (isnull)
> um->options = NIL;
> else
> - um->options = untransformRelOptions(datum);
> + um->options = optionsTextArrayToDefList(datum);
>
> ReleaseSysCache(tp);
>
> @@ -270,7 +270,7 @@ GetForeignTable(Oid relid)
> if (isnull)
> ft->options = NIL;
> else
> - ft->options = untransformRelOptions(datum);
> + ft->options = optionsTextArrayToDefList(datum);
>
> ReleaseSysCache(tp);
>
> @@ -303,7 +303,7 @@ GetForeignColumnOptions(Oid relid, AttrNumber attnum)
> if (isnull)
> options = NIL;
> else
> - options = untransformRelOptions(datum);
> + options = optionsTextArrayToDefList(datum);
>
> ReleaseSysCache(tp);
>
> @@ -572,7 +572,7 @@ pg_options_to_table(PG_FUNCTION_ARGS)
> Datum array = PG_GETARG_DATUM(0);
>
> deflist_to_tuplestore((ReturnSetInfo *) fcinfo->resultinfo,
> - untransformRelOptions(array));
> + optionsTextArrayToDefList(array));
>
> return (Datum) 0;
> }
> @@ -643,7 +643,7 @@ is_conninfo_option(const char *option, Oid context)
> Datum
> postgresql_fdw_validator(PG_FUNCTION_ARGS)
> {
> - List *options_list = untransformRelOptions(PG_GETARG_DATUM(0));
> + List *options_list = optionsTextArrayToDefList(PG_GETARG_DATUM(0));
> Oid catalog = PG_GETARG_OID(1);
>
> ListCell *cell;
> diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c
> index 313d7b6..1fe41b4 100644
> --- a/src/backend/parser/parse_utilcmd.c
> +++ b/src/backend/parser/parse_utilcmd.c
> @@ -1757,7 +1757,7 @@ generateClonedIndexStmt(RangeVar *heapRel, Relation source_idx,
> /* Add the operator class name, if non-default */
> iparam->opclass = get_opclass(indclass->values[keyno], keycoltype);
> iparam->opclassopts =
> - untransformRelOptions(get_attoptions(source_relid, keyno + 1));
> + optionsTextArrayToDefList(get_attoptions(source_relid, keyno + 1));
>
> iparam->ordering = SORTBY_DEFAULT;
> iparam->nulls_ordering = SORTBY_NULLS_DEFAULT;
> @@ -1821,7 +1821,7 @@ generateClonedIndexStmt(RangeVar *heapRel, Relation source_idx,
> datum = SysCacheGetAttr(RELOID, ht_idxrel,
> Anum_pg_class_reloptions, &isnull);
> if (!isnull)
> - index->options = untransformRelOptions(datum);
> + index->options = optionsTextArrayToDefList(datum);
>
> /* If it's a partial index, decompile and append the predicate */
> datum = SysCacheGetAttr(INDEXRELID, ht_idx,
> diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c
> index bf085aa..d12ab1a 100644
> --- a/src/backend/tcop/utility.c
> +++ b/src/backend/tcop/utility.c
> @@ -1155,6 +1155,7 @@ ProcessUtilitySlow(ParseState *pstate,
> CreateStmt *cstmt = (CreateStmt *) stmt;
> Datum toast_options;
> static char *validnsps[] = HEAP_RELOPT_NAMESPACES;
> + List *toastDefList;
>
> /* Remember transformed RangeVar for LIKE */
> table_rv = cstmt->relation;
> @@ -1178,15 +1179,17 @@ ProcessUtilitySlow(ParseState *pstate,
> * parse and validate reloptions for the toast
> * table
> */
> - toast_options = transformRelOptions((Datum) 0,
> - cstmt->options,
> - "toast",
> - validnsps,
> - true,
> - false);
> - (void) heap_reloptions(RELKIND_TOASTVALUE,
> - toast_options,
> - true);
> +
> + optionsDefListValdateNamespaces(
> + ((CreateStmt *) stmt)->options,
> + validnsps);
> +
> + toastDefList = optionsDefListFilterNamespaces(
> + ((CreateStmt *) stmt)->options, "toast");
> +
> + toast_options = transformOptions(
> + get_toast_relopt_spec_set(), (Datum) 0,
> + toastDefList, 0);
>
> NewRelationCreateToastTable(address.objectId,
> toast_options);
> @@ -1295,9 +1298,12 @@ ProcessUtilitySlow(ParseState *pstate,
> * lock on (for example) a relation on which we have no
> * permissions.
> */
> - lockmode = AlterTableGetLockLevel(atstmt->cmds);
> - relid = AlterTableLookupRelation(atstmt, lockmode);
> -
> + relid = AlterTableLookupRelation(atstmt, NoLock); // FIXME!
> + if (OidIsValid(relid))
> + {
> + lockmode = AlterTableGetLockLevel(relid, atstmt->cmds);
> + relid = AlterTableLookupRelation(atstmt, lockmode);
> + }
> if (OidIsValid(relid))
> {
> AlterTableUtilityContext atcontext;
> diff --git a/src/backend/utils/cache/attoptcache.c b/src/backend/utils/cache/attoptcache.c
> index 72d89cb..f651129 100644
> --- a/src/backend/utils/cache/attoptcache.c
> +++ b/src/backend/utils/cache/attoptcache.c
> @@ -16,6 +16,7 @@
> */
> #include "postgres.h"
>
> +#include "access/options.h"
> #include "access/reloptions.h"
> #include "utils/attoptcache.h"
> #include "utils/catcache.h"
> @@ -148,7 +149,8 @@ get_attribute_options(Oid attrelid, int attnum)
> opts = NULL;
> else
> {
> - bytea *bytea_opts = attribute_reloptions(datum, false);
> + bytea *bytea_opts = optionsTextArrayToBytea(
> + get_attribute_options_spec_set(), datum, 0);
>
> opts = MemoryContextAlloc(CacheMemoryContext,
> VARSIZE(bytea_opts));
> diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
> index 13d9994..f22c2d9 100644
> --- a/src/backend/utils/cache/relcache.c
> +++ b/src/backend/utils/cache/relcache.c
> @@ -441,7 +441,7 @@ static void
> RelationParseRelOptions(Relation relation, HeapTuple tuple)
> {
> bytea *options;
> - amoptions_function amoptsfn;
> + amreloptspecset_function amoptspecsetfn;
>
> relation->rd_options = NULL;
>
> @@ -456,11 +456,11 @@ RelationParseRelOptions(Relation relation, HeapTuple tuple)
> case RELKIND_VIEW:
> case RELKIND_MATVIEW:
> case RELKIND_PARTITIONED_TABLE:
> - amoptsfn = NULL;
> + amoptspecsetfn = NULL;
> break;
> case RELKIND_INDEX:
> case RELKIND_PARTITIONED_INDEX:
> - amoptsfn = relation->rd_indam->amoptions;
> + amoptspecsetfn = relation->rd_indam->amreloptspecset;
> break;
> default:
> return;
> @@ -471,7 +471,7 @@ RelationParseRelOptions(Relation relation, HeapTuple tuple)
> * we might not have any other for pg_class yet (consider executing this
> * code for pg_class itself)
> */
> - options = extractRelOptions(tuple, GetPgClassDescriptor(), amoptsfn);
> + options = extractRelOptions(tuple, GetPgClassDescriptor(), amoptspecsetfn);
>
> /*
> * Copy parsed data into CacheMemoryContext. To guard against the
> diff --git a/src/backend/utils/cache/spccache.c b/src/backend/utils/cache/spccache.c
> index 5870f43..87f2fa5 100644
> --- a/src/backend/utils/cache/spccache.c
> +++ b/src/backend/utils/cache/spccache.c
> @@ -148,7 +148,8 @@ get_tablespace(Oid spcid)
> opts = NULL;
> else
> {
> - bytea *bytea_opts = tablespace_reloptions(datum, false);
> + bytea *bytea_opts = optionsTextArrayToBytea(
> + get_tablespace_options_spec_set(), datum, 0);
>
> opts = MemoryContextAlloc(CacheMemoryContext, VARSIZE(bytea_opts));
> memcpy(opts, bytea_opts, VARSIZE(bytea_opts));
> diff --git a/src/include/access/amapi.h b/src/include/access/amapi.h
> index d357ebb..b8fb6b9 100644
> --- a/src/include/access/amapi.h
> +++ b/src/include/access/amapi.h
> @@ -136,10 +136,6 @@ typedef void (*amcostestimate_function) (struct PlannerInfo *root,
> double *indexCorrelation,
> double *indexPages);
>
> -/* parse index reloptions */
> -typedef bytea *(*amoptions_function) (Datum reloptions,
> - bool validate);
> -
> /* report AM, index, or index column property */
> typedef bool (*amproperty_function) (Oid index_oid, int attno,
> IndexAMProperty prop, const char *propname,
> @@ -186,6 +182,9 @@ typedef void (*ammarkpos_function) (IndexScanDesc scan);
> /* restore marked scan position */
> typedef void (*amrestrpos_function) (IndexScanDesc scan);
>
> +/* get catalog of reloptions definitions */
> +typedef void *(*amreloptspecset_function) ();
> +
> /*
> * Callback function signatures - for parallel index scans.
> */
> @@ -263,7 +262,6 @@ typedef struct IndexAmRoutine
> amvacuumcleanup_function amvacuumcleanup;
> amcanreturn_function amcanreturn; /* can be NULL */
> amcostestimate_function amcostestimate;
> - amoptions_function amoptions;
> amproperty_function amproperty; /* can be NULL */
> ambuildphasename_function ambuildphasename; /* can be NULL */
> amvalidate_function amvalidate;
> @@ -275,6 +273,7 @@ typedef struct IndexAmRoutine
> amendscan_function amendscan;
> ammarkpos_function ammarkpos; /* can be NULL */
> amrestrpos_function amrestrpos; /* can be NULL */
> + amreloptspecset_function amreloptspecset; /* can be NULL */
>
> /* interface functions to support parallel index scans */
> amestimateparallelscan_function amestimateparallelscan; /* can be NULL */
> diff --git a/src/include/access/brin.h b/src/include/access/brin.h
> index 4e2be13..25b3456 100644
> --- a/src/include/access/brin.h
> +++ b/src/include/access/brin.h
> @@ -36,6 +36,8 @@ typedef struct BrinStatsData
>
>
> #define BRIN_DEFAULT_PAGES_PER_RANGE 128
> +#define BRIN_MIN_PAGES_PER_RANGE 1
> +#define BRIN_MAX_PAGES_PER_RANGE 131072
> #define BrinGetPagesPerRange(relation) \
> (AssertMacro(relation->rd_rel->relkind == RELKIND_INDEX && \
> relation->rd_rel->relam == BRIN_AM_OID), \
> diff --git a/src/include/access/brin_internal.h b/src/include/access/brin_internal.h
> index 79440eb..a798a96 100644
> --- a/src/include/access/brin_internal.h
> +++ b/src/include/access/brin_internal.h
> @@ -14,6 +14,7 @@
> #include "access/amapi.h"
> #include "storage/bufpage.h"
> #include "utils/typcache.h"
> +#include "access/options.h"
>
>
> /*
> @@ -108,6 +109,7 @@ extern IndexBulkDeleteResult *brinbulkdelete(IndexVacuumInfo *info,
> extern IndexBulkDeleteResult *brinvacuumcleanup(IndexVacuumInfo *info,
> IndexBulkDeleteResult *stats);
> extern bytea *brinoptions(Datum reloptions, bool validate);
> +extern void * bringetreloptspecset (void);
>
> /* brin_validate.c */
> extern bool brinvalidate(Oid opclassoid);
> diff --git a/src/include/access/gin_private.h b/src/include/access/gin_private.h
> index 670a40b..2b7c25c 100644
> --- a/src/include/access/gin_private.h
> +++ b/src/include/access/gin_private.h
> @@ -108,6 +108,7 @@ extern Datum *ginExtractEntries(GinState *ginstate, OffsetNumber attnum,
> extern OffsetNumber gintuple_get_attrnum(GinState *ginstate, IndexTuple tuple);
> extern Datum gintuple_get_key(GinState *ginstate, IndexTuple tuple,
> GinNullCategory *category);
> +extern void *gingetreloptspecset(void);
>
> /* gininsert.c */
> extern IndexBuildResult *ginbuild(Relation heap, Relation index,
> diff --git a/src/include/access/gist_private.h b/src/include/access/gist_private.h
> index 553d364..015b75a 100644
> --- a/src/include/access/gist_private.h
> +++ b/src/include/access/gist_private.h
> @@ -22,6 +22,7 @@
> #include "storage/buffile.h"
> #include "utils/hsearch.h"
> #include "access/genam.h"
> +#include "access/reloptions.h" //FIXME! should be replaced with options.h finally
>
> /*
> * Maximum number of "halves" a page can be split into in one operation.
> @@ -388,6 +389,7 @@ typedef enum GistOptBufferingMode
> GIST_OPTION_BUFFERING_OFF
> } GistOptBufferingMode;
>
> +
> /*
> * Storage type for GiST's reloptions
> */
> @@ -478,7 +480,7 @@ extern void gistadjustmembers(Oid opfamilyoid,
> #define GIST_MIN_FILLFACTOR 10
> #define GIST_DEFAULT_FILLFACTOR 90
>
> -extern bytea *gistoptions(Datum reloptions, bool validate);
> +extern void *gistgetreloptspecset(void);
> extern bool gistproperty(Oid index_oid, int attno,
> IndexAMProperty prop, const char *propname,
> bool *res, bool *isnull);
> diff --git a/src/include/access/hash.h b/src/include/access/hash.h
> index 1cce865..91922ef 100644
> --- a/src/include/access/hash.h
> +++ b/src/include/access/hash.h
> @@ -378,7 +378,6 @@ extern IndexBulkDeleteResult *hashbulkdelete(IndexVacuumInfo *info,
> void *callback_state);
> extern IndexBulkDeleteResult *hashvacuumcleanup(IndexVacuumInfo *info,
> IndexBulkDeleteResult *stats);
> -extern bytea *hashoptions(Datum reloptions, bool validate);
> extern bool hashvalidate(Oid opclassoid);
> extern void hashadjustmembers(Oid opfamilyoid,
> Oid opclassoid,
> @@ -470,6 +469,7 @@ extern BlockNumber _hash_get_newblock_from_oldbucket(Relation rel, Bucket old_bu
> extern Bucket _hash_get_newbucket_from_oldbucket(Relation rel, Bucket old_bucket,
> uint32 lowmask, uint32 maxbucket);
> extern void _hash_kill_items(IndexScanDesc scan);
> +extern void *hashgetreloptspecset(void);
>
> /* hash.c */
> extern void hashbucketcleanup(Relation rel, Bucket cur_bucket,
> diff --git a/src/include/access/nbtree.h b/src/include/access/nbtree.h
> index 30a216e..1fcb5f5 100644
> --- a/src/include/access/nbtree.h
> +++ b/src/include/access/nbtree.h
> @@ -1252,7 +1252,7 @@ extern void _bt_end_vacuum(Relation rel);
> extern void _bt_end_vacuum_callback(int code, Datum arg);
> extern Size BTreeShmemSize(void);
> extern void BTreeShmemInit(void);
> -extern bytea *btoptions(Datum reloptions, bool validate);
> +extern void * btgetreloptspecset (void);
> extern bool btproperty(Oid index_oid, int attno,
> IndexAMProperty prop, const char *propname,
> bool *res, bool *isnull);
> diff --git a/src/include/access/options.h b/src/include/access/options.h
> new file mode 100644
> index 0000000..34e2917
> --- /dev/null
> +++ b/src/include/access/options.h
> @@ -0,0 +1,245 @@
> +/*-------------------------------------------------------------------------
> + *
> + * options.h
> + * Core support for relation and tablespace options (pg_class.reloptions
> + * and pg_tablespace.spcoptions)
> + *
> + * Note: the functions dealing with text-array options values declare
> + * them as Datum, not ArrayType *, to avoid needing to include array.h
> + * into a lot of low-level code.
> + *
> + *
> + * Portions Copyright (c) 1996-2016, PostgreSQL Global Development Group
> + * Portions Copyright (c) 1994, Regents of the University of California
> + *
> + * src/include/access/options.h
> + *
> + *-------------------------------------------------------------------------
> + */
> +#ifndef OPTIONS_H
> +#define OPTIONS_H
> +
> +#include "storage/lock.h"
> +#include "nodes/pg_list.h"
> +
> +
> +/* supported option types */
> +typedef enum option_type
> +{
> + OPTION_TYPE_BOOL,
> + OPTION_TYPE_INT,
> + OPTION_TYPE_REAL,
> + OPTION_TYPE_ENUM,
> + OPTION_TYPE_STRING
> +} option_type;
> +
> +
> +typedef enum option_value_status
> +{
> + OPTION_VALUE_STATUS_EMPTY, /* Option was just initialized */
> + OPTION_VALUE_STATUS_RAW, /* Option just came from syntax analyzer in
> + * has name, and raw (unparsed) value */
> + OPTION_VALUE_STATUS_PARSED, /* Option was parsed and has link to catalog
> + * entry and proper value */
> + OPTION_VALUE_STATUS_FOR_RESET /* This option came from ALTER xxx
> + * RESET */
> +} option_value_status;
> +
> +/* flags for reloptinon definition */
> +typedef enum option_spec_flags
> +{
> + OPTION_DEFINITION_FLAG_FORBID_ALTER = (1 << 0), /* Altering this option
> + * is forbidden */
> + OPTION_DEFINITION_FLAG_IGNORE = (1 << 1), /* Skip this option while
> + * parsing. Used for WITH OIDS
> + * special case */
> + OPTION_DEFINITION_FLAG_REJECT = (1 << 2) /* Option will be rejected
> + * when comes from syntax
> + * analyzer, but still have
> + * default value and offset */
> +} option_spec_flags;
> +
> +/* flags that tells reloption parser how to parse*/
> +typedef enum options_parse_mode
> +{
> + OPTIONS_PARSE_MODE_VALIDATE = (1 << 0),
> + OPTIONS_PARSE_MODE_FOR_ALTER = (1 << 1),
> + OPTIONS_PARSE_MODE_FOR_RESET = (1 << 2)
> +} options_parse_mode;
> +
> +
> +
> +/*
> + * opt_enum_elt_def -- One member of the array of acceptable values
> + * of an enum reloption.
> + */
> +typedef struct opt_enum_elt_def
> +{
> + const char *string_val;
> + int symbol_val;
> +} opt_enum_elt_def;
> +
> +
> +/* generic structure to store Option Spec information */
> +typedef struct option_spec_basic
> +{
> + const char *name; /* must be first (used as list termination
> + * marker) */
> + const char *desc;
> + LOCKMODE lockmode;
> + option_spec_flags flags;
> + option_type type;
> + int struct_offset; /* offset of the value in Bytea representation */
> +} option_spec_basic;
> +
> +
> +/* reloptions records for specific variable types */
> +typedef struct option_spec_bool
> +{
> + option_spec_basic base;
> + bool default_val;
> +} option_spec_bool;
> +
> +typedef struct option_spec_int
> +{
> + option_spec_basic base;
> + int default_val;
> + int min;
> + int max;
> +} option_spec_int;
> +
> +typedef struct option_spec_real
> +{
> + option_spec_basic base;
> + double default_val;
> + double min;
> + double max;
> +} option_spec_real;
> +
> +typedef struct option_spec_enum
> +{
> + option_spec_basic base;
> + opt_enum_elt_def *members;/* FIXME rewrite. Null terminated array of allowed values for
> + * the option */
> + int default_val; /* Number of item of allowed_values array */
> + const char *detailmsg;
> +} option_spec_enum;
> +
> +/* validation routines for strings */
> +typedef void (*validate_string_option) (const char *value);
> +
> +/*
> + * When storing sting reloptions, we shoud deal with special case when
> + * option value is not set. For fixed length options, we just copy default
> + * option value into the binary structure. For varlen value, there can be
> + * "not set" special case, with no default value offered.
> + * In this case we will set offset value to -1, so code that use relptions
> + * can deal this case. For better readability it was defined as a constant.
> + */
> +#define OPTION_STRING_VALUE_NOT_SET_OFFSET -1
> +
> +typedef struct option_spec_string
> +{
> + option_spec_basic base;
> + validate_string_option validate_cb;
> + char *default_val;
> +} option_spec_string;
> +
> +typedef void (*postprocess_bytea_options_function) (void *data, bool validate);
> +
> +typedef struct options_spec_set
> +{
> + option_spec_basic **definitions;
> + int num; /* Number of spec_set items in use */
> + int num_allocated; /* Number of spec_set items allocated */
> + bool forbid_realloc; /* If number of items of the spec_set were
> + * strictly set to certain value do no allow
> + * adding more idems */
> + Size struct_size; /* Size of a structure for options in binary
> + * representation */
> + postprocess_bytea_options_function postprocess_fun; /* This function is
> + * called after options
> + * were converted in
> + * Bytea represenation.
> + * Can be used for extra
> + * validation and so on */
> + char *namespace; /* spec_set is used for options from this
> + * namespase */
> +} options_spec_set;
> +
> +
> +/* holds an option value parsed or unparsed */
> +typedef struct option_value
> +{
> + option_spec_basic *gen;
> + char *namespace;
> + option_value_status status;
> + char *raw_value; /* allocated separately */
> + char *raw_name;
> + union
> + {
> + bool bool_val;
> + int int_val;
> + double real_val;
> + int enum_val;
> + char *string_val; /* allocated separately */
> + } values;
> +} option_value;
> +
> +
> +
> +
> +/*
> + * Options spec_set related functions
> + */
> +extern options_spec_set *allocateOptionsSpecSet(const char *namespace,
> + int size_of_bytea, int num_items_expected);
> +extern void optionsSpecSetAddBool(options_spec_set * spec_set, const char *name,
> + const char *desc, LOCKMODE lockmode, option_spec_flags flags,
> + int struct_offset, bool default_val);
> +extern void optionsSpecSetAddInt(options_spec_set * spec_set, const char *name,
> + const char *desc, LOCKMODE lockmode, option_spec_flags flags,
> + int struct_offset, int default_val, int min_val, int max_val);
> +extern void optionsSpecSetAddReal(options_spec_set * spec_set, const char *name,
> + const char *desc, LOCKMODE lockmode, option_spec_flags flags,
> + int struct_offset, double default_val, double min_val, double max_val);
> +extern void optionsSpecSetAddEnum(options_spec_set * spec_set,
> + const char *name, const char *desc, LOCKMODE lockmode, option_spec_flags flags,
> + int struct_offset, opt_enum_elt_def* members, int default_val, const char *detailmsg);
> +extern void optionsSpecSetAddString(options_spec_set * spec_set, const char *name,
> + const char *desc, LOCKMODE lockmode, option_spec_flags flags,
> +int struct_offset, const char *default_val, validate_string_option validator);
> +
> +
> +/*
> + * This macro allows to get string option value from bytea representation.
> + * "optstruct" - is a structure that is stored in bytea options representation
> + * "member" - member of this structure that has string option value
> + * (actually string values are stored in bytea after the structure, and
> + * and "member" will contain an offset to this value. This macro do all
> + * the math
> + */
> +#define GET_STRING_OPTION(optstruct, member) \
> + ((optstruct)->member == OPTION_STRING_VALUE_NOT_SET_OFFSET ? NULL : \
> + (char *)(optstruct) + (optstruct)->member)
> +
> +/*
> + * Functions related to option convertation, parsing, manipulation
> + * and validation
> + */
> +extern void optionsDefListValdateNamespaces(List *defList,
> + char **allowed_namespaces);
> +extern List *optionsDefListFilterNamespaces(List *defList, const char *namespace);
> +extern List *optionsTextArrayToDefList(Datum options);
> +extern Datum optionsDefListToTextArray(List *defList);
> +/*
> + * Meta functions that uses functions above to get options for relations,
> + * tablespaces, views and so on
> + */
> +
> +extern bytea *optionsTextArrayToBytea(options_spec_set * spec_set, Datum data,
> + bool validate);
> +extern Datum transformOptions(options_spec_set * spec_set, Datum oldOptions,
> + List *defList, options_parse_mode parse_mode);
> +
> +#endif /* OPTIONS_H */
> diff --git a/src/include/access/reloptions.h b/src/include/access/reloptions.h
> index 7c5fbeb..21b91df 100644
> --- a/src/include/access/reloptions.h
> +++ b/src/include/access/reloptions.h
> @@ -22,6 +22,7 @@
> #include "access/amapi.h"
> #include "access/htup.h"
> #include "access/tupdesc.h"
> +#include "access/options.h"
> #include "nodes/pg_list.h"
> #include "storage/lock.h"
>
> @@ -110,20 +111,10 @@ typedef struct relopt_real
> double max;
> } relopt_real;
>
> -/*
> - * relopt_enum_elt_def -- One member of the array of acceptable values
> - * of an enum reloption.
> - */
> -typedef struct relopt_enum_elt_def
> -{
> - const char *string_val;
> - int symbol_val;
> -} relopt_enum_elt_def;
> -
> typedef struct relopt_enum
> {
> relopt_gen gen;
> - relopt_enum_elt_def *members;
> + opt_enum_elt_def *members;
> int default_val;
> const char *detailmsg;
> /* null-terminated array of members */
> @@ -167,6 +158,7 @@ typedef struct local_relopts
> List *options; /* list of local_relopt definitions */
> List *validators; /* list of relopts_validator callbacks */
> Size relopt_struct_size; /* size of parsed bytea structure */
> + options_spec_set * spec_set; /* FIXME */
> } local_relopts;
>
> /*
> @@ -179,21 +171,6 @@ typedef struct local_relopts
> ((optstruct)->member == 0 ? NULL : \
> (char *)(optstruct) + (optstruct)->member)
>
> -extern relopt_kind add_reloption_kind(void);
> -extern void add_bool_reloption(bits32 kinds, const char *name, const char *desc,
> - bool default_val, LOCKMODE lockmode);
> -extern void add_int_reloption(bits32 kinds, const char *name, const char *desc,
> - int default_val, int min_val, int max_val,
> - LOCKMODE lockmode);
> -extern void add_real_reloption(bits32 kinds, const char *name, const char *desc,
> - double default_val, double min_val, double max_val,
> - LOCKMODE lockmode);
> -extern void add_enum_reloption(bits32 kinds, const char *name, const char *desc,
> - relopt_enum_elt_def *members, int default_val,
> - const char *detailmsg, LOCKMODE lockmode);
> -extern void add_string_reloption(bits32 kinds, const char *name, const char *desc,
> - const char *default_val, validate_string_relopt validator,
> - LOCKMODE lockmode);
>
> extern void init_local_reloptions(local_relopts *opts, Size relopt_struct_size);
> extern void register_reloptions_validator(local_relopts *opts,
> @@ -210,7 +187,7 @@ extern void add_local_real_reloption(local_relopts *opts, const char *name,
> int offset);
> extern void add_local_enum_reloption(local_relopts *relopts,
> const char *name, const char *desc,
> - relopt_enum_elt_def *members,
> + opt_enum_elt_def *members,
> int default_val, const char *detailmsg,
> int offset);
> extern void add_local_string_reloption(local_relopts *opts, const char *name,
> @@ -219,29 +196,17 @@ extern void add_local_string_reloption(local_relopts *opts, const char *name,
> validate_string_relopt validator,
> fill_string_relopt filler, int offset);
>
> -extern Datum transformRelOptions(Datum oldOptions, List *defList,
> - const char *namspace, char *validnsps[],
> - bool acceptOidsOff, bool isReset);
> -extern List *untransformRelOptions(Datum options);
> extern bytea *extractRelOptions(HeapTuple tuple, TupleDesc tupdesc,
> - amoptions_function amoptions);
> -extern void *build_reloptions(Datum reloptions, bool validate,
> - relopt_kind kind,
> - Size relopt_struct_size,
> - const relopt_parse_elt *relopt_elems,
> - int num_relopt_elems);
> + amreloptspecset_function amoptions_def_set);
> extern void *build_local_reloptions(local_relopts *relopts, Datum options,
> bool validate);
>
> -extern bytea *default_reloptions(Datum reloptions, bool validate,
> - relopt_kind kind);
> -extern bytea *heap_reloptions(char relkind, Datum reloptions, bool validate);
> -extern bytea *view_reloptions(Datum reloptions, bool validate);
> -extern bytea *partitioned_table_reloptions(Datum reloptions, bool validate);
> -extern bytea *index_reloptions(amoptions_function amoptions, Datum reloptions,
> - bool validate);
> -extern bytea *attribute_reloptions(Datum reloptions, bool validate);
> -extern bytea *tablespace_reloptions(Datum reloptions, bool validate);
> -extern LOCKMODE AlterTableGetRelOptionsLockLevel(List *defList);
> +options_spec_set *get_heap_relopt_spec_set(void);
> +options_spec_set *get_toast_relopt_spec_set(void);
> +options_spec_set *get_partitioned_relopt_spec_set(void);
> +options_spec_set *get_view_relopt_spec_set(void);
> +options_spec_set *get_attribute_options_spec_set(void);
> +options_spec_set *get_tablespace_options_spec_set(void);
> +extern LOCKMODE AlterTableGetRelOptionsLockLevel(Relation rel, List *defList);
>
> #endif /* RELOPTIONS_H */
> diff --git a/src/include/access/spgist.h b/src/include/access/spgist.h
> index 2eb2f42..d9a9b2d 100644
> --- a/src/include/access/spgist.h
> +++ b/src/include/access/spgist.h
> @@ -189,9 +189,6 @@ typedef struct spgLeafConsistentOut
> } spgLeafConsistentOut;
>
>
> -/* spgutils.c */
> -extern bytea *spgoptions(Datum reloptions, bool validate);
> -
> /* spginsert.c */
> extern IndexBuildResult *spgbuild(Relation heap, Relation index,
> struct IndexInfo *indexInfo);
> diff --git a/src/include/access/spgist_private.h b/src/include/access/spgist_private.h
> index 40d3b71..dd9a05a 100644
> --- a/src/include/access/spgist_private.h
> +++ b/src/include/access/spgist_private.h
> @@ -529,6 +529,7 @@ extern OffsetNumber SpGistPageAddNewItem(SpGistState *state, Page page,
> extern bool spgproperty(Oid index_oid, int attno,
> IndexAMProperty prop, const char *propname,
> bool *res, bool *isnull);
> +extern void *spggetreloptspecset(void);
>
> /* spgdoinsert.c */
> extern void spgUpdateNodeLink(SpGistInnerTuple tup, int nodeN,
> diff --git a/src/include/commands/tablecmds.h b/src/include/commands/tablecmds.h
> index 336549c..3f87f98 100644
> --- a/src/include/commands/tablecmds.h
> +++ b/src/include/commands/tablecmds.h
> @@ -34,7 +34,7 @@ extern Oid AlterTableLookupRelation(AlterTableStmt *stmt, LOCKMODE lockmode);
> extern void AlterTable(AlterTableStmt *stmt, LOCKMODE lockmode,
> struct AlterTableUtilityContext *context);
>
> -extern LOCKMODE AlterTableGetLockLevel(List *cmds);
> +extern LOCKMODE AlterTableGetLockLevel(Oid relid, List *cmds);
>
> extern void ATExecChangeOwner(Oid relationOid, Oid newOwnerId, bool recursing, LOCKMODE lockmode);
>
> diff --git a/src/test/modules/dummy_index_am/dummy_index_am.c b/src/test/modules/dummy_index_am/dummy_index_am.c
> index 5365b063..80b39e8 100644
> --- a/src/test/modules/dummy_index_am/dummy_index_am.c
> +++ b/src/test/modules/dummy_index_am/dummy_index_am.c
> @@ -14,7 +14,7 @@
> #include "postgres.h"
>
> #include "access/amapi.h"
> -#include "access/reloptions.h"
> +#include "access/options.h"
> #include "catalog/index.h"
> #include "commands/vacuum.h"
> #include "nodes/pathnodes.h"
> @@ -25,12 +25,6 @@ PG_MODULE_MAGIC;
>
> void _PG_init(void);
>
> -/* parse table for fillRelOptions */
> -relopt_parse_elt di_relopt_tab[6];
> -
> -/* Kind of relation options for dummy index */
> -relopt_kind di_relopt_kind;
> -
> typedef enum DummyAmEnum
> {
> DUMMY_AM_ENUM_ONE,
> @@ -49,7 +43,7 @@ typedef struct DummyIndexOptions
> int option_string_null_offset;
> } DummyIndexOptions;
>
> -relopt_enum_elt_def dummyAmEnumValues[] =
> +opt_enum_elt_def dummyAmEnumValues[] =
> {
> {"one", DUMMY_AM_ENUM_ONE},
> {"two", DUMMY_AM_ENUM_TWO},
> @@ -63,77 +57,85 @@ PG_FUNCTION_INFO_V1(dihandler);
> * Validation function for string relation options.
> */
> static void
> -validate_string_option(const char *value)
> +divalidate_string_option(const char *value)
> {
> ereport(NOTICE,
> (errmsg("new option value for string parameter %s",
> value ? value : "NULL")));
> }
>
> -/*
> - * This function creates a full set of relation option types,
> - * with various patterns.
> - */
> -static void
> -create_reloptions_table(void)
> +static options_spec_set *di_relopt_specset = NULL;
> +void * digetreloptspecset(void);
> +
> +void *
> +digetreloptspecset(void)
> {
> - di_relopt_kind = add_reloption_kind();
> -
> - add_int_reloption(di_relopt_kind, "option_int",
> - "Integer option for dummy_index_am",
> - 10, -10, 100, AccessExclusiveLock);
> - di_relopt_tab[0].optname = "option_int";
> - di_relopt_tab[0].opttype = RELOPT_TYPE_INT;
> - di_relopt_tab[0].offset = offsetof(DummyIndexOptions, option_int);
> -
> - add_real_reloption(di_relopt_kind, "option_real",
> - "Real option for dummy_index_am",
> - 3.1415, -10, 100, AccessExclusiveLock);
> - di_relopt_tab[1].optname = "option_real";
> - di_relopt_tab[1].opttype = RELOPT_TYPE_REAL;
> - di_relopt_tab[1].offset = offsetof(DummyIndexOptions, option_real);
> -
> - add_bool_reloption(di_relopt_kind, "option_bool",
> - "Boolean option for dummy_index_am",
> - true, AccessExclusiveLock);
> - di_relopt_tab[2].optname = "option_bool";
> - di_relopt_tab[2].opttype = RELOPT_TYPE_BOOL;
> - di_relopt_tab[2].offset = offsetof(DummyIndexOptions, option_bool);
> -
> - add_enum_reloption(di_relopt_kind, "option_enum",
> - "Enum option for dummy_index_am",
> - dummyAmEnumValues,
> - DUMMY_AM_ENUM_ONE,
> - "Valid values are \"one\" and \"two\".",
> - AccessExclusiveLock);
> - di_relopt_tab[3].optname = "option_enum";
> - di_relopt_tab[3].opttype = RELOPT_TYPE_ENUM;
> - di_relopt_tab[3].offset = offsetof(DummyIndexOptions, option_enum);
> -
> - add_string_reloption(di_relopt_kind, "option_string_val",
> - "String option for dummy_index_am with non-NULL default",
> - "DefaultValue", &validate_string_option,
> - AccessExclusiveLock);
> - di_relopt_tab[4].optname = "option_string_val";
> - di_relopt_tab[4].opttype = RELOPT_TYPE_STRING;
> - di_relopt_tab[4].offset = offsetof(DummyIndexOptions,
> - option_string_val_offset);
> + if (di_relopt_specset)
> + return di_relopt_specset;
> +
> + di_relopt_specset = allocateOptionsSpecSet(NULL,
> + sizeof(DummyIndexOptions), 6);
> +
> + optionsSpecSetAddInt(
> + di_relopt_specset, "option_int",
> + "Integer option for dummy_index_am",
> + AccessExclusiveLock,
> + 0, offsetof(DummyIndexOptions, option_int),
> + 10, -10, 100
> + );
> +
> +
> + optionsSpecSetAddReal(
> + di_relopt_specset, "option_real",
> + "Real option for dummy_index_am",
> + AccessExclusiveLock,
> + 0, offsetof(DummyIndexOptions, option_real),
> + 3.1415, -10, 100
> + );
> +
> + optionsSpecSetAddBool(
> + di_relopt_specset, "option_bool",
> + "Boolean option for dummy_index_am",
> + AccessExclusiveLock,
> + 0, offsetof(DummyIndexOptions, option_bool), true
> + );
> +
> + optionsSpecSetAddEnum(di_relopt_specset, "option_enum",
> + "Enum option for dummy_index_am",
> + AccessExclusiveLock,
> + 0,
> + offsetof(DummyIndexOptions, option_enum),
> + dummyAmEnumValues,
> + DUMMY_AM_ENUM_ONE,
> + "Valid values are \"one\" and \"two\"."
> + );
> +
> + optionsSpecSetAddString(di_relopt_specset, "option_string_val",
> + "String option for dummy_index_am with non-NULL default",
> + AccessExclusiveLock,
> + 0,
> + offsetof(DummyIndexOptions, option_string_val_offset),
> + "DefaultValue", &divalidate_string_option
> + );
>
> /*
> * String option for dummy_index_am with NULL default, and without
> * description.
> */
> - add_string_reloption(di_relopt_kind, "option_string_null",
> - NULL, /* description */
> - NULL, &validate_string_option,
> - AccessExclusiveLock);
> - di_relopt_tab[5].optname = "option_string_null";
> - di_relopt_tab[5].opttype = RELOPT_TYPE_STRING;
> - di_relopt_tab[5].offset = offsetof(DummyIndexOptions,
> - option_string_null_offset);
> +
> + optionsSpecSetAddString(di_relopt_specset, "option_string_null",
> + NULL, /* description */
> + AccessExclusiveLock,
> + 0,
> + offsetof(DummyIndexOptions, option_string_null_offset),
> + NULL, &divalidate_string_option
> + );
> +
> + return di_relopt_specset;
> }
>
>
> +
> /*
> * Build a new index.
> */
> @@ -219,19 +221,6 @@ dicostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
> }
>
> /*
> - * Parse relation options for index AM, returning a DummyIndexOptions
> - * structure filled with option values.
> - */
> -static bytea *
> -dioptions(Datum reloptions, bool validate)
> -{
> - return (bytea *) build_reloptions(reloptions, validate,
> - di_relopt_kind,
> - sizeof(DummyIndexOptions),
> - di_relopt_tab, lengthof(di_relopt_tab));
> -}
> -
> -/*
> * Validator for index AM.
> */
> static bool
> @@ -308,7 +297,6 @@ dihandler(PG_FUNCTION_ARGS)
> amroutine->amvacuumcleanup = divacuumcleanup;
> amroutine->amcanreturn = NULL;
> amroutine->amcostestimate = dicostestimate;
> - amroutine->amoptions = dioptions;
> amroutine->amproperty = NULL;
> amroutine->ambuildphasename = NULL;
> amroutine->amvalidate = divalidate;
> @@ -322,12 +310,7 @@ dihandler(PG_FUNCTION_ARGS)
> amroutine->amestimateparallelscan = NULL;
> amroutine->aminitparallelscan = NULL;
> amroutine->amparallelrescan = NULL;
> + amroutine->amreloptspecset = digetreloptspecset;
>
> PG_RETURN_POINTER(amroutine);
> }
> -
> -void
> -_PG_init(void)
> -{
> - create_reloptions_table();
> -}

--
Bruce Momjian <bruce(at)momjian(dot)us> https://momjian.us
EDB https://enterprisedb.com

If only the physical world exists, free will is an illusion.