diff --git a/src/backend/access/common/reloptions.c b/src/backend/access/common/reloptions.c index 8ccc228..6118b55 100644 --- a/src/backend/access/common/reloptions.c +++ b/src/backend/access/common/reloptions.c @@ -46,9 +46,8 @@ * 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) - * (iv) add it to the appropriate handling routine (perhaps - * default_reloptions) + * (iii) add it to the appropriate options struct + * (iv) add it to the appropriate handling routine * (v) make sure the lock level is set correctly for that operation * (vi) don't forget to document the option * @@ -1375,9 +1374,11 @@ extractRelOptions(HeapTuple tuple, TupleDesc tupdesc, switch (classForm->relkind) { case RELKIND_RELATION: - case RELKIND_TOASTVALUE: case RELKIND_MATVIEW: - options = heap_reloptions(classForm->relkind, datum, false); + options = heap_reloptions(datum, false); + break; + case RELKIND_TOASTVALUE: + options = toast_reloptions(datum, false); break; case RELKIND_PARTITIONED_TABLE: options = partitioned_table_reloptions(datum, false); @@ -1811,59 +1812,66 @@ fillRelOptions(void *rdopts, Size basesize, /* - * Option parser for anything that uses StdRdOptions. + * Option parsing definition for autovacuum. Used in toast and heap options. + */ + +#define AUTOVACUUM_RELOPTIONS(OFFSET) \ + {"autovacuum_enabled", RELOPT_TYPE_BOOL, \ + OFFSET + offsetof(AutoVacOpts, enabled)}, \ + {"autovacuum_vacuum_threshold", RELOPT_TYPE_INT, \ + OFFSET + offsetof(AutoVacOpts, vacuum_threshold)}, \ + {"autovacuum_vacuum_insert_threshold", RELOPT_TYPE_INT, \ + OFFSET + offsetof(AutoVacOpts, vacuum_ins_threshold)}, \ + {"autovacuum_analyze_threshold", RELOPT_TYPE_INT, \ + OFFSET + offsetof(AutoVacOpts, analyze_threshold)}, \ + {"autovacuum_vacuum_cost_delay", RELOPT_TYPE_REAL, \ + OFFSET + offsetof(AutoVacOpts, vacuum_cost_delay)}, \ + {"autovacuum_vacuum_cost_limit", RELOPT_TYPE_INT, \ + OFFSET + offsetof(AutoVacOpts, vacuum_cost_limit)}, \ + {"autovacuum_freeze_min_age", RELOPT_TYPE_INT, \ + OFFSET + offsetof(AutoVacOpts, freeze_min_age)}, \ + {"autovacuum_freeze_max_age", RELOPT_TYPE_INT, \ + OFFSET + offsetof(AutoVacOpts, freeze_max_age)}, \ + {"autovacuum_freeze_table_age", RELOPT_TYPE_INT, \ + OFFSET + offsetof(AutoVacOpts, freeze_table_age)}, \ + {"autovacuum_multixact_freeze_min_age", RELOPT_TYPE_INT, \ + OFFSET + offsetof(AutoVacOpts, multixact_freeze_min_age)}, \ + {"autovacuum_multixact_freeze_max_age", RELOPT_TYPE_INT, \ + OFFSET + offsetof(AutoVacOpts, multixact_freeze_max_age)}, \ + {"autovacuum_multixact_freeze_table_age", RELOPT_TYPE_INT, \ + OFFSET + offsetof(AutoVacOpts, multixact_freeze_table_age)}, \ + {"log_autovacuum_min_duration", RELOPT_TYPE_INT, \ + OFFSET + offsetof(AutoVacOpts, log_min_duration)}, \ + {"autovacuum_vacuum_scale_factor", RELOPT_TYPE_REAL, \ + OFFSET + offsetof(AutoVacOpts, vacuum_scale_factor)}, \ + {"autovacuum_vacuum_insert_scale_factor", RELOPT_TYPE_REAL, \ + OFFSET + offsetof(AutoVacOpts, vacuum_ins_scale_factor)}, \ + {"autovacuum_analyze_scale_factor", RELOPT_TYPE_REAL, \ + OFFSET + offsetof(AutoVacOpts, analyze_scale_factor)} +/* + * Option parser for heap */ bytea * -default_reloptions(Datum reloptions, bool validate, relopt_kind kind) +heap_reloptions(Datum reloptions, bool validate) { static const relopt_parse_elt tab[] = { - {"fillfactor", RELOPT_TYPE_INT, offsetof(StdRdOptions, fillfactor)}, - {"autovacuum_enabled", RELOPT_TYPE_BOOL, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, enabled)}, - {"autovacuum_vacuum_threshold", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_threshold)}, - {"autovacuum_vacuum_insert_threshold", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_ins_threshold)}, - {"autovacuum_analyze_threshold", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_threshold)}, - {"autovacuum_vacuum_cost_limit", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_limit)}, - {"autovacuum_freeze_min_age", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_min_age)}, - {"autovacuum_freeze_max_age", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_max_age)}, - {"autovacuum_freeze_table_age", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, freeze_table_age)}, - {"autovacuum_multixact_freeze_min_age", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_min_age)}, - {"autovacuum_multixact_freeze_max_age", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_max_age)}, - {"autovacuum_multixact_freeze_table_age", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, multixact_freeze_table_age)}, - {"log_autovacuum_min_duration", RELOPT_TYPE_INT, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, log_min_duration)}, + {"fillfactor", RELOPT_TYPE_INT, offsetof(HeapOptions, fillfactor)}, + AUTOVACUUM_RELOPTIONS(offsetof(HeapOptions, autovacuum)), {"toast_tuple_target", RELOPT_TYPE_INT, - offsetof(StdRdOptions, toast_tuple_target)}, - {"autovacuum_vacuum_cost_delay", RELOPT_TYPE_REAL, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_cost_delay)}, - {"autovacuum_vacuum_scale_factor", RELOPT_TYPE_REAL, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_scale_factor)}, - {"autovacuum_vacuum_insert_scale_factor", RELOPT_TYPE_REAL, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, vacuum_ins_scale_factor)}, - {"autovacuum_analyze_scale_factor", RELOPT_TYPE_REAL, - offsetof(StdRdOptions, autovacuum) + offsetof(AutoVacOpts, analyze_scale_factor)}, + offsetof(HeapOptions, toast_tuple_target)}, {"user_catalog_table", RELOPT_TYPE_BOOL, - offsetof(StdRdOptions, user_catalog_table)}, + offsetof(HeapOptions, user_catalog_table)}, {"parallel_workers", RELOPT_TYPE_INT, - offsetof(StdRdOptions, parallel_workers)}, + offsetof(HeapOptions, parallel_workers)}, {"vacuum_index_cleanup", RELOPT_TYPE_BOOL, - offsetof(StdRdOptions, vacuum_index_cleanup)}, + offsetof(HeapOptions, vacuum_index_cleanup)}, {"vacuum_truncate", RELOPT_TYPE_BOOL, - offsetof(StdRdOptions, vacuum_truncate)} + offsetof(HeapOptions, vacuum_truncate)} }; - return (bytea *) build_reloptions(reloptions, validate, kind, - sizeof(StdRdOptions), + return (bytea *) build_reloptions(reloptions, validate, + RELOPT_KIND_HEAP, + sizeof(HeapOptions), tab, lengthof(tab)); } @@ -1971,6 +1979,32 @@ partitioned_table_reloptions(Datum reloptions, bool validate) } /* + * Option parser for toast + */ +bytea * +toast_reloptions(Datum reloptions, bool validate) +{ + ToastOptions *rdopts; + static const relopt_parse_elt tab[] = { + AUTOVACUUM_RELOPTIONS(offsetof(ToastOptions, autovacuum)), + {"vacuum_index_cleanup", RELOPT_TYPE_BOOL, + offsetof(ToastOptions, vacuum_index_cleanup)}, + {"vacuum_truncate", RELOPT_TYPE_BOOL, + offsetof(ToastOptions, vacuum_truncate)} + }; + + rdopts = build_reloptions(reloptions, validate, + RELOPT_KIND_TOAST, + sizeof(ToastOptions), + tab, lengthof(tab)); + /* adjust default-only parameters for TOAST relations */ + rdopts->autovacuum.analyze_threshold = -1; + rdopts->autovacuum.analyze_scale_factor = -1; + + return (bytea *) rdopts; +} + +/* * Option parser for views */ bytea * @@ -1990,37 +2024,6 @@ view_reloptions(Datum reloptions, bool validate) } /* - * Parse options for heaps, views and toast tables. - */ -bytea * -heap_reloptions(char relkind, Datum reloptions, bool validate) -{ - StdRdOptions *rdopts; - - switch (relkind) - { - case RELKIND_TOASTVALUE: - rdopts = (StdRdOptions *) - default_reloptions(reloptions, validate, RELOPT_KIND_TOAST); - if (rdopts != NULL) - { - /* adjust default-only parameters for TOAST relations */ - rdopts->fillfactor = 100; - rdopts->autovacuum.analyze_threshold = -1; - rdopts->autovacuum.analyze_scale_factor = -1; - } - return (bytea *) rdopts; - case RELKIND_RELATION: - case RELKIND_MATVIEW: - return default_reloptions(reloptions, validate, RELOPT_KIND_HEAP); - default: - /* other relkinds are not supported */ - return NULL; - } -} - - -/* * Parse options for indexes. * * amoptions index AM's option parser function diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c index 9b5f417..473eb4d 100644 --- a/src/backend/access/heap/heapam.c +++ b/src/backend/access/heap/heapam.c @@ -2114,8 +2114,10 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples, AssertArg(!(options & HEAP_INSERT_NO_LOGICAL)); needwal = RelationNeedsWAL(relation); - saveFreeSpace = RelationGetTargetPageFreeSpace(relation, - HEAP_DEFAULT_FILLFACTOR); + if (IsToastRelation(relation)) + saveFreeSpace = ToastGetTargetPageFreeSpace(relation); + else + saveFreeSpace = HeapGetTargetPageFreeSpace(relation); /* Toast and set header data in all the slots */ heaptuples = palloc(ntuples * sizeof(HeapTuple)); diff --git a/src/backend/access/heap/hio.c b/src/backend/access/heap/hio.c index aa3f14c..80e14b0 100644 --- a/src/backend/access/heap/hio.c +++ b/src/backend/access/heap/hio.c @@ -19,6 +19,7 @@ #include "access/hio.h" #include "access/htup_details.h" #include "access/visibilitymap.h" +#include "catalog/catalog.h" #include "storage/bufmgr.h" #include "storage/freespace.h" #include "storage/lmgr.h" @@ -346,8 +347,10 @@ RelationGetBufferForTuple(Relation relation, Size len, len, MaxHeapTupleSize))); /* Compute desired extra freespace due to fillfactor option */ - saveFreeSpace = RelationGetTargetPageFreeSpace(relation, - HEAP_DEFAULT_FILLFACTOR); + if (IsToastRelation(relation)) + saveFreeSpace = ToastGetTargetPageFreeSpace(relation); + else + saveFreeSpace = HeapGetTargetPageFreeSpace(relation); if (otherBuffer != InvalidBuffer) otherBlock = BufferGetBlockNumber(otherBuffer); diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/heap/pruneheap.c index bc510e2..f23a306 100644 --- a/src/backend/access/heap/pruneheap.c +++ b/src/backend/access/heap/pruneheap.c @@ -164,8 +164,11 @@ 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, - HEAP_DEFAULT_FILLFACTOR); + + if (IsToastRelation(relation)) + minfree = ToastGetTargetPageFreeSpace(relation); + else + minfree = HeapGetTargetPageFreeSpace(relation); minfree = Max(minfree, BLCKSZ / 10); if (PageIsFull(page) || PageGetHeapFreeSpace(page) < minfree) diff --git a/src/backend/access/heap/rewriteheap.c b/src/backend/access/heap/rewriteheap.c index 39e3376..5af0157 100644 --- a/src/backend/access/heap/rewriteheap.c +++ b/src/backend/access/heap/rewriteheap.c @@ -663,8 +663,10 @@ raw_heap_insert(RewriteState state, HeapTuple tup) len, MaxHeapTupleSize))); /* Compute desired extra freespace due to fillfactor option */ - saveFreeSpace = RelationGetTargetPageFreeSpace(state->rs_new_rel, - HEAP_DEFAULT_FILLFACTOR); + if (IsToastRelation(state->rs_new_rel)) + saveFreeSpace = ToastGetTargetPageFreeSpace(state->rs_new_rel); + else + saveFreeSpace = HeapGetTargetPageFreeSpace(state->rs_new_rel); /* Now we can check to see if there's enough free space already. */ if (state->rs_buffer_valid) diff --git a/src/backend/commands/createas.c b/src/backend/commands/createas.c index d53ec95..c3942ea 100644 --- a/src/backend/commands/createas.c +++ b/src/backend/commands/createas.c @@ -130,7 +130,7 @@ create_ctas_internal(List *attrList, IntoClause *into) validnsps, true, false); - (void) heap_reloptions(RELKIND_TOASTVALUE, toast_options, true); + (void) toast_reloptions(toast_options, true); NewRelationCreateToastTable(intoRelationAddr.objectId, toast_options); diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c index 3e57c7f..63b0c1d 100644 --- a/src/backend/commands/tablecmds.c +++ b/src/backend/commands/tablecmds.c @@ -756,8 +756,12 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId, case RELKIND_PARTITIONED_TABLE: (void) partitioned_table_reloptions(reloptions, true); break; - default: - (void) heap_reloptions(relkind, reloptions, true); + case RELKIND_TOASTVALUE: + (void) toast_reloptions(reloptions, true); + break; + case RELKIND_RELATION: + case RELKIND_MATVIEW: + (void) heap_reloptions(reloptions, true); } if (stmt->ofTypename) @@ -12932,9 +12936,11 @@ ATExecSetRelOptions(Relation rel, List *defList, AlterTableType operation, switch (rel->rd_rel->relkind) { case RELKIND_RELATION: - case RELKIND_TOASTVALUE: case RELKIND_MATVIEW: - (void) heap_reloptions(rel->rd_rel->relkind, newOptions, true); + (void) heap_reloptions( newOptions, true); + break; + case RELKIND_TOASTVALUE: + (void) toast_reloptions(newOptions, true); break; case RELKIND_PARTITIONED_TABLE: (void) partitioned_table_reloptions(newOptions, true); @@ -13046,7 +13052,7 @@ ATExecSetRelOptions(Relation rel, List *defList, AlterTableType operation, defList, "toast", validnsps, false, operation == AT_ResetRelOptions); - (void) heap_reloptions(RELKIND_TOASTVALUE, newOptions, true); + (void) toast_reloptions(newOptions, 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 ddeec87..7729db9 100644 --- a/src/backend/commands/vacuum.c +++ b/src/backend/commands/vacuum.c @@ -31,6 +31,7 @@ #include "access/tableam.h" #include "access/transam.h" #include "access/xact.h" +#include "catalog/catalog.h" #include "catalog/namespace.h" #include "catalog/pg_database.h" #include "catalog/pg_inherits.h" @@ -1878,7 +1879,10 @@ vacuum_rel(Oid relid, RangeVar *relation, VacuumParams *params) if (params->index_cleanup == VACOPT_TERNARY_DEFAULT) { if (onerel->rd_options == NULL || - ((StdRdOptions *) onerel->rd_options)->vacuum_index_cleanup) + (!IsToastRelation(onerel) && + ((HeapOptions *) onerel->rd_options)->vacuum_index_cleanup) || + (IsToastRelation(onerel) && + ((ToastOptions *) onerel->rd_options)->vacuum_index_cleanup)) params->index_cleanup = VACOPT_TERNARY_ENABLED; else params->index_cleanup = VACOPT_TERNARY_DISABLED; @@ -1888,7 +1892,10 @@ vacuum_rel(Oid relid, RangeVar *relation, VacuumParams *params) if (params->truncate == VACOPT_TERNARY_DEFAULT) { if (onerel->rd_options == NULL || - ((StdRdOptions *) onerel->rd_options)->vacuum_truncate) + (!IsToastRelation(onerel) && + ((HeapOptions *) onerel->rd_options)->vacuum_truncate) || + (IsToastRelation(onerel) && + ((ToastOptions *) onerel->rd_options)->vacuum_truncate)) params->truncate = VACOPT_TERNARY_ENABLED; else params->truncate = VACOPT_TERNARY_DISABLED; diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c index 19ba26b..6e86dbe 100644 --- a/src/backend/postmaster/autovacuum.c +++ b/src/backend/postmaster/autovacuum.c @@ -2737,6 +2737,7 @@ extract_autovac_opts(HeapTuple tup, TupleDesc pg_class_desc) { bytea *relopts; AutoVacOpts *av; + AutoVacOpts *src; Assert(((Form_pg_class) GETSTRUCT(tup))->relkind == RELKIND_RELATION || ((Form_pg_class) GETSTRUCT(tup))->relkind == RELKIND_MATVIEW || @@ -2746,8 +2747,13 @@ extract_autovac_opts(HeapTuple tup, TupleDesc pg_class_desc) if (relopts == NULL) return NULL; + if (((Form_pg_class) GETSTRUCT(tup))->relkind == RELKIND_TOASTVALUE) + src = &(((ToastOptions *) relopts)->autovacuum); + else + src = &(((HeapOptions *) relopts)->autovacuum); + av = palloc(sizeof(AutoVacOpts)); - memcpy(av, &(((StdRdOptions *) relopts)->autovacuum), sizeof(AutoVacOpts)); + memcpy(av, src, sizeof(AutoVacOpts)); pfree(relopts); return av; diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c index 9713a7a..375f253 100644 --- a/src/backend/tcop/utility.c +++ b/src/backend/tcop/utility.c @@ -1179,9 +1179,7 @@ ProcessUtilitySlow(ParseState *pstate, validnsps, true, false); - (void) heap_reloptions(RELKIND_TOASTVALUE, - toast_options, - true); + (void) toast_reloptions(toast_options, true); NewRelationCreateToastTable(address.objectId, toast_options); diff --git a/src/include/access/reloptions.h b/src/include/access/reloptions.h index 5964438..45cce3c 100644 --- a/src/include/access/reloptions.h +++ b/src/include/access/reloptions.h @@ -233,9 +233,8 @@ extern void *build_reloptions(Datum reloptions, bool validate, extern void *build_local_reloptions(local_relopts *relopts, Datum options, bool validate); -extern bytea *default_reloptions(Datum reloptions, bool validate, - relopt_kind kind); -extern bytea *heap_reloptions(char relkind, Datum reloptions, bool validate); +extern bytea *toast_reloptions(Datum reloptions, bool validate); +extern bytea *heap_reloptions(Datum 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/utils/rel.h b/src/include/utils/rel.h index 0b5957b..e475e87 100644 --- a/src/include/utils/rel.h +++ b/src/include/utils/rel.h @@ -266,14 +266,9 @@ typedef struct 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. + * AutoVacOpts + * Auto Vacuum options used both in Heap and Toast relations */ - /* autovacuum-related reloptions. */ typedef struct AutoVacOpts { bool enabled; @@ -294,7 +289,11 @@ typedef struct AutoVacOpts float8 analyze_scale_factor; } AutoVacOpts; -typedef struct StdRdOptions +/* + * HeapOptions + * Binary representation of relation options for Heap relations. + */ +typedef struct HeapOptions { int32 vl_len_; /* varlena header (do not touch directly!) */ int fillfactor; /* page fill factor in percent (0..100) */ @@ -305,40 +304,60 @@ typedef struct StdRdOptions int parallel_workers; /* max number of parallel workers */ bool vacuum_index_cleanup; /* enables index vacuuming and cleanup */ bool vacuum_truncate; /* enables vacuum to truncate a relation */ -} StdRdOptions; +} HeapOptions; #define HEAP_MIN_FILLFACTOR 10 #define HEAP_DEFAULT_FILLFACTOR 100 /* + * ToastOptions + * Binary representation of relation options for Toast relations. + */ +typedef struct ToastOptions +{ + int32 vl_len_; /* varlena header (do not touch directly!) */ + AutoVacOpts autovacuum; /* autovacuum-related options */ + bool vacuum_index_cleanup; /* enables index vacuuming and cleanup */ + bool vacuum_truncate; /* enables vacuum to truncate a relation */ +} ToastOptions; + +#define TOAST_DEFAULT_FILLFACTOR 100 /* Only default is actually used */ + +/* * RelationGetToastTupleTarget - * Returns the relation's toast_tuple_target. Note multiple eval of argument! + * Returns the heap's toast_tuple_target. Note multiple eval of argument! */ -#define RelationGetToastTupleTarget(relation, defaulttarg) \ - ((relation)->rd_options ? \ - ((StdRdOptions *) (relation)->rd_options)->toast_tuple_target : (defaulttarg)) +#define RelationGetToastTupleTarget(relation, defaulttarg) \ + (AssertMacro(relation->rd_rel->relkind == RELKIND_RELATION || \ + relation->rd_rel->relkind == RELKIND_MATVIEW), \ + (relation)->rd_options ? \ + ((HeapOptions *) (relation)->rd_options)->toast_tuple_target : \ + (defaulttarg)) /* - * RelationGetFillFactor - * Returns the relation's fillfactor. Note multiple eval of argument! + * HeapGetFillFactor + * Returns the heap's fillfactor. Note multiple eval of argument! */ -#define RelationGetFillFactor(relation, defaultff) \ - ((relation)->rd_options ? \ - ((StdRdOptions *) (relation)->rd_options)->fillfactor : (defaultff)) +#define HeapGetFillFactor(relation) \ + (AssertMacro(relation->rd_rel->relkind == RELKIND_RELATION || \ + relation->rd_rel->relkind == RELKIND_MATVIEW), \ + (relation)->rd_options ? \ + ((HeapOptions *) (relation)->rd_options)->fillfactor : \ + (HEAP_DEFAULT_FILLFACTOR)) /* - * 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) \ + (BLCKSZ * HeapGetFillFactor(relation) / 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) \ + (BLCKSZ * (100 - HeapGetFillFactor(relation)) / 100) /* * RelationIsUsedAsCatalogTable @@ -349,16 +368,38 @@ typedef struct StdRdOptions ((relation)->rd_options && \ ((relation)->rd_rel->relkind == RELKIND_RELATION || \ (relation)->rd_rel->relkind == RELKIND_MATVIEW) ? \ - ((StdRdOptions *) (relation)->rd_options)->user_catalog_table : false) + ((HeapOptions *) (relation)->rd_options)->user_catalog_table : false) + +/* + * HeapGetParallelWorkers + * Returns the heap's parallel_workers reloption setting. + * Note multiple eval of argument! + */ +#define HeapGetParallelWorkers(relation, defaultpw) \ + (AssertMacro(relation->rd_rel->relkind == RELKIND_RELATION || \ + relation->rd_rel->relkind == RELKIND_MATVIEW), \ + (relation)->rd_options ? \ + ((HeapOptions *) (relation)->rd_options)->parallel_workers : \ + (defaultpw)) /* * RelationGetParallelWorkers * Returns the relation's parallel_workers reloption setting. * Note multiple eval of argument! */ -#define RelationGetParallelWorkers(relation, defaultpw) \ - ((relation)->rd_options ? \ - ((StdRdOptions *) (relation)->rd_options)->parallel_workers : (defaultpw)) + +#define RelationGetParallelWorkers(relation, defaultpw) \ + (((relation)->rd_rel->relkind == RELKIND_RELATION || \ + (relation)->rd_rel->relkind == RELKIND_MATVIEW) ? \ + HeapGetParallelWorkers(relation, defaultpw) : defaultpw) + +/* + * ToastGetTargetPageFreeSpace + * Returns the TOAST relation's desired freespace per page in bytes. + * Always calculated using default fillfactor value. + */ +#define ToastGetTargetPageFreeSpace(relation) \ + (BLCKSZ * (100 - TOAST_DEFAULT_FILLFACTOR) / 100) /* ViewOptions->check_option values */ typedef enum ViewOptCheckOption