В письме от понедельник, 20 июля 2020 г. 18:36:44 MSK пользователь Georgios
Kokolatos написал:
Hi! Sorry for really long delay, I was at my summer vacations, and then has
urgent things to finish first. :-( Now I hope we can continue...
> thank you for the patch. It applies cleanly, compiles and passes check,
> check-world.
Thank you for reviewing efforts.
> I feel as per the discussion, this is a step to the right direction yet it
> does not get far enough. From experience, I can confirm that dealing with
> reloptions in a new table AM is somewhat of a pain. Ultimately, reloptions
> should be handled by the table AM specific code. The current patch does not
> address the issue. Yet it does make the issue easier to address by clearing
> up the current state.
Moving reloptions to AM code is the goal I am slowly moving to. I've started
some time ago with big patch https://commitfest.postgresql.org/14/992/ and
have been told to split it into smaller parts. So I did, and this patch is
last step that cleans options related things up, and then actual moving can be
done.
> If you allow me, I have a couple of comments.
>
> - saveFreeSpace = RelationGetTargetPageFreeSpace(relation,
> -
> HEAP_DEFAULT_FILLFACTOR);
> + if (IsToastRelation(relation))
> + saveFreeSpace = ToastGetTargetPageFreeSpace();
> + else
> + saveFreeSpace = HeapGetTargetPageFreeSpace(relation);
>
> For balance, it does make some sense for ToastGetTargetPageFreeSpace() to
> get relation as an argument, similarly to HeapGetTargetPageFreeSpace().
ToastGetTargetPageFreeSpace return a const value. I've change the code, so it
gets relation argument, that is not used, the way you suggested. But I am not
sure if it is good or bad idea. May be we will get some "Unused variable"
warning on some compilers. I like consistency... But not sure we need it here.
> - /* Retrieve the parallel_workers reloption, or -1 if not set. */
> - rel->rel_parallel_workers = RelationGetParallelWorkers(relation,
> -1);
+ /*
> + * Retrieve the parallel_workers for heap and mat.view relations.
> + * Use -1 if not set, or if we are dealing with other relation
> kinds
+ */
> + if (relation->rd_rel->relkind == RELKIND_RELATION ||
> + relation->rd_rel->relkind == RELKIND_MATVIEW)
> + rel->rel_parallel_workers =
> RelationGetParallelWorkers(relation, -1);
+ else
> + rel->rel_parallel_workers = -1;
> Also, this pattern is repeated in four places, maybe the branch can be
> moved inside a macro or static inline instead?
> If the comment above is agreed upon, then it makes a bit of sense to apply
> the same here. The expression in the branch is already asserted for in
> macro, why not switch there and remove the responsibility from the caller?
I guess here you are right, because here the logic is following: for heap
relation take option from options, for _all_ others use -1. This can be moved
to macro.
So I changed it to
/*
* 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_rel->relkind == RELKIND_RELATION || \
(relation)->rd_rel->relkind == RELKIND_MATVIEW) ? \
HeapGetParallelWorkers(relation, defaultpw) : defaultpw)
But I would not like to move
if (IsToastRelation(relation))
saveFreeSpace = ToastGetTargetPageFreeSpace(relation);
else
saveFreeSpace = HeapGetTargetPageFreeSpace(relation);
into macros, as there is a choice only between heap and toast. All other
relation types are not mentioned.
So we can not call it RelationGetTargetPageFreeSpace. It would be
ToastOrHeapGetTargetPageFreeSpace actually. Better not to have such macro.
Please find new version of the patch in the attachment.
--
Software Developer: https://www.upwork.com/freelancers/~014a87e140ff02c0da
Body-oriented Therapist: https://vk.com/nataraj_rebalancing (Russian)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_<type>_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
