PostgreSQL Source Code  git master
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 "nodes/makefuncs.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_genallocate_reloption (bits32 kinds, int type, const char *name, const char *desc, LOCKMODE lockmode)
 
static relopt_boolinit_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_intinit_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_realinit_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_enuminit_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_stringinit_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)
 
ListuntransformRelOptions (Datum options)
 
byteaextractRelOptions (HeapTuple tuple, TupleDesc tupdesc, amoptions_function amoptions)
 
static void parseRelOptionsInternal (Datum options, bool validate, relopt_value *reloptions, int numoptions)
 
static relopt_valueparseRelOptions (Datum options, bool validate, relopt_kind kind, int *numrelopts)
 
static relopt_valueparseLocalRelOptions (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)
 
byteadefault_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)
 
byteapartitioned_table_reloptions (Datum reloptions, bool validate)
 
byteaview_reloptions (Datum reloptions, bool validate)
 
byteaheap_reloptions (char relkind, Datum reloptions, bool validate)
 
byteaindex_reloptions (amoptions_function amoptions, Datum reloptions, bool validate)
 
byteaattribute_reloptions (Datum reloptions, bool validate)
 
byteatablespace_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 569 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 849 of file reloptions.c.

851 {
852  relopt_bool *newoption = init_bool_reloption(kinds, name, desc,
853  default_val, lockmode);
854 
855  add_reloption((relopt_gen *) newoption);
856 }
static void add_reloption(relopt_gen *newoption)
Definition: reloptions.c:700
static relopt_bool * init_bool_reloption(bits32 kinds, const char *name, const char *desc, bool default_val, LOCKMODE lockmode)
Definition: reloptions.c:832
const char * name

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

1021 {
1022  relopt_enum *newoption = init_enum_reloption(kinds, name, desc,
1023  members, default_val,
1024  detailmsg, lockmode);
1025 
1026  add_reloption((relopt_gen *) newoption);
1027 }
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)
Definition: reloptions.c:989

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

903 {
904  relopt_int *newoption = init_int_reloption(kinds, name, desc,
905  default_val, min_val,
906  max_val, lockmode);
907 
908  add_reloption((relopt_gen *) newoption);
909 }
tree ctl max_val
Definition: radixtree.h:1886
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)
Definition: reloptions.c:881

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

867 {
869  name, desc,
870  default_val, 0);
871 
872  add_local_reloption(relopts, (relopt_gen *) newoption, offset);
873 }
static void add_local_reloption(local_relopts *relopts, relopt_gen *newoption, int offset)
Definition: reloptions.c:757
@ RELOPT_KIND_LOCAL
Definition: reloptions.h:41

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

1039 {
1041  name, desc,
1042  members, default_val,
1043  detailmsg, 0);
1044 
1045  add_local_reloption(relopts, (relopt_gen *) newoption, offset);
1046 }

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

921 {
923  name, desc, default_val,
924  min_val, max_val, 0);
925 
926  add_local_reloption(relopts, (relopt_gen *) newoption, offset);
927 }

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

975 {
977  name, desc,
978  default_val, min_val,
979  max_val, 0);
980 
981  add_local_reloption(relopts, (relopt_gen *) newoption, offset);
982 }
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)
Definition: reloptions.c:934

References add_local_reloption(), init_real_reloption(), max_val, 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 757 of file reloptions.c.

758 {
759  local_relopt *opt = palloc(sizeof(*opt));
760 
761  Assert(offset < relopts->relopt_struct_size);
762 
763  opt->option = newoption;
764  opt->offset = offset;
765 
766  relopts->options = lappend(relopts->options, opt);
767 }
#define Assert(condition)
Definition: c.h:858
List * lappend(List *list, void *datum)
Definition: list.c:339
void * palloc(Size size)
Definition: mcxt.c:1316
relopt_gen * option
Definition: reloptions.h:160
List * options
Definition: reloptions.h:167

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

1122 {
1124  name, desc,
1125  default_val,
1126  validator, filler,
1127  0);
1128 
1129  add_local_reloption(relopts, (relopt_gen *) newoption, offset);
1130 }
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)
Definition: reloptions.c:1053

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

957 {
958  relopt_real *newoption = init_real_reloption(kinds, name, desc,
959  default_val, min_val,
960  max_val, lockmode);
961 
962  add_reloption((relopt_gen *) newoption);
963 }

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

Referenced by create_reloptions_table().

◆ add_reloption()

static void add_reloption ( relopt_gen newoption)
static

Definition at line 700 of file reloptions.c.

701 {
702  static int max_custom_options = 0;
703 
704  if (num_custom_options >= max_custom_options)
705  {
706  MemoryContext oldcxt;
707 
709 
710  if (max_custom_options == 0)
711  {
712  max_custom_options = 8;
713  custom_options = palloc(max_custom_options * sizeof(relopt_gen *));
714  }
715  else
716  {
717  max_custom_options *= 2;
719  max_custom_options * sizeof(relopt_gen *));
720  }
721  MemoryContextSwitchTo(oldcxt);
722  }
723  custom_options[num_custom_options++] = newoption;
724 
725  need_initialization = true;
726 }
MemoryContext TopMemoryContext
Definition: mcxt.c:149
void * repalloc(void *pointer, Size size)
Definition: mcxt.c:1540
MemoryContextSwitchTo(old_ctx)
static int num_custom_options
Definition: reloptions.c:556
static bool need_initialization
Definition: reloptions.c:558
static relopt_gen ** custom_options
Definition: reloptions.c:557

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

684 {
685  /* don't hand out the last bit so that the enum's behavior is portable */
687  ereport(ERROR,
688  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
689  errmsg("user-defined relation parameter types limit exceeded")));
690  last_assigned_kind <<= 1;
692 }
int errcode(int sqlerrcode)
Definition: elog.c:857
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
static bits32 last_assigned_kind
Definition: reloptions.c:554
relopt_kind
Definition: reloptions.h:40
@ RELOPT_KIND_MAX
Definition: reloptions.h:57

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

1101 {
1102  relopt_string *newoption = init_string_reloption(kinds, name, desc,
1103  default_val,
1104  validator, NULL,
1105  lockmode);
1106 
1107  add_reloption((relopt_gen *) newoption);
1108 }

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

777 {
778  MemoryContext oldcxt;
779  size_t size;
780  relopt_gen *newoption;
781 
782  if (kinds != RELOPT_KIND_LOCAL)
784  else
785  oldcxt = NULL;
786 
787  switch (type)
788  {
789  case RELOPT_TYPE_BOOL:
790  size = sizeof(relopt_bool);
791  break;
792  case RELOPT_TYPE_INT:
793  size = sizeof(relopt_int);
794  break;
795  case RELOPT_TYPE_REAL:
796  size = sizeof(relopt_real);
797  break;
798  case RELOPT_TYPE_ENUM:
799  size = sizeof(relopt_enum);
800  break;
801  case RELOPT_TYPE_STRING:
802  size = sizeof(relopt_string);
803  break;
804  default:
805  elog(ERROR, "unsupported reloption type %d", type);
806  return NULL; /* keep compiler quiet */
807  }
808 
809  newoption = palloc(size);
810 
811  newoption->name = pstrdup(name);
812  if (desc)
813  newoption->desc = pstrdup(desc);
814  else
815  newoption->desc = NULL;
816  newoption->kinds = kinds;
817  newoption->namelen = strlen(name);
818  newoption->type = type;
819  newoption->lockmode = lockmode;
820 
821  if (oldcxt != NULL)
822  MemoryContextSwitchTo(oldcxt);
823 
824  return newoption;
825 }
#define elog(elevel,...)
Definition: elog.h:224
char * pstrdup(const char *in)
Definition: mcxt.c:1695
struct relopt_real relopt_real
struct relopt_bool relopt_bool
struct relopt_string relopt_string
struct relopt_enum relopt_enum
struct relopt_int relopt_int
@ RELOPT_TYPE_ENUM
Definition: reloptions.h:34
@ RELOPT_TYPE_INT
Definition: reloptions.h:32
@ RELOPT_TYPE_BOOL
Definition: reloptions.h:31
@ RELOPT_TYPE_REAL
Definition: reloptions.h:33
@ RELOPT_TYPE_STRING
Definition: reloptions.h:35
static pg_noinline void Size size
Definition: slab.c:607
const char * desc
Definition: reloptions.h:68
bits32 kinds
Definition: reloptions.h:69
const char * name
Definition: reloptions.h:66
LOCKMODE lockmode
Definition: reloptions.h:70
relopt_type type
Definition: reloptions.h:72
int namelen
Definition: reloptions.h:71
const char * type

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, size, TopMemoryContext, 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 1702 of file reloptions.c.

1703 {
1704  Size size = base;
1705  int i;
1706 
1707  for (i = 0; i < numoptions; i++)
1708  {
1709  relopt_value *optval = &options[i];
1710 
1711  if (optval->gen->type == RELOPT_TYPE_STRING)
1712  {
1713  relopt_string *optstr = (relopt_string *) optval->gen;
1714 
1715  if (optstr->fill_cb)
1716  {
1717  const char *val = optval->isset ? optval->values.string_val :
1718  optstr->default_isnull ? NULL : optstr->default_val;
1719 
1720  size += optstr->fill_cb(val, NULL);
1721  }
1722  else
1723  size += GET_STRING_RELOPTION_LEN(*optval) + 1;
1724  }
1725  }
1726 
1727  return palloc0(size);
1728 }
size_t Size
Definition: c.h:605
long val
Definition: informix.c:670
int i
Definition: isn.c:73
if(TABLE==NULL||TABLE_index==NULL)
Definition: isn.c:77
void * palloc0(Size size)
Definition: mcxt.c:1346
#define GET_STRING_RELOPTION_LEN(option)
Definition: reloptions.c:569
char * default_val
Definition: reloptions.h:146
fill_string_relopt fill_cb
Definition: reloptions.h:145
bool default_isnull
Definition: reloptions.h:143
relopt_gen * gen
Definition: reloptions.h:78
union relopt_value::@49 values
char * string_val
Definition: reloptions.h:86

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, size, 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 2108 of file reloptions.c.

2109 {
2110  LOCKMODE lockmode = NoLock;
2111  ListCell *cell;
2112 
2113  if (defList == NIL)
2114  return AccessExclusiveLock;
2115 
2116  if (need_initialization)
2118 
2119  foreach(cell, defList)
2120  {
2121  DefElem *def = (DefElem *) lfirst(cell);
2122  int i;
2123 
2124  for (i = 0; relOpts[i]; i++)
2125  {
2126  if (strncmp(relOpts[i]->name,
2127  def->defname,
2128  relOpts[i]->namelen + 1) == 0)
2129  {
2130  if (lockmode < relOpts[i]->lockmode)
2131  lockmode = relOpts[i]->lockmode;
2132  }
2133  }
2134  }
2135 
2136  return lockmode;
2137 }
int LOCKMODE
Definition: lockdefs.h:26
#define NoLock
Definition: lockdefs.h:34
#define AccessExclusiveLock
Definition: lockdefs.h:43
#define lfirst(lc)
Definition: pg_list.h:172
#define NIL
Definition: pg_list.h:68
static void initialize_reloptions(void)
Definition: reloptions.c:580
static relopt_gen ** relOpts
Definition: reloptions.c:553
char * defname
Definition: parsenodes.h:815

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

2070 {
2071  static const relopt_parse_elt tab[] = {
2072  {"n_distinct", RELOPT_TYPE_REAL, offsetof(AttributeOpts, n_distinct)},
2073  {"n_distinct_inherited", RELOPT_TYPE_REAL, offsetof(AttributeOpts, n_distinct_inherited)}
2074  };
2075 
2076  return (bytea *) build_reloptions(reloptions, validate,
2078  sizeof(AttributeOpts),
2079  tab, lengthof(tab));
2080 }
#define lengthof(array)
Definition: c.h:788
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: reloptions.c:1908
@ RELOPT_KIND_ATTRIBUTE
Definition: reloptions.h:48
Definition: c.h:687

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

1946 {
1947  int noptions = list_length(relopts->options);
1948  relopt_parse_elt *elems = palloc(sizeof(*elems) * noptions);
1949  relopt_value *vals;
1950  void *opts;
1951  int i = 0;
1952  ListCell *lc;
1953 
1954  foreach(lc, relopts->options)
1955  {
1956  local_relopt *opt = lfirst(lc);
1957 
1958  elems[i].optname = opt->option->name;
1959  elems[i].opttype = opt->option->type;
1960  elems[i].offset = opt->offset;
1961 
1962  i++;
1963  }
1964 
1965  vals = parseLocalRelOptions(relopts, options, validate);
1967  fillRelOptions(opts, relopts->relopt_struct_size, vals, noptions, validate,
1968  elems, noptions);
1969 
1970  if (validate)
1971  foreach(lc, relopts->validators)
1972  ((relopts_validator) lfirst(lc)) (opts, vals, noptions);
1973 
1974  if (elems)
1975  pfree(elems);
1976 
1977  return opts;
1978 }
void pfree(void *pointer)
Definition: mcxt.c:1520
static AmcheckOptions opts
Definition: pg_amcheck.c:111
static int list_length(const List *l)
Definition: pg_list.h:152
static size_t noptions
static void * allocateReloptStruct(Size base, relopt_value *options, int numoptions)
Definition: reloptions.c:1702
static void fillRelOptions(void *rdopts, Size basesize, relopt_value *options, int numoptions, bool validate, const relopt_parse_elt *elems, int numelems)
Definition: reloptions.c:1742
static relopt_value * parseLocalRelOptions(local_relopts *relopts, Datum options, bool validate)
Definition: reloptions.c:1541
void(* relopts_validator)(void *parsed_options, relopt_value *vals, int nvals)
Definition: reloptions.h:137
List * validators
Definition: reloptions.h:168
Size relopt_struct_size
Definition: reloptions.h:169
const char * optname
Definition: reloptions.h:152
relopt_type opttype
Definition: reloptions.h:153

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

1913 {
1914  int numoptions;
1916  void *rdopts;
1917 
1918  /* parse options specific to given relation option kind */
1919  options = parseRelOptions(reloptions, validate, kind, &numoptions);
1920  Assert(numoptions <= num_relopt_elems);
1921 
1922  /* if none set, we're done */
1923  if (numoptions == 0)
1924  {
1925  Assert(options == NULL);
1926  return NULL;
1927  }
1928 
1929  /* allocate and fill the structure */
1930  rdopts = allocateReloptStruct(relopt_struct_size, options, numoptions);
1931  fillRelOptions(rdopts, relopt_struct_size, options, numoptions,
1932  validate, relopt_elems, num_relopt_elems);
1933 
1934  pfree(options);
1935 
1936  return rdopts;
1937 }
static char ** options
static relopt_value * parseRelOptions(Datum options, bool validate, relopt_kind kind, int *numrelopts)
Definition: reloptions.c:1499

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

1839 {
1840  static const relopt_parse_elt tab[] = {
1841  {"fillfactor", RELOPT_TYPE_INT, offsetof(StdRdOptions, fillfactor)},
1842  {"autovacuum_enabled", RELOPT_TYPE_BOOL,
1843  offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, enabled)},
1844  {"autovacuum_vacuum_threshold", RELOPT_TYPE_INT,
1845  offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_threshold)},
1846  {"autovacuum_vacuum_insert_threshold", RELOPT_TYPE_INT,
1847  offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_ins_threshold)},
1848  {"autovacuum_analyze_threshold", RELOPT_TYPE_INT,
1849  offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_threshold)},
1850  {"autovacuum_vacuum_cost_limit", RELOPT_TYPE_INT,
1851  offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_limit)},
1852  {"autovacuum_freeze_min_age", RELOPT_TYPE_INT,
1853  offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_min_age)},
1854  {"autovacuum_freeze_max_age", RELOPT_TYPE_INT,
1855  offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_max_age)},
1856  {"autovacuum_freeze_table_age", RELOPT_TYPE_INT,
1857  offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_table_age)},
1858  {"autovacuum_multixact_freeze_min_age", RELOPT_TYPE_INT,
1859  offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_min_age)},
1860  {"autovacuum_multixact_freeze_max_age", RELOPT_TYPE_INT,
1861  offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_max_age)},
1862  {"autovacuum_multixact_freeze_table_age", RELOPT_TYPE_INT,
1863  offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_table_age)},
1864  {"log_autovacuum_min_duration", RELOPT_TYPE_INT,
1865  offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, log_min_duration)},
1866  {"toast_tuple_target", RELOPT_TYPE_INT,
1867  offsetof(StdRdOptions, toast_tuple_target)},
1868  {"autovacuum_vacuum_cost_delay", RELOPT_TYPE_REAL,
1869  offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_delay)},
1870  {"autovacuum_vacuum_scale_factor", RELOPT_TYPE_REAL,
1871  offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_scale_factor)},
1872  {"autovacuum_vacuum_insert_scale_factor", RELOPT_TYPE_REAL,
1873  offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_ins_scale_factor)},
1874  {"autovacuum_analyze_scale_factor", RELOPT_TYPE_REAL,
1875  offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_scale_factor)},
1876  {"user_catalog_table", RELOPT_TYPE_BOOL,
1877  offsetof(StdRdOptions, user_catalog_table)},
1878  {"parallel_workers", RELOPT_TYPE_INT,
1879  offsetof(StdRdOptions, parallel_workers)},
1880  {"vacuum_index_cleanup", RELOPT_TYPE_ENUM,
1881  offsetof(StdRdOptions, vacuum_index_cleanup)},
1882  {"vacuum_truncate", RELOPT_TYPE_BOOL,
1883  offsetof(StdRdOptions, vacuum_truncate)}
1884  };
1885 
1886  return (bytea *) build_reloptions(reloptions, validate, kind,
1887  sizeof(StdRdOptions),
1888  tab, lengthof(tab));
1889 }
int fillfactor
Definition: pgbench.c:187
double vacuum_cost_delay
Definition: vacuum.c:80
int vacuum_cost_limit
Definition: vacuum.c:81

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

Referenced by heap_reloptions().

◆ extractRelOptions()

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

Definition at line 1379 of file reloptions.c.

1381 {
1382  bytea *options;
1383  bool isnull;
1384  Datum datum;
1385  Form_pg_class classForm;
1386 
1387  datum = fastgetattr(tuple,
1388  Anum_pg_class_reloptions,
1389  tupdesc,
1390  &isnull);
1391  if (isnull)
1392  return NULL;
1393 
1394  classForm = (Form_pg_class) GETSTRUCT(tuple);
1395 
1396  /* Parse into appropriate format; don't error out here */
1397  switch (classForm->relkind)
1398  {
1399  case RELKIND_RELATION:
1400  case RELKIND_TOASTVALUE:
1401  case RELKIND_MATVIEW:
1402  options = heap_reloptions(classForm->relkind, datum, false);
1403  break;
1404  case RELKIND_PARTITIONED_TABLE:
1405  options = partitioned_table_reloptions(datum, false);
1406  break;
1407  case RELKIND_VIEW:
1408  options = view_reloptions(datum, false);
1409  break;
1410  case RELKIND_INDEX:
1411  case RELKIND_PARTITIONED_INDEX:
1412  options = index_reloptions(amoptions, datum, false);
1413  break;
1414  case RELKIND_FOREIGN_TABLE:
1415  options = NULL;
1416  break;
1417  default:
1418  Assert(false); /* can't get here */
1419  options = NULL; /* keep compiler quiet */
1420  break;
1421  }
1422 
1423  return options;
1424 }
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
static Datum fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
Definition: htup_details.h:749
FormData_pg_class * Form_pg_class
Definition: pg_class.h:153
uintptr_t Datum
Definition: postgres.h:64
bytea * index_reloptions(amoptions_function amoptions, Datum reloptions, bool validate)
Definition: reloptions.c:2054
bytea * heap_reloptions(char relkind, Datum reloptions, bool validate)
Definition: reloptions.c:2019
bytea * view_reloptions(Datum reloptions, bool validate)
Definition: reloptions.c:1998
bytea * partitioned_table_reloptions(Datum reloptions, bool validate)
Definition: reloptions.c:1984

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

1746 {
1747  int i;
1748  int offset = basesize;
1749 
1750  for (i = 0; i < numoptions; i++)
1751  {
1752  int j;
1753  bool found = false;
1754 
1755  for (j = 0; j < numelems; j++)
1756  {
1757  if (strcmp(options[i].gen->name, elems[j].optname) == 0)
1758  {
1759  relopt_string *optstring;
1760  char *itempos = ((char *) rdopts) + elems[j].offset;
1761  char *string_val;
1762 
1763  switch (options[i].gen->type)
1764  {
1765  case RELOPT_TYPE_BOOL:
1766  *(bool *) itempos = options[i].isset ?
1767  options[i].values.bool_val :
1768  ((relopt_bool *) options[i].gen)->default_val;
1769  break;
1770  case RELOPT_TYPE_INT:
1771  *(int *) itempos = options[i].isset ?
1772  options[i].values.int_val :
1773  ((relopt_int *) options[i].gen)->default_val;
1774  break;
1775  case RELOPT_TYPE_REAL:
1776  *(double *) itempos = options[i].isset ?
1777  options[i].values.real_val :
1778  ((relopt_real *) options[i].gen)->default_val;
1779  break;
1780  case RELOPT_TYPE_ENUM:
1781  *(int *) itempos = options[i].isset ?
1782  options[i].values.enum_val :
1783  ((relopt_enum *) options[i].gen)->default_val;
1784  break;
1785  case RELOPT_TYPE_STRING:
1786  optstring = (relopt_string *) options[i].gen;
1787  if (options[i].isset)
1788  string_val = options[i].values.string_val;
1789  else if (!optstring->default_isnull)
1790  string_val = optstring->default_val;
1791  else
1792  string_val = NULL;
1793 
1794  if (optstring->fill_cb)
1795  {
1796  Size size =
1797  optstring->fill_cb(string_val,
1798  (char *) rdopts + offset);
1799 
1800  if (size)
1801  {
1802  *(int *) itempos = offset;
1803  offset += size;
1804  }
1805  else
1806  *(int *) itempos = 0;
1807  }
1808  else if (string_val == NULL)
1809  *(int *) itempos = 0;
1810  else
1811  {
1812  strcpy((char *) rdopts + offset, string_val);
1813  *(int *) itempos = offset;
1814  offset += strlen(string_val) + 1;
1815  }
1816  break;
1817  default:
1818  elog(ERROR, "unsupported reloption type %d",
1819  options[i].gen->type);
1820  break;
1821  }
1822  found = true;
1823  break;
1824  }
1825  }
1826  if (validate && !found)
1827  elog(ERROR, "reloption \"%s\" not found in parse table",
1828  options[i].gen->name);
1829  }
1830  SET_VARSIZE(rdopts, offset);
1831 }
static Datum values[MAXATTR]
Definition: bootstrap.c:152
int j
Definition: isn.c:74
#define SET_VARSIZE(PTR, len)
Definition: varatt.h:305

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, size, and values.

Referenced by build_local_reloptions(), and build_reloptions().

◆ heap_reloptions()

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

Definition at line 2019 of file reloptions.c.

2020 {
2021  StdRdOptions *rdopts;
2022 
2023  switch (relkind)
2024  {
2025  case RELKIND_TOASTVALUE:
2026  rdopts = (StdRdOptions *)
2027  default_reloptions(reloptions, validate, RELOPT_KIND_TOAST);
2028  if (rdopts != NULL)
2029  {
2030  /* adjust default-only parameters for TOAST relations */
2031  rdopts->fillfactor = 100;
2032  rdopts->autovacuum.analyze_threshold = -1;
2033  rdopts->autovacuum.analyze_scale_factor = -1;
2034  }
2035  return (bytea *) rdopts;
2036  case RELKIND_RELATION:
2037  case RELKIND_MATVIEW:
2038  return default_reloptions(reloptions, validate, RELOPT_KIND_HEAP);
2039  default:
2040  /* other relkinds are not supported */
2041  return NULL;
2042  }
2043 }
bytea * default_reloptions(Datum reloptions, bool validate, relopt_kind kind)
Definition: reloptions.c:1838
@ RELOPT_KIND_TOAST
Definition: reloptions.h:43
@ RELOPT_KIND_HEAP
Definition: reloptions.h:42
int analyze_threshold
Definition: rel.h:313
float8 analyze_scale_factor
Definition: rel.h:325
int fillfactor
Definition: rel.h:339
AutoVacOpts autovacuum
Definition: rel.h:341

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

2055 {
2056  Assert(amoptions != NULL);
2057 
2058  /* Assume function is strict */
2059  if (!PointerIsValid(DatumGetPointer(reloptions)))
2060  return NULL;
2061 
2062  return amoptions(reloptions, validate);
2063 }
#define PointerIsValid(pointer)
Definition: c.h:763
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:312

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

834 {
835  relopt_bool *newoption;
836 
837  newoption = (relopt_bool *) allocate_reloption(kinds, RELOPT_TYPE_BOOL,
838  name, desc, lockmode);
839  newoption->default_val = default_val;
840 
841  return newoption;
842 }
static relopt_gen * allocate_reloption(bits32 kinds, int type, const char *name, const char *desc, LOCKMODE lockmode)
Definition: reloptions.c:775
bool default_val
Definition: reloptions.h:94

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

992 {
993  relopt_enum *newoption;
994 
995  newoption = (relopt_enum *) allocate_reloption(kinds, RELOPT_TYPE_ENUM,
996  name, desc, lockmode);
997  newoption->members = members;
998  newoption->default_val = default_val;
999  newoption->detailmsg = detailmsg;
1000 
1001  return newoption;
1002 }
int default_val
Definition: reloptions.h:127
const char * detailmsg
Definition: reloptions.h:128
relopt_enum_elt_def * members
Definition: reloptions.h:126

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

884 {
885  relopt_int *newoption;
886 
887  newoption = (relopt_int *) allocate_reloption(kinds, RELOPT_TYPE_INT,
888  name, desc, lockmode);
889  newoption->default_val = default_val;
890  newoption->min = min_val;
891  newoption->max = max_val;
892 
893  return newoption;
894 }
int default_val
Definition: reloptions.h:100

References allocate_reloption(), relopt_int::default_val, relopt_int::max, max_val, 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 
)

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

937 {
938  relopt_real *newoption;
939 
940  newoption = (relopt_real *) allocate_reloption(kinds, RELOPT_TYPE_REAL,
941  name, desc, lockmode);
942  newoption->default_val = default_val;
943  newoption->min = min_val;
944  newoption->max = max_val;
945 
946  return newoption;
947 }
double min
Definition: reloptions.h:109
double max
Definition: reloptions.h:110
double default_val
Definition: reloptions.h:108

References allocate_reloption(), relopt_real::default_val, relopt_real::max, max_val, 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 1053 of file reloptions.c.

1058 {
1059  relopt_string *newoption;
1060 
1061  /* make sure the validator/default combination is sane */
1062  if (validator)
1063  (validator) (default_val);
1064 
1065  newoption = (relopt_string *) allocate_reloption(kinds, RELOPT_TYPE_STRING,
1066  name, desc, lockmode);
1067  newoption->validate_cb = validator;
1068  newoption->fill_cb = filler;
1069  if (default_val)
1070  {
1071  if (kinds == RELOPT_KIND_LOCAL)
1072  newoption->default_val = strdup(default_val);
1073  else
1074  newoption->default_val = MemoryContextStrdup(TopMemoryContext, default_val);
1075  newoption->default_len = strlen(default_val);
1076  newoption->default_isnull = false;
1077  }
1078  else
1079  {
1080  newoption->default_val = "";
1081  newoption->default_len = 0;
1082  newoption->default_isnull = true;
1083  }
1084 
1085  return newoption;
1086 }
char * MemoryContextStrdup(MemoryContext context, const char *string)
Definition: mcxt.c:1682
validate_string_relopt validate_cb
Definition: reloptions.h:144

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

581 {
582  int i;
583  int j;
584 
585  j = 0;
586  for (i = 0; boolRelOpts[i].gen.name; i++)
587  {
588  Assert(DoLockModesConflict(boolRelOpts[i].gen.lockmode,
590  j++;
591  }
592  for (i = 0; intRelOpts[i].gen.name; i++)
593  {
594  Assert(DoLockModesConflict(intRelOpts[i].gen.lockmode,
596  j++;
597  }
598  for (i = 0; realRelOpts[i].gen.name; i++)
599  {
600  Assert(DoLockModesConflict(realRelOpts[i].gen.lockmode,
602  j++;
603  }
604  for (i = 0; enumRelOpts[i].gen.name; i++)
605  {
606  Assert(DoLockModesConflict(enumRelOpts[i].gen.lockmode,
608  j++;
609  }
610  for (i = 0; stringRelOpts[i].gen.name; i++)
611  {
614  j++;
615  }
617 
618  if (relOpts)
619  pfree(relOpts);
621  (j + 1) * sizeof(relopt_gen *));
622 
623  j = 0;
624  for (i = 0; boolRelOpts[i].gen.name; i++)
625  {
626  relOpts[j] = &boolRelOpts[i].gen;
628  relOpts[j]->namelen = strlen(relOpts[j]->name);
629  j++;
630  }
631 
632  for (i = 0; intRelOpts[i].gen.name; i++)
633  {
634  relOpts[j] = &intRelOpts[i].gen;
636  relOpts[j]->namelen = strlen(relOpts[j]->name);
637  j++;
638  }
639 
640  for (i = 0; realRelOpts[i].gen.name; i++)
641  {
642  relOpts[j] = &realRelOpts[i].gen;
644  relOpts[j]->namelen = strlen(relOpts[j]->name);
645  j++;
646  }
647 
648  for (i = 0; enumRelOpts[i].gen.name; i++)
649  {
650  relOpts[j] = &enumRelOpts[i].gen;
652  relOpts[j]->namelen = strlen(relOpts[j]->name);
653  j++;
654  }
655 
656  for (i = 0; stringRelOpts[i].gen.name; i++)
657  {
658  relOpts[j] = &stringRelOpts[i].gen;
660  relOpts[j]->namelen = strlen(relOpts[j]->name);
661  j++;
662  }
663 
664  for (i = 0; i < num_custom_options; i++)
665  {
667  j++;
668  }
669 
670  /* add a list terminator */
671  relOpts[j] = NULL;
672 
673  /* flag the work is complete */
674  need_initialization = false;
675 }
bool DoLockModesConflict(LOCKMODE mode1, LOCKMODE mode2)
Definition: lock.c:570
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1180
static relopt_real realRelOpts[]
Definition: reloptions.c:388
static relopt_int intRelOpts[]
Definition: reloptions.c:173
static relopt_enum enumRelOpts[]
Definition: reloptions.c:508
static relopt_string stringRelOpts[]
Definition: reloptions.c:547
static relopt_bool boolRelOpts[]
Definition: reloptions.c:94
relopt_gen gen
Definition: reloptions.h:93
relopt_gen gen
Definition: reloptions.h:125
relopt_gen gen
Definition: reloptions.h:99
relopt_gen gen
Definition: reloptions.h:107
relopt_gen gen
Definition: reloptions.h:141

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

1571 {
1572  char *value;
1573  int value_len;
1574  bool parsed;
1575  bool nofree = false;
1576 
1577  if (option->isset && validate)
1578  ereport(ERROR,
1579  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1580  errmsg("parameter \"%s\" specified more than once",
1581  option->gen->name)));
1582 
1583  value_len = text_len - option->gen->namelen - 1;
1584  value = (char *) palloc(value_len + 1);
1585  memcpy(value, text_str + option->gen->namelen + 1, value_len);
1586  value[value_len] = '\0';
1587 
1588  switch (option->gen->type)
1589  {
1590  case RELOPT_TYPE_BOOL:
1591  {
1592  parsed = parse_bool(value, &option->values.bool_val);
1593  if (validate && !parsed)
1594  ereport(ERROR,
1595  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1596  errmsg("invalid value for boolean option \"%s\": %s",
1597  option->gen->name, value)));
1598  }
1599  break;
1600  case RELOPT_TYPE_INT:
1601  {
1602  relopt_int *optint = (relopt_int *) option->gen;
1603 
1604  parsed = parse_int(value, &option->values.int_val, 0, NULL);
1605  if (validate && !parsed)
1606  ereport(ERROR,
1607  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1608  errmsg("invalid value for integer option \"%s\": %s",
1609  option->gen->name, value)));
1610  if (validate && (option->values.int_val < optint->min ||
1611  option->values.int_val > optint->max))
1612  ereport(ERROR,
1613  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1614  errmsg("value %s out of bounds for option \"%s\"",
1615  value, option->gen->name),
1616  errdetail("Valid values are between \"%d\" and \"%d\".",
1617  optint->min, optint->max)));
1618  }
1619  break;
1620  case RELOPT_TYPE_REAL:
1621  {
1622  relopt_real *optreal = (relopt_real *) option->gen;
1623 
1624  parsed = parse_real(value, &option->values.real_val, 0, NULL);
1625  if (validate && !parsed)
1626  ereport(ERROR,
1627  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1628  errmsg("invalid value for floating point option \"%s\": %s",
1629  option->gen->name, value)));
1630  if (validate && (option->values.real_val < optreal->min ||
1631  option->values.real_val > optreal->max))
1632  ereport(ERROR,
1633  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1634  errmsg("value %s out of bounds for option \"%s\"",
1635  value, option->gen->name),
1636  errdetail("Valid values are between \"%f\" and \"%f\".",
1637  optreal->min, optreal->max)));
1638  }
1639  break;
1640  case RELOPT_TYPE_ENUM:
1641  {
1642  relopt_enum *optenum = (relopt_enum *) option->gen;
1643  relopt_enum_elt_def *elt;
1644 
1645  parsed = false;
1646  for (elt = optenum->members; elt->string_val; elt++)
1647  {
1648  if (pg_strcasecmp(value, elt->string_val) == 0)
1649  {
1650  option->values.enum_val = elt->symbol_val;
1651  parsed = true;
1652  break;
1653  }
1654  }
1655  if (validate && !parsed)
1656  ereport(ERROR,
1657  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1658  errmsg("invalid value for enum option \"%s\": %s",
1659  option->gen->name, value),
1660  optenum->detailmsg ?
1661  errdetail_internal("%s", _(optenum->detailmsg)) : 0));
1662 
1663  /*
1664  * If value is not among the allowed string values, but we are
1665  * not asked to validate, just use the default numeric value.
1666  */
1667  if (!parsed)
1668  option->values.enum_val = optenum->default_val;
1669  }
1670  break;
1671  case RELOPT_TYPE_STRING:
1672  {
1673  relopt_string *optstring = (relopt_string *) option->gen;
1674 
1675  option->values.string_val = value;
1676  nofree = true;
1677  if (validate && optstring->validate_cb)
1678  (optstring->validate_cb) (value);
1679  parsed = true;
1680  }
1681  break;
1682  default:
1683  elog(ERROR, "unsupported reloption type %d", option->gen->type);
1684  parsed = true; /* quiet compiler */
1685  break;
1686  }
1687 
1688  if (parsed)
1689  option->isset = true;
1690  if (!nofree)
1691  pfree(value);
1692 }
bool parse_bool(const char *value, bool *result)
Definition: bool.c:30
int errdetail_internal(const char *fmt,...)
Definition: elog.c:1230
int errdetail(const char *fmt,...)
Definition: elog.c:1203
#define _(x)
Definition: elog.c:90
bool parse_int(const char *value, int *result, int flags, const char **hintmsg)
Definition: guc.c:2873
bool parse_real(const char *value, double *result, int flags, const char **hintmsg)
Definition: guc.c:2963
for(;;)
static struct @155 value
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36
const char * name
Definition: getopt_long.h:18
const char * string_val
Definition: reloptions.h:119

References _, relopt_enum::default_val, relopt_enum::detailmsg, elog, ereport, errcode(), errdetail(), errdetail_internal(), errmsg(), ERROR, for(), 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 1541 of file reloptions.c.

1542 {
1543  int nopts = list_length(relopts->options);
1544  relopt_value *values = palloc(sizeof(*values) * nopts);
1545  ListCell *lc;
1546  int i = 0;
1547 
1548  foreach(lc, relopts->options)
1549  {
1550  local_relopt *opt = lfirst(lc);
1551 
1552  values[i].gen = opt->option;
1553  values[i].isset = false;
1554 
1555  i++;
1556  }
1557 
1558  if (options != (Datum) 0)
1559  parseRelOptionsInternal(options, validate, values, nopts);
1560 
1561  return values;
1562 }
static void parseRelOptionsInternal(Datum options, bool validate, relopt_value *reloptions, int numoptions)
Definition: reloptions.c:1427

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

1501 {
1502  relopt_value *reloptions = NULL;
1503  int numoptions = 0;
1504  int i;
1505  int j;
1506 
1507  if (need_initialization)
1509 
1510  /* Build a list of expected options, based on kind */
1511 
1512  for (i = 0; relOpts[i]; i++)
1513  if (relOpts[i]->kinds & kind)
1514  numoptions++;
1515 
1516  if (numoptions > 0)
1517  {
1518  reloptions = palloc(numoptions * sizeof(relopt_value));
1519 
1520  for (i = 0, j = 0; relOpts[i]; i++)
1521  {
1522  if (relOpts[i]->kinds & kind)
1523  {
1524  reloptions[j].gen = relOpts[i];
1525  reloptions[j].isset = false;
1526  j++;
1527  }
1528  }
1529  }
1530 
1531  /* Done if no options */
1533  parseRelOptionsInternal(options, validate, reloptions, numoptions);
1534 
1535  *numrelopts = numoptions;
1536  return reloptions;
1537 }

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

1429 {
1431  Datum *optiondatums;
1432  int noptions;
1433  int i;
1434 
1435  deconstruct_array_builtin(array, TEXTOID, &optiondatums, NULL, &noptions);
1436 
1437  for (i = 0; i < noptions; i++)
1438  {
1439  char *text_str = VARDATA(optiondatums[i]);
1440  int text_len = VARSIZE(optiondatums[i]) - VARHDRSZ;
1441  int j;
1442 
1443  /* Search for a match in reloptions */
1444  for (j = 0; j < numoptions; j++)
1445  {
1446  int kw_len = reloptions[j].gen->namelen;
1447 
1448  if (text_len > kw_len && text_str[kw_len] == '=' &&
1449  strncmp(text_str, reloptions[j].gen->name, kw_len) == 0)
1450  {
1451  parse_one_reloption(&reloptions[j], text_str, text_len,
1452  validate);
1453  break;
1454  }
1455  }
1456 
1457  if (j >= numoptions && validate)
1458  {
1459  char *s;
1460  char *p;
1461 
1462  s = TextDatumGetCString(optiondatums[i]);
1463  p = strchr(s, '=');
1464  if (p)
1465  *p = '\0';
1466  ereport(ERROR,
1467  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1468  errmsg("unrecognized parameter \"%s\"", s)));
1469  }
1470  }
1471 
1472  /* It's worth avoiding memory leaks in this function */
1473  pfree(optiondatums);
1474 
1475  if (((void *) array) != DatumGetPointer(options))
1476  pfree(array);
1477 }
#define DatumGetArrayTypeP(X)
Definition: array.h:261
void deconstruct_array_builtin(ArrayType *array, Oid elmtype, Datum **elemsp, bool **nullsp, int *nelemsp)
Definition: arrayfuncs.c:3678
#define TextDatumGetCString(d)
Definition: builtins.h:98
#define VARHDRSZ
Definition: c.h:692
static void parse_one_reloption(relopt_value *option, char *text_str, int text_len, bool validate)
Definition: reloptions.c:1569
#define VARDATA(PTR)
Definition: varatt.h:278
#define VARSIZE(PTR)
Definition: varatt.h:279

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

1985 {
1986  if (validate && reloptions)
1987  ereport(ERROR,
1988  errcode(ERRCODE_WRONG_OBJECT_TYPE),
1989  errmsg("cannot specify storage parameters for a partitioned table"),
1990  errhint("Specify storage parameters for its leaf partitions instead."));
1991  return NULL;
1992 }
int errhint(const char *fmt,...)
Definition: elog.c:1317

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

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

References lappend(), and local_relopts::validators.

Referenced by ltree_gist_options().

◆ tablespace_reloptions()

bytea* tablespace_reloptions ( Datum  reloptions,
bool  validate 
)

Definition at line 2086 of file reloptions.c.

2087 {
2088  static const relopt_parse_elt tab[] = {
2089  {"random_page_cost", RELOPT_TYPE_REAL, offsetof(TableSpaceOpts, random_page_cost)},
2090  {"seq_page_cost", RELOPT_TYPE_REAL, offsetof(TableSpaceOpts, seq_page_cost)},
2091  {"effective_io_concurrency", RELOPT_TYPE_INT, offsetof(TableSpaceOpts, effective_io_concurrency)},
2092  {"maintenance_io_concurrency", RELOPT_TYPE_INT, offsetof(TableSpaceOpts, maintenance_io_concurrency)}
2093  };
2094 
2095  return (bytea *) build_reloptions(reloptions, validate,
2097  sizeof(TableSpaceOpts),
2098  tab, lengthof(tab));
2099 }
int maintenance_io_concurrency
Definition: bufmgr.c:157
int effective_io_concurrency
Definition: bufmgr.c:150
double random_page_cost
Definition: costsize.c:120
double seq_page_cost
Definition: costsize.c:119
@ RELOPT_KIND_TABLESPACE
Definition: reloptions.h:49

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

1158 {
1159  Datum result;
1160  ArrayBuildState *astate;
1161  ListCell *cell;
1162 
1163  /* no change if empty list */
1164  if (defList == NIL)
1165  return oldOptions;
1166 
1167  /* We build new array using accumArrayResult */
1168  astate = NULL;
1169 
1170  /* Copy any oldOptions that aren't to be replaced */
1171  if (PointerIsValid(DatumGetPointer(oldOptions)))
1172  {
1173  ArrayType *array = DatumGetArrayTypeP(oldOptions);
1174  Datum *oldoptions;
1175  int noldoptions;
1176  int i;
1177 
1178  deconstruct_array_builtin(array, TEXTOID, &oldoptions, NULL, &noldoptions);
1179 
1180  for (i = 0; i < noldoptions; i++)
1181  {
1182  char *text_str = VARDATA(oldoptions[i]);
1183  int text_len = VARSIZE(oldoptions[i]) - VARHDRSZ;
1184 
1185  /* Search for a match in defList */
1186  foreach(cell, defList)
1187  {
1188  DefElem *def = (DefElem *) lfirst(cell);
1189  int kw_len;
1190 
1191  /* ignore if not in the same namespace */
1192  if (namspace == NULL)
1193  {
1194  if (def->defnamespace != NULL)
1195  continue;
1196  }
1197  else if (def->defnamespace == NULL)
1198  continue;
1199  else if (strcmp(def->defnamespace, namspace) != 0)
1200  continue;
1201 
1202  kw_len = strlen(def->defname);
1203  if (text_len > kw_len && text_str[kw_len] == '=' &&
1204  strncmp(text_str, def->defname, kw_len) == 0)
1205  break;
1206  }
1207  if (!cell)
1208  {
1209  /* No match, so keep old option */
1210  astate = accumArrayResult(astate, oldoptions[i],
1211  false, TEXTOID,
1213  }
1214  }
1215  }
1216 
1217  /*
1218  * If CREATE/SET, add new options to array; if RESET, just check that the
1219  * user didn't say RESET (option=val). (Must do this because the grammar
1220  * doesn't enforce it.)
1221  */
1222  foreach(cell, defList)
1223  {
1224  DefElem *def = (DefElem *) lfirst(cell);
1225 
1226  if (isReset)
1227  {
1228  if (def->arg != NULL)
1229  ereport(ERROR,
1230  (errcode(ERRCODE_SYNTAX_ERROR),
1231  errmsg("RESET must not include values for parameters")));
1232  }
1233  else
1234  {
1235  text *t;
1236  const char *value;
1237  Size len;
1238 
1239  /*
1240  * Error out if the namespace is not valid. A NULL namespace is
1241  * always valid.
1242  */
1243  if (def->defnamespace != NULL)
1244  {
1245  bool valid = false;
1246  int i;
1247 
1248  if (validnsps)
1249  {
1250  for (i = 0; validnsps[i]; i++)
1251  {
1252  if (strcmp(def->defnamespace, validnsps[i]) == 0)
1253  {
1254  valid = true;
1255  break;
1256  }
1257  }
1258  }
1259 
1260  if (!valid)
1261  ereport(ERROR,
1262  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1263  errmsg("unrecognized parameter namespace \"%s\"",
1264  def->defnamespace)));
1265  }
1266 
1267  /* ignore if not in the same namespace */
1268  if (namspace == NULL)
1269  {
1270  if (def->defnamespace != NULL)
1271  continue;
1272  }
1273  else if (def->defnamespace == NULL)
1274  continue;
1275  else if (strcmp(def->defnamespace, namspace) != 0)
1276  continue;
1277 
1278  /*
1279  * Flatten the DefElem into a text string like "name=arg". If we
1280  * have just "name", assume "name=true" is meant. Note: the
1281  * namespace is not output.
1282  */
1283  if (def->arg != NULL)
1284  value = defGetString(def);
1285  else
1286  value = "true";
1287 
1288  /*
1289  * This is not a great place for this test, but there's no other
1290  * convenient place to filter the option out. As WITH (oids =
1291  * false) will be removed someday, this seems like an acceptable
1292  * amount of ugly.
1293  */
1294  if (acceptOidsOff && def->defnamespace == NULL &&
1295  strcmp(def->defname, "oids") == 0)
1296  {
1297  if (defGetBoolean(def))
1298  ereport(ERROR,
1299  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
1300  errmsg("tables declared WITH OIDS are not supported")));
1301  /* skip over option, reloptions machinery doesn't know it */
1302  continue;
1303  }
1304 
1305  len = VARHDRSZ + strlen(def->defname) + 1 + strlen(value);
1306  /* +1 leaves room for sprintf's trailing null */
1307  t = (text *) palloc(len + 1);
1308  SET_VARSIZE(t, len);
1309  sprintf(VARDATA(t), "%s=%s", def->defname, value);
1310 
1311  astate = accumArrayResult(astate, PointerGetDatum(t),
1312  false, TEXTOID,
1314  }
1315  }
1316 
1317  if (astate)
1318  result = makeArrayResult(astate, CurrentMemoryContext);
1319  else
1320  result = (Datum) 0;
1321 
1322  return result;
1323 }
ArrayBuildState * accumArrayResult(ArrayBuildState *astate, Datum dvalue, bool disnull, Oid element_type, MemoryContext rcontext)
Definition: arrayfuncs.c:5331
Datum makeArrayResult(ArrayBuildState *astate, MemoryContext rcontext)
Definition: arrayfuncs.c:5401
bool defGetBoolean(DefElem *def)
Definition: define.c:107
char * defGetString(DefElem *def)
Definition: define.c:48
MemoryContext CurrentMemoryContext
Definition: mcxt.c:143
const void size_t len
#define sprintf
Definition: port.h:240
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:322
char * defnamespace
Definition: parsenodes.h:814
Node * arg
Definition: parsenodes.h:816

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

1332 {
1333  List *result = NIL;
1334  ArrayType *array;
1335  Datum *optiondatums;
1336  int noptions;
1337  int i;
1338 
1339  /* Nothing to do if no options */
1341  return result;
1342 
1343  array = DatumGetArrayTypeP(options);
1344 
1345  deconstruct_array_builtin(array, TEXTOID, &optiondatums, NULL, &noptions);
1346 
1347  for (i = 0; i < noptions; i++)
1348  {
1349  char *s;
1350  char *p;
1351  Node *val = NULL;
1352 
1353  s = TextDatumGetCString(optiondatums[i]);
1354  p = strchr(s, '=');
1355  if (p)
1356  {
1357  *p++ = '\0';
1358  val = (Node *) makeString(p);
1359  }
1360  result = lappend(result, makeDefElem(s, val, -1));
1361  }
1362 
1363  return result;
1364 }
DefElem * makeDefElem(char *name, Node *arg, int location)
Definition: makefuncs.c:564
Definition: pg_list.h:54
Definition: nodes.h:129
String * makeString(char *str)
Definition: value.c:63

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

1999 {
2000  static const relopt_parse_elt tab[] = {
2001  {"security_barrier", RELOPT_TYPE_BOOL,
2002  offsetof(ViewOptions, security_barrier)},
2003  {"security_invoker", RELOPT_TYPE_BOOL,
2004  offsetof(ViewOptions, security_invoker)},
2005  {"check_option", RELOPT_TYPE_ENUM,
2006  offsetof(ViewOptions, check_option)}
2007  };
2008 
2009  return (bytea *) build_reloptions(reloptions, validate,
2011  sizeof(ViewOptions),
2012  tab, lengthof(tab));
2013 }
@ RELOPT_KIND_VIEW
Definition: reloptions.h:51

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

Referenced by initialize_reloptions().

◆ custom_options

relopt_gen** custom_options = NULL
static

Definition at line 557 of file reloptions.c.

Referenced by add_reloption(), and initialize_reloptions().

◆ enumRelOpts

relopt_enum enumRelOpts[]
static

Definition at line 508 of file reloptions.c.

Referenced by initialize_reloptions().

◆ gistBufferingOptValues

relopt_enum_elt_def gistBufferingOptValues[]
static
Initial value:
=
{
{(const char *) NULL}
}
@ GIST_OPTION_BUFFERING_OFF
Definition: gist_private.h:388
@ GIST_OPTION_BUFFERING_AUTO
Definition: gist_private.h:386
@ GIST_OPTION_BUFFERING_ON
Definition: gist_private.h:387

Definition at line 491 of file reloptions.c.

◆ intRelOpts

relopt_int intRelOpts[]
static

Definition at line 173 of file reloptions.c.

Referenced by initialize_reloptions().

◆ last_assigned_kind

bits32 last_assigned_kind = RELOPT_KIND_LAST_DEFAULT
static

Definition at line 554 of file reloptions.c.

Referenced by add_reloption_kind().

◆ need_initialization

bool need_initialization = true
static

◆ num_custom_options

int num_custom_options = 0
static

Definition at line 556 of file reloptions.c.

Referenced by add_reloption(), and initialize_reloptions().

◆ realRelOpts

relopt_real realRelOpts[]
static

Definition at line 388 of file reloptions.c.

Referenced by initialize_reloptions().

◆ relOpts

relopt_gen** relOpts = NULL
static

◆ StdRdOptIndexCleanupValues

relopt_enum_elt_def StdRdOptIndexCleanupValues[]
static
Initial value:

Definition at line 476 of file reloptions.c.

◆ stringRelOpts

relopt_string stringRelOpts[]
static
Initial value:
=
{
{{NULL}}
}

Definition at line 547 of file reloptions.c.

Referenced by initialize_reloptions().

◆ viewCheckOptValues

relopt_enum_elt_def viewCheckOptValues[]
static
Initial value:
=
{
{(const char *) NULL}
}
@ VIEW_OPTION_CHECK_OPTION_LOCAL
Definition: rel.h:405
@ VIEW_OPTION_CHECK_OPTION_CASCADED
Definition: rel.h:406

Definition at line 500 of file reloptions.c.