reloptions.c File Reference

#include "postgres.h"
#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 "catalog/pg_type.h"
#include "commands/defrem.h"
#include "commands/tablespace.h"
#include "commands/view.h"
#include "nodes/makefuncs.h"
#include "postmaster/postmaster.h"
#include "utils/array.h"
#include "utils/attoptcache.h"
#include "utils/builtins.h"
#include "utils/guc.h"
#include "utils/memutils.h"
#include "utils/rel.h"

Include dependency graph for reloptions.c:

Go to the source code of this file.

Macros
#define	GET_STRING_RELOPTION_LEN(option)

Functions
static void	initialize_reloptions (void)
static void	parse_one_reloption (relopt_value *option, char *text_str, int text_len, bool validate)
relopt_kind	add_reloption_kind (void)
static void	add_reloption (relopt_gen *newoption)
void	init_local_reloptions (local_relopts *relopts, Size relopt_struct_size)
void	register_reloptions_validator (local_relopts *relopts, relopts_validator validator)
static void	add_local_reloption (local_relopts *relopts, relopt_gen *newoption, int offset)
static relopt_gen *	allocate_reloption (bits32 kinds, int type, const char *name, const char *desc, LOCKMODE lockmode)
static relopt_bool *	init_bool_reloption (bits32 kinds, const char *name, const char *desc, bool default_val, LOCKMODE lockmode)
void	add_bool_reloption (bits32 kinds, const char *name, const char *desc, bool default_val, LOCKMODE lockmode)
void	add_local_bool_reloption (local_relopts *relopts, const char *name, const char *desc, bool default_val, int offset)
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)
void	add_int_reloption (bits32 kinds, const char *name, const char *desc, int default_val, int min_val, int max_val, LOCKMODE lockmode)
void	add_local_int_reloption (local_relopts *relopts, const char *name, const char *desc, int default_val, int min_val, int max_val, int offset)
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)
void	add_real_reloption (bits32 kinds, const char *name, const char *desc, double default_val, double min_val, double max_val, LOCKMODE lockmode)
void	add_local_real_reloption (local_relopts *relopts, const char *name, const char *desc, double default_val, double min_val, double max_val, int offset)
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)
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)
void	add_local_enum_reloption (local_relopts *relopts, const char *name, const char *desc, relopt_enum_elt_def *members, int default_val, const char *detailmsg, int offset)
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)
void	add_string_reloption (bits32 kinds, const char *name, const char *desc, const char *default_val, validate_string_relopt validator, LOCKMODE lockmode)
void	add_local_string_reloption (local_relopts *relopts, const char *name, const char *desc, const char *default_val, validate_string_relopt validator, fill_string_relopt filler, int offset)
Datum	transformRelOptions (Datum oldOptions, List *defList, const char *namspace, char *validnsps[], bool acceptOidsOff, bool isReset)
List *	untransformRelOptions (Datum options)
bytea *	extractRelOptions (HeapTuple tuple, TupleDesc tupdesc, amoptions_function amoptions)
static void	parseRelOptionsInternal (Datum options, bool validate, relopt_value *reloptions, int numoptions)
static relopt_value *	parseRelOptions (Datum options, bool validate, relopt_kind kind, int *numrelopts)
static relopt_value *	parseLocalRelOptions (local_relopts *relopts, Datum options, bool validate)
static void *	allocateReloptStruct (Size base, relopt_value *options, int numoptions)
static void	fillRelOptions (void *rdopts, Size basesize, relopt_value *options, int numoptions, bool validate, const relopt_parse_elt *elems, int numelems)
bytea *	default_reloptions (Datum reloptions, bool validate, relopt_kind kind)
void *	build_reloptions (Datum reloptions, bool validate, relopt_kind kind, Size relopt_struct_size, const relopt_parse_elt *relopt_elems, int num_relopt_elems)
void *	build_local_reloptions (local_relopts *relopts, Datum options, bool validate)
bytea *	partitioned_table_reloptions (Datum reloptions, bool validate)
bytea *	view_reloptions (Datum reloptions, bool validate)
bytea *	heap_reloptions (char relkind, Datum reloptions, bool validate)
bytea *	index_reloptions (amoptions_function amoptions, Datum reloptions, bool validate)
bytea *	attribute_reloptions (Datum reloptions, bool validate)
bytea *	tablespace_reloptions (Datum reloptions, bool validate)
LOCKMODE	AlterTableGetRelOptionsLockLevel (List *defList)

Variables
static relopt_bool	boolRelOpts []
static relopt_int	intRelOpts []
static relopt_real	realRelOpts []
static relopt_enum_elt_def	StdRdOptIndexCleanupValues []
static relopt_enum_elt_def	gistBufferingOptValues []
static relopt_enum_elt_def	viewCheckOptValues []
static relopt_enum	enumRelOpts []
static relopt_string	stringRelOpts []
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

Macro Definition Documentation

GET_STRING_RELOPTION_LEN

#define GET_STRING_RELOPTION_LEN

(

option

)

Value:

    ((option).isset ? strlen((option).values.string_val) : \
     ((relopt_string *) (option).gen)->default_len)

Definition at line 571 of file reloptions.c.

Function Documentation

add_bool_reloption()

void add_bool_reloption	(	bits32	kinds,
		const char *	name,
		const char *	desc,
		bool	default_val,
		LOCKMODE	lockmode
	)

Definition at line 851 of file reloptions.c.

{
    relopt_bool *newoption = init_bool_reloption(kinds, name, desc,
                                                 default_val, lockmode);
 
    add_reloption((relopt_gen *) newoption);
}

References add_reloption(), init_bool_reloption(), and name.

Referenced by create_reloptions_table().

add_enum_reloption()

void add_enum_reloption	(	bits32	kinds,
		const char *	name,
		const char *	desc,
		relopt_enum_elt_def *	members,
		int	default_val,
		const char *	detailmsg,
		LOCKMODE	lockmode
	)

Definition at line 1020 of file reloptions.c.

{
    relopt_enum *newoption = init_enum_reloption(kinds, name, desc,
                                                 members, default_val,
                                                 detailmsg, lockmode);
 
    add_reloption((relopt_gen *) newoption);
}

References add_reloption(), init_enum_reloption(), and name.

Referenced by create_reloptions_table().

add_int_reloption()

void add_int_reloption	(	bits32	kinds,
		const char *	name,
		const char *	desc,
		int	default_val,
		int	min_val,
		int	max_val,
		LOCKMODE	lockmode
	)

Definition at line 903 of file reloptions.c.

{
    relopt_int *newoption = init_int_reloption(kinds, name, desc,
                                               default_val, min_val,
                                               max_val, lockmode);
 
    add_reloption((relopt_gen *) newoption);
}

References add_reloption(), init_int_reloption(), and name.

Referenced by _PG_init(), and create_reloptions_table().

add_local_bool_reloption()

void add_local_bool_reloption	(	local_relopts *	relopts,
		const char *	name,
		const char *	desc,
		bool	default_val,
		int	offset
	)

Definition at line 867 of file reloptions.c.

{
    relopt_bool *newoption = init_bool_reloption(RELOPT_KIND_LOCAL,
                                                 name, desc,
                                                 default_val, 0);
 
    add_local_reloption(relopts, (relopt_gen *) newoption, offset);
}

References add_local_reloption(), init_bool_reloption(), name, and RELOPT_KIND_LOCAL.

add_local_enum_reloption()

void add_local_enum_reloption	(	local_relopts *	relopts,
		const char *	name,
		const char *	desc,
		relopt_enum_elt_def *	members,
		int	default_val,
		const char *	detailmsg,
		int	offset
	)

Definition at line 1038 of file reloptions.c.

{
    relopt_enum *newoption = init_enum_reloption(RELOPT_KIND_LOCAL,
                                                 name, desc,
                                                 members, default_val,
                                                 detailmsg, 0);
 
    add_local_reloption(relopts, (relopt_gen *) newoption, offset);
}

References add_local_reloption(), init_enum_reloption(), name, and RELOPT_KIND_LOCAL.

add_local_int_reloption()

void add_local_int_reloption	(	local_relopts *	relopts,
		const char *	name,
		const char *	desc,
		int	default_val,
		int	min_val,
		int	max_val,
		int	offset
	)

Definition at line 920 of file reloptions.c.

{
    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);
}

References add_local_reloption(), init_int_reloption(), name, and RELOPT_KIND_LOCAL.

Referenced by _ltree_gist_options(), brin_minmax_multi_options(), g_int_options(), g_intbig_options(), ghstore_options(), gtrgm_options(), gtsvector_options(), and ltree_gist_options().

add_local_real_reloption()

void add_local_real_reloption	(	local_relopts *	relopts,
		const char *	name,
		const char *	desc,
		double	default_val,
		double	min_val,
		double	max_val,
		int	offset
	)

Definition at line 974 of file reloptions.c.

{
    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);
}

References add_local_reloption(), init_real_reloption(), name, and RELOPT_KIND_LOCAL.

Referenced by brin_bloom_options().

add_local_reloption()

static void add_local_reloption ( local_relopts *  relopts, relopt_gen *  newoption, int  offset  )

static

Definition at line 759 of file reloptions.c.

{
    local_relopt *opt = palloc(sizeof(*opt));
 
    Assert(offset < relopts->relopt_struct_size);
 
    opt->option = newoption;
    opt->offset = offset;
 
    relopts->options = lappend(relopts->options, opt);
}

References Assert(), lappend(), local_relopt::offset, local_relopt::option, local_relopts::options, and palloc().

Referenced by add_local_bool_reloption(), add_local_enum_reloption(), add_local_int_reloption(), add_local_real_reloption(), and add_local_string_reloption().

add_local_string_reloption()

void add_local_string_reloption	(	local_relopts *	relopts,
		const char *	name,
		const char *	desc,
		const char *	default_val,
		validate_string_relopt	validator,
		fill_string_relopt	filler,
		int	offset
	)

Definition at line 1120 of file reloptions.c.

{
    relopt_string *newoption = init_string_reloption(RELOPT_KIND_LOCAL,
                                                     name, desc,
                                                     default_val,
                                                     validator, filler,
                                                     0);
 
    add_local_reloption(relopts, (relopt_gen *) newoption, offset);
}

References add_local_reloption(), init_string_reloption(), name, and RELOPT_KIND_LOCAL.

add_real_reloption()

void add_real_reloption	(	bits32	kinds,
		const char *	name,
		const char *	desc,
		double	default_val,
		double	min_val,
		double	max_val,
		LOCKMODE	lockmode
	)

Definition at line 956 of file reloptions.c.

{
    relopt_real *newoption = init_real_reloption(kinds, name, desc,
                                                 default_val, min_val,
                                                 max_val, lockmode);
 
    add_reloption((relopt_gen *) newoption);
}

References add_reloption(), init_real_reloption(), and name.

Referenced by create_reloptions_table().

add_reloption()

static void add_reloption ( relopt_gen *  newoption )

static

Definition at line 702 of file reloptions.c.

{
    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;
}

References custom_options, MemoryContextSwitchTo(), need_initialization, num_custom_options, palloc(), repalloc(), and TopMemoryContext.

Referenced by add_bool_reloption(), add_enum_reloption(), add_int_reloption(), add_real_reloption(), and add_string_reloption().

add_reloption_kind()

relopt_kind add_reloption_kind

(

void

)

Definition at line 685 of file reloptions.c.

{
    /* 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;
}

References ereport, errcode(), errmsg(), ERROR, last_assigned_kind, and RELOPT_KIND_MAX.

Referenced by _PG_init(), and create_reloptions_table().

add_string_reloption()

void add_string_reloption	(	bits32	kinds,
		const char *	name,
		const char *	desc,
		const char *	default_val,
		validate_string_relopt	validator,
		LOCKMODE	lockmode
	)

Definition at line 1100 of file reloptions.c.

{
    relopt_string *newoption = init_string_reloption(kinds, name, desc,
                                                     default_val,
                                                     validator, NULL,
                                                     lockmode);
 
    add_reloption((relopt_gen *) newoption);
}

References add_reloption(), init_string_reloption(), and name.

Referenced by create_reloptions_table().

allocate_reloption()

static relopt_gen* allocate_reloption ( bits32  kinds, int  type, const char *  name, const char *  desc, LOCKMODE  lockmode  )

static

Definition at line 777 of file reloptions.c.

{
    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;
}

References relopt_gen::desc, elog(), ERROR, relopt_gen::kinds, relopt_gen::lockmode, MemoryContextSwitchTo(), name, relopt_gen::name, relopt_gen::namelen, palloc(), pstrdup(), RELOPT_KIND_LOCAL, RELOPT_TYPE_BOOL, RELOPT_TYPE_ENUM, RELOPT_TYPE_INT, RELOPT_TYPE_REAL, RELOPT_TYPE_STRING, TopMemoryContext, generate_unaccent_rules::type, and relopt_gen::type.

Referenced by init_bool_reloption(), init_enum_reloption(), init_int_reloption(), init_real_reloption(), and init_string_reloption().

allocateReloptStruct()

static void* allocateReloptStruct ( Size  base, relopt_value *  options, int  numoptions  )

static

Definition at line 1704 of file reloptions.c.

{
    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);
}

References relopt_string::default_isnull, relopt_string::default_val, relopt_string::fill_cb, relopt_value::gen, GET_STRING_RELOPTION_LEN, i, if(), relopt_value::isset, palloc0(), RELOPT_TYPE_STRING, relopt_value::string_val, relopt_gen::type, val, and relopt_value::values.

Referenced by build_local_reloptions(), and build_reloptions().

AlterTableGetRelOptionsLockLevel()

LOCKMODE AlterTableGetRelOptionsLockLevel

(

List *

defList

)

Definition at line 2109 of file reloptions.c.

{
    LOCKMODE    lockmode = NoLock;
    ListCell   *cell;
 
    if (defList == NIL)
        return AccessExclusiveLock;
 
    if (need_initialization)
        initialize_reloptions();
 
    foreach(cell, defList)
    {
        DefElem    *def = (DefElem *) lfirst(cell);
        int         i;
 
        for (i = 0; relOpts[i]; i++)
        {
            if (strncmp(relOpts[i]->name,
                        def->defname,
                        relOpts[i]->namelen + 1) == 0)
            {
                if (lockmode < relOpts[i]->lockmode)
                    lockmode = relOpts[i]->lockmode;
            }
        }
    }
 
    return lockmode;
}

References AccessExclusiveLock, DefElem::defname, i, initialize_reloptions(), lfirst, relopt_gen::lockmode, name, relopt_gen::namelen, need_initialization, NIL, NoLock, and relOpts.

Referenced by AlterTableGetLockLevel().

attribute_reloptions()

bytea* attribute_reloptions	(	Datum	reloptions,
		bool	validate
	)

Definition at line 2070 of file reloptions.c.

{
    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));
}

References build_reloptions(), lengthof, RELOPT_KIND_ATTRIBUTE, and RELOPT_TYPE_REAL.

Referenced by ATExecSetOptions(), and get_attribute_options().

build_local_reloptions()

void* build_local_reloptions	(	local_relopts *	relopts,
		Datum	options,
		bool	validate
	)

Definition at line 1947 of file reloptions.c.

{
    int         noptions = list_length(relopts->options);
    relopt_parse_elt *elems = palloc(sizeof(*elems) * noptions);
    relopt_value *vals;
    void       *opts;
    int         i = 0;
    ListCell   *lc;
 
    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++;
    }
 
    vals = parseLocalRelOptions(relopts, options, validate);
    opts = allocateReloptStruct(relopts->relopt_struct_size, vals, noptions);
    fillRelOptions(opts, relopts->relopt_struct_size, vals, noptions, validate,
                   elems, noptions);
 
    foreach(lc, relopts->validators)
        ((relopts_validator) lfirst(lc)) (opts, vals, noptions);
 
    if (elems)
        pfree(elems);
 
    return opts;
}

References allocateReloptStruct(), fillRelOptions(), i, lfirst, list_length(), relopt_gen::name, noptions, relopt_parse_elt::offset, local_relopt::offset, local_relopt::option, local_relopts::options, relopt_parse_elt::optname, opts, relopt_parse_elt::opttype, palloc(), parseLocalRelOptions(), pfree(), local_relopts::relopt_struct_size, relopt_gen::type, and local_relopts::validators.

Referenced by index_opclass_options().

build_reloptions()

void* build_reloptions	(	Datum	reloptions,
		bool	validate,
		relopt_kind	kind,
		Size	relopt_struct_size,
		const relopt_parse_elt *	relopt_elems,
		int	num_relopt_elems
	)

Definition at line 1910 of file reloptions.c.

{
    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);
 
    pfree(options);
 
    return rdopts;
}

References allocateReloptStruct(), Assert(), fillRelOptions(), options, parseRelOptions(), and pfree().

Referenced by attribute_reloptions(), bloptions(), brinoptions(), btoptions(), default_reloptions(), dioptions(), ginoptions(), gistoptions(), hashoptions(), spgoptions(), tablespace_reloptions(), and view_reloptions().

default_reloptions()

bytea* default_reloptions	(	Datum	reloptions,
		bool	validate,
		relopt_kind	kind
	)

Definition at line 1840 of file reloptions.c.

{
    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));
}

References build_reloptions(), fillfactor, lengthof, RELOPT_TYPE_BOOL, RELOPT_TYPE_ENUM, RELOPT_TYPE_INT, and RELOPT_TYPE_REAL.

Referenced by heap_reloptions().

extractRelOptions()

bytea* extractRelOptions	(	HeapTuple	tuple,
		TupleDesc	tupdesc,
		amoptions_function	amoptions
	)

Definition at line 1381 of file reloptions.c.

{
    bytea      *options;
    bool        isnull;
    Datum       datum;
    Form_pg_class classForm;
 
    datum = fastgetattr(tuple,
                        Anum_pg_class_reloptions,
                        tupdesc,
                        &isnull);
    if (isnull)
        return NULL;
 
    classForm = (Form_pg_class) GETSTRUCT(tuple);
 
    /* Parse into appropriate format; don't error out here */
    switch (classForm->relkind)
    {
        case RELKIND_RELATION:
        case RELKIND_TOASTVALUE:
        case RELKIND_MATVIEW:
            options = heap_reloptions(classForm->relkind, datum, false);
            break;
        case RELKIND_PARTITIONED_TABLE:
            options = partitioned_table_reloptions(datum, false);
            break;
        case RELKIND_VIEW:
            options = view_reloptions(datum, false);
            break;
        case RELKIND_INDEX:
        case RELKIND_PARTITIONED_INDEX:
            options = index_reloptions(amoptions, datum, false);
            break;
        case RELKIND_FOREIGN_TABLE:
            options = NULL;
            break;
        default:
            Assert(false);      /* can't get here */
            options = NULL;     /* keep compiler quiet */
            break;
    }
 
    return options;
}

References Assert(), fastgetattr(), GETSTRUCT, heap_reloptions(), index_reloptions(), options, partitioned_table_reloptions(), and view_reloptions().

Referenced by extract_autovac_opts(), and RelationParseRelOptions().

fillRelOptions()

static void fillRelOptions ( void *  rdopts, Size  basesize, relopt_value *  options, int  numoptions, bool  validate, const relopt_parse_elt *  elems, int  numelems  )

static

Definition at line 1744 of file reloptions.c.

{
    int         i;
    int         offset = basesize;
 
    for (i = 0; i < numoptions; i++)
    {
        int         j;
        bool        found = false;
 
        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);
}

References relopt_string::default_isnull, relopt_string::default_val, elog(), ERROR, relopt_string::fill_cb, i, j, relopt_parse_elt::offset, relopt_parse_elt::optname, RELOPT_TYPE_BOOL, RELOPT_TYPE_ENUM, RELOPT_TYPE_INT, RELOPT_TYPE_REAL, RELOPT_TYPE_STRING, SET_VARSIZE, and values.

Referenced by build_local_reloptions(), and build_reloptions().

heap_reloptions()

bytea* heap_reloptions	(	char	relkind,
		Datum	reloptions,
		bool	validate
	)

Definition at line 2020 of file reloptions.c.

{
    StdRdOptions *rdopts;
 
    switch (relkind)
    {
        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;
    }
}

References AutoVacOpts::analyze_scale_factor, AutoVacOpts::analyze_threshold, StdRdOptions::autovacuum, default_reloptions(), StdRdOptions::fillfactor, RELOPT_KIND_HEAP, and RELOPT_KIND_TOAST.

Referenced by ATExecSetRelOptions(), create_ctas_internal(), DefineRelation(), extractRelOptions(), and ProcessUtilitySlow().

index_reloptions()

bytea* index_reloptions	(	amoptions_function	amoptions,
		Datum	reloptions,
		bool	validate
	)

Definition at line 2055 of file reloptions.c.

{
    Assert(amoptions != NULL);
 
    /* Assume function is strict */
    if (!PointerIsValid(DatumGetPointer(reloptions)))
        return NULL;
 
    return amoptions(reloptions, validate);
}

References Assert(), DatumGetPointer(), and PointerIsValid.

Referenced by ATExecSetRelOptions(), DefineIndex(), and extractRelOptions().

init_bool_reloption()

static relopt_bool* init_bool_reloption ( bits32  kinds, const char *  name, const char *  desc, bool  default_val, LOCKMODE  lockmode  )

static

Definition at line 834 of file reloptions.c.

{
    relopt_bool *newoption;
 
    newoption = (relopt_bool *) allocate_reloption(kinds, RELOPT_TYPE_BOOL,
                                                   name, desc, lockmode);
    newoption->default_val = default_val;
 
    return newoption;
}

References allocate_reloption(), relopt_bool::default_val, name, and RELOPT_TYPE_BOOL.

Referenced by add_bool_reloption(), and add_local_bool_reloption().

init_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  )

static

Definition at line 991 of file reloptions.c.

{
    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;
}

References allocate_reloption(), relopt_enum::default_val, relopt_enum::detailmsg, relopt_enum::members, name, and RELOPT_TYPE_ENUM.

Referenced by add_enum_reloption(), and add_local_enum_reloption().

init_int_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  )

static

Definition at line 883 of file reloptions.c.

{
    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;
}

References allocate_reloption(), relopt_int::default_val, relopt_int::max, relopt_int::min, name, and RELOPT_TYPE_INT.

Referenced by add_int_reloption(), and add_local_int_reloption().

init_local_reloptions()

void init_local_reloptions	(	local_relopts *	relopts,
		Size	relopt_struct_size
	)

Definition at line 736 of file reloptions.c.

{
    relopts->options = NIL;
    relopts->validators = NIL;
    relopts->relopt_struct_size = relopt_struct_size;
}

References NIL, local_relopts::options, local_relopts::relopt_struct_size, and local_relopts::validators.

Referenced by _ltree_gist_options(), brin_bloom_options(), brin_minmax_multi_options(), g_int_options(), g_intbig_options(), ghstore_options(), gtrgm_options(), gtsvector_options(), index_opclass_options(), and ltree_gist_options().

init_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  )

static

Definition at line 936 of file reloptions.c.

{
    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;
}

References allocate_reloption(), relopt_real::default_val, relopt_real::max, relopt_real::min, name, and RELOPT_TYPE_REAL.

Referenced by add_local_real_reloption(), and add_real_reloption().

init_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  )

static

Definition at line 1055 of file reloptions.c.

{
    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;
}

References allocate_reloption(), relopt_string::default_isnull, relopt_string::default_len, relopt_string::default_val, relopt_string::fill_cb, MemoryContextStrdup(), name, RELOPT_KIND_LOCAL, RELOPT_TYPE_STRING, TopMemoryContext, and relopt_string::validate_cb.

Referenced by add_local_string_reloption(), and add_string_reloption().

initialize_reloptions()

static void initialize_reloptions ( void  )

static

Definition at line 582 of file reloptions.c.

{
    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;
}

References Assert(), boolRelOpts, custom_options, DoLockModesConflict(), enumRelOpts, relopt_bool::gen, relopt_int::gen, relopt_real::gen, relopt_enum::gen, relopt_string::gen, i, intRelOpts, j, relopt_gen::lockmode, MemoryContextAlloc(), name, relopt_gen::name, relopt_gen::namelen, need_initialization, num_custom_options, pfree(), realRelOpts, RELOPT_TYPE_BOOL, RELOPT_TYPE_ENUM, RELOPT_TYPE_INT, RELOPT_TYPE_REAL, RELOPT_TYPE_STRING, relOpts, stringRelOpts, TopMemoryContext, and relopt_gen::type.

Referenced by AlterTableGetRelOptionsLockLevel(), and parseRelOptions().

parse_one_reloption()

static void parse_one_reloption ( relopt_value *  option, char *  text_str, int  text_len, bool  validate  )

static

Definition at line 1571 of file reloptions.c.

{
    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;
    }
 
    if (parsed)
        option->isset = true;
    if (!nofree)
        pfree(value);
}

References _, relopt_enum::default_val, relopt_enum::detailmsg, elog(), ereport, errcode(), errdetail(), errdetail_internal(), errmsg(), ERROR, if(), relopt_int::max, relopt_real::max, relopt_enum::members, relopt_int::min, relopt_real::min, option::name, palloc(), parse_bool(), parse_int(), parse_real(), pfree(), pg_strcasecmp(), RELOPT_TYPE_BOOL, RELOPT_TYPE_ENUM, RELOPT_TYPE_INT, RELOPT_TYPE_REAL, RELOPT_TYPE_STRING, relopt_enum_elt_def::string_val, relopt_string::validate_cb, and value.

Referenced by parseRelOptionsInternal().

parseLocalRelOptions()

static relopt_value* parseLocalRelOptions ( local_relopts *  relopts, Datum  options, bool  validate  )

static

Definition at line 1543 of file reloptions.c.

{
    int         nopts = list_length(relopts->options);
    relopt_value *values = palloc(sizeof(*values) * nopts);
    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);
 
    return values;
}

References i, lfirst, list_length(), local_relopt::option, local_relopts::options, palloc(), parseRelOptionsInternal(), and values.

Referenced by build_local_reloptions().

parseRelOptions()

static relopt_value* parseRelOptions ( Datum  options, bool  validate, relopt_kind  kind, int *  numrelopts  )

static

Definition at line 1501 of file reloptions.c.

{
    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;
}

References DatumGetPointer(), relopt_value::gen, i, initialize_reloptions(), relopt_value::isset, j, need_initialization, palloc(), parseRelOptionsInternal(), PointerIsValid, and relOpts.

Referenced by build_reloptions().

parseRelOptionsInternal()

static void parseRelOptionsInternal ( Datum  options, bool  validate, relopt_value *  reloptions, int  numoptions  )

static

Definition at line 1429 of file reloptions.c.

{
    ArrayType  *array = DatumGetArrayTypeP(options);
    Datum      *optiondatums;
    int         noptions;
    int         i;
 
    deconstruct_array_builtin(array, TEXTOID, &optiondatums, NULL, &noptions);
 
    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);
 
    if (((void *) array) != DatumGetPointer(options))
        pfree(array);
}

References DatumGetArrayTypeP, DatumGetPointer(), deconstruct_array_builtin(), ereport, errcode(), errmsg(), ERROR, relopt_value::gen, i, j, relopt_gen::namelen, noptions, parse_one_reloption(), pfree(), TextDatumGetCString, VARDATA, VARHDRSZ, and VARSIZE.

Referenced by parseLocalRelOptions(), and parseRelOptions().

partitioned_table_reloptions()

bytea* partitioned_table_reloptions	(	Datum	reloptions,
		bool	validate
	)

Definition at line 1985 of file reloptions.c.

{
    if (validate && reloptions)
        ereport(ERROR,
                errcode(ERRCODE_WRONG_OBJECT_TYPE),
                errmsg("cannot specify storage parameters for a partitioned table"),
                errhint("Specify storage parameters for its leaf partitions, instead."));
    return NULL;
}

References ereport, errcode(), errhint(), errmsg(), and ERROR.

Referenced by ATExecSetRelOptions(), DefineRelation(), and extractRelOptions().

register_reloptions_validator()

void register_reloptions_validator	(	local_relopts *	relopts,
		relopts_validator	validator
	)

Definition at line 749 of file reloptions.c.

{
    relopts->validators = lappend(relopts->validators, validator);
}

References lappend(), and local_relopts::validators.

tablespace_reloptions()

bytea* tablespace_reloptions	(	Datum	reloptions,
		bool	validate
	)

Definition at line 2087 of file reloptions.c.

{
    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));
}

References build_reloptions(), effective_io_concurrency, lengthof, maintenance_io_concurrency, random_page_cost, RELOPT_KIND_TABLESPACE, RELOPT_TYPE_INT, RELOPT_TYPE_REAL, and seq_page_cost.

Referenced by AlterTableSpaceOptions(), CreateTableSpace(), and get_tablespace().

transformRelOptions()

Datum transformRelOptions	(	Datum	oldOptions,
		List *	defList,
		const char *	namspace,
		char *	validnsps[],
		bool	acceptOidsOff,
		bool	isReset
	)

Definition at line 1158 of file reloptions.c.

{
    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_builtin(array, TEXTOID, &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;
}

References accumArrayResult(), DefElem::arg, CurrentMemoryContext, DatumGetArrayTypeP, DatumGetPointer(), deconstruct_array_builtin(), defGetBoolean(), defGetString(), DefElem::defname, DefElem::defnamespace, ereport, errcode(), errmsg(), ERROR, i, len, lfirst, makeArrayResult(), NIL, palloc(), PointerGetDatum(), PointerIsValid, SET_VARSIZE, sprintf, value, VARDATA, VARHDRSZ, and VARSIZE.

Referenced by AlterTableSpaceOptions(), ATExecSetOptions(), ATExecSetRelOptions(), ComputeIndexAttrs(), create_ctas_internal(), CreateTableSpace(), DefineIndex(), DefineRelation(), and ProcessUtilitySlow().

untransformRelOptions()

List* untransformRelOptions

(

Datum

options

)

Definition at line 1333 of file reloptions.c.

{
    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_builtin(array, TEXTOID, &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(p);
        }
        result = lappend(result, makeDefElem(s, val, -1));
    }
 
    return result;
}

References DatumGetArrayTypeP, DatumGetPointer(), deconstruct_array_builtin(), i, lappend(), makeDefElem(), makeString(), NIL, noptions, PointerIsValid, TextDatumGetCString, and val.

Referenced by ATExecSetRelOptions(), dblink_fdw_validator(), file_fdw_validator(), generateClonedIndexStmt(), GetForeignColumnOptions(), GetForeignDataWrapperExtended(), GetForeignServerExtended(), GetForeignTable(), GetUserMapping(), postgres_fdw_validator(), postgresql_fdw_validator(), and transformGenericOptions().

view_reloptions()

bytea* view_reloptions	(	Datum	reloptions,
		bool	validate
	)

Definition at line 1999 of file reloptions.c.

{
    static const relopt_parse_elt tab[] = {
        {"security_barrier", RELOPT_TYPE_BOOL,
        offsetof(ViewOptions, security_barrier)},
        {"security_invoker", RELOPT_TYPE_BOOL,
        offsetof(ViewOptions, security_invoker)},
        {"check_option", RELOPT_TYPE_ENUM,
        offsetof(ViewOptions, check_option)}
    };
 
    return (bytea *) build_reloptions(reloptions, validate,
                                      RELOPT_KIND_VIEW,
                                      sizeof(ViewOptions),
                                      tab, lengthof(tab));
}

References build_reloptions(), lengthof, RELOPT_KIND_VIEW, RELOPT_TYPE_BOOL, and RELOPT_TYPE_ENUM.

Referenced by ATExecSetRelOptions(), DefineRelation(), and extractRelOptions().

Variable Documentation

boolRelOpts

relopt_bool boolRelOpts[]

static

Definition at line 96 of file reloptions.c.

Referenced by initialize_reloptions().

custom_options

relopt_gen** custom_options = NULL

static

Definition at line 559 of file reloptions.c.

Referenced by add_reloption(), and initialize_reloptions().

enumRelOpts

relopt_enum enumRelOpts[]

static

Definition at line 510 of file reloptions.c.

Referenced by initialize_reloptions().

gistBufferingOptValues

relopt_enum_elt_def gistBufferingOptValues[]

static

Initial value:

=
{
    {"auto", GIST_OPTION_BUFFERING_AUTO},
    {"on", GIST_OPTION_BUFFERING_ON},
    {"off", GIST_OPTION_BUFFERING_OFF},
    {(const char *) NULL}       
}

Definition at line 493 of file reloptions.c.

intRelOpts

relopt_int intRelOpts[]

static

Definition at line 175 of file reloptions.c.

Referenced by initialize_reloptions().

last_assigned_kind

bits32 last_assigned_kind = RELOPT_KIND_LAST_DEFAULT

static

Definition at line 556 of file reloptions.c.

Referenced by add_reloption_kind().

need_initialization

bool need_initialization = true

static

Definition at line 560 of file reloptions.c.

Referenced by add_reloption(), AlterTableGetRelOptionsLockLevel(), initialize_reloptions(), and parseRelOptions().

num_custom_options

int num_custom_options = 0

static

Definition at line 558 of file reloptions.c.

Referenced by add_reloption(), and initialize_reloptions().

realRelOpts

relopt_real realRelOpts[]

static

Definition at line 390 of file reloptions.c.

Referenced by initialize_reloptions().

relOpts

relopt_gen** relOpts = NULL

static

Definition at line 555 of file reloptions.c.

Referenced by AlterTableGetRelOptionsLockLevel(), initialize_reloptions(), and parseRelOptions().

StdRdOptIndexCleanupValues

relopt_enum_elt_def StdRdOptIndexCleanupValues[]

static

Initial value:

=
{
    {"auto", STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO},
    {"on", STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON},
    {"off", STDRD_OPTION_VACUUM_INDEX_CLEANUP_OFF},
    {"true", STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON},
    {"false", STDRD_OPTION_VACUUM_INDEX_CLEANUP_OFF},
    {"yes", STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON},
    {"no", STDRD_OPTION_VACUUM_INDEX_CLEANUP_OFF},
    {"1", STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON},
    {"0", STDRD_OPTION_VACUUM_INDEX_CLEANUP_OFF},
    {(const char *) NULL}       
}

Definition at line 478 of file reloptions.c.

stringRelOpts

relopt_string stringRelOpts[]

static

Initial value:

=
{
    
    {{NULL}}
}

Definition at line 549 of file reloptions.c.

Referenced by initialize_reloptions().

viewCheckOptValues

relopt_enum_elt_def viewCheckOptValues[]

static

Initial value:

=
{
    
    {"local", VIEW_OPTION_CHECK_OPTION_LOCAL},
    {"cascaded", VIEW_OPTION_CHECK_OPTION_CASCADED},
    {(const char *) NULL}       
}

Definition at line 502 of file reloptions.c.