Rename enable_partition_wise_join to enable_partitionwise_join

Discussion: https://www.postgresql.org/message-id/flat/ad24e4f4-6481-066e-e3fb-6ef4a3121882%402ndquadrant.com

Author: petere

contrib/postgres_fdw/expected/postgres_fdw.out

@@ -7682,9 +7682,9 @@ AND ftoptions @> array['fetch_size=60000'];
 
 ROLLBACK;
 -- ===================================================================
--- test partition-wise-joins
+-- test partitionwise joins
 -- ===================================================================
-SET enable_partition_wise_join=on;
+SET enable_partitionwise_join=on;
 CREATE TABLE fprt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
 CREATE TABLE fprt1_p1 (LIKE fprt1);
 CREATE TABLE fprt1_p2 (LIKE fprt1);
@@ -7800,4 +7800,4 @@ SELECT t1.a,t1.b FROM fprt1 t1, LATERAL (SELECT t2.a, t2.b FROM fprt2 t2 WHERE t
  400 | 400
 (4 rows)
 
-RESET enable_partition_wise_join;
+RESET enable_partitionwise_join;

contrib/postgres_fdw/sql/postgres_fdw.sql

@@ -1863,9 +1863,9 @@ AND ftoptions @> array['fetch_size=60000'];
 ROLLBACK;
 
 -- ===================================================================
--- test partition-wise-joins
+-- test partitionwise joins
 -- ===================================================================
-SET enable_partition_wise_join=on;
+SET enable_partitionwise_join=on;
 
 CREATE TABLE fprt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
 CREATE TABLE fprt1_p1 (LIKE fprt1);
@@ -1913,4 +1913,4 @@ EXPLAIN (COSTS OFF)
 SELECT t1.a,t1.b FROM fprt1 t1, LATERAL (SELECT t2.a, t2.b FROM fprt2 t2 WHERE t1.a = t2.b AND t1.b = t2.a) q WHERE t1.a%25 = 0 ORDER BY 1,2;
 SELECT t1.a,t1.b FROM fprt1 t1, LATERAL (SELECT t2.a, t2.b FROM fprt2 t2 WHERE t1.a = t2.b AND t1.b = t2.a) q WHERE t1.a%25 = 0 ORDER BY 1,2;
 
-RESET enable_partition_wise_join;
+RESET enable_partitionwise_join;

doc/src/sgml/config.sgml

@@ -3736,20 +3736,20 @@ ANY <replaceable class="parameter">num_sync</replaceable> ( <replaceable class="
       </listitem>
      </varlistentry>
 
-     <varlistentry id="guc-enable-partition-wise-join" xreflabel="enable_partition_wise_join">
-      <term><varname>enable_partition_wise_join</varname> (<type>boolean</type>)
+     <varlistentry id="guc-enable-partitionwise-join" xreflabel="enable_partitionwise_join">
+      <term><varname>enable_partitionwise_join</varname> (<type>boolean</type>)
       <indexterm>
-       <primary><varname>enable_partition_wise_join</varname> configuration parameter</primary>
+       <primary><varname>enable_partitionwise_join</varname> configuration parameter</primary>
       </indexterm>
       </term>
       <listitem>
        <para>
-        Enables or disables the query planner's use of partition-wise join,
+        Enables or disables the query planner's use of partitionwise join,
         which allows a join between partitioned tables to be performed by
-        joining the matching partitions.  Partition-wise join currently applies
+        joining the matching partitions.  Partitionwise join currently applies
         only when the join conditions include all the partition keys, which
         must be of the same data type and have exactly matching sets of child
-        partitions.  Because partition-wise join planning can use significantly
+        partitions.  Because partitionwise join planning can use significantly
         more CPU time and memory during planning, the default is
         <literal>off</literal>.
        </para>

src/backend/optimizer/README

@@ -1076,8 +1076,8 @@ plan as possible.  Expanding the range of cases in which more work can be
 pushed below the Gather (and costing them accurately) is likely to keep us
 busy for a long time to come.
 
-Partition-wise joins
---------------------
+Partitionwise joins
+-------------------
 A join between two similarly partitioned tables can be broken down into joins
 between their matching partitions if there exists an equi-join condition
 between the partition keys of the joining tables. The equi-join between
@@ -1089,7 +1089,7 @@ partitioned in the same way as the joining relations, thus allowing an N-way
 join between similarly partitioned tables having equi-join condition between
 their partition keys to be broken down into N-way joins between their matching
 partitions. This technique of breaking down a join between partitioned tables
-into joins between their partitions is called partition-wise join. We will use
+into joins between their partitions is called partitionwise join. We will use
 term "partitioned relation" for either a partitioned table or a join between
 compatibly partitioned tables.
 

src/backend/optimizer/geqo/geqo_eval.c

@@ -264,8 +264,8 @@ merge_clump(PlannerInfo *root, List *clumps, Clump *new_clump, bool force)
 			/* Keep searching if join order is not valid */
 			if (joinrel)
 			{
-				/* Create paths for partition-wise joins. */
-				generate_partition_wise_join_paths(root, joinrel);
+				/* Create paths for partitionwise joins. */
+				generate_partitionwise_join_paths(root, joinrel);
 
 				/* Create GatherPaths for any useful partial paths for rel */
 				generate_gather_paths(root, joinrel);

src/backend/optimizer/path/allpaths.c

@@ -929,7 +929,7 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 			/*
 			 * We need attr_needed data for building targetlist of a join
 			 * relation representing join between matching partitions for
-			 * partition-wise join. A given attribute of a child will be
+			 * partitionwise join. A given attribute of a child will be
 			 * needed in the same highest joinrel where the corresponding
 			 * attribute of parent is needed. Hence it suffices to use the
 			 * same Relids set for parent and child.
@@ -973,7 +973,7 @@ set_append_rel_size(PlannerInfo *root, RelOptInfo *rel,
 		/*
 		 * Copy/Modify targetlist. Even if this child is deemed empty, we need
 		 * its targetlist in case it falls on nullable side in a child-join
-		 * because of partition-wise join.
+		 * because of partitionwise join.
 		 *
 		 * NB: the resulting childrel->reltarget->exprs may contain arbitrary
 		 * expressions, which otherwise would not occur in a rel's targetlist.
@@ -2636,7 +2636,7 @@ standard_join_search(PlannerInfo *root, int levels_needed, List *initial_rels)
 		join_search_one_level(root, lev);
 
 		/*
-		 * Run generate_partition_wise_join_paths() and
+		 * Run generate_partitionwise_join_paths() and
 		 * generate_gather_paths() for each just-processed joinrel.  We could
 		 * not do this earlier because both regular and partial paths can get
 		 * added to a particular joinrel at multiple times within
@@ -2649,8 +2649,8 @@ standard_join_search(PlannerInfo *root, int levels_needed, List *initial_rels)
 		{
 			rel = (RelOptInfo *) lfirst(lc);
 
-			/* Create paths for partition-wise joins. */
-			generate_partition_wise_join_paths(root, rel);
+			/* Create paths for partitionwise joins. */
+			generate_partitionwise_join_paths(root, rel);
 
 			/* Create GatherPaths for any useful partial paths for rel */
 			generate_gather_paths(root, rel);
@@ -3405,16 +3405,16 @@ compute_parallel_worker(RelOptInfo *rel, double heap_pages, double index_pages,
 }
 
 /*
- * generate_partition_wise_join_paths
- * 		Create paths representing partition-wise join for given partitioned
+ * generate_partitionwise_join_paths
+ * 		Create paths representing partitionwise join for given partitioned
  * 		join relation.
  *
  * This must not be called until after we are done adding paths for all
  * child-joins. Otherwise, add_path might delete a path to which some path
  * generated here has a reference.
  */
 void
-generate_partition_wise_join_paths(PlannerInfo *root, RelOptInfo *rel)
+generate_partitionwise_join_paths(PlannerInfo *root, RelOptInfo *rel)
 {
 	List	   *live_children = NIL;
 	int			cnt_parts;
@@ -3442,8 +3442,8 @@ generate_partition_wise_join_paths(PlannerInfo *root, RelOptInfo *rel)
 
 		Assert(child_rel != NULL);
 
-		/* Add partition-wise join paths for partitioned child-joins. */
-		generate_partition_wise_join_paths(root, child_rel);
+		/* Add partitionwise join paths for partitioned child-joins. */
+		generate_partitionwise_join_paths(root, child_rel);
 
 		/* Dummy children will not be scanned, so ignore those. */
 		if (IS_DUMMY_REL(child_rel))

src/backend/optimizer/path/costsize.c

@@ -127,7 +127,7 @@ bool		enable_material = true;
 bool		enable_mergejoin = true;
 bool		enable_hashjoin = true;
 bool		enable_gathermerge = true;
-bool		enable_partition_wise_join = false;
+bool		enable_partitionwise_join = false;
 bool		enable_parallel_append = true;
 bool		enable_parallel_hash = true;
 

src/backend/optimizer/path/joinrels.c

@@ -39,7 +39,7 @@ static bool restriction_is_constant_false(List *restrictlist,
 static void populate_joinrel_with_paths(PlannerInfo *root, RelOptInfo *rel1,
 							RelOptInfo *rel2, RelOptInfo *joinrel,
 							SpecialJoinInfo *sjinfo, List *restrictlist);
-static void try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1,
+static void try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1,
 						RelOptInfo *rel2, RelOptInfo *joinrel,
 						SpecialJoinInfo *parent_sjinfo,
 						List *parent_restrictlist);
@@ -903,8 +903,8 @@ populate_joinrel_with_paths(PlannerInfo *root, RelOptInfo *rel1,
 			break;
 	}
 
-	/* Apply partition-wise join technique, if possible. */
-	try_partition_wise_join(root, rel1, rel2, joinrel, sjinfo, restrictlist);
+	/* Apply partitionwise join technique, if possible. */
+	try_partitionwise_join(root, rel1, rel2, joinrel, sjinfo, restrictlist);
 }
 
 
@@ -1286,25 +1286,25 @@ restriction_is_constant_false(List *restrictlist, bool only_pushed_down)
 /*
  * Assess whether join between given two partitioned relations can be broken
  * down into joins between matching partitions; a technique called
- * "partition-wise join"
+ * "partitionwise join"
  *
- * Partition-wise join is possible when a. Joining relations have same
+ * Partitionwise join is possible when a. Joining relations have same
  * partitioning scheme b. There exists an equi-join between the partition keys
  * of the two relations.
  *
- * Partition-wise join is planned as follows (details: optimizer/README.)
+ * Partitionwise join is planned as follows (details: optimizer/README.)
  *
  * 1. Create the RelOptInfos for joins between matching partitions i.e
  * child-joins and add paths to them.
  *
  * 2. Construct Append or MergeAppend paths across the set of child joins.
- * This second phase is implemented by generate_partition_wise_join_paths().
+ * This second phase is implemented by generate_partitionwise_join_paths().
  *
  * The RelOptInfo, SpecialJoinInfo and restrictlist for each child join are
  * obtained by translating the respective parent join structures.
  */
 static void
-try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
+try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 						RelOptInfo *joinrel, SpecialJoinInfo *parent_sjinfo,
 						List *parent_restrictlist)
 {
@@ -1334,7 +1334,7 @@ try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
 		   joinrel->part_scheme == rel2->part_scheme);
 
 	/*
-	 * Since we allow partition-wise join only when the partition bounds of
+	 * Since we allow partitionwise join only when the partition bounds of
 	 * the joining relations exactly match, the partition bounds of the join
 	 * should match those of the joining relations.
 	 */
@@ -1478,7 +1478,7 @@ have_partkey_equi_join(RelOptInfo *rel1, RelOptInfo *rel2, JoinType jointype,
 
 		/*
 		 * Only clauses referencing the partition keys are useful for
-		 * partition-wise join.
+		 * partitionwise join.
 		 */
 		ipk1 = match_expr_to_partition_keys(expr1, rel1, strict_op);
 		if (ipk1 < 0)
@@ -1489,13 +1489,13 @@ have_partkey_equi_join(RelOptInfo *rel1, RelOptInfo *rel2, JoinType jointype,
 
 		/*
 		 * If the clause refers to keys at different ordinal positions, it can
-		 * not be used for partition-wise join.
+		 * not be used for partitionwise join.
 		 */
 		if (ipk1 != ipk2)
 			continue;
 
 		/*
-		 * The clause allows partition-wise join if only it uses the same
+		 * The clause allows partitionwise join if only it uses the same
 		 * operator family as that specified by the partition key.
 		 */
 		if (rel1->part_scheme->strategy == PARTITION_STRATEGY_HASH)

src/backend/optimizer/util/relnode.c

@@ -1601,15 +1601,15 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
 	int			cnt;
 	PartitionScheme part_scheme;
 
-	/* Nothing to do if partition-wise join technique is disabled. */
-	if (!enable_partition_wise_join)
+	/* Nothing to do if partitionwise join technique is disabled. */
+	if (!enable_partitionwise_join)
 	{
 		Assert(!IS_PARTITIONED_REL(joinrel));
 		return;
 	}
 
 	/*
-	 * We can only consider this join as an input to further partition-wise
+	 * We can only consider this join as an input to further partitionwise
 	 * joins if (a) the input relations are partitioned, (b) the partition
 	 * schemes match, and (c) we can identify an equi-join between the
 	 * partition keys.  Note that if it were possible for

src/backend/utils/misc/guc.c

@@ -914,11 +914,11 @@ static struct config_bool ConfigureNamesBool[] =
 		NULL, NULL, NULL
 	},
 	{
-		{"enable_partition_wise_join", PGC_USERSET, QUERY_TUNING_METHOD,
-			gettext_noop("Enables partition-wise join."),
+		{"enable_partitionwise_join", PGC_USERSET, QUERY_TUNING_METHOD,
+			gettext_noop("Enables partitionwise join."),
 			NULL
 		},
-		&enable_partition_wise_join,
+		&enable_partitionwise_join,
 		false,
 		NULL, NULL, NULL
 	},