add ResultRelInfos for partitions to estate->es_result_relations with append_rri_to_estate(), add 'close_rels' param to fini_result_parts_storage(), don't close partitions till xact end after INSERT, fixes

funbringer · funbringer · commit 9fd99a37fe53 · 2016-09-16T23:36:43.000+03:00
diff --git a/src/copy_stmt_hooking.c b/src/copy_stmt_hooking.c
@@ -516,7 +516,9 @@ PathmanCopyFrom(CopyState cstate, Relation parent_rel,
 	pfree(nulls);
 
 	ExecResetTupleTable(estate->es_tupleTable, false);
-	fini_result_parts_storage(&parts_storage);
+
+	/* Close partitions and destroy hash table */
+	fini_result_parts_storage(&parts_storage, true);
 
 	FreeExecutorState(estate);
 
diff --git a/src/nodes_common.c b/src/nodes_common.c
@@ -84,8 +84,8 @@ transform_plans_into_states(RuntimeAppendState *scan_state,
 static ChildScanCommon *
 select_required_plans(HTAB *children_table, Oid *parts, int nparts, int *nres)
 {
-	int					allocated = INITIAL_ALLOC_NUM;
-	int					used = 0;
+	uint32				allocated = INITIAL_ALLOC_NUM,
+						used = 0;
 	ChildScanCommon	   *result;
 	int					i;
 
@@ -101,7 +101,7 @@ select_required_plans(HTAB *children_table, Oid *parts, int nparts, int *nres)
 
 		if (allocated <= used)
 		{
-			allocated *= ALLOC_EXP;
+			allocated = allocated * ALLOC_EXP + 1;
 			result = repalloc(result, allocated * sizeof(ChildScanCommon));
 		}
 
@@ -289,8 +289,8 @@ get_partition_oids(List *ranges, int *n, const PartRelationInfo *prel,
 				   bool include_parent)
 {
 	ListCell   *range_cell;
-	uint32		allocated = INITIAL_ALLOC_NUM;
-	uint32		used = 0;
+	uint32		allocated = INITIAL_ALLOC_NUM,
+				used = 0;
 	Oid		   *result = (Oid *) palloc(allocated * sizeof(Oid));
 	Oid		   *children = PrelGetChildrenArray(prel);
 
@@ -310,7 +310,7 @@ get_partition_oids(List *ranges, int *n, const PartRelationInfo *prel,
 		{
 			if (allocated <= used)
 			{
-				allocated *= ALLOC_EXP;
+				allocated = allocated * ALLOC_EXP + 1;
 				result = repalloc(result, allocated * sizeof(Oid));
 			}
 
@@ -595,10 +595,10 @@ explain_append_common(CustomScanState *node, HTAB *children_table, ExplainState
 	/* Construct excess PlanStates */
 	if (!es->analyze)
 	{
-		int					allocated = INITIAL_ALLOC_NUM;
-		int					used = 0;
-		ChildScanCommon	   *custom_ps;
-		ChildScanCommon		child;
+		uint32				allocated = INITIAL_ALLOC_NUM,
+							used = 0;
+		ChildScanCommon	   *custom_ps,
+							child;
 		HASH_SEQ_STATUS		seqstat;
 		int					i;
 
@@ -614,7 +614,7 @@ explain_append_common(CustomScanState *node, HTAB *children_table, ExplainState
 		{
 			if (allocated <= used)
 			{
-				allocated *= ALLOC_EXP;
+				allocated = allocated * ALLOC_EXP + 1;
 				custom_ps = repalloc(custom_ps, allocated * sizeof(ChildScanCommon));
 			}
 
diff --git a/src/partition_filter.c b/src/partition_filter.c
@@ -19,6 +19,9 @@
 #include "utils/lsyscache.h"
 
 
+#define ALLOC_EXP	2
+
+
 bool				pg_pathman_enable_partition_filter = true;
 
 CustomScanMethods	partition_filter_plan_methods;
@@ -27,6 +30,7 @@ CustomExecMethods	partition_filter_exec_methods;
 
 static void partition_filter_visitor(Plan *plan, void *context);
 static List * pfilter_build_tlist(List *tlist);
+static int append_rri_to_estate(EState *estate, ResultRelInfo *rri, int cur_allocated);
 
 
 void
@@ -86,7 +90,7 @@ check_acl_for_partition(EState *estate,
 	rte->relkind = part_rel->rd_rel->relkind;
 	rte->requiredPerms = ACL_INSERT;
 
-	/* Check permissions for current partition */
+	/* FIXME: Check permissions for partition */
 	ExecCheckRTPerms(list_make1(rte), true);
 
 	/* TODO: append RTE to estate->es_range_table */
@@ -125,40 +129,51 @@ init_result_parts_storage(ResultPartsStorage *parts_storage,
 
 	parts_storage->on_new_rri_holder_callback = on_new_rri_holder_cb;
 	parts_storage->callback_arg = on_new_rri_holder_cb_arg;
+
+	/* Partitions must remain locked till transaction's end */
+	parts_storage->head_open_lock_mode = RowExclusiveLock;
+	parts_storage->heap_close_lock_mode = NoLock;
 }
 
 /*
  * Free ResultPartsStorage (close relations etc).
  */
 void
-fini_result_parts_storage(ResultPartsStorage *parts_storage)
+fini_result_parts_storage(ResultPartsStorage *parts_storage, bool close_rels)
 {
-	HASH_SEQ_STATUS			stat;
-	ResultRelInfoHolder	   *rri_holder; /* ResultRelInfo holder */
-
-	hash_seq_init(&stat, parts_storage->result_rels_table);
-	while ((rri_holder = (ResultRelInfoHolder *) hash_seq_search(&stat)) != NULL)
+	/* Close partitions and their indices if asked to */
+	if (close_rels)
 	{
-		ExecCloseIndices(rri_holder->result_rel_info);
-		heap_close(rri_holder->result_rel_info->ri_RelationDesc,
-				   RowExclusiveLock);
+		HASH_SEQ_STATUS			stat;
+		ResultRelInfoHolder	   *rri_holder; /* ResultRelInfo holder */
+
+		hash_seq_init(&stat, parts_storage->result_rels_table);
+		while ((rri_holder = (ResultRelInfoHolder *) hash_seq_search(&stat)) != NULL)
+		{
+			ExecCloseIndices(rri_holder->result_rel_info);
+
+			heap_close(rri_holder->result_rel_info->ri_RelationDesc,
+					   parts_storage->heap_close_lock_mode);
+		}
 	}
+
+	/* Finally destroy hash table */
 	hash_destroy(parts_storage->result_rels_table);
 }
 
 /*
  * Find a ResultRelInfo for the partition using ResultPartsStorage.
  */
 ResultRelInfoHolder *
-scan_result_parts_storage(Oid partid, ResultPartsStorage *storage)
+scan_result_parts_storage(Oid partid, ResultPartsStorage *parts_storage)
 {
 #define CopyToResultRelInfo(field_name) \
-	( part_result_rel_info->field_name = storage->saved_rel_info->field_name )
+	( part_result_rel_info->field_name = parts_storage->saved_rel_info->field_name )
 
 	ResultRelInfoHolder	   *rri_holder;
 	bool					found;
 
-	rri_holder = hash_search(storage->result_rels_table,
+	rri_holder = hash_search(parts_storage->result_rels_table,
 							 (const void *) &partid,
 							 HASH_ENTER, &found);
 
@@ -167,16 +182,16 @@ scan_result_parts_storage(Oid partid, ResultPartsStorage *storage)
 	{
 		ResultRelInfo *part_result_rel_info = makeNode(ResultRelInfo);
 
+		/* Check that 'saved_rel_info' is set */
+		if (!parts_storage->saved_rel_info)
+			elog(ERROR, "ResultPartsStorage contains no saved_rel_info");
+
 		InitResultRelInfo(part_result_rel_info,
-						  heap_open(partid, RowExclusiveLock),
-						  0,
+						  heap_open(partid, parts_storage->head_open_lock_mode),
+						  parts_storage->saved_rel_info->ri_RangeTableIndex,
 						  0); /* TODO: select suitable options */
 
-		ExecOpenIndices(part_result_rel_info, storage->speculative_inserts);
-
-		/* Check that 'saved_rel_info' is set */
-		if (!storage->saved_rel_info)
-			elog(ERROR, "ResultPartsStorage contains no saved_rel_info");
+		ExecOpenIndices(part_result_rel_info, parts_storage->speculative_inserts);
 
 		/* Copy necessary fields from saved ResultRelInfo */
 		CopyToResultRelInfo(ri_WithCheckOptions);
@@ -189,18 +204,21 @@ scan_result_parts_storage(Oid partid, ResultPartsStorage *storage)
 		/* ri_ConstraintExprs will be initialized by ExecRelCheck() */
 		part_result_rel_info->ri_ConstraintExprs = NULL;
 
-		/* Make 'range table index' point to the parent relation */
-		part_result_rel_info->ri_RangeTableIndex =
-				storage->saved_rel_info->ri_RangeTableIndex;
-
 		/* Now fill the ResultRelInfo holder */
 		rri_holder->partid = partid;
 		rri_holder->result_rel_info = part_result_rel_info;
 
+		/* Add ResultRelInfo to storage->es_alloc_result_rels */
+		parts_storage->es_alloc_result_rels =
+				append_rri_to_estate(parts_storage->estate,
+									 part_result_rel_info,
+									 parts_storage->es_alloc_result_rels);
+
 		/* Call on_new_rri_holder_callback() if needed */
-		if (storage->on_new_rri_holder_callback)
-			storage->on_new_rri_holder_callback(storage->estate, rri_holder,
-												storage->callback_arg);
+		if (parts_storage->on_new_rri_holder_callback)
+			parts_storage->on_new_rri_holder_callback(parts_storage->estate,
+													  rri_holder,
+													  parts_storage->callback_arg);
 	}
 
 	return rri_holder;
@@ -412,8 +430,8 @@ partition_filter_end(CustomScanState *node)
 {
 	PartitionFilterState   *state = (PartitionFilterState *) node;
 
-	/* Close cached relations */
-	fini_result_parts_storage(&state->result_parts);
+	/* Executor will close rels via estate->es_result_relations */
+	fini_result_parts_storage(&state->result_parts, false);
 
 	Assert(list_length(node->custom_ps) == 1);
 	ExecEndNode((PlanState *) linitial(node->custom_ps));
@@ -432,6 +450,29 @@ partition_filter_explain(CustomScanState *node, List *ancestors, ExplainState *e
 	/* Nothing to do here now */
 }
 
+static int
+append_rri_to_estate(EState *estate, ResultRelInfo *rri, int cur_allocated)
+{
+	int result_rels_allocated = cur_allocated;
+
+	if (result_rels_allocated <= estate->es_num_result_relations)
+	{
+		ResultRelInfo *rri_array = estate->es_result_relations;
+
+		result_rels_allocated = result_rels_allocated * ALLOC_EXP + 1;
+		estate->es_result_relations = palloc(result_rels_allocated *
+												sizeof(ResultRelInfo));
+		memcpy(estate->es_result_relations,
+			   rri_array,
+			   estate->es_num_result_relations * sizeof(ResultRelInfo));
+	}
+
+	/* Append ResultRelInfo to 'es_result_relations' array */
+	estate->es_result_relations[estate->es_num_result_relations++] = *rri;
+
+	return result_rels_allocated;
+}
+
 /*
  * Build partition filter's target list pointing to subplan tuple's elements
  */
@@ -465,9 +506,9 @@ pfilter_build_tlist(List *tlist)
 }
 
 /*
- * Add partition filters to ModifyTable node's children
+ * Add partition filters to ModifyTable node's children.
  *
- * 'context' should point to the PlannedStmt->rtable
+ * 'context' should point to the PlannedStmt->rtable.
  */
 static void
 partition_filter_visitor(Plan *plan, void *context)
diff --git a/src/partition_filter.h b/src/partition_filter.h
@@ -12,7 +12,7 @@
 #define RUNTIME_INSERT_H
 
 #include "relation_info.h"
-#include "pathman.h"
+#include "utils.h"
 
 #include "postgres.h"
 #include "commands/explain.h"
@@ -51,6 +51,9 @@ typedef struct
 
 	EState			   *estate;
 	int					es_alloc_result_rels;	/* number of allocated result rels */
+
+	LOCKMODE			head_open_lock_mode;
+	LOCKMODE			heap_close_lock_mode;
 } ResultPartsStorage;
 
 /*
@@ -68,7 +71,7 @@ typedef struct
 	Plan			   *subplan;				/* proxy variable to store subplan */
 	ResultPartsStorage	result_parts;			/* partition ResultRelInfo cache */
 
-	bool				warning_triggered;		/* WARNING message counter */
+	bool				warning_triggered;		/* warning message counter */
 } PartitionFilterState;
 
 
@@ -92,7 +95,8 @@ void init_result_parts_storage(ResultPartsStorage *parts_storage,
 							   Size table_entry_size,
 							   on_new_rri_holder on_new_rri_holder_cb,
 							   void *on_new_rri_holder_cb_arg);
-void fini_result_parts_storage(ResultPartsStorage *parts_storage);
+void fini_result_parts_storage(ResultPartsStorage *parts_storage,
+							   bool close_rels);
 ResultRelInfoHolder * scan_result_parts_storage(Oid partid,
 												ResultPartsStorage *storage);
 
diff --git a/src/pg_pathman.c b/src/pg_pathman.c
@@ -406,6 +406,7 @@ append_child_relation(PlannerInfo *root, RelOptInfo *rel, Index rti,
 	PlanRowMark	   *child_rowmark;
 	AttrNumber		i;
 
+	/* FIXME: acquire a suitable lock on partition */
 	newrelation = heap_open(childOid, NoLock);
 
 	/*

Original file line number	Diff line number	Diff line change
`@@ -84,8 +84,8 @@ transform_plans_into_states(RuntimeAppendState *scan_state,`
`84`	`84`	`static ChildScanCommon *`
`85`	`85`	`select_required_plans(HTAB children_table, Oid parts, int nparts, int *nres)`
`86`	`86`	`{`
`87`		`- int allocated = INITIAL_ALLOC_NUM;`
`88`		`- int used = 0;`
	`87`	`+ uint32 allocated = INITIAL_ALLOC_NUM,`
	`88`	`+ used = 0;`
`89`	`89`	`ChildScanCommon *result;`
`90`	`90`	`int i;`
`91`	`91`
`@@ -101,7 +101,7 @@ select_required_plans(HTAB children_table, Oid parts, int nparts, int *nres)`
`101`	`101`
`102`	`102`	`if (allocated <= used)`
`103`	`103`	`{`
`104`		`- allocated *= ALLOC_EXP;`
	`104`	`+ allocated = allocated * ALLOC_EXP + 1;`
`105`	`105`	`result = repalloc(result, allocated * sizeof(ChildScanCommon));`
`106`	`106`	`}`
`107`	`107`
`@@ -289,8 +289,8 @@ get_partition_oids(List ranges, int n, const PartRelationInfo *prel,`
`289`	`289`	`bool include_parent)`
`290`	`290`	`{`
`291`	`291`	`ListCell *range_cell;`
`292`		`- uint32 allocated = INITIAL_ALLOC_NUM;`
`293`		`- uint32 used = 0;`
	`292`	`+ uint32 allocated = INITIAL_ALLOC_NUM,`
	`293`	`+ used = 0;`
`294`	`294`	`Oid result = (Oid ) palloc(allocated * sizeof(Oid));`
`295`	`295`	`Oid *children = PrelGetChildrenArray(prel);`
`296`	`296`
`@@ -310,7 +310,7 @@ get_partition_oids(List ranges, int n, const PartRelationInfo *prel,`
`310`	`310`	`{`
`311`	`311`	`if (allocated <= used)`
`312`	`312`	`{`
`313`		`- allocated *= ALLOC_EXP;`
	`313`	`+ allocated = allocated * ALLOC_EXP + 1;`
`314`	`314`	`result = repalloc(result, allocated * sizeof(Oid));`
`315`	`315`	`}`
`316`	`316`
`@@ -595,10 +595,10 @@ explain_append_common(CustomScanState node, HTAB children_table, ExplainState`
`595`	`595`	`/* Construct excess PlanStates */`
`596`	`596`	`if (!es->analyze)`
`597`	`597`	`{`
`598`		`- int allocated = INITIAL_ALLOC_NUM;`
`599`		`- int used = 0;`
`600`		`- ChildScanCommon *custom_ps;`
`601`		`- ChildScanCommon child;`
	`598`	`+ uint32 allocated = INITIAL_ALLOC_NUM,`
	`599`	`+ used = 0;`
	`600`	`+ ChildScanCommon *custom_ps,`
	`601`	`+ child;`
`602`	`602`	`HASH_SEQ_STATUS seqstat;`
`603`	`603`	`int i;`
`604`	`604`
`@@ -614,7 +614,7 @@ explain_append_common(CustomScanState node, HTAB children_table, ExplainState`
`614`	`614`	`{`
`615`	`615`	`if (allocated <= used)`
`616`	`616`	`{`
`617`		`- allocated *= ALLOC_EXP;`
	`617`	`+ allocated = allocated * ALLOC_EXP + 1;`
`618`	`618`	`custom_ps = repalloc(custom_ps, allocated * sizeof(ChildScanCommon));`
`619`	`619`	`}`
`620`	`620`