From 8ca761b060b05ce189da3048077809373e996b84 Mon Sep 17 00:00:00 2001 From: Pavel Borisov Date: Thu, 4 Apr 2024 13:35:29 +0400 Subject: [PATCH v9] Custom reloptions for table AM Let table AM define custom reloptions for its tables. This allows to specify AM-specific parameters by WITH clause when creating a table. Reloptions are split into common for all tables and table am specific that are parsed and accessed only by table am functions. The code may use some parts from prior work by Hao Wu. --- src/backend/access/common/reloptions.c | 111 +++++++++++------- src/backend/access/heap/heapam.c | 2 +- src/backend/access/heap/heapam_handler.c | 12 ++ src/backend/access/heap/heaptoast.c | 9 +- src/backend/access/heap/hio.c | 2 +- src/backend/access/heap/pruneheap.c | 2 +- src/backend/access/heap/rewriteheap.c | 2 +- src/backend/access/table/tableam.c | 2 +- src/backend/access/table/tableamapi.c | 25 ++++ src/backend/commands/createas.c | 13 ++- src/backend/commands/tablecmds.c | 63 ++++++---- src/backend/commands/vacuum.c | 8 +- src/backend/postmaster/autovacuum.c | 8 +- src/backend/tcop/utility.c | 9 +- src/backend/utils/cache/relcache.c | 14 ++- src/include/access/reloptions.h | 7 +- src/include/access/tableam.h | 44 +++++++ src/include/utils/rel.h | 140 ++++++++++++----------- 18 files changed, 320 insertions(+), 153 deletions(-) diff --git a/src/backend/access/common/reloptions.c b/src/backend/access/common/reloptions.c index d6eb5d8559..1055b397ef 100644 --- a/src/backend/access/common/reloptions.c +++ b/src/backend/access/common/reloptions.c @@ -24,6 +24,7 @@ #include "access/nbtree.h" #include "access/reloptions.h" #include "access/spgist_private.h" +#include "access/tableam.h" #include "catalog/pg_type.h" #include "commands/defrem.h" #include "commands/tablespace.h" @@ -44,7 +45,7 @@ * value, upper and lower bounds (if applicable); for strings, consider a * validation routine. * (ii) add a record below (or use add__reloption). - * (iii) add it to the appropriate options struct (perhaps StdRdOptions) + * (iii) add it to the appropriate options struct (perhaps commonReloptions) * (iv) add it to the appropriate handling routine (perhaps * default_reloptions) * (v) make sure the lock level is set correctly for that operation @@ -1374,10 +1375,16 @@ untransformRelOptions(Datum options) * tupdesc is pg_class' tuple descriptor. amoptions is a pointer to the index * AM's options parser function in the case of a tuple corresponding to an * index, or NULL otherwise. + * + * common_reloptions should be provided NULL if we don't need to get reloptions, just validate + * If we provide not NULL, then table am will fill *common_reloptions with parsed list or NULL. + * NULL in *common_reloptions means the caller should use defaults. */ + bytea * extractRelOptions(HeapTuple tuple, TupleDesc tupdesc, - amoptions_function amoptions) + const TableAmRoutine *tableam, amoptions_function amoptions, + commonReloptions **common_reloptions) { bytea *options; bool isnull; @@ -1399,7 +1406,8 @@ extractRelOptions(HeapTuple tuple, TupleDesc tupdesc, case RELKIND_RELATION: case RELKIND_TOASTVALUE: case RELKIND_MATVIEW: - options = heap_reloptions(classForm->relkind, datum, false); + options = tableam_reloptions(tableam, classForm->relkind, + datum, common_reloptions, false); break; case RELKIND_PARTITIONED_TABLE: options = partitioned_table_reloptions(datum, false); @@ -1695,7 +1703,7 @@ parse_one_reloption(relopt_value *option, char *text_str, int text_len, * Given the result from parseRelOptions, allocate a struct that's of the * specified base size plus any extra space that's needed for string variables. * - * "base" should be sizeof(struct) of the reloptions struct (StdRdOptions or + * "base" should be sizeof(struct) of the reloptions struct (commonReloptions or * equivalent). */ static void * @@ -1750,7 +1758,6 @@ fillRelOptions(void *rdopts, Size basesize, for (i = 0; i < numoptions; i++) { int j; - bool found = false; for (j = 0; j < numelems; j++) { @@ -1819,72 +1826,65 @@ fillRelOptions(void *rdopts, Size basesize, options[i].gen->type); break; } - found = true; break; } } - if (validate && !found) - elog(ERROR, "reloption \"%s\" not found in parse table", - options[i].gen->name); } SET_VARSIZE(rdopts, offset); } /* - * Option parser for anything that uses StdRdOptions. + * Option parser for anything that uses commonReloptions. */ bytea * default_reloptions(Datum reloptions, bool validate, relopt_kind kind) { static const relopt_parse_elt tab[] = { - {"fillfactor", RELOPT_TYPE_INT, offsetof(StdRdOptions, fillfactor)}, {"autovacuum_enabled", RELOPT_TYPE_BOOL, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, enabled)}, + offsetof(commonReloptions, autovacuum) + offsetof(AutoVacOpts, enabled)}, {"autovacuum_vacuum_threshold", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_threshold)}, + offsetof(commonReloptions, autovacuum) + offsetof(AutoVacOpts, vacuum_threshold)}, {"autovacuum_vacuum_insert_threshold", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_ins_threshold)}, + offsetof(commonReloptions, autovacuum) + offsetof(AutoVacOpts, vacuum_ins_threshold)}, {"autovacuum_analyze_threshold", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_threshold)}, + offsetof(commonReloptions, autovacuum) + offsetof(AutoVacOpts, analyze_threshold)}, {"autovacuum_vacuum_cost_limit", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_limit)}, + offsetof(commonReloptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_limit)}, {"autovacuum_freeze_min_age", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_min_age)}, + offsetof(commonReloptions, autovacuum) + offsetof(AutoVacOpts, freeze_min_age)}, {"autovacuum_freeze_max_age", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_max_age)}, + offsetof(commonReloptions, autovacuum) + offsetof(AutoVacOpts, freeze_max_age)}, {"autovacuum_freeze_table_age", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_table_age)}, + offsetof(commonReloptions, autovacuum) + offsetof(AutoVacOpts, freeze_table_age)}, {"autovacuum_multixact_freeze_min_age", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_min_age)}, + offsetof(commonReloptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_min_age)}, {"autovacuum_multixact_freeze_max_age", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_max_age)}, + offsetof(commonReloptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_max_age)}, {"autovacuum_multixact_freeze_table_age", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_table_age)}, + offsetof(commonReloptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_table_age)}, {"log_autovacuum_min_duration", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, log_min_duration)}, - {"toast_tuple_target", RELOPT_TYPE_INT, - offsetof(StdRdOptions, toast_tuple_target)}, + offsetof(commonReloptions, autovacuum) + offsetof(AutoVacOpts, log_min_duration)}, {"autovacuum_vacuum_cost_delay", RELOPT_TYPE_REAL, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_delay)}, + offsetof(commonReloptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_delay)}, {"autovacuum_vacuum_scale_factor", RELOPT_TYPE_REAL, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_scale_factor)}, + offsetof(commonReloptions, autovacuum) + offsetof(AutoVacOpts, vacuum_scale_factor)}, {"autovacuum_vacuum_insert_scale_factor", RELOPT_TYPE_REAL, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_ins_scale_factor)}, + offsetof(commonReloptions, autovacuum) + offsetof(AutoVacOpts, vacuum_ins_scale_factor)}, {"autovacuum_analyze_scale_factor", RELOPT_TYPE_REAL, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_scale_factor)}, + offsetof(commonReloptions, autovacuum) + offsetof(AutoVacOpts, analyze_scale_factor)}, {"user_catalog_table", RELOPT_TYPE_BOOL, - offsetof(StdRdOptions, user_catalog_table)}, + offsetof(commonReloptions, user_catalog_table)}, {"parallel_workers", RELOPT_TYPE_INT, - offsetof(StdRdOptions, parallel_workers)}, + offsetof(commonReloptions, parallel_workers)}, {"vacuum_index_cleanup", RELOPT_TYPE_ENUM, - offsetof(StdRdOptions, vacuum_index_cleanup)}, + offsetof(commonReloptions, vacuum_index_cleanup)}, {"vacuum_truncate", RELOPT_TYPE_BOOL, - offsetof(StdRdOptions, vacuum_truncate)} + offsetof(commonReloptions, vacuum_truncate)} }; return (bytea *) build_reloptions(reloptions, validate, kind, - sizeof(StdRdOptions), + sizeof(commonReloptions), tab, lengthof(tab)); } @@ -1917,7 +1917,6 @@ build_reloptions(Datum reloptions, bool validate, /* parse options specific to given relation option kind */ options = parseRelOptions(reloptions, validate, kind, &numoptions); - Assert(numoptions <= num_relopt_elems); /* if none set, we're done */ if (numoptions == 0) @@ -2016,30 +2015,60 @@ view_reloptions(Datum reloptions, bool validate) * Parse options for heaps, views and toast tables. */ bytea * -heap_reloptions(char relkind, Datum reloptions, bool validate) +heap_reloptions(char relkind, Datum reloptions, commonReloptions **common_reloptions, bool validate) { - StdRdOptions *rdopts; + commonReloptions *rdopts; + heapReloptions *hopts; + static const relopt_parse_elt tab[] = { + {"fillfactor", RELOPT_TYPE_INT, offsetof(heapReloptions, fillfactor)}, + {"toast_tuple_target", RELOPT_TYPE_INT, + offsetof(heapReloptions, toast_tuple_target)}, + }; switch (relkind) { case RELKIND_TOASTVALUE: - rdopts = (StdRdOptions *) + rdopts = (commonReloptions *) default_reloptions(reloptions, validate, RELOPT_KIND_TOAST); if (rdopts != NULL) { /* adjust default-only parameters for TOAST relations */ - rdopts->fillfactor = 100; rdopts->autovacuum.analyze_threshold = -1; rdopts->autovacuum.analyze_scale_factor = -1; } - return (bytea *) rdopts; + hopts = (heapReloptions *) build_reloptions(reloptions, validate, + RELOPT_KIND_TOAST, + sizeof(heapReloptions), + tab, lengthof(tab)); + if (hopts != NULL) + { + /* adjust default-only parameters for TOAST relations */ + hopts->fillfactor = 100; + } + break; case RELKIND_RELATION: case RELKIND_MATVIEW: - return default_reloptions(reloptions, validate, RELOPT_KIND_HEAP); + rdopts = (commonReloptions *) default_reloptions(reloptions, validate, RELOPT_KIND_HEAP); + hopts = (heapReloptions *) build_reloptions(reloptions, validate, + RELOPT_KIND_HEAP, + sizeof(heapReloptions), + tab, lengthof(tab)); + break; default: /* other relkinds are not supported */ return NULL; } + + /* + * Get here only to validate and do not care about output values of both + * heapReloptions and commonReloptions. + */ + if (common_reloptions == NULL) + return NULL; + + *common_reloptions = rdopts; + + return (bytea *)hopts; } diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c index dada2ecd1e..404b92d1cc 100644 --- a/src/backend/access/heap/heapam.c +++ b/src/backend/access/heap/heapam.c @@ -2129,7 +2129,7 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples, Assert(!(options & HEAP_INSERT_NO_LOGICAL)); needwal = RelationNeedsWAL(relation); - saveFreeSpace = RelationGetTargetPageFreeSpace(relation, + saveFreeSpace = HeapGetTargetPageFreeSpace(relation, HEAP_DEFAULT_FILLFACTOR); /* Toast and set header data in all the slots */ diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c index 3e7a6b5548..961512df9c 100644 --- a/src/backend/access/heap/heapam_handler.c +++ b/src/backend/access/heap/heapam_handler.c @@ -23,6 +23,7 @@ #include "access/heapam.h" #include "access/heaptoast.h" #include "access/multixact.h" +#include "access/reloptions.h" #include "access/rewriteheap.h" #include "access/syncscan.h" #include "access/tableam.h" @@ -2157,6 +2158,16 @@ heapam_relation_toast_am(Relation rel) return rel->rd_rel->relam; } +static bytea * +heapam_reloptions(char relkind, Datum reloptions, commonReloptions **common_reloptions, bool validate) +{ + Assert(relkind == RELKIND_RELATION || + relkind == RELKIND_TOASTVALUE || + relkind == RELKIND_MATVIEW); + + return heap_reloptions(relkind, reloptions, common_reloptions, validate); +} + /* ------------------------------------------------------------------------ * Planner related callbacks for the heap AM @@ -2678,6 +2689,7 @@ static const TableAmRoutine heapam_methods = { .relation_needs_toast_table = heapam_relation_needs_toast_table, .relation_toast_am = heapam_relation_toast_am, .relation_fetch_toast_slice = heap_fetch_toast_slice, + .reloptions = heapam_reloptions, .relation_estimate_size = heapam_estimate_rel_size, diff --git a/src/backend/access/heap/heaptoast.c b/src/backend/access/heap/heaptoast.c index a420e16530..74517e0a7e 100644 --- a/src/backend/access/heap/heaptoast.c +++ b/src/backend/access/heap/heaptoast.c @@ -32,6 +32,13 @@ #include "access/toast_internals.h" #include "utils/fmgroids.h" +/* + * HeapGetToastTupleTarget + * Returns the heap relation's toast_tuple_target. Note multiple eval of argument! + */ +#define HeapGetToastTupleTarget(relation, defaulttarg) \ + ((heapReloptions *) (relation)->rd_options ? \ + ((heapReloptions *) (relation)->rd_options)->toast_tuple_target : (defaulttarg)) /* ---------- * heap_toast_delete - @@ -174,7 +181,7 @@ heap_toast_insert_or_update(Relation rel, HeapTuple newtup, HeapTuple oldtup, hoff += BITMAPLEN(numAttrs); hoff = MAXALIGN(hoff); /* now convert to a limit on the tuple data size */ - maxDataLen = RelationGetToastTupleTarget(rel, TOAST_TUPLE_TARGET) - hoff; + maxDataLen = HeapGetToastTupleTarget(rel, TOAST_TUPLE_TARGET) - hoff; /* * Look for attributes with attstorage EXTENDED to compress. Also find diff --git a/src/backend/access/heap/hio.c b/src/backend/access/heap/hio.c index 7c662cdf46..6c46a7759b 100644 --- a/src/backend/access/heap/hio.c +++ b/src/backend/access/heap/hio.c @@ -536,7 +536,7 @@ RelationGetBufferForTuple(Relation relation, Size len, len, MaxHeapTupleSize))); /* Compute desired extra freespace due to fillfactor option */ - saveFreeSpace = RelationGetTargetPageFreeSpace(relation, + saveFreeSpace = HeapGetTargetPageFreeSpace(relation, HEAP_DEFAULT_FILLFACTOR); /* diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/heap/pruneheap.c index d2eecaf7eb..98f5af76db 100644 --- a/src/backend/access/heap/pruneheap.c +++ b/src/backend/access/heap/pruneheap.c @@ -235,7 +235,7 @@ heap_page_prune_opt(Relation relation, Buffer buffer) * important than sometimes getting a wrong answer in what is after all * just a heuristic estimate. */ - minfree = RelationGetTargetPageFreeSpace(relation, + minfree = HeapGetTargetPageFreeSpace(relation, HEAP_DEFAULT_FILLFACTOR); minfree = Max(minfree, BLCKSZ / 10); diff --git a/src/backend/access/heap/rewriteheap.c b/src/backend/access/heap/rewriteheap.c index 473f3aa9be..0801af0558 100644 --- a/src/backend/access/heap/rewriteheap.c +++ b/src/backend/access/heap/rewriteheap.c @@ -641,7 +641,7 @@ raw_heap_insert(RewriteState state, HeapTuple tup) len, MaxHeapTupleSize))); /* Compute desired extra freespace due to fillfactor option */ - saveFreeSpace = RelationGetTargetPageFreeSpace(state->rs_new_rel, + saveFreeSpace = HeapGetTargetPageFreeSpace(state->rs_new_rel, HEAP_DEFAULT_FILLFACTOR); /* Now we can check to see if there's enough free space already. */ diff --git a/src/backend/access/table/tableam.c b/src/backend/access/table/tableam.c index 805d222ceb..5d5f0e68fd 100644 --- a/src/backend/access/table/tableam.c +++ b/src/backend/access/table/tableam.c @@ -750,7 +750,7 @@ table_block_relation_estimate_size(Relation rel, int32 *attr_widths, * The other branch considers it implicitly by calculating density * from actual relpages/reltuples statistics. */ - fillfactor = RelationGetFillFactor(rel, HEAP_DEFAULT_FILLFACTOR); + fillfactor = HeapGetFillFactor(rel, HEAP_DEFAULT_FILLFACTOR); tuple_width = get_rel_data_width(rel, attr_widths); tuple_width += overhead_bytes_per_tuple; diff --git a/src/backend/access/table/tableamapi.c b/src/backend/access/table/tableamapi.c index 55b8caeadf..d9e23ef317 100644 --- a/src/backend/access/table/tableamapi.c +++ b/src/backend/access/table/tableamapi.c @@ -13,9 +13,11 @@ #include "access/tableam.h" #include "access/xact.h" +#include "catalog/pg_am.h" #include "commands/defrem.h" #include "miscadmin.h" #include "utils/guc_hooks.h" +#include "utils/syscache.h" /* @@ -98,6 +100,29 @@ GetTableAmRoutine(Oid amhandler) return routine; } +/* + * GetTableAmRoutineByAmOid + * Given the table access method oid get its TableAmRoutine struct, which + * will be palloc'd in the caller's memory context. + */ +const TableAmRoutine * +GetTableAmRoutineByAmOid(Oid amoid) +{ + HeapTuple ht_am; + Form_pg_am amrec; + const TableAmRoutine *tableam = NULL; + + ht_am = SearchSysCache1(AMOID, ObjectIdGetDatum(amoid)); + if (!HeapTupleIsValid(ht_am)) + elog(ERROR, "cache lookup failed for access method %u", + amoid); + amrec = (Form_pg_am) GETSTRUCT(ht_am); + + tableam = GetTableAmRoutine(amrec->amhandler); + ReleaseSysCache(ht_am); + return tableam; +} + /* check_hook: validate new default_table_access_method */ bool check_default_table_access_method(char **newval, void **extra, GucSource source) diff --git a/src/backend/commands/createas.c b/src/backend/commands/createas.c index afd3dace07..d5a7d726f9 100644 --- a/src/backend/commands/createas.c +++ b/src/backend/commands/createas.c @@ -85,6 +85,9 @@ create_ctas_internal(List *attrList, IntoClause *into) Datum toast_options; static char *validnsps[] = HEAP_RELOPT_NAMESPACES; ObjectAddress intoRelationAddr; + const TableAmRoutine *tableam = NULL; + Oid accessMethodId = InvalidOid; + Relation rel; /* This code supports both CREATE TABLE AS and CREATE MATERIALIZED VIEW */ is_matview = (into->viewQuery != NULL); @@ -125,7 +128,15 @@ create_ctas_internal(List *attrList, IntoClause *into) validnsps, true, false); - (void) heap_reloptions(RELKIND_TOASTVALUE, toast_options, true); + rel = relation_open(intoRelationAddr.objectId, AccessShareLock); + accessMethodId = table_relation_toast_am(rel); + relation_close(rel, AccessShareLock); + + if(OidIsValid(accessMethodId)) + { + tableam = GetTableAmRoutineByAmOid(accessMethodId); + (void) tableam_reloptions(tableam, RELKIND_TOASTVALUE, toast_options, NULL, true); + } NewRelationCreateToastTable(intoRelationAddr.objectId, toast_options); diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c index 317b89f67c..de1a126cee 100644 --- a/src/backend/commands/tablecmds.c +++ b/src/backend/commands/tablecmds.c @@ -715,6 +715,7 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId, ObjectAddress address; LOCKMODE parentLockmode; Oid accessMethodId = InvalidOid; + const TableAmRoutine *tableam = NULL; /* * Truncate relname to appropriate length (probably a waste of time, as @@ -850,6 +851,28 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId, if (!OidIsValid(ownerId)) ownerId = GetUserId(); + /* + * For relations with table AM and partitioned tables, select access + * method to use: an explicitly indicated one, or (in the case of a + * partitioned table) the parent's, if it has one. + */ + if (stmt->accessMethod != NULL) + { + Assert(RELKIND_HAS_TABLE_AM(relkind) || relkind == RELKIND_PARTITIONED_TABLE); + accessMethodId = get_table_am_oid(stmt->accessMethod, false); + } + else if (RELKIND_HAS_TABLE_AM(relkind) || relkind == RELKIND_PARTITIONED_TABLE) + { + if (stmt->partbound) + { + Assert(list_length(inheritOids) == 1); + accessMethodId = get_rel_relam(linitial_oid(inheritOids)); + } + + if (RELKIND_HAS_TABLE_AM(relkind) && !OidIsValid(accessMethodId)) + accessMethodId = get_table_am_oid(default_table_access_method, false); + } + /* * Parse and validate reloptions, if any. */ @@ -858,6 +881,12 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId, switch (relkind) { + case RELKIND_RELATION: + case RELKIND_TOASTVALUE: + case RELKIND_MATVIEW: + tableam = GetTableAmRoutineByAmOid(accessMethodId); + (void) tableam_reloptions(tableam, relkind, reloptions, NULL, true); + break; case RELKIND_VIEW: (void) view_reloptions(reloptions, true); break; @@ -865,7 +894,12 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId, (void) partitioned_table_reloptions(reloptions, true); break; default: - (void) heap_reloptions(relkind, reloptions, true); + if (OidIsValid(accessMethodId)) + { + tableam = GetTableAmRoutineByAmOid(accessMethodId); + (void) tableam_reloptions(tableam, relkind, reloptions, NULL, true); + } + break; } if (stmt->ofTypename) @@ -957,28 +991,6 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId, } } - /* - * For relations with table AM and partitioned tables, select access - * method to use: an explicitly indicated one, or (in the case of a - * partitioned table) the parent's, if it has one. - */ - if (stmt->accessMethod != NULL) - { - Assert(RELKIND_HAS_TABLE_AM(relkind) || relkind == RELKIND_PARTITIONED_TABLE); - accessMethodId = get_table_am_oid(stmt->accessMethod, false); - } - else if (RELKIND_HAS_TABLE_AM(relkind) || relkind == RELKIND_PARTITIONED_TABLE) - { - if (stmt->partbound) - { - Assert(list_length(inheritOids) == 1); - accessMethodId = get_rel_relam(linitial_oid(inheritOids)); - } - - if (RELKIND_HAS_TABLE_AM(relkind) && !OidIsValid(accessMethodId)) - accessMethodId = get_table_am_oid(default_table_access_method, false); - } - /* * Create the relation. Inherited defaults and constraints are passed in * for immediate handling --- since they don't need parsing, they can be @@ -15528,7 +15540,8 @@ ATExecSetRelOptions(Relation rel, List *defList, AlterTableType operation, case RELKIND_RELATION: case RELKIND_TOASTVALUE: case RELKIND_MATVIEW: - (void) heap_reloptions(rel->rd_rel->relkind, newOptions, true); + (void) table_reloptions(rel, rel->rd_rel->relkind, + newOptions, NULL, true); break; case RELKIND_PARTITIONED_TABLE: (void) partitioned_table_reloptions(newOptions, true); @@ -15641,7 +15654,7 @@ ATExecSetRelOptions(Relation rel, List *defList, AlterTableType operation, defList, "toast", validnsps, false, operation == AT_ResetRelOptions); - (void) heap_reloptions(RELKIND_TOASTVALUE, newOptions, true); + (void) table_reloptions(rel, RELKIND_TOASTVALUE, newOptions, NULL, true); memset(repl_val, 0, sizeof(repl_val)); memset(repl_null, false, sizeof(repl_null)); diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c index b589279d49..9d2ad3e216 100644 --- a/src/backend/commands/vacuum.c +++ b/src/backend/commands/vacuum.c @@ -2121,11 +2121,11 @@ vacuum_rel(Oid relid, RangeVar *relation, VacuumParams *params, { StdRdOptIndexCleanup vacuum_index_cleanup; - if (rel->rd_options == NULL) + if (rel->rd_common_options == NULL) vacuum_index_cleanup = STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO; else vacuum_index_cleanup = - ((StdRdOptions *) rel->rd_options)->vacuum_index_cleanup; + rel->rd_common_options->vacuum_index_cleanup; if (vacuum_index_cleanup == STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO) params->index_cleanup = VACOPTVALUE_AUTO; @@ -2145,8 +2145,8 @@ vacuum_rel(Oid relid, RangeVar *relation, VacuumParams *params, */ if (params->truncate == VACOPTVALUE_UNSPECIFIED) { - if (rel->rd_options == NULL || - ((StdRdOptions *) rel->rd_options)->vacuum_truncate) + if (rel->rd_common_options == NULL || + (rel->rd_common_options->vacuum_truncate)) params->truncate = VACOPTVALUE_ENABLED; else params->truncate = VACOPTVALUE_DISABLED; diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c index c367ede6f8..9f0d56abca 100644 --- a/src/backend/postmaster/autovacuum.c +++ b/src/backend/postmaster/autovacuum.c @@ -2673,19 +2673,21 @@ deleted2: static AutoVacOpts * extract_autovac_opts(HeapTuple tup, TupleDesc pg_class_desc) { - bytea *relopts; + commonReloptions *relopts; AutoVacOpts *av; Assert(((Form_pg_class) GETSTRUCT(tup))->relkind == RELKIND_RELATION || ((Form_pg_class) GETSTRUCT(tup))->relkind == RELKIND_MATVIEW || ((Form_pg_class) GETSTRUCT(tup))->relkind == RELKIND_TOASTVALUE); - relopts = extractRelOptions(tup, pg_class_desc, NULL); + (void) extractRelOptions(tup, pg_class_desc, + GetTableAmRoutineByAmOid(((Form_pg_class) GETSTRUCT(tup))->relam), + NULL, &relopts); if (relopts == NULL) return NULL; av = palloc(sizeof(AutoVacOpts)); - memcpy(av, &(((StdRdOptions *) relopts)->autovacuum), sizeof(AutoVacOpts)); + memcpy(av, &(relopts->autovacuum), sizeof(AutoVacOpts)); pfree(relopts); return av; diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c index fa66b8017e..b1d88133dd 100644 --- a/src/backend/tcop/utility.c +++ b/src/backend/tcop/utility.c @@ -1156,6 +1156,8 @@ ProcessUtilitySlow(ParseState *pstate, CreateStmt *cstmt = (CreateStmt *) stmt; Datum toast_options; static char *validnsps[] = HEAP_RELOPT_NAMESPACES; + const TableAmRoutine *tableam = NULL; + Oid accessMethodId; /* Remember transformed RangeVar for LIKE */ table_rv = cstmt->relation; @@ -1185,8 +1187,13 @@ ProcessUtilitySlow(ParseState *pstate, validnsps, true, false); - (void) heap_reloptions(RELKIND_TOASTVALUE, + + /* TOAST has default access method */ + accessMethodId = get_table_am_oid(default_table_access_method, false); + tableam = GetTableAmRoutineByAmOid(accessMethodId); + (void) tableam_reloptions(tableam, RELKIND_TOASTVALUE, toast_options, + NULL, true); NewRelationCreateToastTable(address.objectId, diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c index 3fe74dabd0..3d7e97d09f 100644 --- a/src/backend/utils/cache/relcache.c +++ b/src/backend/utils/cache/relcache.c @@ -33,6 +33,7 @@ #include "access/htup_details.h" #include "access/multixact.h" #include "access/parallel.h" +#include "access/relation.h" #include "access/reloptions.h" #include "access/sysattr.h" #include "access/table.h" @@ -464,8 +465,11 @@ RelationParseRelOptions(Relation relation, HeapTuple tuple) { bytea *options; amoptions_function amoptsfn; + const TableAmRoutine *tableam = NULL; + commonReloptions *common_reloptions = NULL; relation->rd_options = NULL; + relation->rd_common_options = NULL; /* * Look up any AM-specific parse function; fall out if relkind should not @@ -478,6 +482,7 @@ RelationParseRelOptions(Relation relation, HeapTuple tuple) case RELKIND_VIEW: case RELKIND_MATVIEW: case RELKIND_PARTITIONED_TABLE: + tableam = relation->rd_tableam; amoptsfn = NULL; break; case RELKIND_INDEX: @@ -493,7 +498,14 @@ RelationParseRelOptions(Relation relation, HeapTuple tuple) * we might not have any other for pg_class yet (consider executing this * code for pg_class itself) */ - options = extractRelOptions(tuple, GetPgClassDescriptor(), amoptsfn); + options = extractRelOptions(tuple, GetPgClassDescriptor(), + tableam, amoptsfn, &common_reloptions); + + if (common_reloptions) + { + relation->rd_common_options = MemoryContextAlloc(CacheMemoryContext, sizeof(struct commonReloptions)); + memcpy(relation->rd_common_options, common_reloptions, sizeof(struct commonReloptions)); + } /* * Copy parsed data into CacheMemoryContext. To guard against the diff --git a/src/include/access/reloptions.h b/src/include/access/reloptions.h index 81829b8270..c6d74d1a88 100644 --- a/src/include/access/reloptions.h +++ b/src/include/access/reloptions.h @@ -21,6 +21,7 @@ #include "access/amapi.h" #include "access/htup.h" +#include "access/tableam.h" #include "access/tupdesc.h" #include "nodes/pg_list.h" #include "storage/lock.h" @@ -224,7 +225,9 @@ extern Datum transformRelOptions(Datum oldOptions, List *defList, bool acceptOidsOff, bool isReset); extern List *untransformRelOptions(Datum options); extern bytea *extractRelOptions(HeapTuple tuple, TupleDesc tupdesc, - amoptions_function amoptions); + const TableAmRoutine *tableam, + amoptions_function amoptions, + commonReloptions **common_reloptions); extern void *build_reloptions(Datum reloptions, bool validate, relopt_kind kind, Size relopt_struct_size, @@ -235,7 +238,7 @@ extern void *build_local_reloptions(local_relopts *relopts, Datum options, extern bytea *default_reloptions(Datum reloptions, bool validate, relopt_kind kind); -extern bytea *heap_reloptions(char relkind, Datum reloptions, bool validate); +extern bytea *heap_reloptions(char relkind, Datum reloptions, commonReloptions **common_reloptions, bool validate); extern bytea *view_reloptions(Datum reloptions, bool validate); extern bytea *partitioned_table_reloptions(Datum reloptions, bool validate); extern bytea *index_reloptions(amoptions_function amoptions, Datum reloptions, diff --git a/src/include/access/tableam.h b/src/include/access/tableam.h index e7eeb75409..437e18f9b4 100644 --- a/src/include/access/tableam.h +++ b/src/include/access/tableam.h @@ -739,6 +739,29 @@ typedef struct TableAmRoutine int32 slicelength, struct varlena *result); + /* + * This callback parses and validates the reloptions array for a table. + * + * This is called only when a non-null reloptions array exists for the + * table. 'reloptions' is a text array containing entries of the form + * "name=value". The function should construct a bytea value, which will + * be copied into the rd_options field of the table's relcache entry. The + * data contents of the bytea value are open for the access method to + * define. + * + * When 'validate' is true, the function should report a suitable error + * message if any of the options are unrecognized or have invalid values; + * when 'validate' is false, invalid entries should be silently ignored. + * ('validate' is false when loading options already stored in pg_catalog; + * an invalid entry could only be found if the access method has changed + * its rules for options, and in that case ignoring obsolete entries is + * appropriate.) + * + * It is OK to return NULL if default behavior is wanted. + */ + bytea *(*reloptions) (char relkind, Datum reloptions, + commonReloptions **common_reloptions, bool validate); + /* ------------------------------------------------------------------------ * Planner related functions. @@ -1935,6 +1958,26 @@ table_relation_fetch_toast_slice(Relation toastrel, Oid valueid, result); } +/* + * Parse options for given table. + */ +static inline bytea * +table_reloptions(Relation rel, char relkind, + Datum reloptions, commonReloptions **common_reloptions, bool validate) +{ + return rel->rd_tableam->reloptions(relkind, reloptions, common_reloptions, validate); +} + +/* + * Parse table options without knowledge of particular table. + */ +static inline bytea * +tableam_reloptions(const TableAmRoutine *tableam, char relkind, + Datum reloptions, commonReloptions **common_reloptions, bool validate) +{ + return tableam->reloptions(relkind, reloptions, common_reloptions, validate); +} + /* ---------------------------------------------------------------------------- * Planner related functionality @@ -2113,6 +2156,7 @@ extern void table_block_relation_estimate_size(Relation rel, */ extern const TableAmRoutine *GetTableAmRoutine(Oid amhandler); +extern const TableAmRoutine *GetTableAmRoutineByAmOid(Oid amoid); /* ---------------------------------------------------------------------------- * Functions in heapam_handler.c diff --git a/src/include/utils/rel.h b/src/include/utils/rel.h index f25f769af2..8dfb94a365 100644 --- a/src/include/utils/rel.h +++ b/src/include/utils/rel.h @@ -48,6 +48,50 @@ typedef struct LockInfoData typedef LockInfoData *LockInfo; + /* autovacuum-related reloptions. */ +typedef struct AutoVacOpts +{ + bool enabled; + int vacuum_threshold; + int vacuum_ins_threshold; + int analyze_threshold; + int vacuum_cost_limit; + int freeze_min_age; + int freeze_max_age; + int freeze_table_age; + int multixact_freeze_min_age; + int multixact_freeze_max_age; + int multixact_freeze_table_age; + int log_min_duration; + float8 vacuum_cost_delay; + float8 vacuum_scale_factor; + float8 vacuum_ins_scale_factor; + float8 analyze_scale_factor; +} AutoVacOpts; + +/* StdRdOptions->vacuum_index_cleanup values */ +typedef enum StdRdOptIndexCleanup +{ + STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO = 0, + STDRD_OPTION_VACUUM_INDEX_CLEANUP_OFF, + STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON, +} StdRdOptIndexCleanup; + +/* + * commonReloptions + * Contents of rd_common_options for tables. + */ +typedef struct commonReloptions +{ + int32 vl_len_; /* maybe not needed */ + AutoVacOpts autovacuum; /* autovacuum-related options */ + bool user_catalog_table; /* use as an additional catalog relation */ + int parallel_workers; /* max number of parallel workers */ + StdRdOptIndexCleanup vacuum_index_cleanup; /* controls index vacuuming */ + bool vacuum_truncate; /* enables vacuum to truncate a relation */ +} commonReloptions; + + /* * Here are the contents of a relation cache entry. */ @@ -168,11 +212,16 @@ typedef struct RelationData PublicationDesc *rd_pubdesc; /* publication descriptor, or NULL */ /* - * rd_options is set whenever rd_rel is loaded into the relcache entry. - * Note that you can NOT look into rd_rel for this data. NULL means "use - * defaults". + * rd_options and rd_common_options are set whenever rd_rel is loaded into + * the relcache entry. Note that you can NOT look into rd_rel for this data. + * NULLs means "use defaults". + */ + commonReloptions *rd_common_options; /* parsed pg_class.reloptions common for all tables */ + /* + * am-specific part of pg_class.reloptions parsed by table am specific structure + * (e.g. struct heapReloptions) Contents are not to be accessed outside of table am */ - bytea *rd_options; /* parsed pg_class.reloptions */ + bytea *rd_options; /* * Oid of the handler for this relation. For an index this is a function @@ -297,88 +346,41 @@ typedef struct ForeignKeyCacheInfo Oid conpfeqop[INDEX_MAX_KEYS] pg_node_attr(array_size(nkeys)); } ForeignKeyCacheInfo; - /* - * StdRdOptions - * Standard contents of rd_options for heaps. - * - * RelationGetFillFactor() and RelationGetTargetPageFreeSpace() can only - * be applied to relations that use this format or a superset for - * private options data. + * heapReloptions + * Contents of rd_options specific for heap tables. */ - /* autovacuum-related reloptions. */ -typedef struct AutoVacOpts -{ - bool enabled; - int vacuum_threshold; - int vacuum_ins_threshold; - int analyze_threshold; - int vacuum_cost_limit; - int freeze_min_age; - int freeze_max_age; - int freeze_table_age; - int multixact_freeze_min_age; - int multixact_freeze_max_age; - int multixact_freeze_table_age; - int log_min_duration; - float8 vacuum_cost_delay; - float8 vacuum_scale_factor; - float8 vacuum_ins_scale_factor; - float8 analyze_scale_factor; -} AutoVacOpts; - -/* StdRdOptions->vacuum_index_cleanup values */ -typedef enum StdRdOptIndexCleanup -{ - STDRD_OPTION_VACUUM_INDEX_CLEANUP_AUTO = 0, - STDRD_OPTION_VACUUM_INDEX_CLEANUP_OFF, - STDRD_OPTION_VACUUM_INDEX_CLEANUP_ON, -} StdRdOptIndexCleanup; - -typedef struct StdRdOptions +typedef struct heapReloptions { int32 vl_len_; /* varlena header (do not touch directly!) */ int fillfactor; /* page fill factor in percent (0..100) */ int toast_tuple_target; /* target for tuple toasting */ - AutoVacOpts autovacuum; /* autovacuum-related options */ - bool user_catalog_table; /* use as an additional catalog relation */ - int parallel_workers; /* max number of parallel workers */ - StdRdOptIndexCleanup vacuum_index_cleanup; /* controls index vacuuming */ - bool vacuum_truncate; /* enables vacuum to truncate a relation */ -} StdRdOptions; +} heapReloptions; #define HEAP_MIN_FILLFACTOR 10 #define HEAP_DEFAULT_FILLFACTOR 100 /* - * RelationGetToastTupleTarget - * Returns the relation's toast_tuple_target. Note multiple eval of argument! + * HeapGetFillFactor + * Returns the heap relation's fillfactor. Note multiple eval of argument! */ -#define RelationGetToastTupleTarget(relation, defaulttarg) \ +#define HeapGetFillFactor(relation, defaultff) \ ((relation)->rd_options ? \ - ((StdRdOptions *) (relation)->rd_options)->toast_tuple_target : (defaulttarg)) + ((heapReloptions *) (relation)->rd_options)->fillfactor : (defaultff)) /* - * RelationGetFillFactor - * Returns the relation's fillfactor. Note multiple eval of argument! - */ -#define RelationGetFillFactor(relation, defaultff) \ - ((relation)->rd_options ? \ - ((StdRdOptions *) (relation)->rd_options)->fillfactor : (defaultff)) - -/* - * RelationGetTargetPageUsage + * HeapGetTargetPageUsage * Returns the relation's desired space usage per page in bytes. */ -#define RelationGetTargetPageUsage(relation, defaultff) \ - (BLCKSZ * RelationGetFillFactor(relation, defaultff) / 100) +#define HeapGetTargetPageUsage(relation, defaultff) \ + (BLCKSZ * HeapGetFillFactor(relation, defaultff) / 100) /* - * RelationGetTargetPageFreeSpace + * HeapGetTargetPageFreeSpace * Returns the relation's desired freespace per page in bytes. */ -#define RelationGetTargetPageFreeSpace(relation, defaultff) \ - (BLCKSZ * (100 - RelationGetFillFactor(relation, defaultff)) / 100) +#define HeapGetTargetPageFreeSpace(relation, defaultff) \ + (BLCKSZ * (100 - HeapGetFillFactor(relation, defaultff)) / 100) /* * RelationIsUsedAsCatalogTable @@ -386,10 +388,10 @@ typedef struct StdRdOptions * from the pov of logical decoding. Note multiple eval of argument! */ #define RelationIsUsedAsCatalogTable(relation) \ - ((relation)->rd_options && \ + ((relation)->rd_common_options && \ ((relation)->rd_rel->relkind == RELKIND_RELATION || \ (relation)->rd_rel->relkind == RELKIND_MATVIEW) ? \ - ((StdRdOptions *) (relation)->rd_options)->user_catalog_table : false) + (relation)->rd_common_options->user_catalog_table : false) /* * RelationGetParallelWorkers @@ -397,8 +399,8 @@ typedef struct StdRdOptions * Note multiple eval of argument! */ #define RelationGetParallelWorkers(relation, defaultpw) \ - ((relation)->rd_options ? \ - ((StdRdOptions *) (relation)->rd_options)->parallel_workers : (defaultpw)) + ((relation)->rd_common_options ? \ + (relation)->rd_common_options->parallel_workers : (defaultpw)) /* ViewOptions->check_option values */ typedef enum ViewOptCheckOption -- 2.39.2 (Apple Git-143)