rename some fields in PartRelationInfo

Author: funbringer

src/hooks.c

@@ -325,7 +325,7 @@ pathman_rel_pathlist_hook(PlannerInfo *root,
 			TypeCacheEntry *tce;
 
 			/* Determine operator type */
-			tce = lookup_type_cache(prel->atttype, TYPECACHE_LT_OPR | TYPECACHE_GT_OPR);
+			tce = lookup_type_cache(prel->ev_type, TYPECACHE_LT_OPR | TYPECACHE_GT_OPR);
 
 			/* Make pathkeys */
 			pathkeys = build_expression_pathkey(root, (Expr *) part_expr, NULL,

src/include/relation_info.h

@@ -119,7 +119,7 @@ typedef enum
 } PartType;
 
 /*
- * Child relation info for RANGE partitioning
+ * Child relation info for RANGE partitioning.
  */
 typedef struct
 {
@@ -130,34 +130,38 @@ typedef struct
 
 /*
  * PartRelationInfo
- *		Per-relation partitioning information
+ *		Per-relation partitioning information.
+ *		Allows us to perform partition pruning.
  */
 typedef struct
 {
 	Oid				key;			/* partitioned table's Oid */
-	bool			valid;			/* is this entry valid? */
-	bool			enable_parent;	/* include parent to the plan */
+	bool			valid,			/* is this entry valid? */
+					enable_parent;	/* should plan include parent? */
 
 	PartType		parttype;		/* partitioning type (HASH | RANGE) */
 
+	/* Partition dispatch info */
 	uint32			children_count;
 	Oid			   *children;		/* Oids of child partitions */
 	RangeEntry	   *ranges;			/* per-partition range entry or NULL */
 
+	/* Partitioning expression */
 	const char	   *expr_cstr;		/* original expression */
 	Node		   *expr;			/* planned expression */
 	List		   *expr_vars;		/* vars from expression, lazy */
 	Bitmapset	   *expr_atts;		/* attnums from expression */
 
-	Oid				atttype;		/* expression type */
-	int32			atttypmod;		/* expression type modifier */
-	bool			attbyval;		/* is partitioned column stored by value? */
-	int16			attlen;			/* length of the partitioned column's type */
-	int				attalign;		/* alignment of the part column's type */
-	Oid				attcollid;		/* collation of the partitioned column */
+	/* Partitioning expression's value */
+	Oid				ev_type;		/* expression type */
+	int32			ev_typmod;		/* expression type modifier */
+	bool			ev_byval;		/* is expression's val stored by value? */
+	int16			ev_len;			/* length of the expression val's type */
+	int				ev_align;		/* alignment of the expression val's type */
+	Oid				ev_collid;		/* collation of the expression val */
 
-	Oid				cmp_proc,		/* comparison fuction for 'atttype' */
-					hash_proc;		/* hash function for 'atttype' */
+	Oid				cmp_proc,		/* comparison fuction for 'ev_type' */
+					hash_proc;		/* hash function for 'ev_type' */
 } PartRelationInfo;
 
 #define PART_EXPR_VARNO				( 1 )
@@ -176,6 +180,7 @@ typedef struct
 /*
  * PartBoundInfo
  *		Cached bounds of the specified partition.
+ *		Allows us to deminish overhead of check constraints.
  */
 typedef struct
 {
@@ -255,6 +260,7 @@ PrelExpressionForRelid(const PartRelationInfo *prel, Index rel_index)
 {
 	Node *expr;
 
+	/* TODO: implement some kind of cache */
 	if (rel_index != PART_EXPR_VARNO)
 	{
 		expr = copyObject(prel->expr);
@@ -360,7 +366,7 @@ FreeRangesArray(PartRelationInfo *prel)
 	if (prel->ranges)
 	{
 		/* Remove persistent entries if not byVal */
-		if (!prel->attbyval)
+		if (!prel->ev_byval)
 		{
 			for (i = 0; i < PrelChildrenCount(prel); i++)
 			{
@@ -370,8 +376,8 @@ FreeRangesArray(PartRelationInfo *prel)
 				if (!OidIsValid(child))
 					continue;
 
-				FreeBound(&prel->ranges[i].min, prel->attbyval);
-				FreeBound(&prel->ranges[i].max, prel->attbyval);
+				FreeBound(&prel->ranges[i].min, prel->ev_byval);
+				FreeBound(&prel->ranges[i].max, prel->ev_byval);
 			}
 		}
 

src/init.c

@@ -878,7 +878,7 @@ validate_range_constraint(const Expr *expr,
 	*lower_null = *upper_null = true;
 
 	/* Find type cache entry for partitioned expression type */
-	tce = lookup_type_cache(prel->atttype, TYPECACHE_BTREE_OPFAMILY);
+	tce = lookup_type_cache(prel->ev_type, TYPECACHE_BTREE_OPFAMILY);
 
 	/* Is it an AND clause? */
 	if (and_clause((Node *) expr))
@@ -1034,7 +1034,7 @@ read_opexpr_const(const OpExpr *opexpr,
 	/* Cast Const to a proper type if needed */
 	*value = perform_type_cast(boundary->constvalue,
 							   getBaseType(boundary->consttype),
-							   getBaseType(prel->atttype),
+							   getBaseType(prel->ev_type),
 							   &cast_success);
 
 	if (!cast_success)

src/partition_creation.c

@@ -354,7 +354,7 @@ create_partitions_for_value_internal(Oid relid, Datum value, Oid value_type,
 			shout_if_prel_is_invalid(relid, prel, PT_RANGE);
 
 			/* Fetch base types of prel->atttype & value_type */
-			base_bound_type = getBaseType(prel->atttype);
+			base_bound_type = getBaseType(prel->ev_type);
 			base_value_type = getBaseType(value_type);
 
 			/* Search for a suitable partition if we didn't hold it */
@@ -398,12 +398,12 @@ create_partitions_for_value_internal(Oid relid, Datum value, Oid value_type,
 
 				/* Copy datums in order to protect them from cache invalidation */
 				bound_min = CopyBound(&ranges[0].min,
-									  prel->attbyval,
-									  prel->attlen);
+									  prel->ev_byval,
+									  prel->ev_len);
 
 				bound_max = CopyBound(&ranges[PrelLastChild(prel)].max,
-									  prel->attbyval,
-									  prel->attlen);
+									  prel->ev_byval,
+									  prel->ev_len);
 
 				/* Check if interval is set */
 				if (isnull[Anum_pathman_config_range_interval - 1])
@@ -426,7 +426,7 @@ create_partitions_for_value_internal(Oid relid, Datum value, Oid value_type,
 											  &bound_min, &bound_max, base_bound_type,
 											  interval_binary, interval_type,
 											  value, base_value_type,
-											  prel->attcollid);
+											  prel->ev_collid);
 			}
 		}
 		else
@@ -1259,15 +1259,15 @@ check_range_available(Oid parent_relid,
 	/* Fetch comparison function */
 	fill_type_cmp_fmgr_info(&cmp_func,
 							getBaseType(value_type),
-							getBaseType(prel->atttype));
+							getBaseType(prel->ev_type));
 
 	ranges = PrelGetRangesArray(prel);
 	for (i = 0; i < PrelChildrenCount(prel); i++)
 	{
 		int c1, c2;
 
-		c1 = cmp_bounds(&cmp_func, prel->attcollid, start, &ranges[i].max);
-		c2 = cmp_bounds(&cmp_func, prel->attcollid, end, &ranges[i].min);
+		c1 = cmp_bounds(&cmp_func, prel->ev_collid, start, &ranges[i].max);
+		c2 = cmp_bounds(&cmp_func, prel->ev_collid, end, &ranges[i].min);
 
 		/* There's something! */
 		if (c1 < 0 && c2 > 0)

src/partition_filter.c

@@ -396,10 +396,10 @@ find_partitions_for_value(Datum value, Oid value_type,
 	temp_const.constisnull	= false;
 
 	/* ... and some other important data */
-	CopyToTempConst(consttypmod, atttypmod);
-	CopyToTempConst(constcollid, attcollid);
-	CopyToTempConst(constlen,    attlen);
-	CopyToTempConst(constbyval,  attbyval);
+	CopyToTempConst(consttypmod, ev_typmod);
+	CopyToTempConst(constcollid, ev_collid);
+	CopyToTempConst(constlen,    ev_len);
+	CopyToTempConst(constbyval,  ev_byval);
 
 	/* We use 0 since varno doesn't matter for Const */
 	InitWalkerContext(&wcxt, 0, prel, NULL, true);
@@ -431,7 +431,7 @@ select_partition_for_insert(Datum value, Oid value_type,
 	else if (nparts == 0)
 	{
 		 selected_partid = create_partitions_for_value(PrelParentRelid(prel),
-													   value, prel->atttype);
+													   value, prel->ev_type);
 
 		 /* get_pathman_relation_info() will refresh this entry */
 		 invalidate_pathman_relation_info(PrelParentRelid(prel), NULL);
@@ -446,7 +446,7 @@ select_partition_for_insert(Datum value, Oid value_type,
 	/* Could not find suitable partition */
 	if (rri_holder == NULL)
 		elog(ERROR, ERR_PART_ATTR_NO_PART,
-			 datum_to_cstring(value, prel->atttype));
+			 datum_to_cstring(value, prel->ev_type));
 
 	return rri_holder;
 }
@@ -630,7 +630,7 @@ partition_filter_exec(CustomScanState *node)
 			elog(ERROR, ERR_PART_ATTR_MULTIPLE_RESULTS);
 
 		/* Search for a matching partition */
-		rri_holder = select_partition_for_insert(value, prel->atttype, prel,
+		rri_holder = select_partition_for_insert(value, prel->ev_type, prel,
 												 &state->result_parts, estate);
 
 		/* Switch back and clean up per-tuple context */

src/pg_pathman.c

@@ -740,11 +740,11 @@ handle_const(const Const *c, WalkerContext *context)
 				bool	cast_success;
 
 				/* Peform type cast if types mismatch */
-				if (prel->atttype != c->consttype)
+				if (prel->ev_type != c->consttype)
 				{
 					value = perform_type_cast(c->constvalue,
 											  getBaseType(c->consttype),
-											  getBaseType(prel->atttype),
+											  getBaseType(prel->ev_type),
 											  &cast_success);
 
 					if (!cast_success)
@@ -770,14 +770,14 @@ handle_const(const Const *c, WalkerContext *context)
 
 				fill_type_cmp_fmgr_info(&cmp_finfo,
 										getBaseType(c->consttype),
-										getBaseType(prel->atttype));
+										getBaseType(prel->ev_type));
 
 				select_range_partitions(c->constvalue,
 										&cmp_finfo,
 										PrelGetRangesArray(context->prel),
 										PrelChildrenCount(context->prel),
 										strategy,
-										prel->attcollid,
+										prel->ev_collid,
 										result); /* output */
 
 				result->paramsel = estimate_paramsel_using_prel(prel, strategy);
@@ -1042,7 +1042,7 @@ handle_binary_opexpr(WalkerContext *context, WrapperNode *result,
 		return;
 	}
 
-	tce = lookup_type_cache(prel->atttype, TYPECACHE_BTREE_OPFAMILY);
+	tce = lookup_type_cache(prel->ev_type, TYPECACHE_BTREE_OPFAMILY);
 	strategy = get_op_opfamily_strategy(expr->opno, tce->btree_opf);
 
 	/* There's no strategy for this operator, go to end */
@@ -1077,17 +1077,17 @@ handle_binary_opexpr(WalkerContext *context, WrapperNode *result,
 				 * if operator collation is different from default attribute collation.
 				 * In this case we just return all of them.
 				 */
-				if (expr->opcollid != prel->attcollid &&
+				if (expr->opcollid != prel->ev_collid &&
 					strategy != BTEqualStrategyNumber)
 					goto binary_opexpr_return;
 
 				collid = OidIsValid(expr->opcollid) ?
 											expr->opcollid :
-											prel->attcollid;
+											prel->ev_collid;
 
 				fill_type_cmp_fmgr_info(&cmp_func,
 										getBaseType(c->consttype),
-										getBaseType(prel->atttype));
+										getBaseType(prel->ev_type));
 
 				select_range_partitions(c->constvalue,
 										&cmp_func,
@@ -1122,7 +1122,7 @@ handle_binary_opexpr_param(const PartRelationInfo *prel,
 	int					strategy;
 
 	/* Determine operator type */
-	tce = lookup_type_cache(prel->atttype, TYPECACHE_BTREE_OPFAMILY);
+	tce = lookup_type_cache(prel->ev_type, TYPECACHE_BTREE_OPFAMILY);
 	strategy = get_op_opfamily_strategy(expr->opno, tce->btree_opf);
 
 	result->rangeset = list_make1_irange_full(prel, IR_LOSSY);

src/pl_funcs.c

@@ -186,7 +186,7 @@ get_partition_key_type(PG_FUNCTION_ARGS)
 	prel = get_pathman_relation_info(relid);
 	shout_if_prel_is_invalid(relid, prel, PT_ANY);
 
-	PG_RETURN_OID(prel->atttype);
+	PG_RETURN_OID(prel->ev_type);
 }
 
 /*
@@ -486,7 +486,7 @@ show_partition_list_internal(PG_FUNCTION_ARGS)
 						{
 							Datum rmin = CStringGetTextDatum(
 											datum_to_cstring(BoundGetValue(&re->min),
-															 prel->atttype));
+															 prel->ev_type));
 
 							values[Anum_pathman_pl_range_min - 1] = rmin;
 						}
@@ -497,7 +497,7 @@ show_partition_list_internal(PG_FUNCTION_ARGS)
 						{
 							Datum rmax = CStringGetTextDatum(
 											datum_to_cstring(BoundGetValue(&re->max),
-															 prel->atttype));
+															 prel->ev_type));
 
 							values[Anum_pathman_pl_range_max - 1] = rmax;
 						}