reloptions.h File Reference

#include "access/amapi.h"
#include "access/htup.h"
#include "access/tupdesc.h"
#include "nodes/pg_list.h"
#include "storage/lock.h"

Include dependency graph for reloptions.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	relopt_gen
struct	relopt_value
struct	relopt_bool
struct	relopt_int
struct	relopt_real
struct	relopt_enum_elt_def
struct	relopt_enum
struct	relopt_string
struct	relopt_parse_elt
struct	local_relopt
struct	local_relopts

Macros
#define	HEAP_RELOPT_NAMESPACES   { "toast", NULL }
#define	GET_STRING_RELOPTION(optstruct, member)

Typedefs
typedef enum relopt_type	relopt_type
typedef enum relopt_kind	relopt_kind
typedef struct relopt_gen	relopt_gen
typedef struct relopt_value	relopt_value
typedef struct relopt_bool	relopt_bool
typedef struct relopt_int	relopt_int
typedef struct relopt_real	relopt_real
typedef struct relopt_enum_elt_def	relopt_enum_elt_def
typedef struct relopt_enum	relopt_enum
typedef void(*	validate_string_relopt) (const char *value)
typedef Size(*	fill_string_relopt) (const char *value, void *ptr)
typedef void(*	relopts_validator) (void *parsed_options, relopt_value *vals, int nvals)
typedef struct relopt_string	relopt_string
typedef struct local_relopt	local_relopt
typedef struct local_relopts	local_relopts

Enumerations
enum	relopt_type {   RELOPT_TYPE_BOOL , RELOPT_TYPE_INT , RELOPT_TYPE_REAL , RELOPT_TYPE_ENUM ,   RELOPT_TYPE_STRING }
enum	relopt_kind {   RELOPT_KIND_LOCAL = 0 , RELOPT_KIND_HEAP = (1 << 0) , RELOPT_KIND_TOAST = (1 << 1) , RELOPT_KIND_BTREE = (1 << 2) ,   RELOPT_KIND_HASH = (1 << 3) , RELOPT_KIND_GIN = (1 << 4) , RELOPT_KIND_GIST = (1 << 5) , RELOPT_KIND_ATTRIBUTE = (1 << 6) ,   RELOPT_KIND_TABLESPACE = (1 << 7) , RELOPT_KIND_SPGIST = (1 << 8) , RELOPT_KIND_VIEW = (1 << 9) , RELOPT_KIND_BRIN = (1 << 10) ,   RELOPT_KIND_PARTITIONED = (1 << 11) , RELOPT_KIND_LAST_DEFAULT = RELOPT_KIND_PARTITIONED , RELOPT_KIND_MAX = (1 << 30) }

Functions
relopt_kind	add_reloption_kind (void)
void	add_bool_reloption (bits32 kinds, const char *name, const char *desc, bool default_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_real_reloption (bits32 kinds, const char *name, const char *desc, double default_val, double min_val, double max_val, 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_string_reloption (bits32 kinds, const char *name, const char *desc, const char *default_val, validate_string_relopt validator, LOCKMODE lockmode)
void	init_local_reloptions (local_relopts *relopts, Size relopt_struct_size)
void	register_reloptions_validator (local_relopts *relopts, relopts_validator validator)
void	add_local_bool_reloption (local_relopts *relopts, const char *name, const char *desc, bool default_val, int offset)
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)
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)
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)
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, const char *const validnsps[], bool acceptOidsOff, bool isReset)
List *	untransformRelOptions (Datum options)
bytea *	extractRelOptions (HeapTuple tuple, TupleDesc tupdesc, amoptions_function amoptions)
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 *	default_reloptions (Datum reloptions, bool validate, relopt_kind kind)
bytea *	heap_reloptions (char relkind, Datum reloptions, bool validate)
bytea *	view_reloptions (Datum reloptions, bool validate)
bytea *	partitioned_table_reloptions (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)

Macro Definition Documentation

GET_STRING_RELOPTION

#define GET_STRING_RELOPTION	(		optstruct,
			member
	)

Value:

    ((optstruct)->member == 0 ? NULL : \
     (char *)(optstruct) + (optstruct)->member)

Definition at line 191 of file reloptions.h.

HEAP_RELOPT_NAMESPACES

#define HEAP_RELOPT_NAMESPACES   { "toast", NULL }

Definition at line 61 of file reloptions.h.

Typedef Documentation

fill_string_relopt

typedef Size(* fill_string_relopt) (const char *value, void *ptr)

Definition at line 134 of file reloptions.h.

local_relopt

typedef struct local_relopt local_relopt

local_relopts

typedef struct local_relopts local_relopts

relopt_bool

typedef struct relopt_bool relopt_bool

relopt_enum

typedef struct relopt_enum relopt_enum

relopt_enum_elt_def

typedef struct relopt_enum_elt_def relopt_enum_elt_def

relopt_gen

typedef struct relopt_gen relopt_gen

relopt_int

typedef struct relopt_int relopt_int

relopt_kind

typedef enum relopt_kind relopt_kind

relopt_real

typedef struct relopt_real relopt_real

relopt_string

typedef struct relopt_string relopt_string

relopt_type

typedef enum relopt_type relopt_type

relopt_value

typedef struct relopt_value relopt_value

relopts_validator

typedef void(* relopts_validator) (void *parsed_options, relopt_value *vals, int nvals)

Definition at line 137 of file reloptions.h.

validate_string_relopt

typedef void(* validate_string_relopt) (const char *value)

Definition at line 133 of file reloptions.h.

Enumeration Type Documentation

relopt_kind

enum relopt_kind

Enumerator
RELOPT_KIND_LOCAL
RELOPT_KIND_HEAP
RELOPT_KIND_TOAST
RELOPT_KIND_BTREE
RELOPT_KIND_HASH
RELOPT_KIND_GIN
RELOPT_KIND_GIST
RELOPT_KIND_ATTRIBUTE
RELOPT_KIND_TABLESPACE
RELOPT_KIND_SPGIST
RELOPT_KIND_VIEW
RELOPT_KIND_BRIN
RELOPT_KIND_PARTITIONED
RELOPT_KIND_LAST_DEFAULT
RELOPT_KIND_MAX

Definition at line 39 of file reloptions.h.

{
    RELOPT_KIND_LOCAL = 0,
    RELOPT_KIND_HEAP = (1 << 0),
    RELOPT_KIND_TOAST = (1 << 1),
    RELOPT_KIND_BTREE = (1 << 2),
    RELOPT_KIND_HASH = (1 << 3),
    RELOPT_KIND_GIN = (1 << 4),
    RELOPT_KIND_GIST = (1 << 5),
    RELOPT_KIND_ATTRIBUTE = (1 << 6),
    RELOPT_KIND_TABLESPACE = (1 << 7),
    RELOPT_KIND_SPGIST = (1 << 8),
    RELOPT_KIND_VIEW = (1 << 9),
    RELOPT_KIND_BRIN = (1 << 10),
    RELOPT_KIND_PARTITIONED = (1 << 11),
    /* if you add a new kind, make sure you update "last_default" too */
    RELOPT_KIND_LAST_DEFAULT = RELOPT_KIND_PARTITIONED,
    /* some compilers treat enums as signed ints, so we can't use 1 << 31 */
    RELOPT_KIND_MAX = (1 << 30)
} relopt_kind;

relopt_type

enum relopt_type

Enumerator
RELOPT_TYPE_BOOL
RELOPT_TYPE_INT
RELOPT_TYPE_REAL
RELOPT_TYPE_ENUM
RELOPT_TYPE_STRING

Definition at line 29 of file reloptions.h.

{
    RELOPT_TYPE_BOOL,
    RELOPT_TYPE_INT,
    RELOPT_TYPE_REAL,
    RELOPT_TYPE_ENUM,
    RELOPT_TYPE_STRING,
} relopt_type;

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 860 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 1029 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 912 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(), max_val, 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 876 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 1047 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 929 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(), max_val, 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 983 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(), max_val, name, and RELOPT_KIND_LOCAL.

Referenced by brin_bloom_options().

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 1129 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 965 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(), max_val, and name.

Referenced by create_reloptions_table().

add_reloption_kind()

relopt_kind add_reloption_kind

(

void

)

Definition at line 694 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 1109 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().

AlterTableGetRelOptionsLockLevel()

LOCKMODE AlterTableGetRelOptionsLockLevel

(

List *

defList

)

Definition at line 2135 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 2096 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, RELOPT_TYPE_REAL, and validate().

Referenced by ATExecSetOptions(), and get_attribute_options().

build_local_reloptions()

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

Definition at line 1971 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;
        elems[i].isset_offset = 0;  /* not supported for local relopts yet */
 
        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);
 
    if (validate)
        foreach(lc, relopts->validators)
            ((relopts_validator) lfirst(lc)) (opts, vals, noptions);
 
    if (elems)
        pfree(elems);
 
    return opts;
}

References allocateReloptStruct(), fillRelOptions(), i, relopt_parse_elt::isset_offset, 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, validate(), 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 1934 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(), pfree(), and validate().

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 1860 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_max_threshold", RELOPT_TYPE_INT,
        offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_max_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), offsetof(StdRdOptions, vacuum_truncate_set)},
        {"vacuum_max_eager_freeze_failure_rate", RELOPT_TYPE_REAL,
        offsetof(StdRdOptions, vacuum_max_eager_freeze_failure_rate)}
    };
 
    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, RELOPT_TYPE_REAL, vacuum_cost_delay, vacuum_cost_limit, vacuum_max_eager_freeze_failure_rate, vacuum_truncate, and validate().

Referenced by heap_reloptions().

extractRelOptions()

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

Definition at line 1390 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().

heap_reloptions()

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

Definition at line 2046 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, RELOPT_KIND_TOAST, and validate().

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 2081 of file reloptions.c.

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

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

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

init_local_reloptions()

void init_local_reloptions	(	local_relopts *	relopts,
		Size	relopt_struct_size
	)

Definition at line 745 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().

partitioned_table_reloptions()

bytea * partitioned_table_reloptions	(	Datum	reloptions,
		bool	validate
	)

Definition at line 2011 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(), ERROR, and validate().

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

register_reloptions_validator()

void register_reloptions_validator	(	local_relopts *	relopts,
		relopts_validator	validator
	)

Definition at line 758 of file reloptions.c.

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

References lappend(), and local_relopts::validators.

Referenced by ltree_gist_options().

tablespace_reloptions()

bytea * tablespace_reloptions	(	Datum	reloptions,
		bool	validate
	)

Definition at line 2113 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, seq_page_cost, and validate().

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

transformRelOptions()

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

Definition at line 1167 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 1342 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(), pg_options_to_table(), postgres_fdw_validator(), postgresql_fdw_validator(), and transformGenericOptions().

view_reloptions()

bytea * view_reloptions	(	Datum	reloptions,
		bool	validate
	)

Definition at line 2025 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, RELOPT_TYPE_ENUM, and validate().

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