rdelaage
/
postgresql
mirror of https://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Change the reloptions machinery to use a table-based parser, and provide 

a more complete framework for writing custom option processing routines
by user-defined access methods.

Catalog version bumped due to the general API changes, which are going to
affect user-defined "amoptions" routines.
This commit is contained in:
Alvaro Herrera 2009-01-05 17:14:28 +00:00
parent b0a6ad70a1
commit ba748f7a11
7 changed files with 724 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

661
src/backend/access/common/reloptions.c
View File

@ -8,13 +8,16 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/access/common/reloptions.c,v 1.12 2009/01/01 17:23:34 momjian Exp $ * $PostgreSQL: pgsql/src/backend/access/common/reloptions.c,v 1.13 2009/01/05 17:14:28 alvherre Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
#include "postgres.h" #include "postgres.h"
#include "access/gist_private.h"
#include "access/hash.h"
#include "access/nbtree.h"
#include "access/reloptions.h" #include "access/reloptions.h"
#include "catalog/pg_type.h" #include "catalog/pg_type.h"
#include "commands/defrem.h" #include "commands/defrem.h"
@ -22,8 +25,357 @@
#include "utils/array.h" #include "utils/array.h"
#include "utils/builtins.h" #include "utils/builtins.h"
#include "utils/guc.h" #include "utils/guc.h"
#include "utils/memutils.h"
#include "utils/rel.h" #include "utils/rel.h"
/*
* Contents of pg_class.reloptions
*
* To add an option:
*
* (i) decide on a class (integer, real, bool, string), name, default value,
* upper and lower bounds (if applicable).
* (ii) add a record below.
* (iii) add it to StdRdOptions if appropriate
* (iv) add a block to the appropriate handling routine (probably
* default_reloptions)
* (v) don't forget to document the option
*
* Note that we don't handle "oids" in relOpts because it is handled by
* interpretOidsOption().
*/
static relopt_bool boolRelOpts[] =
{
/* list terminator */
{ { NULL } }
};
static relopt_int intRelOpts[] =
{
{
{
"fillfactor",
"Packs table pages only to this percentage",
RELOPT_KIND_HEAP
},
HEAP_DEFAULT_FILLFACTOR, HEAP_MIN_FILLFACTOR, 100
},
{
{
"fillfactor",
"Packs btree index pages only to this percentage",
RELOPT_KIND_BTREE
},
BTREE_DEFAULT_FILLFACTOR, BTREE_MIN_FILLFACTOR, 100
},
{
{
"fillfactor",
"Packs hash index pages only to this percentage",
RELOPT_KIND_HASH
},
HASH_DEFAULT_FILLFACTOR, HASH_MIN_FILLFACTOR, 100
},
{
{
"fillfactor",
"Packs gist index pages only to this percentage",
RELOPT_KIND_GIST
},
GIST_DEFAULT_FILLFACTOR, GIST_MIN_FILLFACTOR, 100
},
/* list terminator */
{ { NULL } }
};
static relopt_real realRelOpts[] =
{
/* list terminator */
{ { NULL } }
};
static relopt_string stringRelOpts[] =
{
/* list terminator */
{ { NULL } }
};
static relopt_gen **relOpts = NULL;
static int last_assigned_kind = RELOPT_KIND_LAST_DEFAULT + 1;
static int num_custom_options = 0;
static relopt_gen **custom_options = NULL;
static bool need_initialization = true;
static void initialize_reloptions(void);
static void parse_one_reloption(relopt_value *option, char *text_str,
int text_len, bool validate);
/*
* initialize_reloptions
* initialization routine, must be called before parsing
*
* Initialize the relOpts array and fill each variable's type and name length.
*/
static void
initialize_reloptions(void)
{
int i;
int j = 0;
for (i = 0; boolRelOpts[i].gen.name; i++)
j++;
for (i = 0; intRelOpts[i].gen.name; i++)
j++;
for (i = 0; realRelOpts[i].gen.name; i++)
j++;
for (i = 0; stringRelOpts[i].gen.name; i++)
j++;
j += num_custom_options;
if (relOpts)
pfree(relOpts);
relOpts = MemoryContextAlloc(TopMemoryContext,
(j + 1) * sizeof(relopt_gen *));
j = 0;
for (i = 0; boolRelOpts[i].gen.name; i++)
{
relOpts[j] = &boolRelOpts[i].gen;
relOpts[j]->type = RELOPT_TYPE_BOOL;
relOpts[j]->namelen = strlen(relOpts[j]->name);
j++;
}
for (i = 0; intRelOpts[i].gen.name; i++)
{
relOpts[j] = &intRelOpts[i].gen;
relOpts[j]->type = RELOPT_TYPE_INT;
relOpts[j]->namelen = strlen(relOpts[j]->name);
j++;
}
for (i = 0; realRelOpts[i].gen.name; i++)
{
relOpts[j] = &realRelOpts[i].gen;
relOpts[j]->type = RELOPT_TYPE_REAL;
relOpts[j]->namelen = strlen(relOpts[j]->name);
j++;
}
for (i = 0; stringRelOpts[i].gen.name; i++)
{
relOpts[j] = &stringRelOpts[i].gen;
relOpts[j]->type = RELOPT_TYPE_STRING;
relOpts[j]->namelen = strlen(relOpts[j]->name);
j++;
}
for (i = 0; i < num_custom_options; i++)
{
relOpts[j] = custom_options[i];
j++;
}
/* add a list terminator */
relOpts[j] = NULL;
}
/*
* add_reloption_kind
* Create a new relopt_kind value, to be used in custom reloptions by
* user-defined AMs.
*/
int
add_reloption_kind(void)
{
if (last_assigned_kind >= RELOPT_KIND_MAX)
ereport(ERROR,
(errmsg("user-defined relation parameter types limit exceeded")));
return last_assigned_kind++;
}
/*
* add_reloption
* Add an already-created custom reloption to the list, and recompute the
* main parser table.
*/
static void
add_reloption(relopt_gen *newoption)
{
static int max_custom_options = 0;
if (num_custom_options >= max_custom_options)
{
MemoryContext oldcxt;
oldcxt = MemoryContextSwitchTo(TopMemoryContext);
if (max_custom_options == 0)
{
max_custom_options = 8;
custom_options = palloc(max_custom_options * sizeof(relopt_gen *));
}
else
{
max_custom_options *= 2;
custom_options = repalloc(custom_options,
max_custom_options * sizeof(relopt_gen *));
}
MemoryContextSwitchTo(oldcxt);
}
custom_options[num_custom_options++] = newoption;
need_initialization = true;
}
/*
* allocate_reloption
* Allocate a new reloption and initialize the type-agnostic fields
* (for types other than string)
*/
static relopt_gen *
allocate_reloption(int kind, int type, char *name, char *desc)
{
MemoryContext oldcxt;
size_t size;
relopt_gen *newoption;
Assert(type != RELOPT_TYPE_STRING);
oldcxt = MemoryContextSwitchTo(TopMemoryContext);
switch (type)
{
case RELOPT_TYPE_BOOL:
size = sizeof(relopt_bool);
break;
case RELOPT_TYPE_INT:
size = sizeof(relopt_int);
break;
case RELOPT_TYPE_REAL:
size = sizeof(relopt_real);
break;
default:
elog(ERROR, "unsupported option type");
return NULL; /* keep compiler quiet */
}
newoption = palloc(size);
newoption->name = pstrdup(name);
if (desc)
newoption->desc = pstrdup(desc);
else
newoption->desc = NULL;
newoption->kind = kind;
newoption->namelen = strlen(name);
newoption->type = type;
MemoryContextSwitchTo(oldcxt);
return newoption;
}
/*
* add_bool_reloption
* Add a new boolean reloption
*/
void
add_bool_reloption(int kind, char *name, char *desc, bool default_val)
{
relopt_bool *newoption;
newoption = (relopt_bool *) allocate_reloption(kind, RELOPT_TYPE_BOOL,
name, desc);
newoption->default_val = default_val;
add_reloption((relopt_gen *) newoption);
}
/*
* add_int_reloption
* Add a new integer reloption
*/
void
add_int_reloption(int kind, char *name, char *desc, int default_val,
int min_val, int max_val)
{
relopt_int *newoption;
newoption = (relopt_int *) allocate_reloption(kind, RELOPT_TYPE_INT,
name, desc);
newoption->default_val = default_val;
newoption->min = min_val;
newoption->max = max_val;
add_reloption((relopt_gen *) newoption);
}
/*
* add_real_reloption
* Add a new float reloption
*/
void
add_real_reloption(int kind, char *name, char *desc, double default_val,
double min_val, double max_val)
{
relopt_real *newoption;
newoption = (relopt_real *) allocate_reloption(kind, RELOPT_TYPE_REAL,
name, desc);
newoption->default_val = default_val;
newoption->min = min_val;
newoption->max = max_val;
add_reloption((relopt_gen *) newoption);
}
/*
* add_string_reloption
* Add a new string reloption
*/
void
add_string_reloption(int kind, char *name, char *desc, char *default_val)
{
MemoryContext oldcxt;
relopt_string *newoption;
int default_len = 0;
oldcxt = MemoryContextSwitchTo(TopMemoryContext);
if (default_val)
default_len = strlen(default_val);
newoption = palloc0(sizeof(relopt_string) + default_len);
newoption->gen.name = pstrdup(name);
if (desc)
newoption->gen.desc = pstrdup(desc);
else
newoption->gen.desc = NULL;
newoption->gen.kind = kind;
newoption->gen.namelen = strlen(name);
newoption->gen.type = RELOPT_TYPE_STRING;
if (default_val)
{
strcpy(newoption->default_val, default_val);
newoption->default_len = default_len;
newoption->default_isnull = false;
}
else
{
newoption->default_val[0] = '\0';
newoption->default_len = 0;
newoption->default_isnull = true;
}
MemoryContextSwitchTo(oldcxt);
add_reloption((relopt_gen *) newoption);
}
/* /*
* Transform a relation options list (list of DefElem) into the text array * Transform a relation options list (list of DefElem) into the text array
@ -198,137 +550,236 @@ untransformRelOptions(Datum options)
/* /*
* Interpret reloptions that are given in text-array format. * Interpret reloptions that are given in text-array format.
* *
* options: array of "keyword=value" strings, as built by transformRelOptions * options is a reloption text array as constructed by transformRelOptions.
* numkeywords: number of legal keywords * kind specifies the family of options to be processed.
* keywords: the allowed keywords
* values: output area
* validate: if true, throw error for unrecognized keywords.
* *
* The keywords and values arrays must both be of length numkeywords. * The return value is a relopt_value * array on which the options actually
* The values entry corresponding to a keyword is set to a palloc'd string * set in the options array are marked with isset=true. The length of this
* containing the corresponding value, or NULL if the keyword does not appear. * array is returned in *numrelopts. Options not set are also present in the
* array; this is so that the caller can easily locate the default values.
*
* If there are no options of the given kind, numrelopts is set to 0 and NULL
* is returned.
*
* Note: values of type int, bool and real are allocated as part of the
* returned array. Values of type string are allocated separately and must
* be freed by the caller.
*/ */
void relopt_value *
parseRelOptions(Datum options, int numkeywords, const char *const * keywords, parseRelOptions(Datum options, bool validate, relopt_kind kind,
char **values, bool validate) int *numrelopts)
{ {
ArrayType *array; relopt_value *reloptions;
Datum *optiondatums; int numoptions = 0;
int noptions;
int i; int i;
int j;
/* Initialize to "all defaulted" */ if (need_initialization)
MemSet(values, 0, numkeywords * sizeof(char *)); initialize_reloptions();
/* Build a list of expected options, based on kind */
for (i = 0; relOpts[i]; i++)
if (relOpts[i]->kind == kind)
numoptions++;
if (numoptions == 0)
{
*numrelopts = 0;
return NULL;
}
reloptions = palloc(numoptions * sizeof(relopt_value));
for (i = 0, j = 0; relOpts[i]; i++)
{
if (relOpts[i]->kind == kind)
{
reloptions[j].gen = relOpts[i];
reloptions[j].isset = false;
j++;
}
}
/* Done if no options */ /* Done if no options */
if (!PointerIsValid(DatumGetPointer(options))) if (PointerIsValid(DatumGetPointer(options)))
return;
array = DatumGetArrayTypeP(options);
Assert(ARR_ELEMTYPE(array) == TEXTOID);
deconstruct_array(array, TEXTOID, -1, false, 'i',
&optiondatums, NULL, &noptions);
for (i = 0; i < noptions; i++)
{ {
text *optiontext = DatumGetTextP(optiondatums[i]); ArrayType *array;
char *text_str = VARDATA(optiontext); Datum *optiondatums;
int text_len = VARSIZE(optiontext) - VARHDRSZ; int noptions;
int j;
/* Search for a match in keywords */ array = DatumGetArrayTypeP(options);
for (j = 0; j < numkeywords; j++)
Assert(ARR_ELEMTYPE(array) == TEXTOID);
deconstruct_array(array, TEXTOID, -1, false, 'i',
&optiondatums, NULL, &noptions);
for (i = 0; i < noptions; i++)
{ {
int kw_len = strlen(keywords[j]); text *optiontext = DatumGetTextP(optiondatums[i]);
char *text_str = VARDATA(optiontext);
int text_len = VARSIZE(optiontext) - VARHDRSZ;
int j;
if (text_len > kw_len && text_str[kw_len] == '=' && /* Search for a match in reloptions */
pg_strncasecmp(text_str, keywords[j], kw_len) == 0) for (j = 0; j < numoptions; j++)
{ {
char *value; int kw_len = reloptions[j].gen->namelen;
int value_len;
if (values[j] && validate) if (text_len > kw_len && text_str[kw_len] == '=' &&
ereport(ERROR, pg_strncasecmp(text_str, reloptions[j].gen->name,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE), kw_len) == 0)
errmsg("parameter \"%s\" specified more than once", {
keywords[j]))); parse_one_reloption(&reloptions[j], text_str, text_len,
value_len = text_len - kw_len - 1; validate);
value = (char *) palloc(value_len + 1); break;
memcpy(value, text_str + kw_len + 1, value_len); }
value[value_len] = '\0'; }
values[j] = value;
break; if (j >= numoptions && validate)
{
char *s;
char *p;
s = TextDatumGetCString(optiondatums[i]);
p = strchr(s, '=');
if (p)
*p = '\0';
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("unrecognized parameter \"%s\"", s)));
} }
} }
if (j >= numkeywords && validate)
{
char *s;
char *p;
s = TextDatumGetCString(optiondatums[i]);
p = strchr(s, '=');
if (p)
*p = '\0';
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("unrecognized parameter \"%s\"", s)));
}
} }
}
*numrelopts = numoptions;
return reloptions;
}
/* /*
* Parse reloptions for anything using StdRdOptions (ie, fillfactor only) * Subroutine for parseRelOptions, to parse and validate a single option's
* value
*/ */
bytea * static void
default_reloptions(Datum reloptions, bool validate, parse_one_reloption(relopt_value *option, char *text_str, int text_len,
int minFillfactor, int defaultFillfactor) bool validate)
{ {
static const char *const default_keywords[1] = {"fillfactor"}; char *value;
char *values[1]; int value_len;
int fillfactor; bool parsed;
StdRdOptions *result; bool nofree = false;
parseRelOptions(reloptions, 1, default_keywords, values, validate); if (option->isset && validate)
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("parameter \"%s\" specified more than once",
option->gen->name)));
/* value_len = text_len - option->gen->namelen - 1;
* If no options, we can just return NULL rather than doing anything. value = (char *) palloc(value_len + 1);
* (defaultFillfactor is thus not used, but we require callers to pass it memcpy(value, text_str + option->gen->namelen + 1, value_len);
* anyway since we would need it if more options were added.) value[value_len] = '\0';
*/
if (values[0] == NULL)
return NULL;
if (!parse_int(values[0], &fillfactor, 0, NULL)) switch (option->gen->type)
{ {
if (validate) case RELOPT_TYPE_BOOL:
ereport(ERROR, {
(errcode(ERRCODE_INVALID_PARAMETER_VALUE), parsed = parse_bool(value, &option->values.bool_val);
errmsg("fillfactor must be an integer: \"%s\"", if (validate && !parsed)
values[0]))); ereport(ERROR,
return NULL; (errmsg("invalid value for boolean option \"%s\": %s",
option->gen->name, value)));
}
break;
case RELOPT_TYPE_INT:
{
relopt_int *optint = (relopt_int *) option->gen;
parsed = parse_int(value, &option->values.int_val, 0, NULL);
if (validate && !parsed)
ereport(ERROR,
(errmsg("invalid value for integer option \"%s\": %s",
option->gen->name, value)));
if (validate && (option->values.int_val < optint->min ||
option->values.int_val > optint->max))
ereport(ERROR,
(errmsg("value %s out of bounds for option \"%s\"",
value, option->gen->name),
errdetail("Valid values are between \"%d\" and \"%d\".",
optint->min, optint->max)));
}
break;
case RELOPT_TYPE_REAL:
{
relopt_real *optreal = (relopt_real *) option->gen;
parsed = parse_real(value, &option->values.real_val);
if (validate && !parsed)
ereport(ERROR,
(errmsg("invalid value for floating point option \"%s\": %s",
option->gen->name, value)));
if (validate && (option->values.real_val < optreal->min ||
option->values.real_val > optreal->max))
ereport(ERROR,
(errmsg("value %s out of bounds for option \"%s\"",
value, option->gen->name),
errdetail("Valid values are between \"%f\" and \"%f\".",
optreal->min, optreal->max)));
}
break;
case RELOPT_TYPE_STRING:
option->values.string_val = value;
nofree = true;
parsed = true;
/* no validation possible */
break;
default:
elog(ERROR, "unsupported reloption type %d", option->gen->type);
break;
} }
if (fillfactor < minFillfactor || fillfactor > 100) if (parsed)
{ option->isset = true;
if (validate) if (!nofree)
ereport(ERROR, pfree(value);
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("fillfactor=%d is out of range (should be between %d and 100)",
fillfactor, minFillfactor)));
return NULL;
}
result = (StdRdOptions *) palloc(sizeof(StdRdOptions));
SET_VARSIZE(result, sizeof(StdRdOptions));
result->fillfactor = fillfactor;
return (bytea *) result;
} }
/*
* Option parser for anything that uses StdRdOptions (i.e. fillfactor only)
*/
bytea *
default_reloptions(Datum reloptions, bool validate, relopt_kind kind)
{
relopt_value *options;
StdRdOptions *rdopts;
StdRdOptions lopts;
int numoptions;
int len;
int i;
options = parseRelOptions(reloptions, validate, kind, &numoptions);
/* if none set, we're done */
if (numoptions == 0)
return NULL;
MemSet(&lopts, 0, sizeof(StdRdOptions));
for (i = 0; i < numoptions; i++)
{
HANDLE_INT_RELOPTION("fillfactor", lopts.fillfactor, options[i]);
}
pfree(options);
len = sizeof(StdRdOptions);
rdopts = palloc(len);
memcpy(rdopts, &lopts, len);
SET_VARSIZE(rdopts, len);
return (bytea *) rdopts;
}
/* /*
* Parse options for heaps (and perhaps someday toast tables). * Parse options for heaps (and perhaps someday toast tables).
@ -336,9 +787,7 @@ default_reloptions(Datum reloptions, bool validate,
bytea * bytea *
heap_reloptions(char relkind, Datum reloptions, bool validate) heap_reloptions(char relkind, Datum reloptions, bool validate)
{ {
return default_reloptions(reloptions, validate, return default_reloptions(reloptions, validate, RELOPT_KIND_HEAP);
HEAP_MIN_FILLFACTOR,
HEAP_DEFAULT_FILLFACTOR);
} }

13
src/backend/access/gin/ginutil.c
View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/access/gin/ginutil.c,v 1.19 2009/01/01 17:23:34 momjian Exp $ * $PostgreSQL: pgsql/src/backend/access/gin/ginutil.c,v 1.20 2009/01/05 17:14:28 alvherre Exp $
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -317,16 +317,7 @@ ginoptions(PG_FUNCTION_ARGS)
bool validate = PG_GETARG_BOOL(1); bool validate = PG_GETARG_BOOL(1);
bytea *result; bytea *result;
/* result = default_reloptions(reloptions, validate, RELOPT_KIND_GIN);
* It's not clear that fillfactor is useful for GIN, but for the moment
* we'll accept it anyway. (It won't do anything...)
*/
#define GIN_MIN_FILLFACTOR 10
#define GIN_DEFAULT_FILLFACTOR 100
result = default_reloptions(reloptions, validate,
GIN_MIN_FILLFACTOR,
GIN_DEFAULT_FILLFACTOR);
if (result) if (result)
PG_RETURN_BYTEA_P(result); PG_RETURN_BYTEA_P(result);
PG_RETURN_NULL(); PG_RETURN_NULL();

7
src/backend/access/gist/gistutil.c
View File

@ -8,7 +8,7 @@
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/access/gist/gistutil.c,v 1.32 2009/01/01 17:23:35 momjian Exp $ * $PostgreSQL: pgsql/src/backend/access/gist/gistutil.c,v 1.33 2009/01/05 17:14:28 alvherre Exp $
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
#include "postgres.h" #include "postgres.h"
@ -670,9 +670,8 @@ gistoptions(PG_FUNCTION_ARGS)
bool validate = PG_GETARG_BOOL(1); bool validate = PG_GETARG_BOOL(1);
bytea *result; bytea *result;
result = default_reloptions(reloptions, validate, result = default_reloptions(reloptions, validate, RELOPT_KIND_GIST);
GIST_MIN_FILLFACTOR,
GIST_DEFAULT_FILLFACTOR);
if (result) if (result)
PG_RETURN_BYTEA_P(result); PG_RETURN_BYTEA_P(result);
PG_RETURN_NULL(); PG_RETURN_NULL();

7
src/backend/access/hash/hashutil.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/access/hash/hashutil.c,v 1.58 2009/01/01 17:23:35 momjian Exp $ * $PostgreSQL: pgsql/src/backend/access/hash/hashutil.c,v 1.59 2009/01/05 17:14:28 alvherre Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -224,9 +224,8 @@ hashoptions(PG_FUNCTION_ARGS)
bool validate = PG_GETARG_BOOL(1); bool validate = PG_GETARG_BOOL(1);
bytea *result; bytea *result;
result = default_reloptions(reloptions, validate, result = default_reloptions(reloptions, validate, RELOPT_KIND_HASH);
HASH_MIN_FILLFACTOR,
HASH_DEFAULT_FILLFACTOR);
if (result) if (result)
PG_RETURN_BYTEA_P(result); PG_RETURN_BYTEA_P(result);
PG_RETURN_NULL(); PG_RETURN_NULL();

6
src/backend/access/nbtree/nbtutils.c
View File

@ -8,7 +8,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $PostgreSQL: pgsql/src/backend/access/nbtree/nbtutils.c,v 1.92 2009/01/01 17:23:36 momjian Exp $ * $PostgreSQL: pgsql/src/backend/access/nbtree/nbtutils.c,v 1.93 2009/01/05 17:14:28 alvherre Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -1402,9 +1402,7 @@ btoptions(PG_FUNCTION_ARGS)
bool validate = PG_GETARG_BOOL(1); bool validate = PG_GETARG_BOOL(1);
bytea *result; bytea *result;
result = default_reloptions(reloptions, validate, result = default_reloptions(reloptions, validate, RELOPT_KIND_BTREE);
BTREE_MIN_FILLFACTOR,
BTREE_DEFAULT_FILLFACTOR);
if (result) if (result)
PG_RETURN_BYTEA_P(result); PG_RETURN_BYTEA_P(result);
PG_RETURN_NULL(); PG_RETURN_NULL();

167
src/include/access/reloptions.h
View File

@ -11,7 +11,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* $PostgreSQL: pgsql/src/include/access/reloptions.h,v 1.6 2009/01/01 17:23:56 momjian Exp $ * $PostgreSQL: pgsql/src/include/access/reloptions.h,v 1.7 2009/01/05 17:14:28 alvherre Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -20,21 +20,168 @@
#include "nodes/pg_list.h" #include "nodes/pg_list.h"
/* types supported by reloptions */
typedef enum relopt_type
{
RELOPT_TYPE_BOOL,
RELOPT_TYPE_INT,
RELOPT_TYPE_REAL,
RELOPT_TYPE_STRING
} relopt_type;
/* kinds supported by reloptions */
typedef enum relopt_kind
{
RELOPT_KIND_HEAP,
/* XXX do we need a separate kind for TOAST tables? */
RELOPT_KIND_BTREE,
RELOPT_KIND_HASH,
RELOPT_KIND_GIN,
RELOPT_KIND_GIST,
/* if you add a new kind, make sure you update "last_default" too */
RELOPT_KIND_LAST_DEFAULT = RELOPT_KIND_GIST,
RELOPT_KIND_MAX = 255
} relopt_kind;
/* generic struct to hold shared data */
typedef struct relopt_gen
{
const char *name; /* must be first (used as list termination marker) */
const char *desc;
relopt_kind kind;
int namelen;
relopt_type type;
} relopt_gen;
/* holds a parsed value */
typedef struct relopt_value
{
relopt_gen *gen;
bool isset;
union
{
bool bool_val;
int int_val;
double real_val;
char *string_val; /* allocated separately */
} values;
} relopt_value;
/* reloptions records for specific variable types */
typedef struct relopt_bool
{
relopt_gen gen;
bool default_val;
} relopt_bool;
typedef struct relopt_int
{
relopt_gen gen;
int default_val;
int min;
int max;
} relopt_int;
typedef struct relopt_real
{
relopt_gen gen;
double default_val;
double min;
double max;
} relopt_real;
typedef struct relopt_string
{
relopt_gen gen;
int default_len;
bool default_isnull;
char default_val[1]; /* variable length */
} relopt_string;
/*
* These macros exist for the convenience of amoptions writers. See
* default_reloptions for an example of the intended usage. Beware of
* multiple evaluation of arguments!
*
* Most of the time there's no need to call HAVE_RELOPTION manually, but it's
* possible that an amoptions routine needs to walk the array with a different
* purpose (say, to compute the size of a struct to allocate beforehand.)
*/
#define HAVE_RELOPTION(optname, option) \
(pg_strncasecmp(option.gen->name, optname, option.gen->namelen) == 0)
#define HANDLE_INT_RELOPTION(optname, var, option) \
do { \
if (HAVE_RELOPTION(optname, option)) \
{ \
if (option.isset) \
var = option.values.int_val; \
else \
var = ((relopt_int *) option.gen)->default_val; \
continue; \
} \
} while (0)
#define HANDLE_BOOL_RELOPTION(optname, var, option) \
do { \
if (HAVE_RELOPTION(optname, option)) \
{ \
if (option.isset) \
var = option.values.bool_val; \
else \
var = ((relopt_bool *) option.gen)->default_val; \
continue; \
} \
} while (0)
#define HANDLE_REAL_RELOPTION(optname, var, option) \
do { \
if (HAVE_RELOPTION(optname, option)) \
{ \
if (option.isset) \
var = option.values.real_val; \
else \
var = ((relopt_real *) option.gen)->default_val; \
continue; \
} \
} while (0)
/* Note that this assumes that the variable is already allocated! */
#define HANDLE_STRING_RELOPTION(optname, var, option) \
do { \
if (HAVE_RELOPTION(optname, option)) \
{ \
relopt_string *optstring = (relopt_string *) option.gen;\
if (optstring->default_isnull) \
var[0] = '\0'; \
else \
strcpy(var, \
option.isset ? option.values.string_val : \
optstring->default_val); \
continue; \
} \
} while (0)
extern int add_reloption_kind(void);
extern void add_bool_reloption(int kind, char *name, char *desc,
bool default_val);
extern void add_int_reloption(int kind, char *name, char *desc,
int default_val, int min_val, int max_val);
extern void add_real_reloption(int kind, char *name, char *desc,
double default_val, double min_val, double max_val);
extern void add_string_reloption(int kind, char *name, char *desc,
char *default_val);
extern Datum transformRelOptions(Datum oldOptions, List *defList, extern Datum transformRelOptions(Datum oldOptions, List *defList,
bool ignoreOids, bool isReset); bool ignoreOids, bool isReset);
extern List *untransformRelOptions(Datum options); extern List *untransformRelOptions(Datum options);
extern relopt_value *parseRelOptions(Datum options, bool validate,
extern void parseRelOptions(Datum options, int numkeywords, relopt_kind kind, int *numrelopts);
const char *const * keywords,
char **values, bool validate);
extern bytea *default_reloptions(Datum reloptions, bool validate, extern bytea *default_reloptions(Datum reloptions, bool validate,
int minFillfactor, int defaultFillfactor); relopt_kind kind);
extern bytea *heap_reloptions(char relkind, Datum reloptions, bool validate); extern bytea *heap_reloptions(char relkind, Datum reloptions, bool validate);
extern bytea *index_reloptions(RegProcedure amoptions, Datum reloptions, extern bytea *index_reloptions(RegProcedure amoptions, Datum reloptions,
bool validate); bool validate);
#endif /* RELOPTIONS_H */ #endif /* RELOPTIONS_H */

4
src/include/catalog/catversion.h
View File

@ -37,7 +37,7 @@
* Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 1994, Regents of the University of California
* *
* $PostgreSQL: pgsql/src/include/catalog/catversion.h,v 1.516 2009/01/01 17:23:56 momjian Exp $ * $PostgreSQL: pgsql/src/include/catalog/catversion.h,v 1.517 2009/01/05 17:14:28 alvherre Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
@ -53,6 +53,6 @@
*/ */
/* yyyymmddN */ /* yyyymmddN */
#define CATALOG_VERSION_NO 200812301 #define CATALOG_VERSION_NO 200901051
#endif #endif