From 3a9b74780956951bdbe60cdaa96e9752675d3a34 Mon Sep 17 00:00:00 2001 From: Nikita Glukhov Date: Tue, 10 Sep 2019 03:35:39 +0300 Subject: [PATCH 1/5] Introduce opclass parameters --- contrib/bloom/blvalidate.c | 3 + doc/src/sgml/indices.sgml | 2 +- doc/src/sgml/ref/create_index.sgml | 16 +- src/backend/access/brin/brin_validate.c | 3 + src/backend/access/common/reloptions.c | 410 +++++++++++++++++++---- src/backend/access/gin/ginvalidate.c | 3 + src/backend/access/gist/gistvalidate.c | 3 + src/backend/access/hash/hashvalidate.c | 2 + src/backend/access/index/indexam.c | 74 +++- src/backend/access/nbtree/nbtvalidate.c | 3 + src/backend/access/spgist/spgvalidate.c | 3 + src/backend/catalog/heap.c | 8 +- src/backend/catalog/index.c | 22 +- src/backend/catalog/toasting.c | 1 + src/backend/commands/indexcmds.c | 65 +++- src/backend/commands/opclasscmds.c | 41 ++- src/backend/commands/tablecmds.c | 2 +- src/backend/nodes/copyfuncs.c | 1 + src/backend/nodes/equalfuncs.c | 1 + src/backend/nodes/makefuncs.c | 3 + src/backend/nodes/outfuncs.c | 1 + src/backend/optimizer/util/plancat.c | 3 + src/backend/parser/gram.y | 72 ++-- src/backend/parser/parse_utilcmd.c | 8 + src/backend/utils/adt/ruleutils.c | 135 +++++--- src/backend/utils/adt/selfuncs.c | 23 +- src/backend/utils/cache/lsyscache.c | 35 ++ src/backend/utils/cache/relcache.c | 151 ++++++++- src/backend/utils/fmgr/fmgr.c | 28 ++ src/include/access/genam.h | 3 + src/include/access/reloptions.h | 36 ++ src/include/catalog/heap.h | 1 + src/include/catalog/pg_amproc.h | 2 + src/include/fmgr.h | 4 + src/include/nodes/execnodes.h | 2 + src/include/nodes/parsenodes.h | 1 + src/include/nodes/pathnodes.h | 1 + src/include/utils/lsyscache.h | 1 + src/include/utils/rel.h | 1 + src/include/utils/relcache.h | 3 + src/include/utils/ruleutils.h | 1 + src/test/regress/expected/alter_generic.out | 22 +- src/test/regress/expected/btree_index.out | 5 + src/test/regress/expected/opr_sanity.out | 2 +- src/test/regress/input/create_function_1.source | 5 + src/test/regress/output/create_function_1.source | 4 + src/test/regress/regress.c | 7 + src/test/regress/sql/alter_generic.sql | 13 +- src/test/regress/sql/btree_index.sql | 4 + src/test/regress/sql/opr_sanity.sql | 2 +- 50 files changed, 1050 insertions(+), 192 deletions(-) diff --git a/contrib/bloom/blvalidate.c b/contrib/bloom/blvalidate.c index e9bd1b4..dbd675b 100644 --- a/contrib/bloom/blvalidate.c +++ b/contrib/bloom/blvalidate.c @@ -105,6 +105,9 @@ blvalidate(Oid opclassoid) /* Check procedure numbers and function signatures */ switch (procform->amprocnum) { + case OPCLASS_OPTIONS_PROC: + ok = true; + break; case BLOOM_HASH_PROC: ok = check_amproc_signature(procform->amproc, INT4OID, false, 1, 1, opckeytype); diff --git a/doc/src/sgml/indices.sgml b/doc/src/sgml/indices.sgml index 95c0a19..ea3acea 100644 --- a/doc/src/sgml/indices.sgml +++ b/doc/src/sgml/indices.sgml @@ -1253,7 +1253,7 @@ SELECT target FROM tests WHERE subject = 'some-subject' AND success; An index definition can specify an operator class for each column of an index. -CREATE INDEX name ON table (column opclass sort options , ...); +CREATE INDEX name ON table (column opclass [ ( opclass_options ) ] sort options , ...); The operator class identifies the operators to be used by the index for that column. For example, a B-tree index on the type int4 diff --git a/doc/src/sgml/ref/create_index.sgml b/doc/src/sgml/ref/create_index.sgml index 629a31e..61401f3 100644 --- a/doc/src/sgml/ref/create_index.sgml +++ b/doc/src/sgml/ref/create_index.sgml @@ -22,7 +22,7 @@ PostgreSQL documentation CREATE [ UNIQUE ] INDEX [ CONCURRENTLY ] [ [ IF NOT EXISTS ] name ] ON [ ONLY ] table_name [ USING method ] - ( { column_name | ( expression ) } [ COLLATE collation ] [ opclass ] [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [, ...] ) + ( { column_name | ( expression ) } [ COLLATE collation ] { opclass | DEFAULT } [ ( opclass_parameter = value [, ... ] ) ] [ ASC | DESC ] [ NULLS { FIRST | LAST } ] [, ...] ) [ INCLUDE ( column_name [, ...] ) ] [ WITH ( storage_parameter = value [, ... ] ) ] [ TABLESPACE tablespace_name ] @@ -279,6 +279,15 @@ CREATE [ UNIQUE ] INDEX [ CONCURRENTLY ] [ [ IF NOT EXISTS ] + opclass_parameter + + + The name of an operator class parameter. See below for details. + + + + + ASC @@ -646,8 +655,9 @@ Indexes: - An operator class can be specified for each - column of an index. The operator class identifies the operators to be + An operator class with its optional parameters + can be specified for each column of an index. + The operator class identifies the operators to be used by the index for that column. For example, a B-tree index on four-byte integers would use the int4_ops class; this operator class includes comparison functions for four-byte diff --git a/src/backend/access/brin/brin_validate.c b/src/backend/access/brin/brin_validate.c index 0129338..9e6694e 100644 --- a/src/backend/access/brin/brin_validate.c +++ b/src/backend/access/brin/brin_validate.c @@ -87,6 +87,9 @@ brinvalidate(Oid opclassoid) /* Check procedure numbers and function signatures */ switch (procform->amprocnum) { + case OPCLASS_OPTIONS_PROC: + ok = true; + break; case BRIN_PROCNUM_OPCINFO: ok = check_amproc_signature(procform->amproc, INTERNALOID, true, 1, 1, INTERNALOID); diff --git a/src/backend/access/common/reloptions.c b/src/backend/access/common/reloptions.c index 20f4ed3..3ad1324 100644 --- a/src/backend/access/common/reloptions.c +++ b/src/backend/access/common/reloptions.c @@ -445,6 +445,7 @@ static relopt_string stringRelOpts[] = 4, false, gistValidateBufferingOption, + NULL, "auto" }, { @@ -457,6 +458,7 @@ static relopt_string stringRelOpts[] = 0, true, validateWithCheckOption, + NULL, NULL }, /* list terminator */ @@ -615,6 +617,50 @@ add_reloption(relopt_gen *newoption) need_initialization = true; } +typedef struct local_relopt +{ + relopt_gen *option; + int offset; +} local_relopt; + +void +init_local_reloptions(local_relopts *opts, void *base, Size base_size) +{ + opts->options = NIL; + opts->validators = NIL; + opts->base = base; + opts->base_size = base_size; +} + +void +extend_local_reloptions(local_relopts *opts, void *base, Size base_size) +{ + Assert(opts->base_size < base_size); + opts->base = base; + opts->base_size = base_size; +} + +void +register_reloptions_validator(local_relopts *opts, relopts_validator validator) +{ + opts->validators = lappend(opts->validators, validator); +} + +/* + * add_local_reloption + * Add an already-created custom reloption to the local list. + */ +static void +add_local_reloption(local_relopts *relopts, relopt_gen *newoption, void *pval) +{ + local_relopt *opt = palloc(sizeof(*opt)); + + opt->option = newoption; + opt->offset = (char *) pval - (char *) relopts->base; + + relopts->options = lappend(relopts->options, opt); +} + /* * allocate_reloption * Allocate a new reloption and initialize the type-agnostic fields @@ -627,7 +673,10 @@ allocate_reloption(bits32 kinds, int type, const char *name, const char *desc) size_t size; relopt_gen *newoption; - oldcxt = MemoryContextSwitchTo(TopMemoryContext); + if (kinds != RELOPT_KIND_LOCAL) + oldcxt = MemoryContextSwitchTo(TopMemoryContext); + else + oldcxt = NULL; switch (type) { @@ -659,17 +708,19 @@ allocate_reloption(bits32 kinds, int type, const char *name, const char *desc) newoption->namelen = strlen(name); newoption->type = type; - MemoryContextSwitchTo(oldcxt); + if (oldcxt != NULL) + MemoryContextSwitchTo(oldcxt); return newoption; } /* - * add_bool_reloption - * Add a new boolean reloption + * init_bool_reloption + * Allocate and initialize a new boolean reloption */ -void -add_bool_reloption(bits32 kinds, const char *name, const char *desc, bool default_val) +static relopt_bool * +init_bool_reloption(bits32 kinds, const char *name, const char *desc, + bool default_val) { relopt_bool *newoption; @@ -677,16 +728,43 @@ add_bool_reloption(bits32 kinds, const char *name, const char *desc, bool defaul name, desc); newoption->default_val = default_val; + return newoption; +} + +/* + * add_bool_reloption + * Add a new boolean reloption + */ +void +add_bool_reloption(bits32 kinds, const char *name, const char *desc, bool default_val) +{ + relopt_bool *newoption = init_bool_reloption(kinds, name, desc, default_val); + add_reloption((relopt_gen *) newoption); } /* - * add_int_reloption - * Add a new integer reloption + * add_local_bool_reloption + * Add a new boolean local reloption */ void -add_int_reloption(bits32 kinds, const char *name, const char *desc, int default_val, - int min_val, int max_val) +add_local_bool_reloption(local_relopts *relopts, const char *name, + const char *desc, bool default_val, bool *pval) +{ + relopt_bool *newoption = init_bool_reloption(RELOPT_KIND_LOCAL, name, desc, + default_val); + + add_local_reloption(relopts, (relopt_gen *) newoption, pval); +} + + +/* + * init_real_reloption + * Allocate and initialize a new integer reloption + */ +static relopt_int * +init_int_reloption(bits32 kinds, const char *name, const char *desc, + int default_val, int min_val, int max_val) { relopt_int *newoption; @@ -696,16 +774,45 @@ add_int_reloption(bits32 kinds, const char *name, const char *desc, int default_ newoption->min = min_val; newoption->max = max_val; + return newoption; +} + +/* + * add_int_reloption + * Add a new integer reloption + */ +void +add_int_reloption(bits32 kinds, const char *name, const char *desc, int default_val, + int min_val, int max_val) +{ + relopt_int *newoption = init_int_reloption(kinds, name, desc, default_val, + min_val, max_val); + add_reloption((relopt_gen *) newoption); } /* - * add_real_reloption - * Add a new float reloption + * add_local_int_reloption + * Add a new local integer reloption */ void -add_real_reloption(bits32 kinds, const char *name, const char *desc, double default_val, - double min_val, double max_val) +add_local_int_reloption(local_relopts *relopts, const char *name, + const char *desc, int default_val, int min_val, + int max_val, int *pval) +{ + relopt_int *newoption = init_int_reloption(RELOPT_KIND_LOCAL, name, desc, + default_val, min_val, max_val); + + add_local_reloption(relopts, (relopt_gen *) newoption, pval); +} + +/* + * init_real_reloption + * Allocate and initialize a new real reloption + */ +static relopt_real * +init_real_reloption(bits32 kinds, const char *name, const char *desc, + double default_val, double min_val, double max_val) { relopt_real *newoption; @@ -715,21 +822,46 @@ add_real_reloption(bits32 kinds, const char *name, const char *desc, double defa newoption->min = min_val; newoption->max = max_val; + return newoption; +} + +/* + * add_real_reloption + * Add a new float reloption + */ +void +add_real_reloption(bits32 kinds, const char *name, const char *desc, double default_val, + double min_val, double max_val) +{ + relopt_real *newoption = init_real_reloption(kinds, name, desc, default_val, + min_val, max_val); + add_reloption((relopt_gen *) newoption); } /* - * add_string_reloption - * Add a new string reloption - * - * "validator" is an optional function pointer that can be used to test the - * validity of the values. It must elog(ERROR) when the argument string is - * not acceptable for the variable. Note that the default value must pass - * the validation. + * add_local_real_reloption + * Add a new local float reloption */ void -add_string_reloption(bits32 kinds, const char *name, const char *desc, const char *default_val, - validate_string_relopt validator) +add_local_real_reloption(local_relopts *relopts, const char *name, const char *desc, + double default_val, double min_val, double max_val, + double *pval) +{ + relopt_real *newoption = init_real_reloption(RELOPT_KIND_LOCAL, name, desc, + default_val, min_val, max_val); + + add_local_reloption(relopts, (relopt_gen *) newoption, pval); +} + +/* + * init_string_reloption + * Allocate and initialize a new string reloption + */ +static relopt_string * +init_string_reloption(bits32 kinds, const char *name, const char *desc, + const char *default_val, validate_string_relopt validator, + fill_string_relopt filler) { relopt_string *newoption; @@ -740,10 +872,13 @@ add_string_reloption(bits32 kinds, const char *name, const char *desc, const cha newoption = (relopt_string *) allocate_reloption(kinds, RELOPT_TYPE_STRING, name, desc); newoption->validate_cb = validator; + newoption->fill_cb = filler; if (default_val) { - newoption->default_val = MemoryContextStrdup(TopMemoryContext, - default_val); + if (kinds == RELOPT_KIND_LOCAL) + newoption->default_val = strdup(default_val); + else + newoption->default_val = MemoryContextStrdup(TopMemoryContext, default_val); newoption->default_len = strlen(default_val); newoption->default_isnull = false; } @@ -754,10 +889,46 @@ add_string_reloption(bits32 kinds, const char *name, const char *desc, const cha newoption->default_isnull = true; } + return newoption; +} + +/* + * add_string_reloption + * Add a new string reloption + * + * "validator" is an optional function pointer that can be used to test the + * validity of the values. It must elog(ERROR) when the argument string is + * not acceptable for the variable. Note that the default value must pass + * the validation. + */ +void +add_string_reloption(bits32 kinds, const char *name, const char *desc, const char *default_val, + validate_string_relopt validator) +{ + relopt_string *newoption = init_string_reloption(kinds, name, desc, + default_val, validator, NULL); + add_reloption((relopt_gen *) newoption); } /* + * add_local_string_reloption + * Add a new 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 *poffset) +{ + relopt_string *newoption = init_string_reloption(RELOPT_KIND_LOCAL, name, + desc, default_val, + validator, filler); + + add_local_reloption(relopts, (relopt_gen *) newoption, poffset); +} + +/* * Transform a relation options list (list of DefElem) into the text array * format that is kept in pg_class.reloptions, including only those options * that are in the passed namespace. The output values do not include the @@ -1051,6 +1222,60 @@ extractRelOptions(HeapTuple tuple, TupleDesc tupdesc, return options; } +static void +parseRelOptionsInternal(Datum options, bool validate, + relopt_value *reloptions, int numoptions) +{ + ArrayType *array = DatumGetArrayTypeP(options); + Datum *optiondatums; + int noptions; + int i; + + deconstruct_array(array, TEXTOID, -1, false, 'i', + &optiondatums, NULL, &noptions); + + for (i = 0; i < noptions; i++) + { + char *text_str = VARDATA(optiondatums[i]); + int text_len = VARSIZE(optiondatums[i]) - VARHDRSZ; + int j; + + /* Search for a match in reloptions */ + for (j = 0; j < numoptions; j++) + { + int kw_len = reloptions[j].gen->namelen; + + if (text_len > kw_len && text_str[kw_len] == '=' && + strncmp(text_str, reloptions[j].gen->name, kw_len) == 0) + { + parse_one_reloption(&reloptions[j], text_str, text_len, + validate); + break; + } + } + + if (j >= numoptions && validate) + { + char *s; + char *p; + + s = TextDatumGetCString(optiondatums[i]); + p = strchr(s, '='); + if (p) + *p = '\0'; + ereport(ERROR, + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), + errmsg("unrecognized parameter \"%s\"", s))); + } + } + + /* It's worth avoiding memory leaks in this function */ + pfree(optiondatums); + + if (((void *) array) != DatumGetPointer(options)) + pfree(array); +} + /* * Interpret reloptions that are given in text-array format. * @@ -1105,57 +1330,74 @@ parseRelOptions(Datum options, bool validate, relopt_kind kind, /* Done if no options */ if (PointerIsValid(DatumGetPointer(options))) + parseRelOptionsInternal(options, validate, reloptions, numoptions); + + *numrelopts = numoptions; + return reloptions; +} + +/* Parse local unregistered options. */ +relopt_value * +parseLocalRelOptions(local_relopts *relopts, Datum options, bool validate) +{ + int nopts = list_length(relopts->options); + relopt_value *values = palloc(sizeof(*values) * nopts); + ListCell *lc; + int i = 0; + + foreach(lc, relopts->options) { - ArrayType *array = DatumGetArrayTypeP(options); - Datum *optiondatums; - int noptions; + local_relopt *opt = lfirst(lc); - deconstruct_array(array, TEXTOID, -1, false, 'i', - &optiondatums, NULL, &noptions); + values[i].gen = opt->option; + values[i].isset = false; - for (i = 0; i < noptions; i++) - { - char *text_str = VARDATA(optiondatums[i]); - int text_len = VARSIZE(optiondatums[i]) - VARHDRSZ; - int j; + i++; + } - /* Search for a match in reloptions */ - for (j = 0; j < numoptions; j++) - { - int kw_len = reloptions[j].gen->namelen; + if (options != (Datum) 0) + parseRelOptionsInternal(options, validate, values, nopts); - if (text_len > kw_len && text_str[kw_len] == '=' && - strncmp(text_str, reloptions[j].gen->name, kw_len) == 0) - { - parse_one_reloption(&reloptions[j], text_str, text_len, - validate); - break; - } - } + return values; +} - if (j >= numoptions && validate) - { - char *s; - char *p; +/* + * Parse local options, allocate a bytea struct that's of the specified + * 'base_size' plus any extra space that's needed for string variables, + * fill its option's fields located at the given offsets and return it. + */ +void * +parseAndFillLocalRelOptions(local_relopts *relopts, Datum options, bool validate) +{ + int noptions = list_length(relopts->options); + relopt_parse_elt *elems = palloc(sizeof(*elems) * noptions); + relopt_value *vals; + void *opts; + int i = 0; + ListCell *lc; + + foreach(lc, relopts->options) + { + local_relopt *opt = lfirst(lc); - s = TextDatumGetCString(optiondatums[i]); - p = strchr(s, '='); - if (p) - *p = '\0'; - ereport(ERROR, - (errcode(ERRCODE_INVALID_PARAMETER_VALUE), - errmsg("unrecognized parameter \"%s\"", s))); - } - } + elems[i].optname = opt->option->name; + elems[i].opttype = opt->option->type; + elems[i].offset = opt->offset; - /* It's worth avoiding memory leaks in this function */ - pfree(optiondatums); - if (((void *) array) != DatumGetPointer(options)) - pfree(array); + i++; } - *numrelopts = numoptions; - return reloptions; + vals = parseLocalRelOptions(relopts, options, validate); + opts = allocateReloptStruct(relopts->base_size, vals, noptions); + fillRelOptions(opts, relopts->base_size, vals, noptions, validate, elems, noptions); + + foreach(lc, relopts->validators) + ((relopts_validator) lfirst(lc))(opts, vals, noptions); + + if (elems) + pfree(elems); + + return opts; } /* @@ -1271,8 +1513,24 @@ allocateReloptStruct(Size base, relopt_value *options, int numoptions) int i; for (i = 0; i < numoptions; i++) - if (options[i].gen->type == RELOPT_TYPE_STRING) - size += GET_STRING_RELOPTION_LEN(options[i]) + 1; + { + relopt_value *optval = &options[i]; + + if (optval->gen->type == RELOPT_TYPE_STRING) + { + relopt_string *optstr = (relopt_string *) optval->gen; + + if (optstr->fill_cb) + { + const char *val = optval->isset ? optval->values.string_val : + optstr->default_isnull ? NULL : optstr->default_val; + + size += optstr->fill_cb(val, NULL); + } + else + size += GET_STRING_RELOPTION_LEN(*optval) + 1; + } + } return palloc0(size); } @@ -1336,7 +1594,21 @@ fillRelOptions(void *rdopts, Size basesize, else string_val = NULL; - if (string_val == NULL) + if (optstring->fill_cb) + { + Size size = + optstring->fill_cb(string_val, + (char *) rdopts + offset); + + if (size) + { + *(int *) itempos = offset; + offset += size; + } + else + *(int *) itempos = 0; + } + else if (string_val == NULL) *(int *) itempos = 0; else { diff --git a/src/backend/access/gin/ginvalidate.c b/src/backend/access/gin/ginvalidate.c index 63bd7f2..337eeec 100644 --- a/src/backend/access/gin/ginvalidate.c +++ b/src/backend/access/gin/ginvalidate.c @@ -106,6 +106,9 @@ ginvalidate(Oid opclassoid) /* Check procedure numbers and function signatures */ switch (procform->amprocnum) { + case OPCLASS_OPTIONS_PROC: + ok = true; + break; case GIN_COMPARE_PROC: ok = check_amproc_signature(procform->amproc, INT4OID, false, 2, 2, opckeytype, opckeytype); diff --git a/src/backend/access/gist/gistvalidate.c b/src/backend/access/gist/gistvalidate.c index dfc1a87..ea8cd0e 100644 --- a/src/backend/access/gist/gistvalidate.c +++ b/src/backend/access/gist/gistvalidate.c @@ -106,6 +106,9 @@ gistvalidate(Oid opclassoid) /* Check procedure numbers and function signatures */ switch (procform->amprocnum) { + case OPCLASS_OPTIONS_PROC: + ok = true; + break; case GIST_CONSISTENT_PROC: ok = check_amproc_signature(procform->amproc, BOOLOID, false, 5, 5, INTERNALOID, opcintype, diff --git a/src/backend/access/hash/hashvalidate.c b/src/backend/access/hash/hashvalidate.c index 9315872..7650a30 100644 --- a/src/backend/access/hash/hashvalidate.c +++ b/src/backend/access/hash/hashvalidate.c @@ -105,6 +105,8 @@ hashvalidate(Oid opclassoid) /* Check procedure numbers and function signatures */ switch (procform->amprocnum) { + case OPCLASS_OPTIONS_PROC: + break; case HASHSTANDARD_PROC: case HASHEXTENDED_PROC: if (!check_hash_func_signature(procform->amproc, procform->amprocnum, diff --git a/src/backend/access/index/indexam.c b/src/backend/access/index/indexam.c index 2e8f53a..bbed726 100644 --- a/src/backend/access/index/indexam.c +++ b/src/backend/access/index/indexam.c @@ -45,17 +45,23 @@ #include "access/amapi.h" #include "access/heapam.h" +#include "access/reloptions.h" #include "access/relscan.h" #include "access/tableam.h" #include "access/transam.h" #include "access/xlog.h" #include "catalog/index.h" +#include "catalog/pg_amproc.h" #include "catalog/pg_type.h" +#include "commands/defrem.h" +#include "nodes/makefuncs.h" #include "pgstat.h" #include "storage/bufmgr.h" #include "storage/lmgr.h" #include "storage/predicate.h" +#include "utils/ruleutils.h" #include "utils/snapmgr.h" +#include "utils/syscache.h" /* ---------------------------------------------------------------- @@ -767,9 +773,9 @@ index_getprocid(Relation irel, nproc = irel->rd_indam->amsupport; - Assert(procnum > 0 && procnum <= (uint16) nproc); + Assert(procnum >= 0 && procnum <= (uint16) nproc); - procindex = (nproc * (attnum - 1)) + (procnum - 1); + procindex = ((nproc + 1) * (attnum - 1)) + procnum; loc = irel->rd_support; @@ -801,9 +807,9 @@ index_getprocinfo(Relation irel, nproc = irel->rd_indam->amsupport; - Assert(procnum > 0 && procnum <= (uint16) nproc); + Assert(procnum >= 0 && procnum <= (uint16) nproc); - procindex = (nproc * (attnum - 1)) + (procnum - 1); + procindex = ((nproc + 1) * (attnum - 1)) + procnum; locinfo = irel->rd_supportinfo; @@ -832,6 +838,17 @@ index_getprocinfo(Relation irel, procnum, attnum, RelationGetRelationName(irel)); fmgr_info_cxt(procId, locinfo, irel->rd_indexcxt); + + if (procnum != OPCLASS_OPTIONS_PROC) + { + /* Initialize locinfo->fn_expr with opclass options Const */ + bytea **attoptions = RelationGetIndexAttOptions(irel, false); + MemoryContext oldcxt = MemoryContextSwitchTo(irel->rd_indexcxt); + + set_fn_opclass_options(locinfo, attoptions[attnum - 1]); + + MemoryContextSwitchTo(oldcxt); + } } return locinfo; @@ -911,3 +928,52 @@ index_store_float8_orderby_distances(IndexScanDesc scan, Oid *orderByTypes, } } } + +/* ---------------- + * index_opclass_options + * + * Parse opclass-specific options for index column. + * ---------------- + */ +bytea * +index_opclass_options(Relation indrel, AttrNumber attnum, Datum attoptions, + bool validate) +{ + Oid procid = index_getprocid(indrel, attnum, 0); + FmgrInfo *procinfo; + local_relopts relopts; + + if (!OidIsValid(procid)) + { + Oid opclass; + Datum indclassDatum; + oidvector *indclass; + bool isnull; + + if (!DatumGetPointer(attoptions)) + return NULL; /* ok, no options, no procedure */ + + /* + * Report an error if the opclass's options-parsing procedure does not + * exist but the opclass options are specified. + */ + indclassDatum = SysCacheGetAttr(INDEXRELID, indrel->rd_indextuple, + Anum_pg_index_indclass, &isnull); + Assert(!isnull); + indclass = (oidvector *) DatumGetPointer(indclassDatum); + opclass = indclass->values[attnum - 1]; + + ereport(ERROR, + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), + errmsg("operator class %s has no options", + generate_opclass_name(opclass)))); + } + + init_local_reloptions(&relopts, NULL, 0); + + procinfo = index_getprocinfo(indrel, attnum, 0); + + (void) FunctionCall1(procinfo, PointerGetDatum(&relopts)); + + return parseAndFillLocalRelOptions(&relopts, attoptions, validate); +} diff --git a/src/backend/access/nbtree/nbtvalidate.c b/src/backend/access/nbtree/nbtvalidate.c index 0148ea7..418edc8 100644 --- a/src/backend/access/nbtree/nbtvalidate.c +++ b/src/backend/access/nbtree/nbtvalidate.c @@ -87,6 +87,9 @@ btvalidate(Oid opclassoid) /* Check procedure numbers and function signatures */ switch (procform->amprocnum) { + case OPCLASS_OPTIONS_PROC: + ok = true; + break; case BTORDER_PROC: ok = check_amproc_signature(procform->amproc, INT4OID, true, 2, 2, procform->amproclefttype, diff --git a/src/backend/access/spgist/spgvalidate.c b/src/backend/access/spgist/spgvalidate.c index 4b9fdbd..a5bb850 100644 --- a/src/backend/access/spgist/spgvalidate.c +++ b/src/backend/access/spgist/spgvalidate.c @@ -105,6 +105,9 @@ spgvalidate(Oid opclassoid) /* Check procedure numbers and function signatures */ switch (procform->amprocnum) { + case OPCLASS_OPTIONS_PROC: + ok = true; + break; case SPGIST_CONFIG_PROC: ok = check_amproc_signature(procform->amproc, VOIDOID, true, 2, 2, INTERNALOID, INTERNALOID); diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c index b7bcdd9..d5a4900 100644 --- a/src/backend/catalog/heap.c +++ b/src/backend/catalog/heap.c @@ -693,6 +693,7 @@ CheckAttributeType(const char *attname, void InsertPgAttributeTuple(Relation pg_attribute_rel, Form_pg_attribute new_attribute, + Datum attoptions, CatalogIndexState indstate) { Datum values[Natts_pg_attribute]; @@ -724,10 +725,11 @@ InsertPgAttributeTuple(Relation pg_attribute_rel, values[Anum_pg_attribute_attislocal - 1] = BoolGetDatum(new_attribute->attislocal); values[Anum_pg_attribute_attinhcount - 1] = Int32GetDatum(new_attribute->attinhcount); values[Anum_pg_attribute_attcollation - 1] = ObjectIdGetDatum(new_attribute->attcollation); + values[Anum_pg_attribute_attoptions - 1] = attoptions; /* start out with empty permissions and empty options */ nulls[Anum_pg_attribute_attacl - 1] = true; - nulls[Anum_pg_attribute_attoptions - 1] = true; + nulls[Anum_pg_attribute_attoptions - 1] = attoptions == (Datum) 0; nulls[Anum_pg_attribute_attfdwoptions - 1] = true; nulls[Anum_pg_attribute_attmissingval - 1] = true; @@ -781,7 +783,7 @@ AddNewAttributeTuples(Oid new_rel_oid, /* Make sure this is OK, too */ attr->attstattarget = -1; - InsertPgAttributeTuple(rel, attr, indstate); + InsertPgAttributeTuple(rel, attr, (Datum) 0, indstate); /* Add dependency info */ myself.classId = RelationRelationId; @@ -819,7 +821,7 @@ AddNewAttributeTuples(Oid new_rel_oid, /* Fill in the correct relation OID in the copied tuple */ attStruct.attrelid = new_rel_oid; - InsertPgAttributeTuple(rel, &attStruct, indstate); + InsertPgAttributeTuple(rel, &attStruct, (Datum) 0, indstate); } } diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c index 3e1d406..cb7f0ba 100644 --- a/src/backend/catalog/index.c +++ b/src/backend/catalog/index.c @@ -26,6 +26,7 @@ #include "access/amapi.h" #include "access/heapam.h" #include "access/multixact.h" +#include "access/reloptions.h" #include "access/relscan.h" #include "access/sysattr.h" #include "access/tableam.h" @@ -106,7 +107,8 @@ static TupleDesc ConstructTupleDescriptor(Relation heapRelation, Oid *classObjectId); static void InitializeAttributeOids(Relation indexRelation, int numatts, Oid indexoid); -static void AppendAttributeTuples(Relation indexRelation, int numatts); +static void AppendAttributeTuples(Relation indexRelation, int numatts, + Datum *attopts); static void UpdateIndexRelation(Oid indexoid, Oid heapoid, Oid parentIndexId, IndexInfo *indexInfo, @@ -486,7 +488,7 @@ InitializeAttributeOids(Relation indexRelation, * ---------------------------------------------------------------- */ static void -AppendAttributeTuples(Relation indexRelation, int numatts) +AppendAttributeTuples(Relation indexRelation, int numatts, Datum *attopts) { Relation pg_attribute; CatalogIndexState indstate; @@ -508,10 +510,11 @@ AppendAttributeTuples(Relation indexRelation, int numatts) for (i = 0; i < numatts; i++) { Form_pg_attribute attr = TupleDescAttr(indexTupDesc, i); + Datum attoptions = attopts ? attopts[i] : (Datum) 0; Assert(attr->attnum == i + 1); - InsertPgAttributeTuple(pg_attribute, attr, indstate); + InsertPgAttributeTuple(pg_attribute, attr, attoptions, indstate); } CatalogCloseIndexes(indstate); @@ -591,6 +594,7 @@ UpdateIndexRelation(Oid indexoid, else predDatum = (Datum) 0; + /* * open the system catalog index relation */ @@ -933,7 +937,8 @@ index_create(Relation heapRelation, /* * append ATTRIBUTE tuples for the index */ - AppendAttributeTuples(indexRelation, indexInfo->ii_NumIndexAttrs); + AppendAttributeTuples(indexRelation, indexInfo->ii_NumIndexAttrs, + indexInfo->ii_OpclassOptions); /* ---------------- * update pg_index @@ -1146,6 +1151,13 @@ index_create(Relation heapRelation, indexRelation->rd_index->indnkeyatts = indexInfo->ii_NumIndexKeyAttrs; + /* Validate opclass-specific options */ + if (indexInfo->ii_OpclassOptions) + for (i = 0; i < indexInfo->ii_NumIndexKeyAttrs; i++) + (void) index_opclass_options(indexRelation, i + 1, + indexInfo->ii_OpclassOptions[i], + true); + /* * If this is bootstrap (initdb) time, then we don't actually fill in the * index yet. We'll be creating more indexes and classes later, so we @@ -2266,6 +2278,8 @@ BuildIndexInfo(Relation index) &ii->ii_ExclusionStrats); } + ii->ii_OpclassOptions = RelationGetIndexRawAttOptions(index); + return ii; } diff --git a/src/backend/catalog/toasting.c b/src/backend/catalog/toasting.c index de6282a..7290731 100644 --- a/src/backend/catalog/toasting.c +++ b/src/backend/catalog/toasting.c @@ -304,6 +304,7 @@ create_toast_table(Relation rel, Oid toastOid, Oid toastIndexOid, indexInfo->ii_ExclusionOps = NULL; indexInfo->ii_ExclusionProcs = NULL; indexInfo->ii_ExclusionStrats = NULL; + indexInfo->ii_OpclassOptions = NULL; indexInfo->ii_Unique = true; indexInfo->ii_ReadyForInserts = true; indexInfo->ii_Concurrent = false; diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c index 1477755..04148e5 100644 --- a/src/backend/commands/indexcmds.c +++ b/src/backend/commands/indexcmds.c @@ -90,6 +90,7 @@ static void RangeVarCallbackForReindexIndex(const RangeVar *relation, static bool ReindexRelationConcurrently(Oid relationOid, int options); static void ReindexPartitionedIndex(Relation parentIdx); static void update_relispartition(Oid relationId, bool newval); +static bool CompareOpclassOptions(Datum *opts1, Datum *opts2, int natts); /* * callback argument type for RangeVarCallbackForReindexIndex() @@ -268,6 +269,18 @@ CheckIndexCompatible(Oid oldId, } } + /* Any change in opclass options break compatibility. */ + if (ret) + { + Datum *opclassOptions = RelationGetIndexRawAttOptions(irel); + + ret = CompareOpclassOptions(opclassOptions, + indexInfo->ii_OpclassOptions, old_natts); + + if (opclassOptions) + pfree(opclassOptions); + } + /* Any change in exclusion operator selections breaks compatibility. */ if (ret && indexInfo->ii_ExclusionOps != NULL) { @@ -302,6 +315,42 @@ CheckIndexCompatible(Oid oldId, return ret; } +/* + * CompareOpclassOptions + * + * Compare per-column opclass options which are represented by arrays of text[] + * datums. Both elements of arrays and array themselves can be NULL. + */ +static bool +CompareOpclassOptions(Datum *opts1, Datum *opts2, int natts) +{ + int i; + + if (!opts1 && !opts2) + return true; + + for (i = 0; i < natts; i++) + { + Datum opt1 = opts1 ? opts1[i] : (Datum) 0; + Datum opt2 = opts2 ? opts2[i] : (Datum) 0; + + if (opt1 == (Datum) 0) + { + if (opt2 == (Datum) 0) + continue; + else + return false; + } + else if (opt2 == (Datum) 0) + return false; + + /* Compare non-NULL text[] datums. */ + if (!DatumGetBool(DirectFunctionCall2(array_eq, opt1, opt2))) + return false; + } + + return true; +} /* * WaitForOlderSnapshots @@ -1509,7 +1558,7 @@ CheckPredicate(Expr *predicate) /* * Compute per-index-column information, including indexed column numbers - * or index expressions, opclasses, and indoptions. Note, all output vectors + * or index expressions, opclasses and their options. Note, all output vectors * should be allocated for all columns, including "including" ones. */ static void @@ -1810,6 +1859,20 @@ ComputeIndexAttrs(IndexInfo *indexInfo, accessMethodName))); } + /* Set up the per-column opclass options (attoptions field). */ + if (attribute->opclassopts) + { + Assert(attn < nkeycols); + + if (!indexInfo->ii_OpclassOptions) + indexInfo->ii_OpclassOptions = + palloc0(sizeof(Datum) * indexInfo->ii_NumIndexAttrs); + + indexInfo->ii_OpclassOptions[attn] = + transformRelOptions((Datum) 0, attribute->opclassopts, + NULL, NULL, false, false); + } + attn++; } } diff --git a/src/backend/commands/opclasscmds.c b/src/backend/commands/opclasscmds.c index 6a1ccdeb..f2777a5 100644 --- a/src/backend/commands/opclasscmds.c +++ b/src/backend/commands/opclasscmds.c @@ -523,11 +523,11 @@ DefineOpClass(CreateOpClassStmt *stmt) addFamilyMember(&operators, member, false); break; case OPCLASS_ITEM_FUNCTION: - if (item->number <= 0 || item->number > maxProcNumber) + if (item->number < 0 || item->number > maxProcNumber) ereport(ERROR, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), errmsg("invalid function number %d," - " must be between 1 and %d", + " must be between 0 and %d", item->number, maxProcNumber))); funcOid = LookupFuncWithArgs(OBJECT_FUNCTION, item->name, false); #ifdef NOT_USED @@ -537,7 +537,6 @@ DefineOpClass(CreateOpClassStmt *stmt) aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION, get_func_name(funcOid)); #endif - /* Save the info */ member = (OpFamilyMember *) palloc0(sizeof(OpFamilyMember)); member->object = funcOid; @@ -902,11 +901,11 @@ AlterOpFamilyAdd(AlterOpFamilyStmt *stmt, Oid amoid, Oid opfamilyoid, addFamilyMember(&operators, member, false); break; case OPCLASS_ITEM_FUNCTION: - if (item->number <= 0 || item->number > maxProcNumber) + if (item->number < 0 || item->number > maxProcNumber) ereport(ERROR, (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), errmsg("invalid function number %d," - " must be between 1 and %d", + " must be between 0 and %d", item->number, maxProcNumber))); funcOid = LookupFuncWithArgs(OBJECT_FUNCTION, item->name, false); #ifdef NOT_USED @@ -1141,6 +1140,36 @@ assignProcTypes(OpFamilyMember *member, Oid amoid, Oid typeoid) elog(ERROR, "cache lookup failed for function %u", member->object); procform = (Form_pg_proc) GETSTRUCT(proctup); + /* Check the signature of the opclass options parsing function */ + if (member->number == OPCLASS_OPTIONS_PROC) + { + if (OidIsValid(typeoid)) + { + if ((OidIsValid(member->lefttype) && member->lefttype != typeoid) || + (OidIsValid(member->righttype) && member->righttype != typeoid)) + ereport(ERROR, + (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), + errmsg("associated data types for opclass options " + "parsing functions must match opclass input type"))); + } + else + { + if (member->lefttype != member->righttype) + ereport(ERROR, + (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), + errmsg("left and right associated data types for " + "opclass options parsing functions must match"))); + } + + if (procform->prorettype != VOIDOID || + procform->pronargs != 1 || + procform->proargtypes.values[0] != INTERNALOID) + ereport(ERROR, + (errcode(ERRCODE_INVALID_OBJECT_DEFINITION), + errmsg("invalid opclass options parsing function"), + errhint("opclass options parsing function must have signature '%s'", + "(internal) RETURNS void"))); + } /* * btree comparison procs must be 2-arg procs returning int4. btree * sortsupport procs must take internal and return void. btree in_range @@ -1148,7 +1177,7 @@ assignProcTypes(OpFamilyMember *member, Oid amoid, Oid typeoid) * a 1-arg proc returning int4, while proc 2 must be a 2-arg proc * returning int8. Otherwise we don't know. */ - if (amoid == BTREE_AM_OID) + else if (amoid == BTREE_AM_OID) { if (member->number == BTORDER_PROC) { diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c index 05593f3..afef6a9 100644 --- a/src/backend/commands/tablecmds.c +++ b/src/backend/commands/tablecmds.c @@ -5737,7 +5737,7 @@ ATExecAddColumn(List **wqueue, AlteredTableInfo *tab, Relation rel, ReleaseSysCache(typeTuple); - InsertPgAttributeTuple(attrdesc, &attribute, NULL); + InsertPgAttributeTuple(attrdesc, &attribute, (Datum) 0, NULL); table_close(attrdesc, RowExclusiveLock); diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c index a2617c7..d44a5b0 100644 --- a/src/backend/nodes/copyfuncs.c +++ b/src/backend/nodes/copyfuncs.c @@ -2868,6 +2868,7 @@ _copyIndexElem(const IndexElem *from) COPY_STRING_FIELD(indexcolname); COPY_NODE_FIELD(collation); COPY_NODE_FIELD(opclass); + COPY_NODE_FIELD(opclassopts); COPY_SCALAR_FIELD(ordering); COPY_SCALAR_FIELD(nulls_ordering); diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c index 4f2ebe5..6b14095 100644 --- a/src/backend/nodes/equalfuncs.c +++ b/src/backend/nodes/equalfuncs.c @@ -2546,6 +2546,7 @@ _equalIndexElem(const IndexElem *a, const IndexElem *b) COMPARE_STRING_FIELD(indexcolname); COMPARE_NODE_FIELD(collation); COMPARE_NODE_FIELD(opclass); + COMPARE_NODE_FIELD(opclassopts); COMPARE_SCALAR_FIELD(ordering); COMPARE_SCALAR_FIELD(nulls_ordering); diff --git a/src/backend/nodes/makefuncs.c b/src/backend/nodes/makefuncs.c index 18466ac..12d43bd 100644 --- a/src/backend/nodes/makefuncs.c +++ b/src/backend/nodes/makefuncs.c @@ -763,6 +763,9 @@ makeIndexInfo(int numattrs, int numkeyattrs, Oid amoid, List *expressions, n->ii_ExclusionProcs = NULL; n->ii_ExclusionStrats = NULL; + /* opclass options */ + n->ii_OpclassOptions = NULL; + /* speculative inserts */ n->ii_UniqueOps = NULL; n->ii_UniqueProcs = NULL; diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c index e6ce8e2..37b6d6f 100644 --- a/src/backend/nodes/outfuncs.c +++ b/src/backend/nodes/outfuncs.c @@ -2850,6 +2850,7 @@ _outIndexElem(StringInfo str, const IndexElem *node) WRITE_STRING_FIELD(indexcolname); WRITE_NODE_FIELD(collation); WRITE_NODE_FIELD(opclass); + WRITE_NODE_FIELD(opclassopts); WRITE_ENUM_FIELD(ordering, SortByDir); WRITE_ENUM_FIELD(nulls_ordering, SortByNulls); } diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c index cf17614..de9b6f4 100644 --- a/src/backend/optimizer/util/plancat.c +++ b/src/backend/optimizer/util/plancat.c @@ -279,6 +279,9 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent, info->amcostestimate = amroutine->amcostestimate; Assert(info->amcostestimate != NULL); + /* Fetch index opclass options */ + info->opclassoptions = RelationGetIndexAttOptions(indexRelation, true); + /* * Fetch the ordering information for the index, if any. */ diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y index a954acf..c8b5d91 100644 --- a/src/backend/parser/gram.y +++ b/src/backend/parser/gram.y @@ -491,7 +491,7 @@ static Node *makeRecursiveViewSelect(char *relname, List *aliases, Node *query); %type alias_clause opt_alias_clause %type func_alias_clause %type sortby -%type index_elem +%type index_elem index_elem_options %type table_ref %type joined_table %type relation_expr @@ -7420,43 +7420,65 @@ index_params: index_elem { $$ = list_make1($1); } | index_params ',' index_elem { $$ = lappend($1, $3); } ; + +index_elem_options: + opt_collate opt_class opt_asc_desc opt_nulls_order + { + $$ = makeNode(IndexElem); + $$->name = NULL; + $$->expr = NULL; + $$->indexcolname = NULL; + $$->collation = $1; + $$->opclass = $2; + $$->opclassopts = NIL; + $$->ordering = $3; + $$->nulls_ordering = $4; + } + | opt_collate any_name reloptions opt_asc_desc opt_nulls_order + { + $$ = makeNode(IndexElem); + $$->name = NULL; + $$->expr = NULL; + $$->indexcolname = NULL; + $$->collation = $1; + $$->opclass = $2; + $$->opclassopts = $3; + $$->ordering = $4; + $$->nulls_ordering = $5; + } + | opt_collate DEFAULT reloptions opt_asc_desc opt_nulls_order + { + $$ = makeNode(IndexElem); + $$->name = NULL; + $$->expr = NULL; + $$->indexcolname = NULL; + $$->collation = $1; + $$->opclass = NIL; + $$->opclassopts = $3; + $$->ordering = $4; + $$->nulls_ordering = $5; + } + ; + /* * Index attributes can be either simple column references, or arbitrary * expressions in parens. For backwards-compatibility reasons, we allow * an expression that's just a function call to be written without parens. */ -index_elem: ColId opt_collate opt_class opt_asc_desc opt_nulls_order +index_elem: ColId index_elem_options { - $$ = makeNode(IndexElem); + $$ = $2; $$->name = $1; - $$->expr = NULL; - $$->indexcolname = NULL; - $$->collation = $2; - $$->opclass = $3; - $$->ordering = $4; - $$->nulls_ordering = $5; } - | func_expr_windowless opt_collate opt_class opt_asc_desc opt_nulls_order + | func_expr_windowless index_elem_options { - $$ = makeNode(IndexElem); - $$->name = NULL; + $$ = $2; $$->expr = $1; - $$->indexcolname = NULL; - $$->collation = $2; - $$->opclass = $3; - $$->ordering = $4; - $$->nulls_ordering = $5; } - | '(' a_expr ')' opt_collate opt_class opt_asc_desc opt_nulls_order + | '(' a_expr ')' index_elem_options { - $$ = makeNode(IndexElem); - $$->name = NULL; + $$ = $4; $$->expr = $2; - $$->indexcolname = NULL; - $$->collation = $4; - $$->opclass = $5; - $$->ordering = $6; - $$->nulls_ordering = $7; } ; diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c index 6e5768c..5872376 100644 --- a/src/backend/parser/parse_utilcmd.c +++ b/src/backend/parser/parse_utilcmd.c @@ -1577,6 +1577,8 @@ generateClonedIndexStmt(RangeVar *heapRel, Relation source_idx, /* Add the operator class name, if non-default */ iparam->opclass = get_opclass(indclass->values[keyno], keycoltype); + iparam->opclassopts = + untransformRelOptions(get_attoptions(source_relid, keyno + 1)); iparam->ordering = SORTBY_DEFAULT; iparam->nulls_ordering = SORTBY_NULLS_DEFAULT; @@ -2153,9 +2155,13 @@ transformIndexConstraint(Constraint *constraint, CreateStmtContext *cxt) * semantics as you'd get from a normally-created constraint; * and there's also the dump/reload problem mentioned above. */ + Datum attoptions = + get_attoptions(RelationGetRelid(index_rel), i + 1); + defopclass = GetDefaultOpClass(attform->atttypid, index_rel->rd_rel->relam); if (indclass->values[i] != defopclass || + attoptions != (Datum) 0 || index_rel->rd_indoption[i] != 0) ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), @@ -2335,6 +2341,7 @@ transformIndexConstraint(Constraint *constraint, CreateStmtContext *cxt) iparam->indexcolname = NULL; iparam->collation = NIL; iparam->opclass = NIL; + iparam->opclassopts = NIL; iparam->ordering = SORTBY_DEFAULT; iparam->nulls_ordering = SORTBY_NULLS_DEFAULT; index->indexParams = lappend(index->indexParams, iparam); @@ -2448,6 +2455,7 @@ transformIndexConstraint(Constraint *constraint, CreateStmtContext *cxt) iparam->indexcolname = NULL; iparam->collation = NIL; iparam->opclass = NIL; + iparam->opclassopts = NIL; index->indexIncludingParams = lappend(index->indexIncludingParams, iparam); } diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c index 3e64390..faecf04 100644 --- a/src/backend/utils/adt/ruleutils.c +++ b/src/backend/utils/adt/ruleutils.c @@ -469,6 +469,7 @@ static void add_cast_to(StringInfo buf, Oid typid); static char *generate_qualified_type_name(Oid typid); static text *string_to_text(char *str); static char *flatten_reloptions(Oid relid); +static void get_reloptions(StringInfo buf, Datum reloptions); #define only_marker(rte) ((rte)->inh ? "" : "ONLY ") @@ -1371,6 +1372,8 @@ pg_get_indexdef_worker(Oid indexrelid, int colno, { int16 opt = indoption->values[keyno]; Oid indcoll = indcollation->values[keyno]; + Datum attoptions = get_attoptions(indexrelid, keyno + 1); + bool has_options = attoptions != (Datum) 0; /* Add collation, if not default for column */ if (OidIsValid(indcoll) && indcoll != keycolcollation) @@ -1378,7 +1381,15 @@ pg_get_indexdef_worker(Oid indexrelid, int colno, generate_collation_name((indcoll))); /* Add the operator class name, if not default */ - get_opclass_name(indclass->values[keyno], keycoltype, &buf); + get_opclass_name(indclass->values[keyno], + has_options ? InvalidOid : keycoltype, &buf); + + if (has_options) + { + appendStringInfoString(&buf, " ("); + get_reloptions(&buf, attoptions); + appendStringInfoChar(&buf, ')'); + } /* Add options if relevant */ if (amroutine->amcanorder) @@ -10506,6 +10517,23 @@ get_opclass_name(Oid opclass, Oid actual_datatype, } /* + * generate_opclass_name + * Compute the name to display for a opclass specified by OID + * + * The result includes all necessary quoting and schema-prefixing. + */ +char * +generate_opclass_name(Oid opclass) +{ + StringInfoData buf; + + initStringInfo(&buf); + get_opclass_name(opclass, InvalidOid, &buf); + + return &buf.data[1]; /* get_opclass_name() prepends space */ +} + +/* * processIndirection - take care of array and subfield assignment * * We strip any top-level FieldStore or assignment SubscriptingRef nodes that @@ -11183,6 +11211,62 @@ string_to_text(char *str) } /* + * Generate a C string representing a relation options from text[] datum. + */ +static void +get_reloptions(StringInfo buf, Datum reloptions) +{ + Datum *options; + int noptions; + int i; + + deconstruct_array(DatumGetArrayTypeP(reloptions), + TEXTOID, -1, false, 'i', + &options, NULL, &noptions); + + for (i = 0; i < noptions; i++) + { + char *option = TextDatumGetCString(options[i]); + char *name; + char *separator; + char *value; + + /* + * Each array element should have the form name=value. If the "=" + * is missing for some reason, treat it like an empty value. + */ + name = option; + separator = strchr(option, '='); + if (separator) + { + *separator = '\0'; + value = separator + 1; + } + else + value = ""; + + if (i > 0) + appendStringInfoString(buf, ", "); + appendStringInfo(buf, "%s=", quote_identifier(name)); + + /* + * In general we need to quote the value; but to avoid unnecessary + * clutter, do not quote if it is an identifier that would not + * need quoting. (We could also allow numbers, but that is a bit + * trickier than it looks --- for example, are leading zeroes + * significant? We don't want to assume very much here about what + * custom reloptions might mean.) + */ + if (quote_identifier(value) == value) + appendStringInfoString(buf, value); + else + simple_quote_literal(buf, value); + + pfree(option); + } +} + +/* * Generate a C string representing a relation's reloptions, or NULL if none. */ static char * @@ -11202,56 +11286,9 @@ flatten_reloptions(Oid relid) if (!isnull) { StringInfoData buf; - Datum *options; - int noptions; - int i; initStringInfo(&buf); - - deconstruct_array(DatumGetArrayTypeP(reloptions), - TEXTOID, -1, false, 'i', - &options, NULL, &noptions); - - for (i = 0; i < noptions; i++) - { - char *option = TextDatumGetCString(options[i]); - char *name; - char *separator; - char *value; - - /* - * Each array element should have the form name=value. If the "=" - * is missing for some reason, treat it like an empty value. - */ - name = option; - separator = strchr(option, '='); - if (separator) - { - *separator = '\0'; - value = separator + 1; - } - else - value = ""; - - if (i > 0) - appendStringInfoString(&buf, ", "); - appendStringInfo(&buf, "%s=", quote_identifier(name)); - - /* - * In general we need to quote the value; but to avoid unnecessary - * clutter, do not quote if it is an identifier that would not - * need quoting. (We could also allow numbers, but that is a bit - * trickier than it looks --- for example, are leading zeroes - * significant? We don't want to assume very much here about what - * custom reloptions might mean.) - */ - if (quote_identifier(value) == value) - appendStringInfoString(&buf, value); - else - simple_quote_literal(&buf, value); - - pfree(option); - } + get_reloptions(&buf, reloptions); result = buf.data; } diff --git a/src/backend/utils/adt/selfuncs.c b/src/backend/utils/adt/selfuncs.c index 1710129..638d5ad 100644 --- a/src/backend/utils/adt/selfuncs.c +++ b/src/backend/utils/adt/selfuncs.c @@ -6260,6 +6260,7 @@ gincost_pattern(IndexOptInfo *index, int indexcol, Oid clause_op, Datum query, GinQualCounts *counts) { + FmgrInfo flinfo; Oid extractProcOid; Oid collation; int strategy_op; @@ -6309,15 +6310,19 @@ gincost_pattern(IndexOptInfo *index, int indexcol, else collation = DEFAULT_COLLATION_OID; - OidFunctionCall7Coll(extractProcOid, - collation, - query, - PointerGetDatum(&nentries), - UInt16GetDatum(strategy_op), - PointerGetDatum(&partial_matches), - PointerGetDatum(&extra_data), - PointerGetDatum(&nullFlags), - PointerGetDatum(&searchMode)); + fmgr_info(extractProcOid, &flinfo); + + set_fn_opclass_options(&flinfo, index->opclassoptions[indexcol]); + + FunctionCall7Coll(&flinfo, + collation, + query, + PointerGetDatum(&nentries), + UInt16GetDatum(strategy_op), + PointerGetDatum(&partial_matches), + PointerGetDatum(&extra_data), + PointerGetDatum(&nullFlags), + PointerGetDatum(&searchMode)); if (nentries <= 0 && searchMode == GIN_SEARCH_MODE_DEFAULT) { diff --git a/src/backend/utils/cache/lsyscache.c b/src/backend/utils/cache/lsyscache.c index 27602fa..8fbf5e3 100644 --- a/src/backend/utils/cache/lsyscache.c +++ b/src/backend/utils/cache/lsyscache.c @@ -908,6 +908,41 @@ get_atttypetypmodcoll(Oid relid, AttrNumber attnum, ReleaseSysCache(tp); } +/* + * get_attoptions + * + * Given the relation id and the attribute number, + * return the attribute options text[] datum, if any. + */ +Datum +get_attoptions(Oid relid, int16 attnum) +{ + HeapTuple tuple; + Datum attopts; + Datum result; + bool isnull; + + tuple = SearchSysCache2(ATTNUM, + ObjectIdGetDatum(relid), + Int16GetDatum(attnum)); + + if (!HeapTupleIsValid(tuple)) + elog(ERROR, "cache lookup failed for attribute %d of relation %u", + attnum, relid); + + attopts = SysCacheGetAttr(ATTNAME, tuple, Anum_pg_attribute_attoptions, + &isnull); + + if (isnull) + result = (Datum) 0; + else + result = datumCopy(attopts, false, -1); /* text[] */ + + ReleaseSysCache(tuple); + + return result; +} + /* ---------- COLLATION CACHE ---------- */ /* diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c index 585dcee..7f96935 100644 --- a/src/backend/utils/cache/relcache.c +++ b/src/backend/utils/cache/relcache.c @@ -1438,7 +1438,7 @@ RelationInitIndexAccessInfo(Relation relation) amsupport = relation->rd_indam->amsupport; if (amsupport > 0) { - int nsupport = indnatts * amsupport; + int nsupport = indnatts * (amsupport + 1); relation->rd_support = (RegProcedure *) MemoryContextAllocZero(indexcxt, nsupport * sizeof(RegProcedure)); @@ -1502,6 +1502,10 @@ RelationInitIndexAccessInfo(Relation relation) indoption = (int2vector *) DatumGetPointer(indoptionDatum); memcpy(relation->rd_indoption, indoption->values, indnkeyatts * sizeof(int16)); +#if 0 + (void) RelationGetIndexAttOptions(relation, false); +#endif + /* * expressions, predicate, exclusion caches will be filled later */ @@ -1551,9 +1555,9 @@ IndexSupportInitialize(oidvector *indclass, opFamily[attIndex] = opcentry->opcfamily; opcInType[attIndex] = opcentry->opcintype; if (maxSupportNumber > 0) - memcpy(&indexSupport[attIndex * maxSupportNumber], + memcpy(&indexSupport[attIndex * (maxSupportNumber + 1)], opcentry->supportProcs, - maxSupportNumber * sizeof(RegProcedure)); + (maxSupportNumber + 1) * sizeof(RegProcedure)); } } @@ -1618,7 +1622,7 @@ LookupOpclassInfo(Oid operatorClassOid, if (numSupport > 0) opcentry->supportProcs = (RegProcedure *) MemoryContextAllocZero(CacheMemoryContext, - numSupport * sizeof(RegProcedure)); + (numSupport + 1) * sizeof(RegProcedure)); else opcentry->supportProcs = NULL; } @@ -1705,13 +1709,12 @@ LookupOpclassInfo(Oid operatorClassOid, { Form_pg_amproc amprocform = (Form_pg_amproc) GETSTRUCT(htup); - if (amprocform->amprocnum <= 0 || + if (amprocform->amprocnum < 0 || (StrategyNumber) amprocform->amprocnum > numSupport) elog(ERROR, "invalid amproc number %d for opclass %u", amprocform->amprocnum, operatorClassOid); - opcentry->supportProcs[amprocform->amprocnum - 1] = - amprocform->amproc; + opcentry->supportProcs[amprocform->amprocnum] = amprocform->amproc; } systable_endscan(scan); @@ -3998,6 +4001,10 @@ load_critical_index(Oid indexoid, Oid heapoid) ird->rd_refcnt = 1; UnlockRelationOid(indexoid, AccessShareLock); UnlockRelationOid(heapoid, AccessShareLock); + +#if 0 + (void) RelationGetIndexAttOptions(ird, false); +#endif } /* @@ -5153,6 +5160,99 @@ GetRelationPublicationActions(Relation relation) } /* + * RelationGetIndexRawAttOptions -- get AM/opclass-specific options for the index + */ +Datum * +RelationGetIndexRawAttOptions(Relation indexrel) +{ + Oid indexrelid = RelationGetRelid(indexrel); + int16 natts = RelationGetNumberOfAttributes(indexrel); + Datum *options = NULL; + int16 attnum; + + for (attnum = 1; attnum <= natts; attnum++) + { + if (!OidIsValid(index_getprocid(indexrel, attnum, OPCLASS_OPTIONS_PROC))) + continue; + + if (!options) + options = palloc0(sizeof(Datum) * natts); + + options[attnum - 1] = get_attoptions(indexrelid, attnum); + } + + return options; +} + +static bytea ** +CopyIndexAttOptions(bytea **srcopts, int natts) +{ + bytea **opts = palloc(sizeof(*opts) * natts); + + for (int i = 0; i < natts; i++) + { + bytea *opt = srcopts[i]; + + opts[i] = !opt ? NULL : (bytea *) + DatumGetPointer(datumCopy(PointerGetDatum(opt), false, -1)); + } + + return opts; +} + +/* + * RelationGetIndexAttOptions + * get AM/opclass-specific options for an index parsed into a binary form + */ +bytea ** +RelationGetIndexAttOptions(Relation relation, bool copy) +{ + MemoryContext oldcxt; + bytea **opts = relation->rd_opcoptions; + Oid relid = RelationGetRelid(relation); + int natts = RelationGetNumberOfAttributes(relation); /* XXX IndexRelationGetNumberOfKeyAttributes */ + int i; + + /* Try to copy cached options. */ + if (opts) + return copy ? CopyIndexAttOptions(opts, natts) : opts; + + /* Get and parse opclass options. */ + opts = palloc0(sizeof(*opts) * natts); + + for (i = 0; i < natts; i++) + { + if (criticalRelcachesBuilt && relid != AttributeRelidNumIndexId) + { + Datum attoptions = get_attoptions(relid, i + 1); + + opts[i] = index_opclass_options(relation, i + 1, attoptions, false); + + if (attoptions != (Datum) 0) + pfree(DatumGetPointer(attoptions)); + } + } + + /* Copy parsed options to the cache. */ + oldcxt = MemoryContextSwitchTo(relation->rd_indexcxt); + relation->rd_opcoptions = CopyIndexAttOptions(opts, natts); + MemoryContextSwitchTo(oldcxt); + + if (copy) + return opts; + + for (i = 0; i < natts; i++) + { + if (opts[i]) + pfree(opts[i]); + } + + pfree(opts); + + return relation->rd_opcoptions; +} + +/* * Routines to support ereport() reports of relation-related errors * * These could have been put into elog.c, but it seems like a module layering @@ -5513,8 +5613,27 @@ load_relcache_init_file(bool shared) rel->rd_indoption = indoption; +#if 0 + /* finally, read the vector of opcoptions values */ + rel->rd_opcoptions = (bytea **) + MemoryContextAllocZero(indexcxt, sizeof(*rel->rd_opcoptions) * relform->relnatts); + + for (i = 0; i < relform->relnatts; i++) + { + if (fread(&len, 1, sizeof(len), fp) != sizeof(len)) + goto read_failed; + + if (len > 0) + { + rel->rd_opcoptions[i] = (bytea *) MemoryContextAlloc(indexcxt, len); + if (fread(rel->rd_opcoptions[i], 1, len, fp) != len) + goto read_failed; + } + } +#endif + /* set up zeroed fmgr-info vector */ - nsupport = relform->relnatts * rel->rd_indam->amsupport; + nsupport = relform->relnatts * (rel->rd_indam->amsupport + 1); rel->rd_supportinfo = (FmgrInfo *) MemoryContextAllocZero(indexcxt, nsupport * sizeof(FmgrInfo)); } @@ -5541,6 +5660,7 @@ load_relcache_init_file(bool shared) Assert(rel->rd_supportinfo == NULL); Assert(rel->rd_indoption == NULL); Assert(rel->rd_indcollation == NULL); + Assert(rel->rd_opcoptions == NULL); } /* @@ -5568,6 +5688,7 @@ load_relcache_init_file(bool shared) rel->rd_exclprocs = NULL; rel->rd_exclstrats = NULL; rel->rd_fdwroutine = NULL; + rel->rd_opcoptions = NULL; /* * Reset transient-state fields in the relcache entry @@ -5814,7 +5935,7 @@ write_relcache_init_file(bool shared) /* next, write the vector of support procedure OIDs */ write_item(rel->rd_support, - relform->relnatts * (rel->rd_indam->amsupport * sizeof(RegProcedure)), + relform->relnatts * ((rel->rd_indam->amsupport + 1) * sizeof(RegProcedure)), fp); /* next, write the vector of collation OIDs */ @@ -5826,6 +5947,18 @@ write_relcache_init_file(bool shared) write_item(rel->rd_indoption, relform->relnatts * sizeof(int16), fp); + +#if 0 + Assert(rel->rd_opcoptions); + + /* finally, write the vector of opcoptions values */ + for (i = 0; i < relform->relnatts; i++) + { + bytea *opt = rel->rd_opcoptions[i]; + + write_item(opt, opt ? VARSIZE(opt) : 0, fp); + } +#endif } } diff --git a/src/backend/utils/fmgr/fmgr.c b/src/backend/utils/fmgr/fmgr.c index 0484adb..e11146a 100644 --- a/src/backend/utils/fmgr/fmgr.c +++ b/src/backend/utils/fmgr/fmgr.c @@ -18,9 +18,11 @@ #include "access/detoast.h" #include "catalog/pg_language.h" #include "catalog/pg_proc.h" +#include "catalog/pg_type.h" #include "executor/functions.h" #include "lib/stringinfo.h" #include "miscadmin.h" +#include "nodes/makefuncs.h" #include "nodes/nodeFuncs.h" #include "pgstat.h" #include "utils/acl.h" @@ -1967,6 +1969,32 @@ get_fn_expr_variadic(FmgrInfo *flinfo) return false; } +void +set_fn_opclass_options(FmgrInfo *flinfo, bytea *options) +{ + flinfo->fn_expr = (Node *) makeConst(BYTEAOID, -1, InvalidOid, -1, + PointerGetDatum(options), + options == NULL, false); +} + +bytea * +get_fn_opclass_options(FmgrInfo *flinfo) +{ + if (flinfo && flinfo->fn_expr && IsA(flinfo->fn_expr, Const)) + { + Const *expr = (Const *) flinfo->fn_expr; + + if (expr->consttype == BYTEAOID) + return expr->constisnull ? NULL : DatumGetByteaP(expr->constvalue); + } + + ereport(ERROR, + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), + errmsg("opclass options info is absent in function call context"))); + + return NULL; +} + /*------------------------------------------------------------------------- * Support routines for procedural language implementations *------------------------------------------------------------------------- diff --git a/src/include/access/genam.h b/src/include/access/genam.h index 6c56717..778d17c 100644 --- a/src/include/access/genam.h +++ b/src/include/access/genam.h @@ -182,6 +182,9 @@ extern void index_store_float8_orderby_distances(IndexScanDesc scan, double *distanceValues, bool *distanceNulls, bool recheckOrderBy); +extern bytea *index_opclass_options(Relation relation, AttrNumber attnum, + Datum attoptions, bool validate); + /* * index access method support routines (in genam.c) diff --git a/src/include/access/reloptions.h b/src/include/access/reloptions.h index 6d392e4..70238f9 100644 --- a/src/include/access/reloptions.h +++ b/src/include/access/reloptions.h @@ -37,6 +37,7 @@ typedef enum relopt_type /* kinds supported by reloptions */ typedef enum relopt_kind { + RELOPT_KIND_LOCAL = 0, RELOPT_KIND_HEAP = (1 << 0), RELOPT_KIND_TOAST = (1 << 1), RELOPT_KIND_BTREE = (1 << 2), @@ -109,6 +110,9 @@ typedef struct relopt_real /* validation routines for strings */ typedef void (*validate_string_relopt) (const char *value); +typedef Size (*fill_string_relopt) (const char *value, void *ptr); + +typedef void (*relopts_validator)(void *parsed_options, relopt_value *vals, int nvals); typedef struct relopt_string { @@ -116,6 +120,7 @@ typedef struct relopt_string int default_len; bool default_isnull; validate_string_relopt validate_cb; + fill_string_relopt fill_cb; char *default_val; } relopt_string; @@ -127,6 +132,13 @@ typedef struct int offset; /* offset of field in result struct */ } relopt_parse_elt; +typedef struct local_relopts +{ + List *options; + List *validators; + void *base; + Size base_size; +} local_relopts; /* * These macros exist for the convenience of amoptions writers (but consider @@ -255,6 +267,26 @@ extern void add_real_reloption(bits32 kinds, const char *name, const char *desc, extern void add_string_reloption(bits32 kinds, const char *name, const char *desc, const char *default_val, validate_string_relopt validator); +extern void init_local_reloptions(local_relopts *opts, void *base, Size base_size); +extern void extend_local_reloptions(local_relopts *opts, void *base, Size base_size); +extern void register_reloptions_validator(local_relopts *opts, + relopts_validator validator); +extern void add_local_bool_reloption(local_relopts *opts, const char *name, + const char *desc, bool default_val, + bool *pval); +extern void add_local_int_reloption(local_relopts *opts, const char *name, + const char *desc, int default_val, + int min_val, int max_val, int *pval); +extern void add_local_real_reloption(local_relopts *opts, const char *name, + const char *desc, double default_val, + double min_val, double max_val, + double *pval); +extern void add_local_string_reloption(local_relopts *opts, const char *name, + const char *desc, + const char *default_val, + validate_string_relopt validator, + fill_string_relopt filler, int *poffset); + extern Datum transformRelOptions(Datum oldOptions, List *defList, const char *namspace, char *validnsps[], bool acceptOidsOff, bool isReset); @@ -263,12 +295,16 @@ extern bytea *extractRelOptions(HeapTuple tuple, TupleDesc tupdesc, amoptions_function amoptions); extern relopt_value *parseRelOptions(Datum options, bool validate, relopt_kind kind, int *numrelopts); +extern relopt_value *parseLocalRelOptions(local_relopts *relopts, Datum options, + bool validate); extern void *allocateReloptStruct(Size base, relopt_value *options, int numoptions); extern void fillRelOptions(void *rdopts, Size basesize, relopt_value *options, int numoptions, bool validate, const relopt_parse_elt *elems, int nelems); +extern void *parseAndFillLocalRelOptions(local_relopts *relopts, Datum options, + bool validate); extern bytea *default_reloptions(Datum reloptions, bool validate, relopt_kind kind); diff --git a/src/include/catalog/heap.h b/src/include/catalog/heap.h index eec71c2..866e94d 100644 --- a/src/include/catalog/heap.h +++ b/src/include/catalog/heap.h @@ -94,6 +94,7 @@ extern List *heap_truncate_find_FKs(List *relationIds); extern void InsertPgAttributeTuple(Relation pg_attribute_rel, Form_pg_attribute new_attribute, + Datum attoptions, CatalogIndexState indstate); extern void InsertPgClassTuple(Relation pg_class_desc, diff --git a/src/include/catalog/pg_amproc.h b/src/include/catalog/pg_amproc.h index 62ca564..75cb340 100644 --- a/src/include/catalog/pg_amproc.h +++ b/src/include/catalog/pg_amproc.h @@ -67,4 +67,6 @@ CATALOG(pg_amproc,2603,AccessMethodProcedureRelationId) */ typedef FormData_pg_amproc *Form_pg_amproc; +#define OPCLASS_OPTIONS_PROC 0 /* amprocnum for opclass options */ + #endif /* PG_AMPROC_H */ diff --git a/src/include/fmgr.h b/src/include/fmgr.h index 29ae467..568a9c6 100644 --- a/src/include/fmgr.h +++ b/src/include/fmgr.h @@ -331,6 +331,8 @@ extern struct varlena *pg_detoast_datum_packed(struct varlena *datum); #define PG_GETARG_BPCHAR_P(n) DatumGetBpCharP(PG_GETARG_DATUM(n)) #define PG_GETARG_VARCHAR_P(n) DatumGetVarCharP(PG_GETARG_DATUM(n)) +#define PG_GET_OPCLASS_OPTIONS() get_fn_opclass_options(fcinfo->flinfo) + /* To return a NULL do this: */ #define PG_RETURN_NULL() \ do { fcinfo->isnull = true; return (Datum) 0; } while (0) @@ -699,6 +701,8 @@ extern Oid get_call_expr_argtype(fmNodePtr expr, int argnum); extern bool get_fn_expr_arg_stable(FmgrInfo *flinfo, int argnum); extern bool get_call_expr_arg_stable(fmNodePtr expr, int argnum); extern bool get_fn_expr_variadic(FmgrInfo *flinfo); +extern bytea *get_fn_opclass_options(FmgrInfo *flinfo); +extern void set_fn_opclass_options(FmgrInfo *flinfo, bytea *options); extern bool CheckFunctionValidatorAccess(Oid validatorOid, Oid functionOid); /* diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h index b593d22..967c818 100644 --- a/src/include/nodes/execnodes.h +++ b/src/include/nodes/execnodes.h @@ -139,6 +139,7 @@ typedef struct ExprState * UniqueProcs * UniqueStrats * Unique is it a unique index? + * OpclassOptions opclass-specific options, or NULL if none * ReadyForInserts is it valid for inserts? * Concurrent are we doing a concurrent index build? * BrokenHotChain did we detect any broken HOT chains? @@ -167,6 +168,7 @@ typedef struct IndexInfo Oid *ii_UniqueOps; /* array with one entry per column */ Oid *ii_UniqueProcs; /* array with one entry per column */ uint16 *ii_UniqueStrats; /* array with one entry per column */ + Datum *ii_OpclassOptions; /* array with one entry per column */ bool ii_Unique; bool ii_ReadyForInserts; bool ii_Concurrent; diff --git a/src/include/nodes/parsenodes.h b/src/include/nodes/parsenodes.h index 94ded3c..aa266b2 100644 --- a/src/include/nodes/parsenodes.h +++ b/src/include/nodes/parsenodes.h @@ -701,6 +701,7 @@ typedef struct IndexElem char *indexcolname; /* name for index column; NULL = default */ List *collation; /* name of collation; NIL = default */ List *opclass; /* name of desired opclass; NIL = default */ + List *opclassopts; /* opclass-specific options, or NIL */ SortByDir ordering; /* ASC/DESC/default */ SortByNulls nulls_ordering; /* FIRST/LAST/default */ } IndexElem; diff --git a/src/include/nodes/pathnodes.h b/src/include/nodes/pathnodes.h index 23a06d7..a07c44d 100644 --- a/src/include/nodes/pathnodes.h +++ b/src/include/nodes/pathnodes.h @@ -806,6 +806,7 @@ struct IndexOptInfo Oid *sortopfamily; /* OIDs of btree opfamilies, if orderable */ bool *reverse_sort; /* is sort order descending? */ bool *nulls_first; /* do NULLs come first in the sort order? */ + bytea **opclassoptions; /* opclass-specific options for columns */ bool *canreturn; /* which index cols can be returned in an * index-only scan? */ Oid relam; /* OID of the access method (in pg_am) */ diff --git a/src/include/utils/lsyscache.h b/src/include/utils/lsyscache.h index c8df5bf..2fa9965 100644 --- a/src/include/utils/lsyscache.h +++ b/src/include/utils/lsyscache.h @@ -90,6 +90,7 @@ extern char get_attgenerated(Oid relid, AttrNumber attnum); extern Oid get_atttype(Oid relid, AttrNumber attnum); extern void get_atttypetypmodcoll(Oid relid, AttrNumber attnum, Oid *typid, int32 *typmod, Oid *collid); +extern Datum get_attoptions(Oid relid, int16 attnum); extern char *get_collation_name(Oid colloid); extern bool get_collation_isdeterministic(Oid colloid); extern char *get_constraint_name(Oid conoid); diff --git a/src/include/utils/rel.h b/src/include/utils/rel.h index 91b3b1b..552d9eb 100644 --- a/src/include/utils/rel.h +++ b/src/include/utils/rel.h @@ -166,6 +166,7 @@ typedef struct RelationData Oid *rd_exclprocs; /* OIDs of exclusion ops' procs, if any */ uint16 *rd_exclstrats; /* exclusion ops' strategy numbers, if any */ Oid *rd_indcollation; /* OIDs of index collations */ + bytea **rd_opcoptions; /* parsed opclass-specific options */ /* * rd_amcache is available for index and table AMs to cache private data diff --git a/src/include/utils/relcache.h b/src/include/utils/relcache.h index 2f2ace3..adc2b26 100644 --- a/src/include/utils/relcache.h +++ b/src/include/utils/relcache.h @@ -14,6 +14,7 @@ #ifndef RELCACHE_H #define RELCACHE_H +#include "postgres.h" #include "access/tupdesc.h" #include "nodes/bitmapset.h" @@ -49,6 +50,8 @@ extern Oid RelationGetPrimaryKeyIndex(Relation relation); extern Oid RelationGetReplicaIndex(Relation relation); extern List *RelationGetIndexExpressions(Relation relation); extern List *RelationGetIndexPredicate(Relation relation); +extern Datum *RelationGetIndexRawAttOptions(Relation relation); +extern bytea **RelationGetIndexAttOptions(Relation relation, bool copy); typedef enum IndexAttrBitmapKind { diff --git a/src/include/utils/ruleutils.h b/src/include/utils/ruleutils.h index d34cad2..e295052 100644 --- a/src/include/utils/ruleutils.h +++ b/src/include/utils/ruleutils.h @@ -34,6 +34,7 @@ extern List *set_deparse_context_planstate(List *dpcontext, extern List *select_rtable_names_for_explain(List *rtable, Bitmapset *rels_used); extern char *generate_collation_name(Oid collid); +extern char *generate_opclass_name(Oid opclass); extern char *get_range_partbound_string(List *bound_datums); #endif /* RULEUTILS_H */ diff --git a/src/test/regress/expected/alter_generic.out b/src/test/regress/expected/alter_generic.out index 8663f0c..40b3267 100644 --- a/src/test/regress/expected/alter_generic.out +++ b/src/test/regress/expected/alter_generic.out @@ -353,10 +353,11 @@ ALTER OPERATOR FAMILY alt_opf4 USING btree ADD OPERATOR 0 < (int4, int2); -- ope ERROR: invalid operator number 0, must be between 1 and 5 ALTER OPERATOR FAMILY alt_opf4 USING btree ADD OPERATOR 1 < ; -- operator without argument types ERROR: operator argument types must be specified in ALTER OPERATOR FAMILY -ALTER OPERATOR FAMILY alt_opf4 USING btree ADD FUNCTION 0 btint42cmp(int4, int2); -- function number should be between 1 and 5 -ERROR: invalid function number 0, must be between 1 and 3 -ALTER OPERATOR FAMILY alt_opf4 USING btree ADD FUNCTION 6 btint42cmp(int4, int2); -- function number should be between 1 and 5 -ERROR: invalid function number 6, must be between 1 and 3 +ALTER OPERATOR FAMILY alt_opf4 USING btree ADD FUNCTION 0 btint42cmp(int4, int2); -- invalid options parsing function +ERROR: invalid opclass options parsing function +HINT: opclass options parsing function must have signature '(internal) RETURNS void' +ALTER OPERATOR FAMILY alt_opf4 USING btree ADD FUNCTION 4 btint42cmp(int4, int2); -- function number should be between 0 and 3 +ERROR: invalid function number 4, must be between 0 and 3 ALTER OPERATOR FAMILY alt_opf4 USING btree ADD STORAGE invalid_storage; -- Ensure STORAGE is not a part of ALTER OPERATOR FAMILY ERROR: STORAGE cannot be specified in ALTER OPERATOR FAMILY DROP OPERATOR FAMILY alt_opf4 USING btree; @@ -496,6 +497,19 @@ ALTER OPERATOR FAMILY alt_opf18 USING btree ADD ALTER OPERATOR FAMILY alt_opf18 USING btree DROP FUNCTION 2 (int4, int4); ERROR: function 2(integer,integer) does not exist in operator family "alt_opf18" DROP OPERATOR FAMILY alt_opf18 USING btree; +-- Should fail. Invalid opclass options function (#0) specifications. +CREATE OPERATOR FAMILY alt_opf19 USING btree; +ALTER OPERATOR FAMILY alt_opf19 USING btree ADD FUNCTION 0 test_opclass_options_func(internal, text[], bool); +ERROR: function test_opclass_options_func(internal, text[], boolean) does not exist +ALTER OPERATOR FAMILY alt_opf19 USING btree ADD FUNCTION 0 (int4) btint42cmp(int4, int2); +ERROR: invalid opclass options parsing function +HINT: opclass options parsing function must have signature '(internal) RETURNS void' +ALTER OPERATOR FAMILY alt_opf19 USING btree ADD FUNCTION 0 (int4, int2) btint42cmp(int4, int2); +ERROR: left and right associated data types for opclass options parsing functions must match +ALTER OPERATOR FAMILY alt_opf19 USING btree ADD FUNCTION 0 (int4) test_opclass_options_func(internal); -- Ok +ALTER OPERATOR FAMILY alt_opf19 USING btree DROP FUNCTION 0 (int4, int4); +ERROR: invalid function number 0, must be between 1 and 3 +DROP OPERATOR FAMILY alt_opf19 USING btree; -- -- Statistics -- diff --git a/src/test/regress/expected/btree_index.out b/src/test/regress/expected/btree_index.out index acab8e0..b4023de 100644 --- a/src/test/regress/expected/btree_index.out +++ b/src/test/regress/expected/btree_index.out @@ -262,3 +262,8 @@ VACUUM delete_test_table; -- The vacuum above should've turned the leaf page into a fast root. We just -- need to insert some rows to cause the fast root page to split. INSERT INTO delete_test_table SELECT i, 1, 2, 3 FROM generate_series(1,1000) i; +-- Test unsupported btree opclass parameters +create index on btree_tall_tbl (id int4_ops(foo=1)); +ERROR: operator class int4_ops has no options +create index on btree_tall_tbl (id default(foo=1)); +ERROR: operator class int4_ops has no options diff --git a/src/test/regress/expected/opr_sanity.out b/src/test/regress/expected/opr_sanity.out index 33c058f..1f53a9c 100644 --- a/src/test/regress/expected/opr_sanity.out +++ b/src/test/regress/expected/opr_sanity.out @@ -2054,7 +2054,7 @@ WHERE p1.amopopr = p2.oid AND p2.oprcode = p3.oid AND SELECT p1.amprocfamily, p1.amprocnum FROM pg_amproc as p1 WHERE p1.amprocfamily = 0 OR p1.amproclefttype = 0 OR p1.amprocrighttype = 0 - OR p1.amprocnum < 1 OR p1.amproc = 0; + OR p1.amprocnum < 0 OR p1.amproc = 0; amprocfamily | amprocnum --------------+----------- (0 rows) diff --git a/src/test/regress/input/create_function_1.source b/src/test/regress/input/create_function_1.source index 223454a..412e339 100644 --- a/src/test/regress/input/create_function_1.source +++ b/src/test/regress/input/create_function_1.source @@ -73,6 +73,11 @@ CREATE FUNCTION test_support_func(internal) AS '@libdir@/regress@DLSUFFIX@', 'test_support_func' LANGUAGE C STRICT; +CREATE FUNCTION test_opclass_options_func(internal) + RETURNS void + AS '@libdir@/regress@DLSUFFIX@', 'test_opclass_options_func' + LANGUAGE C; + -- Things that shouldn't work: CREATE FUNCTION test1 (int) RETURNS int LANGUAGE SQL diff --git a/src/test/regress/output/create_function_1.source b/src/test/regress/output/create_function_1.source index 5f43e8d..4d78fa1 100644 --- a/src/test/regress/output/create_function_1.source +++ b/src/test/regress/output/create_function_1.source @@ -64,6 +64,10 @@ CREATE FUNCTION test_support_func(internal) RETURNS internal AS '@libdir@/regress@DLSUFFIX@', 'test_support_func' LANGUAGE C STRICT; +CREATE FUNCTION test_opclass_options_func(internal) + RETURNS void + AS '@libdir@/regress@DLSUFFIX@', 'test_opclass_options_func' + LANGUAGE C; -- Things that shouldn't work: CREATE FUNCTION test1 (int) RETURNS int LANGUAGE SQL AS 'SELECT ''not an integer'';'; diff --git a/src/test/regress/regress.c b/src/test/regress/regress.c index 826556e..3ade2d6 100644 --- a/src/test/regress/regress.c +++ b/src/test/regress/regress.c @@ -940,3 +940,10 @@ test_support_func(PG_FUNCTION_ARGS) PG_RETURN_POINTER(ret); } + +PG_FUNCTION_INFO_V1(test_opclass_options_func); +Datum +test_opclass_options_func(PG_FUNCTION_ARGS) +{ + PG_RETURN_NULL(); +} diff --git a/src/test/regress/sql/alter_generic.sql b/src/test/regress/sql/alter_generic.sql index ce9dbb1..31ad01c 100644 --- a/src/test/regress/sql/alter_generic.sql +++ b/src/test/regress/sql/alter_generic.sql @@ -298,8 +298,8 @@ ALTER OPERATOR FAMILY alt_opf4 USING invalid_index_method ADD OPERATOR 1 < (int ALTER OPERATOR FAMILY alt_opf4 USING btree ADD OPERATOR 6 < (int4, int2); -- operator number should be between 1 and 5 ALTER OPERATOR FAMILY alt_opf4 USING btree ADD OPERATOR 0 < (int4, int2); -- operator number should be between 1 and 5 ALTER OPERATOR FAMILY alt_opf4 USING btree ADD OPERATOR 1 < ; -- operator without argument types -ALTER OPERATOR FAMILY alt_opf4 USING btree ADD FUNCTION 0 btint42cmp(int4, int2); -- function number should be between 1 and 5 -ALTER OPERATOR FAMILY alt_opf4 USING btree ADD FUNCTION 6 btint42cmp(int4, int2); -- function number should be between 1 and 5 +ALTER OPERATOR FAMILY alt_opf4 USING btree ADD FUNCTION 0 btint42cmp(int4, int2); -- invalid options parsing function +ALTER OPERATOR FAMILY alt_opf4 USING btree ADD FUNCTION 4 btint42cmp(int4, int2); -- function number should be between 0 and 3 ALTER OPERATOR FAMILY alt_opf4 USING btree ADD STORAGE invalid_storage; -- Ensure STORAGE is not a part of ALTER OPERATOR FAMILY DROP OPERATOR FAMILY alt_opf4 USING btree; @@ -433,6 +433,15 @@ ALTER OPERATOR FAMILY alt_opf18 USING btree ADD ALTER OPERATOR FAMILY alt_opf18 USING btree DROP FUNCTION 2 (int4, int4); DROP OPERATOR FAMILY alt_opf18 USING btree; +-- Should fail. Invalid opclass options function (#0) specifications. +CREATE OPERATOR FAMILY alt_opf19 USING btree; +ALTER OPERATOR FAMILY alt_opf19 USING btree ADD FUNCTION 0 test_opclass_options_func(internal, text[], bool); +ALTER OPERATOR FAMILY alt_opf19 USING btree ADD FUNCTION 0 (int4) btint42cmp(int4, int2); +ALTER OPERATOR FAMILY alt_opf19 USING btree ADD FUNCTION 0 (int4, int2) btint42cmp(int4, int2); +ALTER OPERATOR FAMILY alt_opf19 USING btree ADD FUNCTION 0 (int4) test_opclass_options_func(internal); -- Ok +ALTER OPERATOR FAMILY alt_opf19 USING btree DROP FUNCTION 0 (int4, int4); +DROP OPERATOR FAMILY alt_opf19 USING btree; + -- -- Statistics -- diff --git a/src/test/regress/sql/btree_index.sql b/src/test/regress/sql/btree_index.sql index 48eaf4f..7290c86 100644 --- a/src/test/regress/sql/btree_index.sql +++ b/src/test/regress/sql/btree_index.sql @@ -140,3 +140,7 @@ VACUUM delete_test_table; -- The vacuum above should've turned the leaf page into a fast root. We just -- need to insert some rows to cause the fast root page to split. INSERT INTO delete_test_table SELECT i, 1, 2, 3 FROM generate_series(1,1000) i; + +-- Test unsupported btree opclass parameters +create index on btree_tall_tbl (id int4_ops(foo=1)); +create index on btree_tall_tbl (id default(foo=1)); diff --git a/src/test/regress/sql/opr_sanity.sql b/src/test/regress/sql/opr_sanity.sql index 1227ef7..cee6a40 100644 --- a/src/test/regress/sql/opr_sanity.sql +++ b/src/test/regress/sql/opr_sanity.sql @@ -1306,7 +1306,7 @@ WHERE p1.amopopr = p2.oid AND p2.oprcode = p3.oid AND SELECT p1.amprocfamily, p1.amprocnum FROM pg_amproc as p1 WHERE p1.amprocfamily = 0 OR p1.amproclefttype = 0 OR p1.amprocrighttype = 0 - OR p1.amprocnum < 1 OR p1.amproc = 0; + OR p1.amprocnum < 0 OR p1.amproc = 0; -- Support routines that are primary members of opfamilies must be immutable -- (else it suggests that the index ordering isn't fixed). But cross-type -- 2.7.4