agora inbox for pgsql-hackers@postgresql.org
help / color / mirror / Atom feedadvanced partition matching algorithm for partition-wise join
154+ messages / 20 participants
[nested] [flat]
* advanced partition matching algorithm for partition-wise join
@ 2017-08-21 07:13 Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2017-08-21 07:13 UTC (permalink / raw)
To: pgsql-hackers
The patch-set in [1] supports partition-wise join when the partition bounds and
partition keys of the joining tables exactly match. The last two patches in the
last few patch-sets in that thread implement more
advanced partition matching code. In order to avoid mixing reviews for advanced
partition matching and the basic partition-wise join implementation, I am
starting a new thread to discuss the same. I am attaching the last two
patches from that patch set here.
The new partition matching algorithm handles following cases when a
given partition
on one side has at most one matching partition matching on the other side.
1. When the ranges of the joining tables do not match exactly E.g. partition
table t1 has partitions t1p1 (0 - 100), t1p2 (150 - 200) and partition table t2
has partitions t2p1 (0 - 50), t2p2 (100 - 175). In this case (t1p1, t2p1) and
(t1p2, t2p2) form the matching partition pairs, which can be joined. While
matching the pairs, we also compute the partition bounds for the resulting
join. An INNER join between t1 and t2 will have ranges (0 - 50) since no row
with 50 <= key < 100 from t1p1 is going to find a matching row in t2p1 and (150
- 175) since no row with 100 <= key < 150 from t2p2 is going to find a matching
row in t1p2 and no row with 175 <= key < 200 in t1p2 is going to find a
matching row in t1p2. A t1 LEFT join t2 on the other hand will have ranges same
as the outer relation i.e. t1, (0 - 100), (150 - 200) since all rows from t1
will be part of the join. Thus depending upon the type of join the partition
bounds of the resultant join relation change. Similarly for list partitioned
table, when the lists do not match exactly, the algorithm finds matching pairs
of partitions and the lists of resultant join relation. E.g. t1 has
partitions t1p1 ('a',
'b', 'c'), t1p2 ('e', 'f') and t2 has partitions t2p1 ('a', 'b'), t2p2 ('d',
'e', 'f'). In this case (t1p1, t2p1) and (t2p1, t2p2) form the matching
pairs which are joined. Inner join will have bounds ('a','b'), ('e', 'f') and
t1 LEFT JOIN t2 will have bounds same as t1.
2. When one or both side have at least one partition that does not have
matching partition on the other side. E.g. t1 has partitions t1p1 ('a','b'),
t1p2 ('c','d') and t2 has only one partition t2p1 ('a','b') OR t1 has
partitions t1p1 (0 - 100), t1p2 (100 - 200) and t2 has only one partition t2p1
(0 - 100). In this case as well different types of joins will have different
partition bounds for the result using similar rules described above.
3. A combination of 1 and 2 e.g. t1 has partitions t1p1('a','b','c'),
t1p2('d','e','f') and t2 has a single partition t2p1 ('a','b', 'z').
Algorithm
---------
The pairs of matching partitions and the partition bounds of the join are
calculated by an algorithm similar to merge join.
In such a join, it can be observed that every partition on either side,
contributes to at most one partition of the resultant join relation. Thus for
every partition on either side, we keep track of the partition of resultant
join (if any), which it contributes to. If multiple partitions from any of the
joining relations map to a single partition of the resultant join, we need to
gang those partitions together before joining the partition/s from the other
side. Since we do not have infrastructure for ganging multiple arbitrary
RelOptInfos together in a parent RelOptInfo, we do not support such a
partitionw-wise join right now. We stop merging the bounds immediately when we
detect such a case.
For list partitioned tables, we compare list values from both the sides,
starting with the lowest. If the two list values being compared match,
corresponding partitions from both sides form a pair of partitions to be
joined. We record this mapping and also include the list value in join bounds.
If the two list values do not match and the lower of those two comes from the
outer side of the join, we include it in the join bounds. We advance to the
next list value on side with the lower list value continuing the process of
merging till list values on at least one side are exhausted. If the remaining
values are from the outer side, we include those in the join partition bounds.
Every list value included in the join bounds, and its originating partition/s
are associated with appropriate partition of the resultant join. For more
details please see partition_list_bounds_merge() in the attached patch.
In case of range partitioned tables, we compare the ranges of the partitions in
increasing order of their bounds. If two ranges being compared overlap,
corresponding partitions from both sides form a pair of partitions to be
joined. We record this mapping and also include the merged range in the bounds
of resultant join. The overlapping ranges are merged based on the type of join
as described above. If either of the ranges completely precedes the other, and
it's on the outer side, we include that range in the bounds of resultant join.
We advance to the next range on the side with lower upper bound till ranges on
at least one side are exhausted. If the remaining ranges are from the outer
side, we include those in the partition bounds of resultant join. While
including a range in the partition bounds of the resultant join if its lower
bound precedes the upper bound of the last included range, it indicates that
multiple partitions on that side map to one partition on the other side, so we
bail out. Notice that in this method, we always include the ranges in the
partition bounds of the resultant join in the increasing order of their bounds.
Every range included in the join's partition bounds and it's corresponding
partition/s from joining relations are associated with appropriate partition of
the resultant join. For more details please see partition_range_bounds_merge()
in the attached patch.
The partitions from both sides (one partition from each side) which map to the
same partition of the resultant join are joined to form child-joins. The case
when an outer partition may not have a matching partition from the inner side
will be discussed in the next section. Except for the above algorithm to find
the pairs of matching partitions and calculating bounds of the resultant join,
the rest of the partition-wise join algorithm remains the same.
Unsupported case: When a partition from outer side doesn't have matching
partition on the inner side.
--------------------------------------------------------------------------
Consider a join t1 LEFT JOIN t2 where t1 has partitions t1p1 (0 - 100), t1p2
(100 - 200) and t2 has a single partition t2p1(0 - 100). The rows in t1p2 won't
have a matching row in t2 since there is no partition matching t1p2. The result
of the join will have rows in t1p2 with columns from t2 NULLed. In order to
execute this join as a partition-wise join, we need a dummy relation in place
of the missing partition, which we can join with t1p2. We need this placeholder
dummy relation (its targetlist, relids etc.), so that rest of the planner can
work with the resulting child-join.
We notice the missing partitions only while planning the join (during the
execution of make_one_rel()), by which time we have frozen the number of base
relations. Introducing a base relation during join planning is not supported
in current planner. Similarly, a partition can be missing from a partitioned
join relation, in which case we have to add a dummy join relation. This might
need adding corresponding base relations as well. I have not spent time looking
for what it takes to support these cases. For now the patch does not support
partition-wise join in such cases.
TODOs
-----------
1. Add tests for advanced partition matching algorithm
2. Improve code quality, commenting, function names etc.
[1] https://www.postgresql.org/message-id/CAFjFpRd9Vqh_=-Ldv-XqWY006d07TJ+VXuhXCbdj=P1jukYBrw@mail.gmail...
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Attachments:
[text/x-patch] 0010-Modify-bound-comparision-functions-to-accept-members.patch (7.5K, ../../CAFjFpRdjQvaUEV5DJX3TW6pU5eq54NCkadtxHX2JiJG_GvbrCA@mail.gmail.com/2-0010-Modify-bound-comparision-functions-to-accept-members.patch)
download | inline diff:
From 7a9d903deb0475b4f8b0742fbe904a7cf0ce69c1 Mon Sep 17 00:00:00 2001
From: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
Date: Thu, 6 Jul 2017 14:15:22 +0530
Subject: [PATCH 10/11] Modify bound comparision functions to accept members
of PartitionKey
Functions partition_bound_cmp(), partition_rbound_cmp() and
partition_rbound_datum_cmp() are required to merge partition bounds
from joining relations. While doing so, we do not have access to the
PartitionKey of either relations. So, modify these functions to accept
only required members of PartitionKey so that the functions can be
reused for merging bounds.
Ashutosh Bapat.
---
src/backend/catalog/partition.c | 76 ++++++++++++++++++++++-----------------
1 file changed, 44 insertions(+), 32 deletions(-)
diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 96a64ce..d42e1b5 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -126,15 +126,17 @@ static List *generate_partition_qual(Relation rel);
static PartitionRangeBound *make_one_range_bound(PartitionKey key, int index,
List *datums, bool lower);
-static int32 partition_rbound_cmp(PartitionKey key,
- Datum *datums1, PartitionRangeDatumKind *kind1,
- bool lower1, PartitionRangeBound *b2);
-static int32 partition_rbound_datum_cmp(PartitionKey key,
- Datum *rb_datums, PartitionRangeDatumKind *rb_kind,
+static int32 partition_rbound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, Datum *datums1,
+ PartitionRangeDatumKind *kind1, bool lower1,
+ PartitionRangeBound *b2);
+static int32 partition_rbound_datum_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, Datum *rb_datums,
+ PartitionRangeDatumKind *rb_kind,
Datum *tuple_datums);
-static int32 partition_bound_cmp(PartitionKey key,
- PartitionBoundInfo boundinfo,
+static int32 partition_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, PartitionBoundInfo boundinfo,
int offset, void *probe, bool probe_is_bound);
static int partition_bound_bsearch(PartitionKey key,
PartitionBoundInfo boundinfo,
@@ -719,8 +721,9 @@ check_new_partition_bound(char *relname, Relation parent,
* First check if the resulting range would be empty with
* specified lower and upper bounds
*/
- if (partition_rbound_cmp(key, lower->datums, lower->kind, true,
- upper) >= 0)
+ if (partition_rbound_cmp(key->partnatts, key->partsupfunc,
+ key->partcollation, lower->datums,
+ lower->kind, true, upper) >= 0)
{
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
@@ -771,9 +774,11 @@ check_new_partition_bound(char *relname, Relation parent,
{
int32 cmpval;
- cmpval = partition_bound_cmp(key, boundinfo,
- offset + 1, upper,
- true);
+ cmpval = partition_bound_cmp(key->partnatts,
+ key->partsupfunc,
+ key->partcollation,
+ boundinfo, offset + 1,
+ upper, true);
if (cmpval < 0)
{
/*
@@ -2138,7 +2143,9 @@ qsort_partition_rbound_cmp(const void *a, const void *b, void *arg)
PartitionRangeBound *b2 = (*(PartitionRangeBound *const *) b);
PartitionKey key = (PartitionKey) arg;
- return partition_rbound_cmp(key, b1->datums, b1->kind, b1->lower, b2);
+ return partition_rbound_cmp(key->partnatts, key->partsupfunc,
+ key->partcollation, b1->datums, b1->kind,
+ b1->lower, b2);
}
/*
@@ -2155,7 +2162,7 @@ qsort_partition_rbound_cmp(const void *a, const void *b, void *arg)
* two contiguous partitions.
*/
static int32
-partition_rbound_cmp(PartitionKey key,
+partition_rbound_cmp(int partnatts, FmgrInfo *partsupfunc, Oid *partcollation,
Datum *datums1, PartitionRangeDatumKind *kind1,
bool lower1, PartitionRangeBound *b2)
{
@@ -2165,7 +2172,7 @@ partition_rbound_cmp(PartitionKey key,
PartitionRangeDatumKind *kind2 = b2->kind;
bool lower2 = b2->lower;
- for (i = 0; i < key->partnatts; i++)
+ for (i = 0; i < partnatts; i++)
{
/*
* First, handle cases where the column is unbounded, which should not
@@ -2186,8 +2193,8 @@ partition_rbound_cmp(PartitionKey key,
*/
break;
- cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[i],
- key->partcollation[i],
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[i],
+ partcollation[i],
datums1[i],
datums2[i]));
if (cmpval != 0)
@@ -2213,22 +2220,23 @@ partition_rbound_cmp(PartitionKey key,
* is <, =, or > partition key of tuple (tuple_datums)
*/
static int32
-partition_rbound_datum_cmp(PartitionKey key,
- Datum *rb_datums, PartitionRangeDatumKind *rb_kind,
+partition_rbound_datum_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, Datum *rb_datums,
+ PartitionRangeDatumKind *rb_kind,
Datum *tuple_datums)
{
int i;
int32 cmpval = -1;
- for (i = 0; i < key->partnatts; i++)
+ for (i = 0; i < partnatts; i++)
{
if (rb_kind[i] == PARTITION_RANGE_DATUM_MINVALUE)
return -1;
else if (rb_kind[i] == PARTITION_RANGE_DATUM_MAXVALUE)
return 1;
- cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[i],
- key->partcollation[i],
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[i],
+ partcollation[i],
rb_datums[i],
tuple_datums[i]));
if (cmpval != 0)
@@ -2245,17 +2253,18 @@ partition_rbound_datum_cmp(PartitionKey key,
* specified in *probe.
*/
static int32
-partition_bound_cmp(PartitionKey key, PartitionBoundInfo boundinfo,
- int offset, void *probe, bool probe_is_bound)
+partition_bound_cmp(int partnatts, FmgrInfo *partsupfunc, Oid *partcollation,
+ PartitionBoundInfo boundinfo, int offset, void *probe,
+ bool probe_is_bound)
{
Datum *bound_datums = boundinfo->datums[offset];
int32 cmpval = -1;
- switch (key->strategy)
+ switch (boundinfo->strategy)
{
case PARTITION_STRATEGY_LIST:
- cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[0],
- key->partcollation[0],
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
+ partcollation[0],
bound_datums[0],
*(Datum *) probe));
break;
@@ -2273,12 +2282,14 @@ partition_bound_cmp(PartitionKey key, PartitionBoundInfo boundinfo,
*/
bool lower = boundinfo->indexes[offset] < 0;
- cmpval = partition_rbound_cmp(key,
- bound_datums, kind, lower,
+ cmpval = partition_rbound_cmp(partnatts, partsupfunc,
+ partcollation, bound_datums,
+ kind, lower,
(PartitionRangeBound *) probe);
}
else
- cmpval = partition_rbound_datum_cmp(key,
+ cmpval = partition_rbound_datum_cmp(partnatts, partsupfunc,
+ partcollation,
bound_datums, kind,
(Datum *) probe);
break;
@@ -2286,7 +2297,7 @@ partition_bound_cmp(PartitionKey key, PartitionBoundInfo boundinfo,
default:
elog(ERROR, "unexpected partition strategy: %d",
- (int) key->strategy);
+ (int) boundinfo->strategy);
}
return cmpval;
@@ -2320,7 +2331,8 @@ partition_bound_bsearch(PartitionKey key, PartitionBoundInfo boundinfo,
int32 cmpval;
mid = (lo + hi + 1) / 2;
- cmpval = partition_bound_cmp(key, boundinfo, mid, probe,
+ cmpval = partition_bound_cmp(key->partnatts, key->partsupfunc,
+ key->partcollation, boundinfo, mid, probe,
probe_is_bound);
if (cmpval <= 0)
{
--
1.7.9.5
[text/x-patch] 0011-WIP-Partition-wise-join-for-1-1-1-0-0-1-partition-ma.patch (47.8K, ../../CAFjFpRdjQvaUEV5DJX3TW6pU5eq54NCkadtxHX2JiJG_GvbrCA@mail.gmail.com/3-0011-WIP-Partition-wise-join-for-1-1-1-0-0-1-partition-ma.patch)
download | inline diff:
From a650bbfa5510aa8db87d36be9def50d265779a3e Mon Sep 17 00:00:00 2001
From: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
Date: Wed, 9 Aug 2017 12:30:34 +0530
Subject: [PATCH 11/11] WIP Partition-wise join for 1:1, 1:0, 0:1 partition
matching.
Earlier version of partition-wise join implementation allowed
partition-wise join between two relations with exactly same partition
bounds. This commit allows partition-wise join to be applied under
following conditions
1. the partition bounds of joining relations are such that rows from
given partition on one side join can join with rows from maximum one
partition on the other side i.e. bounds of a given partition on one
side match/overlap with those of maximum one partition on the other
side. If the mapping happens to be m:n where m > 1 or n > 1, we have
to gang multiple partition relations together into a single relation.
This means that we have to add simple relations during join
processing, something which is not supported right now. ALso, in such
a case, different pairs of joining relations can produce different
partition bounds for the same join relation, which again is not
supported right now.
2. For every partition on outer side that can contribute to the result
of an OUTER side, there exists at least one (taken along with item 1,
it means exactly one) matching partition on the inner side. To
support partition-wise join when the inner matching partition doesn't
exist, we have to add a dummy base relation corresponding to the
non-existent inner partition. We don't have support add base relations
during join processing.
This commit is not complete yet.
Ashutosh Bapat.
---
src/backend/catalog/partition.c | 1231 +++++++++++++++++++++++++++++++++
src/backend/optimizer/path/joinrels.c | 77 ++-
src/backend/optimizer/util/relnode.c | 42 +-
src/include/catalog/partition.h | 6 +
4 files changed, 1325 insertions(+), 31 deletions(-)
diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index d42e1b5..eb35fab 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -141,6 +141,38 @@ static int32 partition_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
static int partition_bound_bsearch(PartitionKey key,
PartitionBoundInfo boundinfo,
void *probe, bool probe_is_bound, bool *is_equal);
+static PartitionBoundInfo partition_range_bounds_merge(int partnatts,
+ FmgrInfo *supfuncs, Oid *collations,
+ PartitionBoundInfo boundinfo1, int nparts1,
+ PartitionBoundInfo boundinfo2, int nparts2,
+ JoinType jointype, List **parts1, List **parts2);
+static PartitionBoundInfo partition_list_bounds_merge(int partnatts,
+ FmgrInfo *partsupfunc, Oid *collations,
+ PartitionBoundInfo boundinfo1, int nparts1,
+ PartitionBoundInfo boundinfo2, int nparts2,
+ JoinType jointype, List **parts1, List **parts2);
+static void generate_matching_part_pairs(int *mergemap1, int npart1,
+ int *mergemap2, int nparts2, JoinType jointype,
+ int nparts, List **parts1, List **parts2);
+static PartitionBoundInfo build_merged_partition_bounds(char strategy,
+ List *merged_datums, List *merged_indexes,
+ List *merged_contents, int null_index);
+static int map_and_merge_partitions(int *partmap1, int *mergemap1, int index1,
+ int *partmap2, int *mergemap2, int index2,
+ int *next_index);
+static int32 partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *collations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2);
+static int partition_range_cmp(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, bool *overlap);
+static bool partition_range_merge_next_lb(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes);
/*
* RelationBuildPartitionDesc
@@ -2348,3 +2380,1202 @@ partition_bound_bsearch(PartitionKey key, PartitionBoundInfo boundinfo,
return lo;
}
+
+/*
+ * Merge the given partition bounds.
+ *
+ * If given partition bounds can not be merged, return NULL.
+ *
+ * The function also returns two lists of partition indexes one for each of the
+ * joining relations. Both the lists contain the same number of elements. The
+ * partition indexes at the same positions in the list indicate partitions from
+ * each side to be joined and their position corresponds to the index of
+ * partition to which the results of the child-join belong in the partitioned
+ * join.
+ */
+extern PartitionBoundInfo
+partition_bounds_merge(int partnatts, FmgrInfo *partsupfunc, Oid *partcollation,
+ PartitionBoundInfo boundinfo1, int nparts1,
+ PartitionBoundInfo boundinfo2, int nparts2,
+ JoinType jointype, List **parts1, List **parts2)
+{
+ PartitionBoundInfo merged_bounds;
+ char strategy;
+
+ /* Bail out if partitioning strategies are different. */
+ if (boundinfo1->strategy != boundinfo2->strategy)
+ return NULL;
+
+ *parts1 = NIL;
+ *parts2 = NIL;
+ strategy = boundinfo1->strategy;
+ if (strategy == PARTITION_STRATEGY_LIST)
+ merged_bounds = partition_list_bounds_merge(partnatts, partsupfunc,
+ partcollation, boundinfo1,
+ nparts1, boundinfo2,
+ nparts2, jointype, parts1,
+ parts2);
+ else if (strategy == PARTITION_STRATEGY_RANGE)
+ merged_bounds = partition_range_bounds_merge(partnatts, partsupfunc,
+ partcollation, boundinfo1,
+ nparts1, boundinfo2,
+ nparts2, jointype, parts1,
+ parts2);
+ else
+ elog(ERROR, "unexpected partition strategy: %d", strategy);
+
+ Assert(merged_bounds || (*parts1 == NIL && *parts2 == NIL));
+ return merged_bounds;
+}
+
+/*
+ * partition_get_range_bounds
+ *
+ * Given the index of lower bound in datums array, return lower and upper
+ * bounds and the index of the partition with that lower bound.
+ */
+static int
+partition_get_range_bounds(PartitionBoundInfo bi, int lb_index,
+ PartitionRangeBound *lower,
+ PartitionRangeBound *upper)
+{
+ int part_index;
+
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The lower bound should correspond to a valid partition. */
+ part_index = bi->indexes[lb_index + 1];
+ Assert(part_index >= 0);
+
+ lower->kind = bi->kind[lb_index];
+ lower->datums = bi->datums[lb_index];
+ lower->lower = true;
+ upper->kind = bi->kind[lb_index + 1];
+ upper->datums = bi->datums[lb_index + 1];
+ upper->lower = false;
+
+ return part_index;
+}
+
+/*
+ * partition_range_get_next_lb_index
+ *
+ * Given the index of lower bound in datums array return the
+ * index of lower bound of the next partition. When the given index corresponds
+ * to the last partition, return -1.
+ */
+static int
+partition_range_get_next_lb_index(PartitionBoundInfo bi, int lb_index)
+{
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The lower bound should correspond to a valid partition. */
+ Assert(bi->indexes[lb_index + 1] >= 0);
+
+ /*
+ * If there are no bounds left beyond the upper bound, we have reached the
+ * last partition.
+ */
+ if (lb_index + 2 < bi->ndatums)
+ {
+ /*
+ * If the bound next to the upper bound corresponds to no partition,
+ * that's the next lower bound of the next partition. Otherwise, the
+ * current upper bound is the lower bound of the next partition.
+ */
+ if (bi->indexes[lb_index + 2] < 0)
+ return lb_index + 2;
+ else
+ return lb_index + 1;
+ }
+ else
+ return -1;
+}
+
+static int32
+partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc, Oid *collations,
+ PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2)
+{
+ return partition_rbound_cmp(partnatts, partsupfunc, collations,
+ bound1->datums, bound1->kind, bound1->lower,
+ bound2);
+}
+
+/*
+ * partition_range_cmp
+ *
+ * Compare the bounds of two range partitions and return <, = or > 0, if the
+ * first partition's upper bound is lower than, equal to or higher than the
+ * second partition's upper bound resp.
+ *
+ * Also, set overlaps to true, if the ranges overlap, otherwise set it to
+ * false.
+ */
+static int
+partition_range_cmp(int partnatts, FmgrInfo *supfuncs, Oid *collations,
+ PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, bool *overlap)
+{
+ /*
+ * Compare upper bound of the first partition with the lower bound of the
+ * second and vice-versa. If lower bound is higher than the upper bound,
+ * the partitions are not overlapping. All other cases indicate overlapping
+ * partitions.
+ * TODO: Add a testcase which has lower and upper bound matching exactly.
+ * Lower bound is inclusive and upper bound is exclusive, so even if the
+ * datums match, the bounds do not match exactly.
+ */
+ if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ lower_bound1, upper_bound2) > 0)
+ {
+ *overlap = false;
+ return 1;
+ }
+ else if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ lower_bound2, upper_bound1) > 0)
+ {
+ *overlap = false;
+ return -1;
+ }
+ else
+ {
+ *overlap = true;
+ return partition_range_bound_cmp(partnatts, supfuncs, collations,
+ upper_bound1, upper_bound2);
+ }
+}
+
+/*
+ * partition_range_merge
+ *
+ * Merge the partition bounds of given two partitions such that the join
+ * between the given two partitions fits merged bounds.
+ *
+ * "merged_upper" will be set to one of the given upper bounds and
+ * "merged_lower" will be set to one of the given lower bounds.
+ */
+static void
+partition_range_merge(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, JoinType jointype,
+ PartitionRangeBound *left_lb,
+ PartitionRangeBound *left_ub,
+ PartitionRangeBound *right_lb,
+ PartitionRangeBound *right_ub,
+ PartitionRangeBound **merged_lb,
+ PartitionRangeBound **merged_ub)
+{
+ /*
+ * An outer join will have all the rows from the outer side, so merged
+ * bounds will be same as the outer bounds. An inner join will have rows
+ * that fit both the bounds, thus lower merged bound will be higher of two
+ * lower bounds and upper merged bound will be lower of the two upper
+ * bounds.
+ */
+ switch (jointype)
+ {
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ *merged_ub = left_ub;
+ *merged_lb = left_lb;
+ break;
+
+ case JOIN_RIGHT:
+ *merged_ub = right_ub;
+ *merged_lb = right_lb;
+ break;
+
+ case JOIN_INNER:
+ case JOIN_SEMI:
+ if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ left_ub, right_ub) < 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ left_lb, right_lb) > 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ case JOIN_FULL:
+ if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ left_ub, right_ub) > 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ left_lb, right_lb) < 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ default:
+ elog(ERROR, "Unexpected join type %d", jointype);
+ }
+
+ return;
+}
+
+/*
+ * Add the lower bound of the next range to the list of bounds, if the lower
+ * bound is higher or equal to the previous upper bound. If successful return
+ * true, otherwise false.
+ */
+static bool
+partition_range_merge_next_lb(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes)
+{
+ int cmpval;
+
+ if (!*merged_datums)
+ {
+ Assert(!*merged_kinds && !*merged_indexes);
+ cmpval = 1;
+ }
+ else
+ {
+ PartitionRangeBound prev_ub;
+
+ prev_ub.datums = llast(*merged_datums);
+ prev_ub.kind = llast(*merged_kinds);
+ prev_ub.lower = false;
+
+ /*
+ * TODO: explain why do we pass lower to be false for the next lower
+ * bound.
+ */
+ cmpval = partition_rbound_cmp(partnatts, supfuncs, collations,
+ next_lb_datums, next_lb_kind, false,
+ &prev_ub);
+ }
+
+ /*
+ * The lower bound is lower than the last upper bound, thus does not fit
+ * the bounds created so far and hence can not be merged with the existing
+ * bounds.
+ */
+ if (cmpval < 0)
+ return false;
+
+ /*
+ * Add bounds of the new merged partition. If the next lower bound is
+ * higher than the last upper bound, add new range with index
+ * corresponding to the lower bound as -1. If the merged lower bound
+ * is same as the last merged upper bound, the last upper bound will be
+ * reused as the lower bound of the next range.
+ */
+ if (cmpval > 0)
+ {
+ *merged_datums = lappend(*merged_datums, next_lb_datums);
+ *merged_kinds = lappend(*merged_kinds, next_lb_kind);
+ *merged_indexes = lappend_int(*merged_indexes, -1);
+ }
+
+ return true;
+}
+
+/*
+ * Merge given two range partition bounds.
+ *
+ * Work horse function for partition_bounds_merge() for range partitioned
+ * tables.
+ *
+ * TODO: for an anti-join, the caller is supposed to send the outer relation as
+ * left relation. May be we should rename left and right as inner and outer. We
+ * don't need to handle RIGHT joins in this function, so renaming them as outer
+ * and inner is fine.
+ */
+static PartitionBoundInfo
+partition_range_bounds_merge(int partnatts, FmgrInfo *supfuncs, Oid *collations,
+ PartitionBoundInfo left_bi, int left_nparts,
+ PartitionBoundInfo right_bi, int right_nparts,
+ JoinType jointype, List **left_parts, List **right_parts)
+{
+ int *left_pmap;
+ int *left_mmap;
+ int *right_pmap;
+ int *right_mmap;
+ int cnt1;
+ int cnt2;
+ int left_part;
+ int right_part;
+ PartitionBoundInfo merged_bounds = NULL;
+ bool merged = true; /* By default we ranges are merge-able. */
+ int left_lb_index;
+ int right_lb_index;
+ int next_index;
+ int cmpval;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ List *merged_kinds = NIL;
+
+ Assert(left_bi->strategy == right_bi->strategy &&
+ left_bi->strategy == PARTITION_STRATEGY_RANGE);
+
+ *left_parts = NIL;
+ *right_parts = NIL;
+
+ /* Allocate and initialize partition maps. */
+ left_pmap = (int *) palloc(sizeof(int) * left_nparts);
+ left_mmap = (int *) palloc(sizeof(int) * left_nparts);
+ right_pmap = (int *) palloc(sizeof(int) * right_nparts);
+ right_mmap = (int *) palloc(sizeof(int) * right_nparts);
+
+ for (cnt1 = 0; cnt1 < left_nparts; cnt1++)
+ {
+ left_pmap[cnt1] = -1;
+ left_mmap[cnt1] = -1;
+ }
+ for (cnt2 = 0; cnt2 < right_nparts; cnt2++)
+ {
+ right_pmap[cnt2] = -1;
+ right_mmap[cnt2] = -1;
+ }
+
+ left_lb_index = 0;
+ right_lb_index = 0;
+ next_index = 0;
+ while (left_lb_index >= 0 && right_lb_index >= 0)
+ {
+ PartitionRangeBound left_lb;
+ PartitionRangeBound left_ub;
+ PartitionRangeBound right_lb;
+ PartitionRangeBound right_ub;
+ PartitionRangeBound *merged_lb = NULL;
+ PartitionRangeBound *merged_ub = NULL;
+ int merged_index = -1;
+ bool overlap;
+
+ /* Get the range bounds of the next partition. */
+ left_part = partition_get_range_bounds(left_bi, left_lb_index,
+ &left_lb, &left_ub);
+ right_part = partition_get_range_bounds(right_bi, right_lb_index,
+ &right_lb, &right_ub);
+
+ cmpval = partition_range_cmp(partnatts, supfuncs, collations,
+ &left_lb, &left_ub, &right_lb, &right_ub,
+ &overlap);
+
+ if (overlap)
+ {
+ /* Overlapping ranges, try merging. */
+ partition_range_merge(partnatts, supfuncs, collations, jointype,
+ &left_lb, &left_ub, &right_lb, &right_ub,
+ &merged_lb, &merged_ub);
+ merged_index = map_and_merge_partitions(left_pmap, left_mmap,
+ left_part, right_pmap,
+ right_mmap, right_part,
+ &next_index);
+
+ if (merged_index < 0)
+ {
+ merged = false;
+ break;
+ }
+ }
+
+ if (cmpval == 0)
+ {
+ Assert(overlap);
+
+ /* Move to the next pair of partitions. */
+ left_lb_index = partition_range_get_next_lb_index(left_bi,
+ left_lb_index);
+ right_lb_index = partition_range_get_next_lb_index(right_bi,
+ right_lb_index);
+ }
+ else if (cmpval < 0)
+ {
+ /*
+ * If the partition on the left was not mapped to any partition on
+ * the right. Any row from that partition will not have a matching
+ * row from the other relation. So the partition will be part of
+ * the join if it's an anti-join or the left side is the outer
+ * side.
+ */
+ if (jointype == JOIN_INNER || jointype == JOIN_SEMI ||
+ jointype == JOIN_RIGHT)
+ {
+ /* Nothing to do. */
+ }
+ else if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (left_mmap[left_part] < 0)
+ {
+ left_mmap[left_part] = next_index++;
+ merged_index = left_mmap[left_part];
+ merged_lb = &left_lb;
+ merged_ub = &left_ub;
+ }
+ }
+ else
+ {
+ /* Don't know what to do with other join types. Bail out. */
+ merged = false;
+ }
+
+ /* Move to the next partition on the left side. */
+ left_lb_index = partition_range_get_next_lb_index(left_bi,
+ left_lb_index);
+ }
+ else
+ {
+ Assert(cmpval > 0);
+
+ /*
+ * If the partition on the right was not mapped to any partition on
+ * the left. Any row from that partition will not have a matching
+ * row from the other relation. So the partition will be part of
+ * the join if the right side is the outer side.
+ */
+ if (jointype == JOIN_INNER || jointype == JOIN_SEMI ||
+ jointype == JOIN_LEFT || jointype == JOIN_ANTI)
+ merged_index = -1;
+ else if (jointype == JOIN_RIGHT || jointype == JOIN_FULL)
+ {
+ if (right_mmap[right_part] < 0)
+ {
+ right_mmap[right_part] = next_index++;
+ merged_index = right_mmap[right_part];
+ merged_lb = &right_lb;
+ merged_ub = &right_ub;
+ }
+ }
+ else
+ {
+ /* Don't know what to do with other join types. Bail out. */
+ merged = false;
+ }
+
+ /* Move to the next partition on the right side. */
+ right_lb_index = partition_range_get_next_lb_index(right_bi,
+ right_lb_index);
+ }
+
+ if (!merged)
+ break;
+
+ /* A skipped partition is not added to merged bounds. */
+ if (merged_index < 0)
+ continue;
+
+ /*
+ * We have a valid partition index for the next partition of join. The
+ * partition should have valid range.
+ */
+ Assert(merged_lb && merged_ub);
+
+ /* Try merging merged lower bound with the last upper bound. */
+ merged = partition_range_merge_next_lb(partnatts, supfuncs,
+ collations, merged_lb->datums,
+ merged_lb->kind, &merged_datums,
+ &merged_kinds, &merged_indexes);
+ if (merged)
+ {
+ /* Add upper bound with the merged partition index. */
+ merged_datums = lappend(merged_datums, merged_ub->datums);
+ merged_kinds = lappend(merged_kinds, merged_ub->kind);
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ }
+ else
+ break;
+ }
+
+ /*
+ * We will run the above loop till we exhaust ranges of at least one side
+ * unless we failed to merge the ranges.
+ */
+ Assert (!merged || (left_lb_index < 0 || right_lb_index < 0));
+
+ /*
+ * Handle any remaining partition bounds. If remaining partitions fall on
+ * the inner side of the join, none of the rows in those partition are
+ * going to be joined with any row on the outer side and hence those
+ * partitions will not be part of the join result. Hence only consider the
+ * remaining partitions on the outer side of the join.
+ */
+ if (merged &&
+ ((left_lb_index >= 0 &&
+ (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT)) ||
+ (right_lb_index >= 0 &&
+ (jointype == JOIN_RIGHT || jointype == JOIN_FULL))))
+ {
+ int bound_index = -1;
+ PartitionBoundInfo rem_bi = NULL;
+ int *mmap = NULL;
+
+ if (left_lb_index >= 0)
+ {
+ Assert(jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI);
+ bound_index = left_lb_index;
+ rem_bi = left_bi;
+ mmap = left_mmap;
+ }
+ else if (right_lb_index >= 0)
+ {
+ Assert(jointype == JOIN_RIGHT || jointype == JOIN_FULL);
+ bound_index = right_lb_index;
+ rem_bi = right_bi;
+ mmap = right_mmap;
+ }
+
+ Assert(bound_index >= 0 && rem_bi && mmap);
+
+ /*
+ * Merge lower bound of the next range with the upper bound of last
+ * range.
+ */
+ merged = partition_range_merge_next_lb(partnatts, supfuncs, collations,
+ rem_bi->datums[bound_index],
+ rem_bi->kind[bound_index],
+ &merged_datums, &merged_kinds,
+ &merged_indexes);
+
+ /*
+ * Rest of the bounds correspond to valid ranges so add them after
+ * remapping their partitions as required.
+ */
+ for (bound_index++; merged && bound_index < rem_bi->ndatums;
+ bound_index++)
+ {
+ Datum *datums = rem_bi->datums[bound_index];
+ int index = rem_bi->indexes[bound_index];
+ int part_index;
+
+ if (index < 0)
+ part_index = index;
+ else
+ {
+ if (mmap[index] < 0)
+ mmap[index] = next_index++;
+ part_index = mmap[index];
+ }
+
+ merged_indexes = lappend_int(merged_indexes, part_index);
+ merged_datums = lappend(merged_datums, datums);
+ merged_kinds = lappend(merged_kinds,
+ rem_bi->kind[bound_index]);
+ }
+ }
+
+ /* Create PartitionBoundInfo */
+ if (merged)
+ {
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(left_mmap, left_nparts, right_mmap,
+ right_nparts, jointype, next_index,
+ left_parts, right_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*left_parts && *right_parts)
+ {
+ Assert(list_length(*left_parts) == list_length(*right_parts));
+ Assert(list_length(*left_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(left_bi->strategy,
+ merged_datums,
+ merged_indexes,
+ merged_kinds,
+ -1);
+ }
+ }
+
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ pfree(left_pmap);
+ pfree(right_pmap);
+ pfree(left_mmap);
+ pfree(right_mmap);
+
+ /* Free any memory we used in this function. */
+ return merged_bounds;
+}
+
+/*
+ * partition_bounds_merge()'s arm for list partitioned tables.
+ *
+ * The function builds the maps of matching partitions from either relation. It
+ * builds the list of partition key values that may appear in the join result
+ * alongwith the list of indexes of partitions of join to which those values
+ * belong. It then crafts a PartitionBoundInfo structure representing the
+ * partition bounds of the join result.
+ */
+static PartitionBoundInfo
+partition_list_bounds_merge(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, PartitionBoundInfo left_bi,
+ int left_nparts, PartitionBoundInfo right_bi,
+ int right_nparts, JoinType jointype, List **left_parts,
+ List **right_parts)
+{
+ int *left_pmap; /* left to right partition map */
+ int *left_mmap; /* left to merged partition map */
+ int *right_pmap; /* right to left partition map */
+ int *right_mmap; /* right to merged partition map */
+ int cntl;
+ int cntr;
+ bool merged = true;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ int next_index = 0;
+ int null_index;
+ PartitionBoundInfo merged_bounds = NULL;
+ int *left_indexes = left_bi->indexes;
+ int *right_indexes = right_bi->indexes;
+ int left_ni = left_bi->null_index;
+ int right_ni = right_bi->null_index;
+
+ Assert(left_bi->strategy == right_bi->strategy &&
+ left_bi->strategy == PARTITION_STRATEGY_LIST);
+
+ /* List partitions do not require unbounded ranges. */
+ Assert(!left_bi->kind && !right_bi->kind);
+
+ /* Allocate and initialize partition maps. */
+ left_pmap = (int *) palloc(sizeof(int) * left_nparts);
+ left_mmap = (int *) palloc(sizeof(int) * left_nparts);
+ right_pmap = (int *) palloc(sizeof(int) * right_nparts);
+ right_mmap = (int *) palloc(sizeof(int) * right_nparts);
+
+ /* Initialize partition maps. */
+ for (cntl = 0; cntl < left_nparts; cntl++)
+ {
+ left_pmap[cntl] = -1;
+ left_mmap[cntl] = -1;
+ }
+ for (cntr = 0; cntr < right_nparts; cntr++)
+ {
+ right_pmap[cntr] = -1;
+ right_mmap[cntr] = -1;
+ }
+
+ cntl = cntr = 0;
+ while (cntl < left_bi->ndatums && cntr < right_bi->ndatums)
+ {
+ Datum *ldatums = left_bi->datums[cntl];
+ Datum *rdatums = right_bi->datums[cntr];
+ int l_index = left_indexes[cntl];
+ int r_index = right_indexes[cntr];
+ int cmpval;
+ int merged_index;
+ Datum *merged_datum;
+
+ /* Every list datum should map to a valid partition index. */
+ Assert(l_index >= 0 && r_index >= 0);
+
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
+ partcollation[0], ldatums[0],
+ rdatums[0]));
+ if (cmpval == 0)
+ {
+ /*
+ * Try matching partitions containing the matching datums. If
+ * successful, add the datum to the merged bounds with index of
+ * merged partition containing it.
+ */
+ merged_datum = ldatums;
+ merged_index = map_and_merge_partitions(left_pmap, left_mmap, l_index,
+ right_pmap, right_mmap, r_index,
+ &next_index);
+
+ if (merged_index < 0)
+ {
+ merged = false;
+ break;
+ }
+
+ /* Move to the next pair of bounds. */
+ cntl++;
+ cntr++;
+ }
+ else if (cmpval < 0)
+ {
+ /*
+ * This list datum is present in the left side but not the right
+ * side. So it will appear in the join when the left side is outer
+ * side.
+ */
+ if (jointype == JOIN_INNER || jointype == JOIN_RIGHT ||
+ jointype == JOIN_SEMI)
+ merged_index = -1;
+ else if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (left_mmap[l_index] < 0)
+ left_mmap[l_index] = next_index++;
+ merged_index = left_mmap[l_index];
+ merged_datum = ldatums;
+ }
+ else
+ {
+ /* Don't know what to do with other join types. */
+ merged = false;
+ break;
+ }
+
+ /* Move to the next datum on the left side. */
+ cntl++;
+ }
+ else
+ {
+ Assert(cmpval > 0);
+
+ /*
+ * This list datum is present in the right side but not the left
+ * side. So it will appear in the join when the right side is outer
+ * side.
+ */
+ if (jointype == JOIN_INNER || jointype == JOIN_LEFT ||
+ jointype == JOIN_SEMI || jointype == JOIN_ANTI)
+ merged_index = -1;
+ else if (jointype == JOIN_RIGHT || jointype == JOIN_FULL)
+ {
+ /*
+ * Every list value on the outer side will appear in the
+ * join. Find the merged partition to which this value
+ * belongs.
+ */
+ if (right_mmap[r_index] < 0)
+ right_mmap[r_index] = next_index++;
+ merged_index = right_mmap[r_index];
+ merged_datum = rdatums;
+ }
+ else
+ {
+ /* Don't know what to do with other join types. */
+ merged = false;
+ break;
+ }
+
+ /* Move to the next datum on the right side. */
+ cntr++;
+ }
+
+ /*
+ * Add the datum with appropriate index in the list of datums, if the
+ * rows containing that datum are deemed to be part of the join.
+ */
+ if (merged_index >= 0)
+ {
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ merged_datums = lappend(merged_datums, merged_datum);
+ }
+ }
+
+ /*
+ * If merge is unsuccessful, bail out without any further processing.
+ * That leaks the memory allocated in this function. So, try not to leak
+ * memory.
+ */
+ if (!merged)
+ goto merge_failed;
+
+ /* We should have exhausted datums on at least one side. */
+ Assert(cntr >= right_bi->ndatums || cntl >= left_bi->ndatums);
+
+ /*
+ * Add any remaining list values on the outer side, assigning partition
+ * indexes if required.
+ */
+ if (jointype == JOIN_LEFT || jointype == JOIN_FULL || jointype == JOIN_ANTI)
+ {
+ for (;cntl < left_bi->ndatums; cntl++)
+ {
+ Datum *ldatums = left_bi->datums[cntl];
+ int l_index = left_indexes[cntl];
+
+ if (left_mmap[l_index] < 0)
+ left_mmap[l_index] = next_index++;
+ merged_indexes = lappend_int(merged_indexes, left_mmap[l_index]);
+ merged_datums = lappend(merged_datums, ldatums);
+ }
+ }
+
+ if (jointype == JOIN_RIGHT || jointype == JOIN_FULL)
+ {
+ for (;cntr < right_bi->ndatums; cntr++)
+ {
+ Datum *rdatums = right_bi->datums[cntr];
+ int r_index = right_indexes[cntr];
+
+ if (right_mmap[r_index] < 0)
+ right_mmap[r_index] = next_index++;
+ merged_indexes = lappend_int(merged_indexes, right_mmap[r_index]);
+ merged_datums = lappend(merged_datums, rdatums);
+ }
+ }
+
+ /*
+ * Merge NULL partitions if any. Find the index of merged partition to
+ * which the NULL values belong in the join result. We can eliminate a NULL
+ * partition when it appears only in the inner relation.
+ */
+ if (!partition_bound_accepts_nulls(left_bi) &&
+ !partition_bound_accepts_nulls(right_bi))
+ null_index = -1;
+ else if (partition_bound_accepts_nulls(left_bi) &&
+ !partition_bound_accepts_nulls(right_bi))
+ {
+ if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (left_mmap[left_ni] < 0)
+ left_mmap[left_ni] = next_index++;
+ null_index = left_mmap[left_ni];
+ }
+ else
+ null_index = -1;
+ }
+ else if (!partition_bound_accepts_nulls(left_bi) &&
+ partition_bound_accepts_nulls(right_bi))
+ {
+ if (jointype == JOIN_RIGHT || jointype == JOIN_FULL)
+ {
+ if (right_mmap[right_ni] < 0)
+ right_mmap[right_ni] = next_index++;
+ null_index = right_mmap[right_ni];
+ }
+ else
+ null_index = -1;
+ }
+ else
+ {
+ /* Both the relations have NULL partitions, try merging them. */
+ null_index = map_and_merge_partitions(left_pmap, left_mmap,
+ left_ni, right_pmap,
+ right_mmap, right_ni,
+ &next_index);
+ if (null_index < 0)
+ merged = false;
+ }
+
+ /* If successful build the output structures. */
+ if (merged)
+ {
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(left_mmap, left_nparts, right_mmap,
+ right_nparts, jointype, next_index,
+ left_parts, right_parts);
+ /* Craft a PartitionBoundInfo to return. */
+ if (*left_parts && *right_parts)
+ {
+ Assert(list_length(*left_parts) == list_length(*right_parts));
+ Assert(list_length(*left_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(left_bi->strategy,
+ merged_datums,
+ merged_indexes, NIL,
+ null_index);
+ }
+ }
+
+merge_failed:
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ pfree(left_pmap);
+ pfree(right_pmap);
+ pfree(left_mmap);
+ pfree(right_mmap);
+
+ return merged_bounds;
+}
+
+/*
+ * map_and_merge_partitions
+ *
+ * If the two given partitions (given by index1 and index2 resp.) are already
+ * mapped to each other return the index of corresponding partition in the
+ * merged set of partitions. If they do not have a merged partition associated
+ * with them, assign a new merged partition index. If the partitions are
+ * already mapped and their mapped partitions are different from each other,
+ * they can not be merged, so return -1.
+ *
+ * partmap1[i] gives the partition of relation 2 which matches ith partition of
+ * relation 1. Similarly for partmap2.
+ *
+ * mergemap1[i] gives the partition in the merged set to which ith partition of
+ * relation 1 maps to. Similarly for mergemap2.
+ *
+ * index1 and index2 are the indexes of matching partition from respective
+ * relations.
+ *
+ * *next_index is used and incremented when the given partitions require a new
+ * merged partition.
+ */
+static int
+map_and_merge_partitions(int *partmap1, int *mergemap1, int index1,
+ int *partmap2, int *mergemap2, int index2,
+ int *next_index)
+{
+ int merged_index;
+
+ /*
+ * If both the partitions are not mapped to each other, update the
+ * maps.
+ */
+ if (partmap1[index1] < 0 && partmap2[index2] < 0)
+ {
+ partmap1[index1] = index2;
+ partmap2[index2] = index1;
+ }
+
+ /*
+ * If the given to partitions map to each other, find the corresponding
+ * merged partition index .
+ */
+ if (partmap1[index1] == index2 && partmap2[index2] == index1)
+ {
+ /*
+ * If both the partitions are mapped to the same merged partition, get
+ * the index of merged partition.
+ */
+ if (mergemap1[index1] == mergemap2[index2])
+ {
+ merged_index = mergemap1[index1];
+
+ /*
+ * If the given two partitions do not have a merged partition
+ * associated with them, allocate a new merged partition.
+ */
+ if (merged_index < 0)
+ {
+ merged_index = *next_index;
+ *next_index = *next_index + 1;
+ mergemap1[index1] = merged_index;
+ mergemap2[index2] = merged_index;
+ }
+ }
+
+ /*
+ * If partition from one relation was mapped to a merged partition but
+ * not the partition from the other relation, map the same merged
+ * partition to the partition from other relation, since matching
+ * partitions map to the same merged partition.
+ */
+ else if (mergemap1[index1] >= 0 && mergemap2[index2] < 0)
+ {
+ mergemap2[index2] = mergemap1[index1];
+ merged_index = mergemap1[index1];
+ }
+ else if (mergemap1[index1] < 0 && mergemap2[index2] >= 0)
+ {
+ mergemap1[index1] = mergemap2[index2];
+ merged_index = mergemap2[index2];
+ }
+ else
+ {
+ Assert(mergemap1[index1] != mergemap2[index2] &&
+ mergemap1[index1] >= 0 && mergemap2[index2] >= 0);
+
+ /*
+ * Both the partitions map to different merged partitions. This
+ * means that multiple partitions from one relation matches to one
+ * partition from the other relation. Partition-wise join does not
+ * handle this case right now, since it requires ganging multiple
+ * partitions together (into one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+ }
+ else
+ {
+ /*
+ * Multiple partitions from one relation map to one partition from the
+ * other relation. Partition-wise join does not handle this case right
+ * now, since it requires ganging multiple partitions together (into
+ * one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+
+ return merged_index;
+}
+
+/*
+ * generate_matching_part_pairs
+ *
+ * Given the merged partition to which partition on either side of join map,
+ * produce the list pairs of partitions which when joined produce the merged
+ * partitions in the order of merged partition indexes.
+ *
+ * If successful, the pairs of partitions are returned as two separate lists
+ * one for each side. Otherwise, those lists will be set to NIL.
+ *
+ * TODO: rename the sides as outer and inner. You may not need to support
+ * JOIN_RIGHT, since we won't see that type here.
+ */
+static void
+generate_matching_part_pairs(int *mergemap1, int nparts1, int *mergemap2,
+ int nparts2, JoinType jointype, int nparts,
+ List **parts1, List **parts2)
+{
+ bool merged = true;
+ int **matching_parts;
+ int cnt1;
+ int cnt2;
+
+ matching_parts = (int **) palloc(sizeof(int *) * 2);
+ matching_parts[0] = (int *) palloc(sizeof(int) * nparts);
+ matching_parts[1] = (int *) palloc(sizeof(int) * nparts);
+
+ *parts1 = NIL;
+ *parts2 = NIL;
+
+ for (cnt1 = 0; cnt1 < nparts; cnt1++)
+ {
+ matching_parts[0][cnt1] = -1;
+ matching_parts[1][cnt1] = -1;
+ }
+
+ /* Set pairs of matching partitions. */
+ for (cnt1 = 0; cnt1 < nparts1; cnt1++)
+ {
+ if (mergemap1[cnt1] >= 0)
+ {
+ Assert(mergemap1[cnt1] < nparts);
+ matching_parts[0][mergemap1[cnt1]] = cnt1;
+ }
+ }
+ for (cnt2 = 0; cnt2 < nparts2; cnt2++)
+ {
+ if (mergemap2[cnt2] >= 0)
+ {
+ Assert(mergemap2[cnt2] < nparts);
+ matching_parts[1][mergemap2[cnt2]] = cnt2;
+ }
+ }
+
+ /*
+ * If we have a partition missing on an inner side, we need to add a dummy
+ * relation which joins with the outer partition. If the inner relation
+ * happens to be a base relation, it will require adding a dummy child
+ * base relation during join processing. Right now, we freeze the base
+ * relation arrays like PlannerInfo::simple_rte_array after planning for
+ * base relations. Adding a new (dummy) base relation would require some
+ * changes to that. So, right now, we do not implement partition-wise join
+ * in such cases.
+ */
+ for (cnt1 = 0; cnt1 < nparts; cnt1++)
+ {
+ int part1 = matching_parts[0][cnt1];
+ int part2 = matching_parts[1][cnt1];
+
+ /* At least one of the partitions should exist. */
+ Assert(part1 >= 0 || part2 >= 0);
+
+ switch (jointype)
+ {
+ case JOIN_INNER:
+ case JOIN_SEMI:
+
+ /*
+ * An inner or semi join can not return any row when the
+ * matching partition on either side is missing. We should
+ * have eliminated all such cases while merging the bounds.
+ */
+ Assert(part1 >= 0 && part2 >= 0);
+ break;
+
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ Assert(part1 >= 0);
+ if (part2 < 0)
+ merged = false;
+ break;
+
+ case JOIN_RIGHT:
+ Assert(part2 >= 0);
+ if (part1 < 0)
+ merged = false;
+ break;
+
+ case JOIN_FULL:
+ if (part1 < 0 || part2 < 0)
+ merged = false;
+ break;
+
+ default:
+ /* We do not know what to do in this case. Bail out. */
+ merged = false;
+ }
+
+ if (!merged)
+ break;
+
+ *parts1 = lappend_int(*parts1, part1);
+ *parts2 = lappend_int(*parts2, part2);
+ }
+
+ pfree(matching_parts[0]);
+ pfree(matching_parts[1]);
+ pfree(matching_parts);
+
+ if (!merged)
+ {
+ list_free(*parts1);
+ list_free(*parts2);
+ *parts1 = NIL;
+ *parts2 = NIL;
+ }
+}
+
+static PartitionBoundInfo
+build_merged_partition_bounds(char strategy, List *merged_datums,
+ List *merged_indexes, List *merged_kinds,
+ int null_index)
+{
+ int cnt;
+ PartitionBoundInfo merged_bounds;
+ ListCell *lc;
+
+ /* We expect the same number of elements in datums and indexes lists. */
+ Assert(list_length(merged_datums) == list_length(merged_indexes));
+
+ merged_bounds = (PartitionBoundInfo) palloc(sizeof(PartitionBoundInfoData));
+ merged_bounds->strategy = strategy;
+ merged_bounds->ndatums = list_length(merged_datums);
+
+ if (strategy == PARTITION_STRATEGY_RANGE)
+ {
+ Assert(list_length(merged_datums) == list_length(merged_kinds));
+ merged_bounds->kind = (PartitionRangeDatumKind **) palloc(sizeof(PartitionRangeDatumKind *) *
+ list_length(merged_kinds));
+ cnt = 0;
+ foreach(lc, merged_kinds)
+ merged_bounds->kind[cnt++] = lfirst(lc);
+
+ /* There are ndatums+1 indexes in case of range partitions */
+ merged_indexes = lappend_int(merged_indexes, -1);
+ }
+ else
+ merged_bounds->kind = NULL;
+
+ cnt = 0;
+ merged_bounds->datums = (Datum **) palloc(sizeof(Datum *) *
+ list_length(merged_datums));
+ foreach(lc, merged_datums)
+ merged_bounds->datums[cnt++] = lfirst(lc);
+
+ merged_bounds->indexes = (int *) palloc(sizeof(int) *
+ list_length(merged_indexes));
+ cnt = 0;
+ foreach(lc, merged_indexes)
+ merged_bounds->indexes[cnt++] = lfirst_int(lc);
+
+ merged_bounds->null_index = null_index;
+
+ return merged_bounds;
+}
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index a97a895..fb8d752 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1308,8 +1308,13 @@ try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
RelOptInfo *joinrel, SpecialJoinInfo *parent_sjinfo,
List *parent_restrictlist)
{
- int nparts;
int cnt_parts;
+ PartitionScheme part_scheme;
+ PartitionBoundInfo join_boundinfo;
+ List *parts1;
+ List *parts2;
+ ListCell *lc1;
+ ListCell *lc2;
/* Guard against stack overflow due to overly deep partition hierarchy. */
check_stack_depth();
@@ -1353,39 +1358,54 @@ try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
*/
Assert(joinrel->part_scheme == rel1->part_scheme &&
joinrel->part_scheme == rel2->part_scheme);
+ part_scheme = joinrel->part_scheme;
/*
- * Since we allow partition-wise 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.
+ * Get the list of matching partitions from both sides of the join. While
+ * doing so, we also build the partition bounds of the join relation,
+ * which should match the bounds calculated for other pairs. TODO: why
+ * should every pair result in the same partition bounds?
*/
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel1->boundinfo));
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel2->boundinfo));
-
- nparts = joinrel->nparts;
-
+ join_boundinfo = partition_bounds_merge(part_scheme->partnatts,
+ part_scheme->partsupfunc,
+ part_scheme->parttypcoll,
+ rel1->boundinfo, rel1->nparts,
+ rel2->boundinfo, rel2->nparts,
+ parent_sjinfo->jointype,
+ &parts1, &parts2);
+
+ Assert(join_boundinfo);
+ Assert(partition_bounds_equal(part_scheme->partnatts,
+ part_scheme->parttyplen,
+ part_scheme->parttypbyval, join_boundinfo,
+ joinrel->boundinfo));
elog(DEBUG3, "join between relations %s and %s is considered for partition-wise join.",
bmsToString(rel1->relids), bmsToString(rel2->relids));
- /* Allocate space to hold child-joins RelOptInfos, if not already done. */
+ /*
+ * Every pair of joining relations should result in the same number of
+ * child-joins.
+ */
+ Assert(joinrel->nparts == list_length(parts1));
+ Assert(joinrel->nparts == list_length(parts2));
+
+ /* Allocate space for hold child-joins RelOptInfos, if not already done. */
if (!joinrel->part_rels)
- joinrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) * nparts);
+ joinrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+ joinrel->nparts);
/*
* Create child-join relations for this partitioned join, if those don't
* exist. Add paths to child-joins for a pair of child relations
* corresponding to the given pair of parent relations.
*/
- for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+ cnt_parts = 0;
+ forboth(lc1, parts1, lc2, parts2)
{
- RelOptInfo *child_rel1 = rel1->part_rels[cnt_parts];
- RelOptInfo *child_rel2 = rel2->part_rels[cnt_parts];
+ int part1 = lfirst_int(lc1);
+ int part2 = lfirst_int(lc2);
+ RelOptInfo *child_rel1;
+ RelOptInfo *child_rel2;
SpecialJoinInfo *child_sjinfo;
List *child_restrictlist;
RelOptInfo *child_joinrel;
@@ -1393,6 +1413,10 @@ try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
AppendRelInfo **appinfos;
int nappinfos;
+ Assert(part1 >= 0 && part2 >= 0);
+ child_rel1 = rel1->part_rels[part1];
+ child_rel2 = rel2->part_rels[part2];
+
/* We should never try to join two overlapping sets of rels. */
Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1425,6 +1449,15 @@ try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
joinrel->part_rels[cnt_parts] = child_joinrel;
}
+ /*
+ * For every pair of joining relations, the set of matching partitions
+ * would change. However, the base relation partitions constituting
+ * the given child should remain same for all the joining pairs. Since
+ * the order in which children are stored in the array of child-joins,
+ * depends upon partition bounds of the join, which are same for all
+ * the joining pairs, every joining pair yields the child-joins in the
+ * same order.
+ */
Assert(bms_equal(child_joinrel->relids, child_joinrelids));
populate_joinrel_with_paths(root, child_rel1, child_rel2,
@@ -1437,7 +1470,11 @@ try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
*/
try_partition_wise_join(root, child_rel1, child_rel2, child_joinrel,
child_sjinfo, child_restrictlist);
+
+ cnt_parts++;
}
+
+ Assert(cnt_parts == joinrel->nparts);
}
/*
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 72b6832..c58b00c 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1623,6 +1623,9 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
int partnatts;
int cnt;
PartitionScheme part_scheme;
+ PartitionBoundInfo join_boundinfo;
+ List *parts1;
+ List *parts2;
/* Nothing to do if partition-wise join technique is disabled. */
if (!enable_partition_wise_join)
@@ -1663,17 +1666,26 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
REL_HAS_ALL_PART_PROPS(inner_rel));
/*
- * For now, our partition matching algorithm can match partitions only
- * when the partition bounds of the joining relations are exactly same.
- * So, bail out otherwise.
+ * Every pair of joining relations would yield the same partition bounds
+ * for a given join (TODO: why?) so we compute the bounds only the first
+ * time. Then for every pair we find the pairs of matching partitions from
+ * the joining relations and join those. TODO: Needs a better explanation
+ * of why is this true. TODO: Also there is no reason to have
+ * part_indexes1 and part_indexes2 pulled here just to be freed up later.
+ * So, we might want to do something better.
*/
- if (outer_rel->nparts != inner_rel->nparts ||
- !partition_bounds_equal(part_scheme->partnatts,
- part_scheme->parttyplen,
- part_scheme->parttypbyval,
- outer_rel->boundinfo, inner_rel->boundinfo))
+ join_boundinfo = partition_bounds_merge(part_scheme->partnatts,
+ part_scheme->partsupfunc,
+ part_scheme->parttypcoll,
+ outer_rel->boundinfo,
+ outer_rel->nparts,
+ inner_rel->boundinfo,
+ inner_rel->nparts,
+ jointype, &parts1, &parts2);
+ if (!join_boundinfo)
{
Assert(!IS_PARTITIONED_REL(joinrel));
+ Assert(!parts1 && !parts2);
return;
}
@@ -1686,13 +1698,16 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
!joinrel->nullable_partexprs && !joinrel->part_rels &&
!joinrel->boundinfo);
+ Assert(list_length(parts1) == list_length(parts2));
+
/*
* Join relation is partitioned using same partitioning scheme as the
- * joining relations and has same bounds.
+ * joining relations. It will have as many partitions as the pairs of
+ * matching partitions we found.
*/
joinrel->part_scheme = part_scheme;
- joinrel->boundinfo = outer_rel->boundinfo;
- joinrel->nparts = outer_rel->nparts;
+ joinrel->nparts = list_length(parts1);
+ joinrel->boundinfo = join_boundinfo;
partnatts = joinrel->part_scheme->partnatts;
/*
@@ -1813,4 +1828,9 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
joinrel->nullable_partexprs[cnt] = nullable_partexprs;
}
}
+
+ /* TODO: OR we could actually create the child-join relations here.*/
+ list_free(parts1);
+ list_free(parts2);
+
}
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 2283c67..056a4f9 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -99,4 +99,10 @@ extern int get_partition_for_tuple(PartitionDispatch *pd,
EState *estate,
PartitionDispatchData **failed_at,
TupleTableSlot **failed_slot);
+extern PartitionBoundInfo partition_bounds_merge(int partnatts,
+ FmgrInfo *supfuncs, Oid *collations,
+ PartitionBoundInfo boundinfo1, int nparts1,
+ PartitionBoundInfo boundinfo2, int nparts2,
+ JoinType jointype, List **parts1, List **parts2);
+
#endif /* PARTITION_H */
--
1.7.9.5
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2017-08-28 07:14 ` Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Rajkumar Raghuwanshi @ 2017-08-28 07:14 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; +Cc: pgsql-hackers
On Mon, Aug 21, 2017 at 12:43 PM, Ashutosh Bapat <
ashutosh.bapat@enterprisedb.com> wrote:
> TODOs
> -----------
> 1. Add tests for advanced partition matching algorithm
>
Hi Ashutosh,
I have applied all partition-wise-join patches (v26) and tested feature. I
have modified partition_join.sql file and added extra test cases to test
partition matching.
Attaching WIP test case patch which as of now have some server crashes and
a data corruptions issue which is commented in the file itself and need to
be removed once issue got solved. Also some of queries is not picking or
picking partition-wise-join as per expectation which may need some
adjustment.
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Attachments:
[text/x-patch] advanced_partition_matching_test.patch (210.8K, ../../CAKcux6nqCb7+zJBEF=QQzzHOB9acf2rMU+L609eWnkLtkKb5Vw@mail.gmail.com/3-advanced_partition_matching_test.patch)
download | inline diff:
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index a246d87..e9dd539 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -5,6 +5,9 @@
-- Enable partition-wise join, which by default is disabled.
SET enable_partition_wise_join to true;
--
+-- tests for range partitioned tables.
+--
+--
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
@@ -16,15 +19,20 @@ CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
ANALYZE prt1;
+-- prt2 have missing starting 0-50 range and missing ending 550-600
+-- range bounds
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
-CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
+CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (50) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
-CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599, 3) i;
+CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (550);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0+50, 599-50, 3) i;
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
@@ -56,10 +64,10 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b =
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
a | c | b | c
-----+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
+ 50 | 0050 | 50 | 0050
+ 200 | 0200 | 200 | 0200
+ 350 | 0350 | 350 | 0350
+ 500 | 0500 | 500 | 0500
(4 rows)
-- left outer join, with whole-row reference
@@ -94,25 +102,25 @@ SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER
SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
t1 | t2
--------------+--------------
- (0,0,0000) | (0,0,0000)
- (50,0,0050) |
+ (0,0,0000) |
+ (50,0,0050) | (0,50,0050)
(100,0,0100) |
- (150,0,0150) | (0,150,0150)
- (200,0,0200) |
+ (150,0,0150) |
+ (200,0,0200) | (0,200,0200)
(250,0,0250) |
- (300,0,0300) | (0,300,0300)
- (350,0,0350) |
+ (300,0,0300) |
+ (350,0,0350) | (0,350,0350)
(400,0,0400) |
- (450,0,0450) | (0,450,0450)
- (500,0,0500) |
+ (450,0,0450) |
+ (500,0,0500) | (0,500,0500)
(550,0,0550) |
(12 rows)
-- right outer join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
----------------------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------
Sort
Sort Key: t1.a, t2.b
-> Result
@@ -129,171 +137,150 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHE
-> Hash
-> Seq Scan on prt2_p2 t2_1
Filter: (a = 0)
- -> Nested Loop Left Join
- -> Seq Scan on prt2_p3 t2_2
- Filter: (a = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_1
- Index Cond: (a = t2_2.b)
-(21 rows)
+ -> Hash Right Join
+ Hash Cond: (t1_1.a = t2_2.b)
+ -> Seq Scan on prt1_p3 t1_1
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_2
+ Filter: (a = 0)
+(22 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b;
a | c | b | c
-----+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
- | | 75 | 0075
- | | 225 | 0225
- | | 375 | 0375
- | | 525 | 0525
-(8 rows)
+ 50 | 0050 | 50 | 0050
+ 200 | 0200 | 200 | 0200
+ 350 | 0350 | 350 | 0350
+ 500 | 0500 | 500 | 0500
+ | | 125 | 0125
+ | | 275 | 0275
+ | | 425 | 0425
+(7 rows)
-- full outer join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------
Sort
Sort Key: prt1_p1.a, prt2_p1.b
- -> Append
- -> Hash Full Join
- Hash Cond: (prt1_p1.a = prt2_p1.b)
+ -> Hash Full Join
+ Hash Cond: (prt1_p1.a = prt2_p1.b)
+ -> Append
-> Seq Scan on prt1_p1
Filter: (b = 0)
- -> Hash
- -> Seq Scan on prt2_p1
- Filter: (a = 0)
- -> Hash Full Join
- Hash Cond: (prt1_p2.a = prt2_p2.b)
+ -> Seq Scan on prt1_p3
+ Filter: (b = 0)
-> Seq Scan on prt1_p2
Filter: (b = 0)
- -> Hash
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p1
+ Filter: (a = 0)
-> Seq Scan on prt2_p2
Filter: (a = 0)
- -> Hash Full Join
- Hash Cond: (prt1_p3.a = prt2_p3.b)
- -> Seq Scan on prt1_p3
- Filter: (b = 0)
- -> Hash
-> Seq Scan on prt2_p3
Filter: (a = 0)
-(24 rows)
+(19 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) ORDER BY t1.a, t2.b;
a | c | b | c
-----+------+-----+------
- 0 | 0000 | 0 | 0000
- 50 | 0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | 50 | 0050
100 | 0100 | |
- 150 | 0150 | 150 | 0150
- 200 | 0200 | |
+ 150 | 0150 | |
+ 200 | 0200 | 200 | 0200
250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
+ 300 | 0300 | |
+ 350 | 0350 | 350 | 0350
400 | 0400 | |
- 450 | 0450 | 450 | 0450
- 500 | 0500 | |
+ 450 | 0450 | |
+ 500 | 0500 | 500 | 0500
550 | 0550 | |
- | | 75 | 0075
- | | 225 | 0225
- | | 375 | 0375
- | | 525 | 0525
-(16 rows)
+ | | 125 | 0125
+ | | 275 | 0275
+ | | 425 | 0425
+(15 rows)
-- Cases with non-nullable expressions in subquery results;
-- make sure these go to null as expected
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) WHERE t1.phv = t1.a OR t2.phv = t2.b ORDER BY t1.a, t2.b;
- QUERY PLAN
-------------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------
Sort
Sort Key: prt1_p1.a, prt2_p1.b
- -> Append
- -> Hash Full Join
- Hash Cond: (prt1_p1.a = prt2_p1.b)
- Filter: (((50) = prt1_p1.a) OR ((75) = prt2_p1.b))
+ -> Hash Full Join
+ Hash Cond: (prt1_p1.a = prt2_p1.b)
+ Filter: (((50) = prt1_p1.a) OR ((75) = prt2_p1.b))
+ -> Append
-> Seq Scan on prt1_p1
Filter: (b = 0)
- -> Hash
- -> Seq Scan on prt2_p1
- Filter: (a = 0)
- -> Hash Full Join
- Hash Cond: (prt1_p2.a = prt2_p2.b)
- Filter: (((50) = prt1_p2.a) OR ((75) = prt2_p2.b))
+ -> Seq Scan on prt1_p3
+ Filter: (b = 0)
-> Seq Scan on prt1_p2
Filter: (b = 0)
- -> Hash
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p1
+ Filter: (a = 0)
-> Seq Scan on prt2_p2
Filter: (a = 0)
- -> Hash Full Join
- Hash Cond: (prt1_p3.a = prt2_p3.b)
- Filter: (((50) = prt1_p3.a) OR ((75) = prt2_p3.b))
- -> Seq Scan on prt1_p3
- Filter: (b = 0)
- -> Hash
-> Seq Scan on prt2_p3
Filter: (a = 0)
-(27 rows)
+(20 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) WHERE t1.phv = t1.a OR t2.phv = t2.b ORDER BY t1.a, t2.b;
a | c | b | c
----+------+----+------
- 50 | 0050 | |
- | | 75 | 0075
-(2 rows)
+ 50 | 0050 | 50 | 0050
+(1 row)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t1.phv, t2.b, t2.c, t2.phv FROM (SELECT 25 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 50 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------
Sort
Sort Key: prt1_p1.a, prt2_p1.b
- -> Result
+ -> Hash Full Join
+ Hash Cond: (prt1_p1.a = prt2_p1.b)
-> Append
- -> Hash Full Join
- Hash Cond: (prt1_p1.a = prt2_p1.b)
- -> Seq Scan on prt1_p1
- Filter: (b = 0)
- -> Hash
- -> Seq Scan on prt2_p1
- Filter: (a = 0)
- -> Hash Full Join
- Hash Cond: (prt1_p2.a = prt2_p2.b)
- -> Seq Scan on prt1_p2
- Filter: (b = 0)
- -> Hash
- -> Seq Scan on prt2_p2
- Filter: (a = 0)
- -> Hash Full Join
- Hash Cond: (prt1_p3.a = prt2_p3.b)
- -> Seq Scan on prt1_p3
- Filter: (b = 0)
- -> Hash
- -> Seq Scan on prt2_p3
- Filter: (a = 0)
-(25 rows)
+ -> Seq Scan on prt1_p1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3
+ Filter: (a = 0)
+(19 rows)
SELECT t1.a, t1.c, t1.phv, t2.b, t2.c, t2.phv FROM (SELECT 25 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 50 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) ORDER BY t1.a, t2.b;
a | c | phv | b | c | phv
-----+------+-----+-----+------+-----
- 0 | 0000 | 25 | 0 | 0000 | 50
- 50 | 0050 | 25 | | |
+ 0 | 0000 | 25 | | |
+ 50 | 0050 | 25 | 50 | 0050 | 50
100 | 0100 | 25 | | |
- 150 | 0150 | 25 | 150 | 0150 | 50
- 200 | 0200 | 25 | | |
+ 150 | 0150 | 25 | | |
+ 200 | 0200 | 25 | 200 | 0200 | 50
250 | 0250 | 25 | | |
- 300 | 0300 | 25 | 300 | 0300 | 50
- 350 | 0350 | 25 | | |
+ 300 | 0300 | 25 | | |
+ 350 | 0350 | 25 | 350 | 0350 | 50
400 | 0400 | 25 | | |
- 450 | 0450 | 25 | 450 | 0450 | 50
- 500 | 0500 | 25 | | |
+ 450 | 0450 | 25 | | |
+ 500 | 0500 | 25 | 500 | 0500 | 50
550 | 0550 | 25 | | |
- | | | 75 | 0075 | 50
- | | | 225 | 0225 | 50
- | | | 375 | 0375 | 50
- | | | 525 | 0525 | 50
-(16 rows)
+ | | | 125 | 0125 | 50
+ | | | 275 | 0275 | 50
+ | | | 425 | 0425 | 50
+(15 rows)
-- Join with pruned partitions from joining relations
EXPLAIN (COSTS OFF)
@@ -315,7 +302,7 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.a <
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.a < 450 AND t2.b > 250 AND t1.b = 0 ORDER BY t1.a, t2.b;
a | c | b | c
-----+------+-----+------
- 300 | 0300 | 300 | 0300
+ 350 | 0350 | 350 | 0350
(1 row)
EXPLAIN (COSTS OFF)
@@ -350,43 +337,32 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
150 | 0150 | |
200 | 0200 | |
250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
+ 300 | 0300 | |
+ 350 | 0350 | 350 | 0350
400 | 0400 | |
(9 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
-------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
- -> Append
- -> Hash Full Join
- Hash Cond: (prt1_p1.a = b)
- Filter: ((prt1_p1.b = 0) OR (a = 0))
+ Sort Key: prt1_p1.a, prt2_p2.b
+ -> Hash Full Join
+ Hash Cond: (prt1_p1.a = prt2_p2.b)
+ Filter: ((prt1_p1.b = 0) OR (prt2_p2.a = 0))
+ -> Append
-> Seq Scan on prt1_p1
Filter: (a < 450)
- -> Hash
- -> Result
- One-Time Filter: false
- -> Hash Full Join
- Hash Cond: (prt1_p2.a = prt2_p2.b)
- Filter: ((prt1_p2.b = 0) OR (prt2_p2.a = 0))
-> Seq Scan on prt1_p2
Filter: (a < 450)
- -> Hash
+ -> Hash
+ -> Append
-> Seq Scan on prt2_p2
Filter: (b > 250)
- -> Hash Full Join
- Hash Cond: (prt2_p3.b = a)
- Filter: ((b = 0) OR (prt2_p3.a = 0))
- -> Seq Scan on prt2_p3
- Filter: (b > 250)
- -> Hash
- -> Result
- One-Time Filter: false
-(27 rows)
+ -> Seq Scan on prt2_p3
+ Filter: (b > 250)
+(16 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
a | c | b | c
@@ -397,12 +373,12 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JO
150 | 0150 | |
200 | 0200 | |
250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
+ 300 | 0300 | |
+ 350 | 0350 | 350 | 0350
400 | 0400 | |
- | | 375 | 0375
- | | 450 | 0450
- | | 525 | 0525
+ | | 275 | 0275
+ | | 425 | 0425
+ | | 500 | 0500
(12 rows)
-- Semi-join
@@ -439,10 +415,46 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
a | b | c
-----+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
+ 50 | 0 | 0050
+ 200 | 0 | 0200
+ 350 | 0 | 0350
+ 500 | 0 | 0500
+(4 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------
+ Append
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Seq Scan on prt2_p1 t1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_1.b = t2_2.a)
+ -> Seq Scan on prt2_p2 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p2 t2_2
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: (t1_2.b = t2_1.a)
+ -> Seq Scan on prt2_p3 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt1_p3 t2_1
+ Filter: (b = 0)
+(21 rows)
+
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.a;
+ a | b | c
+---+-----+------
+ 0 | 50 | 0050
+ 0 | 200 | 0200
+ 0 | 350 | 0350
+ 0 | 500 | 0500
(4 rows)
-- Anti-join with aggregates
@@ -472,7 +484,31 @@ SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
sum | avg | sum | avg
-------+----------------------+------+---------------------
- 60000 | 300.0000000000000000 | 2400 | 12.0000000000000000
+ 64584 | 299.0000000000000000 | 2584 | 11.9629629629629630
+(1 row)
+
+EXPLAIN (COSTS OFF)
+SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a);
+ QUERY PLAN
+--------------------------------------------------
+ Aggregate
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p1 t1
+ -> Seq Scan on prt2_p2 t1_1
+ -> Seq Scan on prt2_p3 t1_2
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p1 t2
+ -> Seq Scan on prt1_p3 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+(12 rows)
+
+SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a);
+ sum | avg | sum | avg
+-----+---------------------+-------+----------------------
+ 992 | 11.9518072289156627 | 24817 | 299.0000000000000000
(1 row)
-- lateral reference
@@ -484,50 +520,46 @@ SELECT * FROM prt1 t1 LEFT JOIN LATERAL
--------------------------------------------------------------------------------
Sort
Sort Key: t1.a
- -> Result
+ -> Nested Loop Left Join
-> Append
- -> Nested Loop Left Join
- -> Seq Scan on prt1_p1 t1
- Filter: (b = 0)
- -> Nested Loop
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t3.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p1 t3
+ -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p3 t3_2
+ -> Hash
+ -> Append
-> Index Only Scan using iprt1_p1_a on prt1_p1 t2
Index Cond: (a = t1.a)
- -> Index Scan using iprt2_p1_b on prt2_p1 t3
- Index Cond: (b = t2.a)
- -> Nested Loop Left Join
- -> Seq Scan on prt1_p2 t1_2
- Filter: (b = 0)
- -> Nested Loop
- -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
- Index Cond: (a = t1_2.a)
- -> Index Scan using iprt2_p2_b on prt2_p2 t3_1
- Index Cond: (b = t2_2.a)
- -> Nested Loop Left Join
- -> Seq Scan on prt1_p3 t1_1
- Filter: (b = 0)
- -> Nested Loop
-> Index Only Scan using iprt1_p3_a on prt1_p3 t2_1
- Index Cond: (a = t1_1.a)
- -> Index Scan using iprt2_p3_b on prt2_p3 t3_2
- Index Cond: (b = t2_1.a)
-(28 rows)
+ Index Cond: (a = t1.a)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1.a)
+(24 rows)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, least(t1.a,t2.a,t3.b) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.a = ss.t2a WHERE t1.b = 0 ORDER BY t1.a;
a | b | c | t2a | t3a | least
-----+---+------+-----+-----+-------
- 0 | 0 | 0000 | 0 | 0 | 0
- 50 | 0 | 0050 | | |
+ 0 | 0 | 0000 | | |
+ 50 | 0 | 0050 | 50 | 0 | 50
100 | 0 | 0100 | | |
- 150 | 0 | 0150 | 150 | 0 | 150
- 200 | 0 | 0200 | | |
+ 150 | 0 | 0150 | | |
+ 200 | 0 | 0200 | 200 | 0 | 200
250 | 0 | 0250 | | |
- 300 | 0 | 0300 | 300 | 0 | 300
- 350 | 0 | 0350 | | |
+ 300 | 0 | 0300 | | |
+ 350 | 0 | 0350 | 350 | 0 | 350
400 | 0 | 0400 | | |
- 450 | 0 | 0450 | 450 | 0 | 450
- 500 | 0 | 0500 | | |
+ 450 | 0 | 0450 | | |
+ 500 | 0 | 0500 | 500 | 0 | 500
550 | 0 | 0550 | | |
(12 rows)
@@ -570,17 +602,17 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
ON t1.c = ss.t2c WHERE (t1.b + coalesce(ss.t2b, 0)) = 0 ORDER BY t1.a;
a | t2a | t2c
-----+-----+------
- 0 | 0 | 0000
- 50 | |
+ 0 | |
+ 50 | 50 | 0050
100 | |
- 150 | 150 | 0150
- 200 | |
+ 150 | |
+ 200 | 200 | 0200
250 | |
- 300 | 300 | 0300
- 350 | |
+ 300 | |
+ 350 | 350 | 0350
400 | |
- 450 | 450 | 0450
- 500 | |
+ 450 | |
+ 500 | 500 | 0500
550 | |
(12 rows)
@@ -641,55 +673,50 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 =
--
-- N-way join
--
+--TODO: remove below comments and enable partition_wise_join
+--one issue got fixed
+--Server crashed with below queries
+--setting partition-wise-join to off
+SET enable_partition_wise_join to false;
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t3 WHERE t1.a = t2.b AND t1.a = (t3.a + t3.b)/2 AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
----------------------------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------------------------
Sort
Sort Key: t1.a
- -> Result
+ -> Hash Join
+ Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
-> Append
- -> Nested Loop
- Join Filter: (t1.a = ((t3.a + t3.b) / 2))
- -> Hash Join
- Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p3 t3_2
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
-> Seq Scan on prt2_p1 t2
- -> Hash
- -> Seq Scan on prt1_p1 t1
- Filter: (b = 0)
- -> Index Scan using iprt1_e_p1_ab2 on prt1_e_p1 t3
- Index Cond: (((a + b) / 2) = t2.b)
- -> Nested Loop
- Join Filter: (t1_2.a = ((t3_1.a + t3_1.b) / 2))
- -> Hash Join
- Hash Cond: (t2_1.b = t1_2.a)
-> Seq Scan on prt2_p2 t2_1
- -> Hash
- -> Seq Scan on prt1_p2 t1_2
- Filter: (b = 0)
- -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_1
- Index Cond: (((a + b) / 2) = t2_1.b)
- -> Nested Loop
- Join Filter: (t1_1.a = ((t3_2.a + t3_2.b) / 2))
- -> Hash Join
- Hash Cond: (t2_2.b = t1_1.a)
-> Seq Scan on prt2_p3 t2_2
- -> Hash
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
-> Seq Scan on prt1_p3 t1_1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_2
- Index Cond: (((a + b) / 2) = t2_2.b)
-(34 rows)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+(23 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t3 WHERE t1.a = t2.b AND t1.a = (t3.a + t3.b)/2 AND t1.b = 0 ORDER BY t1.a, t2.b;
a | c | b | c | ?column? | c
-----+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
+ 50 | 0050 | 50 | 0050 | 100 | 0
+ 200 | 0200 | 200 | 0200 | 400 | 0
+ 350 | 0350 | 350 | 0350 | 700 | 0
+ 500 | 0500 | 500 | 0500 | 1000 | 0
(4 rows)
+SET enable_partition_wise_join to true;
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
QUERY PLAN
@@ -733,17 +760,17 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
a | c | b | c | ?column? | c
-----+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
+ 0 | 0000 | | | 0 | 0
+ 50 | 0050 | 50 | 0050 | 100 | 0
100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
+ 150 | 0150 | | | 300 | 0
+ 200 | 0200 | 200 | 0200 | 400 | 0
250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
+ 300 | 0300 | | | 600 | 0
+ 350 | 0350 | 350 | 0350 | 700 | 0
400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
+ 450 | 0450 | | | 900 | 0
+ 500 | 0500 | 500 | 0500 | 1000 | 0
550 | 0550 | | | 1100 | 0
(12 rows)
@@ -787,17 +814,17 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
a | c | b | c | ?column? | c
-----+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
+ 0 | 0000 | | | 0 | 0
+ 50 | 0050 | 50 | 0050 | 100 | 0
100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
+ 150 | 0150 | | | 300 | 0
+ 200 | 0200 | 200 | 0200 | 400 | 0
250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
+ 300 | 0300 | | | 600 | 0
+ 350 | 0350 | 350 | 0350 | 700 | 0
400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
+ 450 | 0450 | | | 900 | 0
+ 500 | 0500 | 500 | 0500 | 1000 | 0
550 | 0550 | | | 1100 | 0
(12 rows)
@@ -805,65 +832,51 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
-- make sure these go to null as expected
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b)) FULL JOIN (SELECT 50 phv, * FROM prt1_e WHERE prt1_e.c = 0) t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.a = t1.phv OR t2.b = t2.phv OR (t3.a + t3.b)/2 = t3.phv ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------------------------------
Sort
Sort Key: prt1_p1.a, prt2_p1.b, ((prt1_e_p1.a + prt1_e_p1.b))
- -> Result
- -> Append
- -> Hash Full Join
- Hash Cond: (prt1_p1.a = ((prt1_e_p1.a + prt1_e_p1.b) / 2))
- Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
- -> Hash Full Join
- Hash Cond: (prt1_p1.a = prt2_p1.b)
- -> Seq Scan on prt1_p1
- Filter: (b = 0)
- -> Hash
- -> Seq Scan on prt2_p1
- Filter: (a = 0)
- -> Hash
- -> Seq Scan on prt1_e_p1
- Filter: (c = 0)
- -> Hash Full Join
- Hash Cond: (prt1_p2.a = ((prt1_e_p2.a + prt1_e_p2.b) / 2))
- Filter: ((prt1_p2.a = (50)) OR (prt2_p2.b = (75)) OR (((prt1_e_p2.a + prt1_e_p2.b) / 2) = (50)))
- -> Hash Full Join
- Hash Cond: (prt1_p2.a = prt2_p2.b)
- -> Seq Scan on prt1_p2
- Filter: (b = 0)
- -> Hash
- -> Seq Scan on prt2_p2
- Filter: (a = 0)
- -> Hash
- -> Seq Scan on prt1_e_p2
- Filter: (c = 0)
- -> Hash Full Join
- Hash Cond: (prt1_p3.a = ((prt1_e_p3.a + prt1_e_p3.b) / 2))
- Filter: ((prt1_p3.a = (50)) OR (prt2_p3.b = (75)) OR (((prt1_e_p3.a + prt1_e_p3.b) / 2) = (50)))
- -> Hash Full Join
- Hash Cond: (prt1_p3.a = prt2_p3.b)
- -> Seq Scan on prt1_p3
- Filter: (b = 0)
- -> Hash
- -> Seq Scan on prt2_p3
- Filter: (a = 0)
- -> Hash
- -> Seq Scan on prt1_e_p3
- Filter: (c = 0)
-(43 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p1.a = ((prt1_e_p1.a + prt1_e_p1.b) / 2))
+ Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ -> Hash Full Join
+ Hash Cond: (prt1_p1.a = prt2_p1.b)
+ -> Append
+ -> Seq Scan on prt1_p1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_e_p1
+ Filter: (c = 0)
+ -> Seq Scan on prt1_e_p2
+ Filter: (c = 0)
+ -> Seq Scan on prt1_e_p3
+ Filter: (c = 0)
+(30 rows)
SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b)) FULL JOIN (SELECT 50 phv, * FROM prt1_e WHERE prt1_e.c = 0) t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.a = t1.phv OR t2.b = t2.phv OR (t3.a + t3.b)/2 = t3.phv ORDER BY t1.a, t2.b, t3.a + t3.b;
a | phv | b | phv | ?column? | phv
----+-----+----+-----+----------+-----
- 50 | 50 | | | 100 | 50
- | | 75 | 75 | |
-(2 rows)
+ 50 | 50 | 50 | 75 | 100 | 50
+(1 row)
-- Semi-join
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHERE t1.a = 0 AND t1.b = (t2.a + t2.b)/2) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
----------------------------------------------------------------------------------
+ QUERY PLAN
+-------------------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
@@ -897,23 +910,24 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHER
Join Filter: (t1_1.a = t1_5.b)
-> HashAggregate
Group Key: t1_5.b
- -> Nested Loop
- -> Seq Scan on prt2_p3 t1_5
- Filter: (a = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_2
- Index Cond: (((a + b) / 2) = t1_5.b)
+ -> Hash Join
+ Hash Cond: (((t2_2.a + t2_2.b) / 2) = t1_5.b)
+ -> Seq Scan on prt1_e_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt2_p3 t1_5
+ Filter: (a = 0)
-> Index Scan using iprt1_p3_a on prt1_p3 t1_1
Index Cond: (a = ((t2_2.a + t2_2.b) / 2))
Filter: (b = 0)
-(41 rows)
+(42 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHERE t1.a = 0 AND t1.b = (t2.a + t2.b)/2) AND t1.b = 0 ORDER BY t1.a;
a | b | c
-----+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
+ 50 | 0 | 0050
+ 200 | 0 | 0200
+ 350 | 0 | 0350
+ 500 | 0 | 0500
(4 rows)
EXPLAIN (COSTS OFF)
@@ -965,10 +979,10 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
a | b | c
-----+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
+ 50 | 0 | 0050
+ 200 | 0 | 0200
+ 350 | 0 | 0350
+ 500 | 0 | 0500
(4 rows)
-- test merge joins
@@ -1030,10 +1044,10 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
a | b | c
-----+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
+ 50 | 0 | 0050
+ 200 | 0 | 0200
+ 350 | 0 | 0350
+ 500 | 0 | 0500
(4 rows)
EXPLAIN (COSTS OFF)
@@ -1097,22 +1111,899 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
a | c | b | c | ?column? | c
-----+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
+ 0 | 0000 | | | 0 | 0
+ 50 | 0050 | 50 | 0050 | 100 | 0
100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
+ 150 | 0150 | | | 300 | 0
+ 200 | 0200 | 200 | 0200 | 400 | 0
250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
+ 300 | 0300 | | | 600 | 0
+ 350 | 0350 | 350 | 0350 | 700 | 0
400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
+ 450 | 0450 | | | 900 | 0
+ 500 | 0500 | 500 | 0500 | 1000 | 0
550 | 0550 | | | 1100 | 0
(12 rows)
RESET enable_hashjoin;
RESET enable_nestloop;
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 699, 3) i;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p1 t2
+ -> Hash
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_1.a)
+ -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p3 t1_1
+ Filter: (b = 0)
+(21 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+---+------
+ 50 | 0050 | 0 | 0050
+ 200 | 0200 | 0 | 0200
+ 350 | 0350 | 0 | 0350
+ 500 | 0500 | 0 | 0500
+(4 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p1 t2
+ -> Hash
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_1.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_2.b = t1_1.a)
+ -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p3 t1_1
+ Filter: (b = 0)
+(21 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+---+------
+ 0 | 0000 | |
+ 50 | 0050 | 0 | 0050
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | 0 | 0200
+ 250 | 0250 | |
+ 300 | 0300 | |
+ 350 | 0350 | 0 | 0350
+ 400 | 0400 | |
+ 450 | 0450 | |
+ 500 | 0500 | 0 | 0500
+ 550 | 0550 | |
+(12 rows)
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------
+ Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p3 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p1 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_3
+ Filter: (a = 0)
+(16 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+---+------
+ 50 | 0050 | 0 | 0050
+ 200 | 0200 | 0 | 0200
+ 350 | 0350 | 0 | 0350
+ 500 | 0500 | 0 | 0500
+ | | 0 | 0275
+ | | 0 | 0425
+ | | 0 | 0125
+ | | 0 | 0600
+ | | 0 | 0675
+(9 rows)
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+----------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t1.a = t2.b)
+ Join Filter: ((t1.b + t2.a) = 0)
+ -> Seq Scan on prt1_p1 t1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2
+ -> Hash Join
+ Hash Cond: (t1_2.a = t2_1.b)
+ Join Filter: ((t1_2.b + t2_1.a) = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_1
+ -> Hash Join
+ Hash Cond: (t1_1.a = t2_2.b)
+ Join Filter: ((t1_1.b + t2_2.a) = 0)
+ -> Seq Scan on prt1_p3 t1_1
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_2
+(21 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+---+------
+ 50 | 0050 | 0 | 0050
+ 200 | 0200 | 0 | 0200
+ 350 | 0350 | 0 | 0350
+ 500 | 0500 | 0 | 0500
+(4 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_1.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_1
+ -> Hash Semi Join
+ Hash Cond: (t1_1.a = t2_2.b)
+ -> Seq Scan on prt1_p3 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_2
+(21 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 50 | 0 | 0050
+ 200 | 0 | 0200
+ 350 | 0 | 0350
+ 500 | 0 | 0500
+(4 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Seq Scan on prt2_p1 t1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2
+ -> Hash Semi Join
+ Hash Cond: (t1_1.b = t2_2.a)
+ -> Seq Scan on prt2_p2 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p2 t2_2
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p3 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_1
+ Index Cond: (a = t1_2.b)
+(20 rows)
+
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+---+-----+------
+ 0 | 50 | 0050
+ 0 | 200 | 0200
+ 0 | 350 | 0350
+ 0 | 500 | 0500
+(4 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2
+ -> Hash Anti Join
+ Hash Cond: (t1_2.a = t2_1.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_1
+ -> Hash Anti Join
+ Hash Cond: (t1_1.a = t2_2.b)
+ -> Seq Scan on prt1_p3 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_2
+(21 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 100 | 0 | 0100
+ 150 | 0 | 0150
+ 250 | 0 | 0250
+ 300 | 0 | 0300
+ 400 | 0 | 0400
+ 450 | 0 | 0450
+ 550 | 0 | 0550
+(8 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Seq Scan on prt2_p1 t1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2
+ -> Hash Anti Join
+ Hash Cond: (t1_1.b = t2_2.a)
+ -> Seq Scan on prt2_p2 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p2 t2_2
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p3 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_1
+ Index Cond: (a = t1_2.b)
+(20 rows)
+
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+---+-----+------
+ 0 | 125 | 0125
+ 0 | 275 | 0275
+ 0 | 425 | 0425
+(3 rows)
+
+--TODO: remove below comments and enable partition_wise_join
+--one issue got fixed
+--Getting wrong output with partition wise join
+--setting partition-wise-join to off to get correct output
+SET enable_partition_wise_join to false;
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+---+-----+------
+ 0 | 125 | 0125
+ 0 | 275 | 0275
+ 0 | 425 | 0425
+ 0 | 600 | 0600
+ 0 | 675 | 0675
+(5 rows)
+
+SET enable_partition_wise_join to true;
+-- N-Way joins
+--TODO: remove below comments and enable partition_wise_join
+--one issue got fixed
+--Server crashed with below queries
+--setting partition-wise-join to off
+SET enable_partition_wise_join to false;
+-- t1 join t2 qualify partition-wise-join and t2 join t3 qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt2 t3 ON t2.b = t3.b WHERE t1.b = 0 ORDER BY 1,2,3,4,5,6;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c, t2.a, t2.c, t3.a, t3.c
+ -> Hash Right Join
+ Hash Cond: (t3.b = t2.b)
+ -> Append
+ -> Seq Scan on prt2_p1 t3
+ -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p3 t3_2
+ -> Seq Scan on prt2_p4 t3_3
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+(25 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt2 t3 ON t2.b = t3.b WHERE t1.b = 0 ORDER BY 1,2,3,4,5,6;
+ a | c | a | c | a | c
+-----+------+---+------+---+------
+ 50 | 0050 | 0 | 0050 | 0 | 0050
+ 200 | 0200 | 0 | 0200 | 0 | 0200
+ 350 | 0350 | 0 | 0350 | 0 | 0350
+ 500 | 0500 | 0 | 0500 | 0 | 0500
+(4 rows)
+
+-- t1 join t2 qualify partition-wise-join and t2 join t3 not qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt2 t3 ON t2.b = t3.b WHERE t1.b = 0 ORDER BY 1,2,3,4,5,6;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c, t2.a, t2.c, t3.a, t3.c
+ -> Hash Join
+ Hash Cond: (t3.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p1 t3
+ -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p3 t3_2
+ -> Seq Scan on prt2_p4 t3_3
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+(25 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt2 t3 ON t2.b = t3.b WHERE t1.b = 0 ORDER BY 1,2,3,4,5,6;
+ a | c | a | c | a | c
+-----+------+---+------+---+------
+ 50 | 0050 | 0 | 0050 | 0 | 0050
+ 200 | 0200 | 0 | 0200 | 0 | 0200
+ 350 | 0350 | 0 | 0350 | 0 | 0350
+ 500 | 0500 | 0 | 0500 | 0 | 0500
+(4 rows)
+
+-- t1 join t2 not qualify partition-wise-join and t2 join t3 qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b) INNER JOIN prt2 t3 ON t2.b = t3.b WHERE t1.b = 0 ORDER BY 1,2,3,4,5,6;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c, t2.a, t2.c, t3.a, t3.c
+ -> Hash Join
+ Hash Cond: (t3.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p1 t3
+ -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p3 t3_2
+ -> Seq Scan on prt2_p4 t3_3
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+(25 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b) INNER JOIN prt2 t3 ON t2.b = t3.b WHERE t1.b = 0 ORDER BY 1,2,3,4,5,6;
+ a | c | a | c | a | c
+-----+------+---+------+---+------
+ 50 | 0050 | 0 | 0050 | 0 | 0050
+ 200 | 0200 | 0 | 0200 | 0 | 0200
+ 350 | 0350 | 0 | 0350 | 0 | 0350
+ 500 | 0500 | 0 | 0500 | 0 | 0500
+(4 rows)
+
+-- t1 join t2 not qualify partition-wise-join and t2 join t3 not qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b) FULL JOIN prt2 t3 ON t2.b = t3.b WHERE t1.b = 0 ORDER BY 1,2,3,4,5,6;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c, t2.a, t2.c, t3.a, t3.c
+ -> Hash Right Join
+ Hash Cond: (t3.b = t2.b)
+ -> Append
+ -> Seq Scan on prt2_p1 t3
+ -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p3 t3_2
+ -> Seq Scan on prt2_p4 t3_3
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+(25 rows)
+
+SET enable_partition_wise_join to true;
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (550) TO (700);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(550, 699, 3) i;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+(17 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+(17 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------
+ Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p3 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p1 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_3
+ Filter: (a = 0)
+(16 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Join
+ Hash Cond: (t1.a = t2.b)
+ Join Filter: ((t1.b + t2.a) = 0)
+ -> Append
+ -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p3 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+(15 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+(17 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p1 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_3
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p1 t2
+ -> Seq Scan on prt1_p3 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+(18 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+(17 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p1 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_3
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p1 t2
+ -> Seq Scan on prt1_p3 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+(18 rows)
+
+-- N-Way joins
+-- t1 join t2 not qualify partition-wise-join and t2 join t3 qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b) INNER JOIN prt1 t3 ON t2.b = t3.a WHERE t1.b = 0 ORDER BY 1,2,3,4,5,6;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c, t2.a, t2.c, t3.c
+ -> Hash Join
+ Hash Cond: (t3.a = t1.a)
+ -> Append
+ -> Seq Scan on prt1_p1 t3
+ -> Seq Scan on prt1_p3 t3_1
+ -> Seq Scan on prt1_p2 t3_2
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+(24 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b) INNER JOIN prt1 t3 ON t2.b = t3.a WHERE t1.b = 0 ORDER BY 1,2,3,4,5,6;
+ a | c | a | c | a | c
+-----+------+---+------+-----+------
+ 50 | 0050 | 0 | 0050 | 50 | 0050
+ 200 | 0200 | 0 | 0200 | 200 | 0200
+ 350 | 0350 | 0 | 0350 | 350 | 0350
+ 500 | 0500 | 0 | 0500 | 500 | 0500
+ 550 | 0550 | 0 | 0550 | 550 | 0550
+(5 rows)
+
+-- t1 join t2 not qualify partition-wise-join and t2 join t3 not qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt2 t3 ON t2.b = t3.b WHERE t1.b = 0 ORDER BY 1,2,3,4,5,6;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c, t2.a, t2.c, t3.a, t3.c
+ -> Hash Join
+ Hash Cond: (t3.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p1 t3
+ -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p3 t3_2
+ -> Seq Scan on prt2_p4 t3_3
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+(25 rows)
+
+-- Partition-wise join with minvalue/maxvalue bounds
+DROP TABLE prt2_p1;
+DROP TABLE prt2_p3;
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (MINVALUE) TO (250);
+CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 250, 3) i;
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(500, 600, 3) i;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_1.a)
+ -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p3 t1_1
+ Filter: (b = 0)
+(21 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+---+------
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 0 | 0150
+ 350 | 0350 | 0 | 0350
+ 500 | 0500 | 0 | 0500
+(4 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+----------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2_1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t1.a = t2_1.b)
+ Join Filter: ((t1.b + t2_1.a) = 0)
+ -> Seq Scan on prt1_p1 t1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Join
+ Hash Cond: (t1_2.a = t2.b)
+ Join Filter: ((t1_2.b + t2.a) = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t2
+ -> Hash Join
+ Hash Cond: (t1_1.a = t2_2.b)
+ Join Filter: ((t1_1.b + t2_2.a) = 0)
+ -> Seq Scan on prt1_p3 t1_1
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_2
+(21 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+---+------
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 0 | 0150
+ 350 | 0350 | 0 | 0350
+ 500 | 0500 | 0 | 0500
+(4 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2
+ -> Hash Semi Join
+ Hash Cond: (t1_1.a = t2_2.b)
+ -> Seq Scan on prt1_p3 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_2
+(21 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 350 | 0 | 0350
+ 500 | 0 | 0500
+(4 rows)
+
--
-- partitioned by multiple columns
--
@@ -1182,83 +2073,2174 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1
--
-- tests for list partitioned tables.
--
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt2_p1 t2
+ -> Hash
+ -> Seq Scan on plt1_p1 t1
+ -> Hash Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt1_p2 t1_1
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p3 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_2
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2
+ -> Hash
+ -> Seq Scan on plt1_p1 t1
+ -> Hash Left Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_1
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_2
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------------
+ Sort
+ Sort Key: t2_3.a
+ -> Result
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt2_p1 t2
+ -> Hash
+ -> Seq Scan on plt1_p1 t1
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p2 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_1
+ -> Hash Right Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt1_p3 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_2
+(28 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a, t2_3.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2
+ -> Hash
+ -> Seq Scan on plt1_p1 t1
+ -> Hash Full Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_1
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_2
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a, t1_3.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p4 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2_3.c)::text
+ -> Seq Scan on plt2_p4 t2_3
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p1 t2
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p2 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p3 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_2
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a, t1_3.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> HashAggregate
+ Group Key: (t2_3.c)::text
+ -> Seq Scan on plt1_p4 t2_3
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1_3
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p2 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p3 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_2
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a, t1_3.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p4 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p1 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p2 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p3 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_2
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a, t1_3.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p4 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2_3
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p2 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p3 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_2
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 470 | 0 | 0011
+(1 row)
+
+-- N-Way joins
+-- inner-inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM plt1 t1,plt2 t2,plt1 t3 WHERE t1.c = t2.c AND t2.c = t3.c AND t1.b + t2.b = 0 AND t2.b + t3.b = 0 ORDER BY t1.a,t2.b;
+ QUERY PLAN
+------------------------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a, t2_3.b
+ -> Result
+ -> Append
+ -> Merge Join
+ Merge Cond: ((t2_3.c)::text = (t1_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Merge Join
+ Merge Cond: ((t3_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t2_3.b + t3_3.b) = 0)
+ -> Sort
+ Sort Key: t3_3.c
+ -> Seq Scan on plt1_p4 t3_3
+ -> Sort
+ Sort Key: t2_3.c
+ -> Seq Scan on plt2_p4 t2_3
+ -> Sort
+ Sort Key: t1_3.c
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash Join
+ Hash Cond: ((t3.c)::text = (t1.c)::text)
+ Join Filter: ((t2.b + t3.b) = 0)
+ -> Seq Scan on plt1_p1 t3
+ -> Hash
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt2_p1 t2
+ -> Hash
+ -> Seq Scan on plt1_p1 t1
+ -> Hash Join
+ Hash Cond: ((t3_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t2_1.b + t3_1.b) = 0)
+ -> Seq Scan on plt1_p2 t3_1
+ -> Hash
+ -> Hash Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt1_p2 t1_1
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p3 t1_2
+ -> Hash
+ -> Hash Join
+ Hash Cond: ((t3_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t2_2.b + t3_2.b) = 0)
+ -> Seq Scan on plt1_p3 t3_2
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_2
+(52 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM plt1 t1,plt2 t2,plt1 t3 WHERE t1.c = t2.c AND t2.c = t3.c AND t1.b + t2.b = 0 AND t2.b + t3.b = 0 ORDER BY t1.a,t2.b;
+ a | c | a | c | a | c
+-----+------+-----+------+-----+------
+ 0 | 0000 | 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left-left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c LEFT JOIN plt2 t3 ON (t2.c = t3.c) WHERE t1.b + coalesce(t2.b, 0) = 0 AND t2.b + coalesce(t3.b, 0) = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+-----------------------------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a, t2_3.b
+ -> Result
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t3_3.c)::text = (t2_3.c)::text)
+ Filter: ((t2_3.b + COALESCE(t3_3.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t3_3
+ -> Hash
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p1 t1
+ -> Hash
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t3.c)::text)
+ Filter: ((t2.b + COALESCE(t3.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2
+ -> Hash
+ -> Seq Scan on plt2_p1 t3
+ -> Hash Right Join
+ Hash Cond: ((t3_1.c)::text = (t2_1.c)::text)
+ Filter: ((t2_1.b + COALESCE(t3_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p2 t3_1
+ -> Hash
+ -> Hash Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ Join Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_1
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_1
+ -> Hash Right Join
+ Hash Cond: ((t3_2.c)::text = (t2_2.c)::text)
+ Filter: ((t2_2.b + COALESCE(t3_2.b, 0)) = 0)
+ -> Seq Scan on plt2_p3 t3_2
+ -> Hash
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_2
+(48 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c LEFT JOIN plt2 t3 ON (t2.c = t3.c) WHERE t1.b + coalesce(t2.b, 0) = 0 AND t2.b + coalesce(t3.b, 0) = 0 ORDER BY t1.a, t2.b;
+ a | c | a | c | a | c
+-----+------+-----+------+-----+------
+ 0 | 0000 | 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left-right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c RIGHT JOIN plt1 t3 ON (t2.c = t3.c) WHERE t1.b + coalesce(t2.b,0) = 0 AND coalesce(t1.b, 0) + t3.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+-----------------------------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a, t2_3.b
+ -> Result
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t3_3.c)::text = (t1_3.c)::text)
+ Join Filter: ((COALESCE(t1_3.b, 0) + t3_3.b) = 0)
+ -> Seq Scan on plt1_p4 t3_3
+ -> Hash
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash Join
+ Hash Cond: ((t3.c)::text = (t1.c)::text)
+ Join Filter: ((COALESCE(t1.b, 0) + t3.b) = 0)
+ -> Seq Scan on plt1_p1 t3
+ -> Hash
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2
+ -> Hash
+ -> Seq Scan on plt1_p1 t1
+ -> Hash Join
+ Hash Cond: ((t3_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((COALESCE(t1_1.b, 0) + t3_1.b) = 0)
+ -> Seq Scan on plt1_p2 t3_1
+ -> Hash
+ -> Hash Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ Join Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_1
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_1
+ -> Hash Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Join Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt2_p3 t2_2
+ -> Hash
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t3_2.c)::text)
+ Join Filter: ((COALESCE(t1_2.b, 0) + t3_2.b) = 0)
+ -> Seq Scan on plt1_p3 t1_2
+ -> Hash
+ -> Seq Scan on plt1_p3 t3_2
+(48 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c RIGHT JOIN plt1 t3 ON (t2.c = t3.c) WHERE t1.b + coalesce(t2.b,0) = 0 AND coalesce(t1.b, 0) + t3.b = 0 ORDER BY t1.a, t2.b;
+ a | c | a | c | a | c
+-----+------+-----+------+-----+------
+ 0 | 0000 | 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- right-full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c FULL JOIN plt1 t3 ON (t2.c = t3.c) WHERE coalesce(t1.b,0) + t2.b = 0 AND coalesce(t2.b,0) + coalesce(t3.b,0) = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+------------------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a, t2_3.b
+ -> Hash Right Join
+ Hash Cond: ((t3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t2_3.b, 0) + COALESCE(t3.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p1 t3
+ -> Seq Scan on plt1_p2 t3_1
+ -> Seq Scan on plt1_p3 t3_2
+ -> Seq Scan on plt1_p4 t3_3
+ -> Hash
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt2_p1 t2
+ -> Hash
+ -> Seq Scan on plt1_p1 t1
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p2 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_1
+ -> Hash Right Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt1_p3 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_2
+(36 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c FULL JOIN plt1 t3 ON (t2.c = t3.c) WHERE coalesce(t1.b,0) + t2.b = 0 AND coalesce(t2.b,0) + coalesce(t3.b,0) = 0 ORDER BY t1.a, t2.b;
+ a | c | a | c | a | c
+-----+------+-----+------+-----+------
+ 0 | 0000 | 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002 | 376 | 0002
+ | | 470 | 0011 | |
+(6 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM plt1 t1 WHERE t1.c IN (SELECT t1.c FROM plt2 t1 WHERE t1.c IN (SELECT t3.c FROM plt1 t3 WHERE t3.b = 0)) AND t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1_3.c)::text = (t1_7.c)::text)
+ -> HashAggregate
+ Group Key: (t1_7.c)::text
+ -> Hash Join
+ Hash Cond: ((t1_7.c)::text = (t3_3.c)::text)
+ -> Seq Scan on plt2_p4 t1_7
+ -> Hash
+ -> HashAggregate
+ Group Key: (t3_3.c)::text
+ -> Seq Scan on plt1_p4 t3_3
+ Filter: (b = 0)
+ -> Materialize
+ -> Seq Scan on plt1_p4 t1_3
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t1_4.c)::text)
+ -> HashAggregate
+ Group Key: (t1_4.c)::text
+ -> Hash Join
+ Hash Cond: ((t1_4.c)::text = (t3.c)::text)
+ -> Seq Scan on plt2_p1 t1_4
+ -> Hash
+ -> HashAggregate
+ Group Key: (t3.c)::text
+ -> Seq Scan on plt1_p1 t3
+ Filter: (b = 0)
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t1_5.c)::text)
+ -> HashAggregate
+ Group Key: (t1_5.c)::text
+ -> Hash Join
+ Hash Cond: ((t1_5.c)::text = (t3_1.c)::text)
+ -> Seq Scan on plt2_p2 t1_5
+ -> Hash
+ -> HashAggregate
+ Group Key: (t3_1.c)::text
+ -> Seq Scan on plt1_p2 t3_1
+ Filter: (b = 0)
+ -> Materialize
+ -> Seq Scan on plt1_p2 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t1_6.c)::text)
+ -> Seq Scan on plt1_p3 t1_2
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: ((t1_6.c)::text = (t3_2.c)::text)
+ -> Seq Scan on plt2_p3 t1_6
+ -> Hash
+ -> Seq Scan on plt1_p3 t3_2
+ Filter: (b = 0)
+(58 rows)
+
+SELECT t1.* FROM plt1 t1 WHERE t1.c IN (SELECT t1.c FROM plt2 t1 WHERE t1.c IN (SELECT t3.c FROM plt1 t3 WHERE t3.b = 0)) AND t1.b = 0 ORDER BY t1.a;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
--
-- list partitioned by expression
--
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
ANALYZE plt1_e;
--- test partition matching with N-way join
+-- test partition matching with N-way join with expression
EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- QUERY PLAN
---------------------------------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------------
Sort
- Sort Key: t1.c, t3.c
+ Sort Key: t1_3.c, t3_3.c
-> HashAggregate
- Group Key: t1.c, t2.c, t3.c
+ Group Key: t1_3.c, t2_3.c, t3_3.c
-> Result
-> Append
-> Hash Join
- Hash Cond: (t1.c = t2.c)
- -> Seq Scan on plt1_p1 t1
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = ltrim(t3_3.c, 'A'::text))
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Seq Scan on plt1_e_p4 t3_3
-> Hash
- -> Hash Join
- Hash Cond: (t2.c = ltrim(t3.c, 'A'::text))
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_e_p1 t3
+ -> Seq Scan on plt2_p4 t2_3
-> Hash Join
- Hash Cond: (t1_1.c = t2_1.c)
- -> Seq Scan on plt1_p2 t1_1
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = ltrim(t3.c, 'A'::text))
+ -> Seq Scan on plt2_p1 t2
+ -> Hash
+ -> Seq Scan on plt1_e_p1 t3
-> Hash
- -> Hash Join
- Hash Cond: (t2_1.c = ltrim(t3_1.c, 'A'::text))
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_e_p2 t3_1
+ -> Seq Scan on plt1_p1 t1
-> Hash Join
- Hash Cond: (t1_2.c = t2_2.c)
- -> Seq Scan on plt1_p3 t1_2
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Hash Join
+ Hash Cond: ((t1_1.c)::text = ltrim(t3_1.c, 'A'::text))
+ -> Seq Scan on plt1_p2 t1_1
+ -> Hash
+ -> Seq Scan on plt1_e_p2 t3_1
-> Hash
- -> Hash Join
- Hash Cond: (t2_2.c = ltrim(t3_2.c, 'A'::text))
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_e_p3 t3_2
-(33 rows)
+ -> Seq Scan on plt2_p2 t2_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = ltrim(t3_2.c, 'A'::text))
+ -> Seq Scan on plt1_p3 t1_2
+ -> Hash
+ -> Seq Scan on plt1_e_p3 t3_2
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_2
+(42 rows)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- avg | avg | avg | c | c | c
-----------------------+----------------------+-----------------------+------+------+-------
- 24.0000000000000000 | 24.0000000000000000 | 48.0000000000000000 | 0000 | 0000 | A0000
- 74.0000000000000000 | 75.0000000000000000 | 148.0000000000000000 | 0001 | 0001 | A0001
- 124.0000000000000000 | 124.5000000000000000 | 248.0000000000000000 | 0002 | 0002 | A0002
- 174.0000000000000000 | 174.0000000000000000 | 348.0000000000000000 | 0003 | 0003 | A0003
- 224.0000000000000000 | 225.0000000000000000 | 448.0000000000000000 | 0004 | 0004 | A0004
- 274.0000000000000000 | 274.5000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
- 324.0000000000000000 | 324.0000000000000000 | 648.0000000000000000 | 0006 | 0006 | A0006
- 374.0000000000000000 | 375.0000000000000000 | 748.0000000000000000 | 0007 | 0007 | A0007
- 424.0000000000000000 | 424.5000000000000000 | 848.0000000000000000 | 0008 | 0008 | A0008
- 474.0000000000000000 | 474.0000000000000000 | 948.0000000000000000 | 0009 | 0009 | A0009
- 524.0000000000000000 | 525.0000000000000000 | 1048.0000000000000000 | 0010 | 0010 | A0010
- 574.0000000000000000 | 574.5000000000000000 | 1148.0000000000000000 | 0011 | 0011 | A0011
-(12 rows)
+ avg | avg | avg | c | c | c
+----------------------+---------------------+----------------------+------+------+------
+ 246.5000000000000000 | 22.4666666666666667 | 268.9666666666666667 | 0000 | 0000 | 0000
+ 248.5000000000000000 | 21.3333333333333333 | 269.8333333333333333 | 0002 | 0002 | 0002
+ 249.5000000000000000 | 22.3333333333333333 | 271.8333333333333333 | 0003 | 0003 | 0003
+ 250.5000000000000000 | 23.3333333333333333 | 273.8333333333333333 | 0004 | 0004 | 0004
+ 251.5000000000000000 | 22.7666666666666667 | 274.2666666666666667 | 0005 | 0005 | 0005
+ 252.5000000000000000 | 22.2000000000000000 | 274.7000000000000000 | 0006 | 0006 | 0006
+ 246.0000000000000000 | 23.9655172413793103 | 269.9655172413793103 | 0008 | 0008 | 0008
+ 247.0000000000000000 | 23.3448275862068966 | 270.3448275862068966 | 0009 | 0009 | 0009
+(8 rows)
+
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt2_p1 t2
+ -> Hash
+ -> Seq Scan on plt1_p1 t1
+ -> Hash Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt1_p2 t1_1
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p3 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_2
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2
+ -> Hash
+ -> Seq Scan on plt1_p1 t1
+ -> Hash Left Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_1
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_2
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p1 t1
+ -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p4 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 470 | 0011
+ | | 235 | 0014
+(8 rows)
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p1 t1
+ -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p4 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 235 | 0014
+ | | 470 | 0011
+(10 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a, t1_3.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p4 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2_3.c)::text
+ -> Seq Scan on plt2_p4 t2_3
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p1 t2
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p2 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p3 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_2
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a, t1_3.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> HashAggregate
+ Group Key: (t2_3.c)::text
+ -> Seq Scan on plt1_p4 t2_3
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1_3
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p2 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p3 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_2
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a, t1_3.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p4 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p1 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p2 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p3 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_2
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p1 t2
+ -> Seq Scan on plt1_p2 t2_1
+ -> Seq Scan on plt1_p3 t2_2
+ -> Seq Scan on plt1_p4 t2_3
+(21 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 47 | 0 | 0013
+ 235 | 0 | 0014
+ 470 | 0 | 0011
+(3 rows)
+
+-- N-Way joins
+-- t1 join t2 qualify partition-wise-join and t2 join t3 qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c) LEFT JOIN plt2 t3 ON t2.c = t3.c WHERE t1.b + t2.b = 0 AND t2.b + coalesce(t3.b,0) = 0 ORDER BY t1.a,t2.b;
+ QUERY PLAN
+------------------------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a, t2_3.b
+ -> Result
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t3_3.c)::text = (t2_3.c)::text)
+ Filter: ((t2_3.b + COALESCE(t3_3.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t3_3
+ -> Hash
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p1 t1
+ -> Hash
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t3.c)::text)
+ Filter: ((t2.b + COALESCE(t3.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2
+ -> Hash
+ -> Seq Scan on plt2_p1 t3
+ -> Hash Right Join
+ Hash Cond: ((t3_1.c)::text = (t2_1.c)::text)
+ Filter: ((t2_1.b + COALESCE(t3_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p2 t3_1
+ -> Hash
+ -> Hash Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt1_p2 t1_1
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_1
+ -> Hash Right Join
+ Hash Cond: ((t3_2.c)::text = (t2_2.c)::text)
+ Filter: ((t2_2.b + COALESCE(t3_2.b, 0)) = 0)
+ -> Seq Scan on plt2_p3 t3_2
+ -> Hash
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p3 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_2
+(48 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c) LEFT JOIN plt2 t3 ON t2.c = t3.c WHERE t1.b + t2.b = 0 AND t2.b + coalesce(t3.b,0) = 0 ORDER BY t1.a,t2.b;
+ a | c | a | c | a | c
+-----+------+-----+------+-----+------
+ 0 | 0000 | 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- t1 join t2 qualify partition-wise-join and t2 join t3 not qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c) RIGHT JOIN plt2 t3 ON (t2.c = t3.c) WHERE t1.b + coalesce(t2.b,0) = 0 AND coalesce(t2.b,0) + t3.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+-----------------------------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a, t2_3.b
+ -> Result
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t3_3.c)::text = (t1_3.c)::text)
+ Join Filter: ((COALESCE(t2_3.b, 0) + t3_3.b) = 0)
+ -> Seq Scan on plt2_p4 t3_3
+ -> Hash
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash Join
+ Hash Cond: ((t3.c)::text = (t1.c)::text)
+ Join Filter: ((COALESCE(t2.b, 0) + t3.b) = 0)
+ -> Seq Scan on plt2_p1 t3
+ -> Hash
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2
+ -> Hash
+ -> Seq Scan on plt1_p1 t1
+ -> Hash Join
+ Hash Cond: ((t3_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((COALESCE(t2_1.b, 0) + t3_1.b) = 0)
+ -> Seq Scan on plt2_p2 t3_1
+ -> Hash
+ -> Hash Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ Join Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_1
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_1
+ -> Hash Join
+ Hash Cond: ((t3_2.c)::text = (t1_2.c)::text)
+ Join Filter: ((COALESCE(t2_2.b, 0) + t3_2.b) = 0)
+ -> Seq Scan on plt2_p3 t3_2
+ -> Hash
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_2
+(48 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c) RIGHT JOIN plt2 t3 ON (t2.c = t3.c) WHERE t1.b + coalesce(t2.b,0) = 0 AND coalesce(t2.b,0) + t3.b = 0 ORDER BY t1.a, t2.b;
+ a | c | a | c | a | c
+-----+------+-----+------+-----+------
+ 0 | 0000 | 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- t1 join t2 not qualify partition-wise-join and t2 join t3 qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c) INNER JOIN plt2 t3 ON (t2.c = t3.c) WHERE coalesce(t1.b, 0) + t2.b = 0 AND t2.b + t3.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.b
+ -> Hash Join
+ Hash Cond: ((t3.c)::text = (t2.c)::text)
+ Join Filter: ((t2.b + t3.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p1 t3
+ -> Seq Scan on plt2_p2 t3_1
+ -> Seq Scan on plt2_p3 t3_2
+ -> Seq Scan on plt2_p4 t3_3
+ -> Seq Scan on plt2_p5 t3_4
+ -> Hash
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p1 t1
+ -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p4 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c) INNER JOIN plt2 t3 ON (t2.c = t3.c) WHERE coalesce(t1.b, 0) + t2.b = 0 AND t2.b + t3.b = 0 ORDER BY t1.a, t2.b;
+ a | c | a | c | a | c
+-----+------+-----+------+-----+------
+ 0 | 0000 | 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002 | 376 | 0002
+ | | 470 | 0011 | 470 | 0011
+ | | 47 | 0013 | 47 | 0013
+ | | 235 | 0014 | 235 | 0014
+(8 rows)
+
+-- t1 join t2 not qualify partition-wise-join and t2 join t3 not qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c) FULL JOIN plt1 t3 ON (t2.c = t3.c) WHERE coalesce(t1.b, 0) + t2.b = 0 AND coalesce(t2.b,0) + coalesce(t3.b,0) = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.b
+ -> Hash Right Join
+ Hash Cond: ((t3.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t2.b, 0) + COALESCE(t3.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p1 t3
+ -> Seq Scan on plt1_p2 t3_1
+ -> Seq Scan on plt1_p3 t3_2
+ -> Seq Scan on plt1_p4 t3_3
+ -> Hash
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p1 t1
+ -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p4 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(26 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p1 t1
+ -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p4 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p1 t1
+ -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p4 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p1 t1
+ -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p4 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p1 t1
+ -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p4 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p4 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p4 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p1 t2
+ -> Seq Scan on plt1_p2 t2_1
+ -> Seq Scan on plt1_p3 t2_2
+ -> Seq Scan on plt1_p4 t2_3
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+----------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p4 t1_3
+ Filter: (b = 0)
+ -> Materialize
+ -> Append
+ -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p4 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(20 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p1 t2
+ -> Seq Scan on plt1_p2 t2_1
+ -> Seq Scan on plt1_p3 t2_2
+ -> Seq Scan on plt1_p4 t2_3
+(21 rows)
+
+-- N-Way joins
+-- t1 join t2 not qualify partition-wise-join and t2 join t3 qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c) INNER JOIN plt1 t3 ON (t2.c = t3.c) WHERE t1.b + t2.b = 0 AND t2.b + t3.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.b
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p1 t1
+ -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Hash Join
+ Hash Cond: ((t3.c)::text = (t2.c)::text)
+ Join Filter: ((t2.b + t3.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p1 t3
+ -> Seq Scan on plt1_p2 t3_1
+ -> Seq Scan on plt1_p3 t3_2
+ -> Seq Scan on plt1_p4 t3_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p4 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(26 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c) INNER JOIN plt1 t3 ON (t2.c = t3.c) WHERE t1.b + t2.b = 0 AND t2.b + t3.b = 0 ORDER BY t1.a, t2.b;
+ a | c | a | c | a | c
+-----+------+-----+------+-----+------
+ 0 | 0000 | 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005 | 141 | 0005
+ 188 | 0001 | 188 | 0001 | 188 | 0001
+ 329 | 0006 | 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002 | 376 | 0002
+(6 rows)
+
+-- t1 join t2 not qualify partition-wise-join and t2 join t3 not qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c) RIGHT JOIN plt2 t3 ON (t2.c = t3.c) WHERE t1.b + coalesce(t2.b, 0) = 0 AND coalesce(t2.b,0) + t3.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+-------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.b
+ -> Hash Join
+ Hash Cond: ((t3.c)::text = (t1.c)::text)
+ Join Filter: ((COALESCE(t2.b, 0) + t3.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p1 t3
+ -> Seq Scan on plt2_p2 t3_1
+ -> Seq Scan on plt2_p3 t3_2
+ -> Seq Scan on plt2_p4 t3_3
+ -> Seq Scan on plt2_p5 t3_4
+ -> Hash
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p1 t1
+ -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p4 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(27 rows)
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2_3.c)::text = (t1_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt2_p1 t2
+ -> Hash
+ -> Seq Scan on plt1_p1 t1
+ -> Hash Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt1_p2 t1_1
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p3 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_2
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t2_3.c)::text = (t1_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2
+ -> Hash
+ -> Seq Scan on plt1_p1 t1
+ -> Hash Left Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_1
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_2
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------------
+ Sort
+ Sort Key: t2_3.a
+ -> Result
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t2_3.c)::text = (t1_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt2_p1 t2
+ -> Hash
+ -> Seq Scan on plt1_p1 t1
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p2 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_1
+ -> Hash Right Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt1_p3 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_2
+(28 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a, t2_3.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t2_3.c)::text = (t1_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash
+ -> Seq Scan on plt1_p4 t1_3
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2
+ -> Hash
+ -> Seq Scan on plt1_p1 t1
+ -> Hash Full Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_1
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_2
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a, t1_3.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> HashAggregate
+ Group Key: (t2_3.c)::text
+ -> Seq Scan on plt2_p4 t2_3
+ -> Materialize
+ -> Seq Scan on plt1_p4 t1_3
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p1 t2
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p2 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p3 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_2
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a, t1_3.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> HashAggregate
+ Group Key: (t2_3.c)::text
+ -> Seq Scan on plt1_p4 t2_3
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1_3
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p2 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p3 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_2
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a, t1_3.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p4 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p1 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p2 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p3 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_2
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1_3.a, t1_3.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p4 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2_3
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p2 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p3 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_2
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+---
+ 470 | 0 |
+(1 row)
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p1 t1
+ -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p4 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p1 t1
+ -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p4 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p1 t1
+ -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p4 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p4 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p1 t1
+ -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p4 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p4 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p4 t2_3
+(22 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p1 t2
+ -> Seq Scan on plt1_p2 t2_1
+ -> Seq Scan on plt1_p4 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(22 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p4 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p4 t2_3
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p1 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p1 t2
+ -> Seq Scan on plt1_p2 t2_1
+ -> Seq Scan on plt1_p4 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(19 rows)
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
@@ -1286,9 +4268,9 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
-> Hash Left Join
Hash Cond: (t2.b = a)
-> Append
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p2 t2
Filter: (a = 0)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
-> Seq Scan on prt2_p3 t2_2
Filter: (a = 0)
@@ -1306,9 +4288,9 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
-> Hash Left Join
Hash Cond: (t2.b = a)
-> Append
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p2 t2
Filter: (a = 0)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
-> Seq Scan on prt2_p3 t2_2
Filter: (a = 0)
@@ -1341,7 +4323,7 @@ CREATE TABLE prt2_l_p3_p2 PARTITION OF prt2_l_p3 FOR VALUES FROM (13) TO (25);
INSERT INTO prt2_l SELECT i % 25, i, to_char(i % 4, 'FM0000') FROM generate_series(0, 599, 3) i;
ANALYZE prt2_l;
-- inner join, qual covering only top-level partitions
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1, prt2_l t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
QUERY PLAN
-------------------------------------------------------------
@@ -1386,7 +4368,7 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1, prt2_l t2 WHERE t1.a = t2.b AND t1
(4 rows)
-- left join
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 LEFT JOIN prt2_l t2 ON t1.a = t2.b AND t1.c = t2.c WHERE t1.b = 0 ORDER BY t1.a, t2.b;
QUERY PLAN
------------------------------------------------------------------------------------
@@ -1440,7 +4422,7 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 LEFT JOIN prt2_l t2 ON t1.a = t2.b
(12 rows)
-- right join
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 RIGHT JOIN prt2_l t2 ON t1.a = t2.b AND t1.c = t2.c WHERE t2.a = 0 ORDER BY t1.a, t2.b;
QUERY PLAN
------------------------------------------------------------------------------------------
@@ -1491,7 +4473,7 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 RIGHT JOIN prt2_l t2 ON t1.a = t2.b
(8 rows)
-- full join
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_l WHERE prt1_l.b = 0) t1 FULL JOIN (SELECT * FROM prt2_l WHERE prt2_l.a = 0) t2 ON (t1.a = t2.b AND t1.c = t2.c) ORDER BY t1.a, t2.b;
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------
@@ -1552,7 +4534,7 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_l WHERE prt1_l.b = 0) t1
(16 rows)
-- lateral partition-wise join
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT * FROM prt1_l t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t2.c AS t2c, t2.b AS t2b, t3.b AS t3b, least(t1.a,t2.a,t3.b) FROM prt1_l t2 JOIN prt2_l t3 ON (t2.a = t3.b AND t2.c = t3.c)) ss
ON t1.a = ss.t2a AND t1.c = ss.t2c WHERE t1.b = 0 ORDER BY t1.a;
@@ -1626,7 +4608,7 @@ SELECT * FROM prt1_l t1 LEFT JOIN LATERAL
(12 rows)
-- join with one side empty
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_l WHERE a = 1 AND a = 2) t1 RIGHT JOIN prt2_l t2 ON t1.a = t2.b AND t1.b = t2.a AND t1.c = t2.c;
QUERY PLAN
-------------------------------------------------------------------------
@@ -1699,15 +4681,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2, prt2 t3 WHERE t1.a = t2.a
-> Hash
-> Append
-> Hash Join
- Hash Cond: (t1.a = t3.b)
+ Hash Cond: (t1.a = t3_1.b)
-> Seq Scan on prt1_p1 t1
-> Hash
- -> Seq Scan on prt2_p1 t3
+ -> Seq Scan on prt2_p1 t3_1
-> Hash Join
- Hash Cond: (t1_2.a = t3_1.b)
+ Hash Cond: (t1_2.a = t3.b)
-> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p2 t3
-> Hash Join
Hash Cond: (t1_1.a = t3_2.b)
-> Seq Scan on prt1_p3 t1_1
@@ -1719,21 +4701,20 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2, prt2 t3 WHERE t1.a = t2.a
-- between partition keys
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON (t1.a < t2.b);
- QUERY PLAN
----------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------
Nested Loop Left Join
+ Join Filter: (t1.a < t2.b)
-> Append
-> Seq Scan on prt1_p1 t1
-> Seq Scan on prt1_p3 t1_1
-> Seq Scan on prt1_p2 t1_2
- -> Append
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
- Index Cond: (t1.a < b)
-(12 rows)
+ -> Materialize
+ -> Append
+ -> Seq Scan on prt2_p2 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p3 t2_2
+(11 rows)
-- equi-join with join condition on partial keys does not qualify for
-- partition-wise join
@@ -1819,16 +4800,17 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 JOIN prt2_n t2 ON (t1.c = t2.c) JOI
-> Seq Scan on prt2_n_p2 t2_1
-> Hash
-> Hash Join
- Hash Cond: (t3.c = (t1.c)::text)
+ Hash Cond: ((t3.c)::text = (t1.c)::text)
-> Append
-> Seq Scan on plt1_p1 t3
-> Seq Scan on plt1_p2 t3_1
- -> Seq Scan on plt1_p3 t3_2
+ -> Seq Scan on plt1_p4 t3_2
+ -> Seq Scan on plt1_p3 t3_3
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(16 rows)
+(17 rows)
-- partition-wise join can not be applied for a join between list and range
-- partitioned table
diff --git a/src/test/regress/sql/partition_join.sql b/src/test/regress/sql/partition_join.sql
index cd54ea0..7aa53c0 100644
--- a/src/test/regress/sql/partition_join.sql
+++ b/src/test/regress/sql/partition_join.sql
@@ -7,6 +7,10 @@
SET enable_partition_wise_join to true;
--
+-- tests for range partitioned tables.
+--
+
+--
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
@@ -19,16 +23,22 @@ CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
ANALYZE prt1;
+-- prt2 have missing starting 0-50 range and missing ending 550-600
+-- range bounds
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
-CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
+CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (50) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
-CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599, 3) i;
+CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (550);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0+50, 599-50, 3) i;
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
@@ -77,11 +87,19 @@ EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.a;
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.a;
+
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
+EXPLAIN (COSTS OFF)
+SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a);
+SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a);
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -126,9 +144,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 =
--
-- N-way join
--
+--TODO: remove below comments and enable partition_wise_join
+--one issue got fixed
+--Server crashed with below queries
+--setting partition-wise-join to off
+SET enable_partition_wise_join to false;
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t3 WHERE t1.a = t2.b AND t1.a = (t3.a + t3.b)/2 AND t1.b = 0 ORDER BY t1.a, t2.b;
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t3 WHERE t1.a = t2.b AND t1.a = (t3.a + t3.b)/2 AND t1.b = 0 ORDER BY t1.a, t2.b;
+SET enable_partition_wise_join to true;
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
@@ -168,6 +192,156 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
RESET enable_hashjoin;
RESET enable_nestloop;
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 699, 3) i;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a;
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+--TODO: remove below comments and enable partition_wise_join
+--one issue got fixed
+--Getting wrong output with partition wise join
+--setting partition-wise-join to off to get correct output
+SET enable_partition_wise_join to false;
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+SET enable_partition_wise_join to true;
+
+-- N-Way joins
+--TODO: remove below comments and enable partition_wise_join
+--one issue got fixed
+--Server crashed with below queries
+--setting partition-wise-join to off
+SET enable_partition_wise_join to false;
+-- t1 join t2 qualify partition-wise-join and t2 join t3 qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt2 t3 ON t2.b = t3.b WHERE t1.b = 0 ORDER BY 1,2,3,4,5,6;
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt2 t3 ON t2.b = t3.b WHERE t1.b = 0 ORDER BY 1,2,3,4,5,6;
+
+-- t1 join t2 qualify partition-wise-join and t2 join t3 not qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt2 t3 ON t2.b = t3.b WHERE t1.b = 0 ORDER BY 1,2,3,4,5,6;
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt2 t3 ON t2.b = t3.b WHERE t1.b = 0 ORDER BY 1,2,3,4,5,6;
+
+-- t1 join t2 not qualify partition-wise-join and t2 join t3 qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b) INNER JOIN prt2 t3 ON t2.b = t3.b WHERE t1.b = 0 ORDER BY 1,2,3,4,5,6;
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b) INNER JOIN prt2 t3 ON t2.b = t3.b WHERE t1.b = 0 ORDER BY 1,2,3,4,5,6;
+
+-- t1 join t2 not qualify partition-wise-join and t2 join t3 not qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b) FULL JOIN prt2 t3 ON t2.b = t3.b WHERE t1.b = 0 ORDER BY 1,2,3,4,5,6;
+SET enable_partition_wise_join to true;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (550) TO (700);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(550, 699, 3) i;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- N-Way joins
+-- t1 join t2 not qualify partition-wise-join and t2 join t3 qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b) INNER JOIN prt1 t3 ON t2.b = t3.a WHERE t1.b = 0 ORDER BY 1,2,3,4,5,6;
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b) INNER JOIN prt1 t3 ON t2.b = t3.a WHERE t1.b = 0 ORDER BY 1,2,3,4,5,6;
+-- t1 join t2 not qualify partition-wise-join and t2 join t3 not qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt2 t3 ON t2.b = t3.b WHERE t1.b = 0 ORDER BY 1,2,3,4,5,6;
+
+-- Partition-wise join with minvalue/maxvalue bounds
+DROP TABLE prt2_p1;
+DROP TABLE prt2_p3;
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (MINVALUE) TO (250);
+CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 250, 3) i;
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(500, 600, 3) i;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
--
-- partitioned by multiple columns
--
@@ -192,35 +366,311 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1
--
-- tests for list partitioned tables.
--
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- N-Way joins
+-- inner-inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM plt1 t1,plt2 t2,plt1 t3 WHERE t1.c = t2.c AND t2.c = t3.c AND t1.b + t2.b = 0 AND t2.b + t3.b = 0 ORDER BY t1.a,t2.b;
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM plt1 t1,plt2 t2,plt1 t3 WHERE t1.c = t2.c AND t2.c = t3.c AND t1.b + t2.b = 0 AND t2.b + t3.b = 0 ORDER BY t1.a,t2.b;
+
+-- left-left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c LEFT JOIN plt2 t3 ON (t2.c = t3.c) WHERE t1.b + coalesce(t2.b, 0) = 0 AND t2.b + coalesce(t3.b, 0) = 0 ORDER BY t1.a, t2.b;
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c LEFT JOIN plt2 t3 ON (t2.c = t3.c) WHERE t1.b + coalesce(t2.b, 0) = 0 AND t2.b + coalesce(t3.b, 0) = 0 ORDER BY t1.a, t2.b;
+
+-- left-right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c RIGHT JOIN plt1 t3 ON (t2.c = t3.c) WHERE t1.b + coalesce(t2.b,0) = 0 AND coalesce(t1.b, 0) + t3.b = 0 ORDER BY t1.a, t2.b;
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c RIGHT JOIN plt1 t3 ON (t2.c = t3.c) WHERE t1.b + coalesce(t2.b,0) = 0 AND coalesce(t1.b, 0) + t3.b = 0 ORDER BY t1.a, t2.b;
+
+-- right-full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c FULL JOIN plt1 t3 ON (t2.c = t3.c) WHERE coalesce(t1.b,0) + t2.b = 0 AND coalesce(t2.b,0) + coalesce(t3.b,0) = 0 ORDER BY t1.a, t2.b;
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c FULL JOIN plt1 t3 ON (t2.c = t3.c) WHERE coalesce(t1.b,0) + t2.b = 0 AND coalesce(t2.b,0) + coalesce(t3.b,0) = 0 ORDER BY t1.a, t2.b;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM plt1 t1 WHERE t1.c IN (SELECT t1.c FROM plt2 t1 WHERE t1.c IN (SELECT t3.c FROM plt1 t3 WHERE t3.b = 0)) AND t1.b = 0 ORDER BY t1.a;
+SELECT t1.* FROM plt1 t1 WHERE t1.c IN (SELECT t1.c FROM plt2 t1 WHERE t1.c IN (SELECT t3.c FROM plt1 t3 WHERE t3.b = 0)) AND t1.b = 0 ORDER BY t1.a;
--
-- list partitioned by expression
--
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
ANALYZE plt1_e;
--- test partition matching with N-way join
+-- test partition matching with N-way join with expression
EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- N-Way joins
+-- t1 join t2 qualify partition-wise-join and t2 join t3 qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c) LEFT JOIN plt2 t3 ON t2.c = t3.c WHERE t1.b + t2.b = 0 AND t2.b + coalesce(t3.b,0) = 0 ORDER BY t1.a,t2.b;
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c) LEFT JOIN plt2 t3 ON t2.c = t3.c WHERE t1.b + t2.b = 0 AND t2.b + coalesce(t3.b,0) = 0 ORDER BY t1.a,t2.b;
+
+-- t1 join t2 qualify partition-wise-join and t2 join t3 not qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c) RIGHT JOIN plt2 t3 ON (t2.c = t3.c) WHERE t1.b + coalesce(t2.b,0) = 0 AND coalesce(t2.b,0) + t3.b = 0 ORDER BY t1.a, t2.b;
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c) RIGHT JOIN plt2 t3 ON (t2.c = t3.c) WHERE t1.b + coalesce(t2.b,0) = 0 AND coalesce(t2.b,0) + t3.b = 0 ORDER BY t1.a, t2.b;
+
+-- t1 join t2 not qualify partition-wise-join and t2 join t3 qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c) INNER JOIN plt2 t3 ON (t2.c = t3.c) WHERE coalesce(t1.b, 0) + t2.b = 0 AND t2.b + t3.b = 0 ORDER BY t1.a, t2.b;
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c) INNER JOIN plt2 t3 ON (t2.c = t3.c) WHERE coalesce(t1.b, 0) + t2.b = 0 AND t2.b + t3.b = 0 ORDER BY t1.a, t2.b;
+
+-- t1 join t2 not qualify partition-wise-join and t2 join t3 not qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c) FULL JOIN plt1 t3 ON (t2.c = t3.c) WHERE coalesce(t1.b, 0) + t2.b = 0 AND coalesce(t2.b,0) + coalesce(t3.b,0) = 0 ORDER BY t1.a, t2.b;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- N-Way joins
+-- t1 join t2 not qualify partition-wise-join and t2 join t3 qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c) INNER JOIN plt1 t3 ON (t2.c = t3.c) WHERE t1.b + t2.b = 0 AND t2.b + t3.b = 0 ORDER BY t1.a, t2.b;
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c) INNER JOIN plt1 t3 ON (t2.c = t3.c) WHERE t1.b + t2.b = 0 AND t2.b + t3.b = 0 ORDER BY t1.a, t2.b;
+
+-- t1 join t2 not qualify partition-wise-join and t2 join t3 not qualify partition-wise-join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c, t3.a, t3.c FROM (plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c) RIGHT JOIN plt2 t3 ON (t2.c = t3.c) WHERE t1.b + coalesce(t2.b, 0) = 0 AND coalesce(t2.b,0) + t3.b = 0 ORDER BY t1.a, t2.b;
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.a = 1 AND t1.a = 2;
@@ -260,27 +710,27 @@ INSERT INTO prt2_l SELECT i % 25, i, to_char(i % 4, 'FM0000') FROM generate_seri
ANALYZE prt2_l;
-- inner join, qual covering only top-level partitions
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1, prt2_l t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1, prt2_l t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
-- left join
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 LEFT JOIN prt2_l t2 ON t1.a = t2.b AND t1.c = t2.c WHERE t1.b = 0 ORDER BY t1.a, t2.b;
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 LEFT JOIN prt2_l t2 ON t1.a = t2.b AND t1.c = t2.c WHERE t1.b = 0 ORDER BY t1.a, t2.b;
-- right join
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 RIGHT JOIN prt2_l t2 ON t1.a = t2.b AND t1.c = t2.c WHERE t2.a = 0 ORDER BY t1.a, t2.b;
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 RIGHT JOIN prt2_l t2 ON t1.a = t2.b AND t1.c = t2.c WHERE t2.a = 0 ORDER BY t1.a, t2.b;
-- full join
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_l WHERE prt1_l.b = 0) t1 FULL JOIN (SELECT * FROM prt2_l WHERE prt2_l.a = 0) t2 ON (t1.a = t2.b AND t1.c = t2.c) ORDER BY t1.a, t2.b;
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_l WHERE prt1_l.b = 0) t1 FULL JOIN (SELECT * FROM prt2_l WHERE prt2_l.a = 0) t2 ON (t1.a = t2.b AND t1.c = t2.c) ORDER BY t1.a, t2.b;
-- lateral partition-wise join
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT * FROM prt1_l t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t2.c AS t2c, t2.b AS t2b, t3.b AS t3b, least(t1.a,t2.a,t3.b) FROM prt1_l t2 JOIN prt2_l t3 ON (t2.a = t3.b AND t2.c = t3.c)) ss
ON t1.a = ss.t2a AND t1.c = ss.t2c WHERE t1.b = 0 ORDER BY t1.a;
@@ -289,7 +739,7 @@ SELECT * FROM prt1_l t1 LEFT JOIN LATERAL
ON t1.a = ss.t2a AND t1.c = ss.t2c WHERE t1.b = 0 ORDER BY t1.a;
-- join with one side empty
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_l WHERE a = 1 AND a = 2) t1 RIGHT JOIN prt2_l t2 ON t1.a = t2.b AND t1.b = t2.a AND t1.c = t2.c;
--
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
@ 2017-09-01 19:12 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2017-09-01 19:12 UTC (permalink / raw)
To: Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; +Cc: pgsql-hackers
PFA the patches rebased on the latest sources. There are also fixes
for some of the crashes and bugs reported. I haven't yet included the
testcase patch in the main patchset.
On Mon, Aug 28, 2017 at 12:44 PM, Rajkumar Raghuwanshi
<rajkumar.raghuwanshi@enterprisedb.com> wrote:
> On Mon, Aug 21, 2017 at 12:43 PM, Ashutosh Bapat
> <ashutosh.bapat@enterprisedb.com> wrote:
>>
>> TODOs
>> -----------
>> 1. Add tests for advanced partition matching algorithm
>
>
> Hi Ashutosh,
>
> I have applied all partition-wise-join patches (v26) and tested feature. I
> have modified partition_join.sql file and added extra test cases to test
> partition matching.
>
> Attaching WIP test case patch which as of now have some server crashes and a
> data corruptions issue which is commented in the file itself and need to be
> removed once issue got solved. Also some of queries is not picking or
> picking partition-wise-join as per expectation which may need some
> adjustment.
>
>
>
>
>
>
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Attachments:
[text/x-patch] 0011-Modify-bound-comparision-functions-to-accept-members.patch (7.5K, ../../CAFjFpReNYx3814Twfg5rMMwCaOo8fzSmyhNLT8QmcFOnwiTJBQ@mail.gmail.com/2-0011-Modify-bound-comparision-functions-to-accept-members.patch)
download | inline diff:
From 865242c79b56f021dc619bc028480097d11bb69a Mon Sep 17 00:00:00 2001
From: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
Date: Thu, 6 Jul 2017 14:15:22 +0530
Subject: [PATCH 11/12] Modify bound comparision functions to accept members
of PartitionKey
Functions partition_bound_cmp(), partition_rbound_cmp() and
partition_rbound_datum_cmp() are required to merge partition bounds
from joining relations. While doing so, we do not have access to the
PartitionKey of either relations. So, modify these functions to accept
only required members of PartitionKey so that the functions can be
reused for merging bounds.
Ashutosh Bapat.
---
src/backend/catalog/partition.c | 76 ++++++++++++++++++++++-----------------
1 file changed, 44 insertions(+), 32 deletions(-)
diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 96a64ce..d42e1b5 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -126,15 +126,17 @@ static List *generate_partition_qual(Relation rel);
static PartitionRangeBound *make_one_range_bound(PartitionKey key, int index,
List *datums, bool lower);
-static int32 partition_rbound_cmp(PartitionKey key,
- Datum *datums1, PartitionRangeDatumKind *kind1,
- bool lower1, PartitionRangeBound *b2);
-static int32 partition_rbound_datum_cmp(PartitionKey key,
- Datum *rb_datums, PartitionRangeDatumKind *rb_kind,
+static int32 partition_rbound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, Datum *datums1,
+ PartitionRangeDatumKind *kind1, bool lower1,
+ PartitionRangeBound *b2);
+static int32 partition_rbound_datum_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, Datum *rb_datums,
+ PartitionRangeDatumKind *rb_kind,
Datum *tuple_datums);
-static int32 partition_bound_cmp(PartitionKey key,
- PartitionBoundInfo boundinfo,
+static int32 partition_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, PartitionBoundInfo boundinfo,
int offset, void *probe, bool probe_is_bound);
static int partition_bound_bsearch(PartitionKey key,
PartitionBoundInfo boundinfo,
@@ -719,8 +721,9 @@ check_new_partition_bound(char *relname, Relation parent,
* First check if the resulting range would be empty with
* specified lower and upper bounds
*/
- if (partition_rbound_cmp(key, lower->datums, lower->kind, true,
- upper) >= 0)
+ if (partition_rbound_cmp(key->partnatts, key->partsupfunc,
+ key->partcollation, lower->datums,
+ lower->kind, true, upper) >= 0)
{
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
@@ -771,9 +774,11 @@ check_new_partition_bound(char *relname, Relation parent,
{
int32 cmpval;
- cmpval = partition_bound_cmp(key, boundinfo,
- offset + 1, upper,
- true);
+ cmpval = partition_bound_cmp(key->partnatts,
+ key->partsupfunc,
+ key->partcollation,
+ boundinfo, offset + 1,
+ upper, true);
if (cmpval < 0)
{
/*
@@ -2138,7 +2143,9 @@ qsort_partition_rbound_cmp(const void *a, const void *b, void *arg)
PartitionRangeBound *b2 = (*(PartitionRangeBound *const *) b);
PartitionKey key = (PartitionKey) arg;
- return partition_rbound_cmp(key, b1->datums, b1->kind, b1->lower, b2);
+ return partition_rbound_cmp(key->partnatts, key->partsupfunc,
+ key->partcollation, b1->datums, b1->kind,
+ b1->lower, b2);
}
/*
@@ -2155,7 +2162,7 @@ qsort_partition_rbound_cmp(const void *a, const void *b, void *arg)
* two contiguous partitions.
*/
static int32
-partition_rbound_cmp(PartitionKey key,
+partition_rbound_cmp(int partnatts, FmgrInfo *partsupfunc, Oid *partcollation,
Datum *datums1, PartitionRangeDatumKind *kind1,
bool lower1, PartitionRangeBound *b2)
{
@@ -2165,7 +2172,7 @@ partition_rbound_cmp(PartitionKey key,
PartitionRangeDatumKind *kind2 = b2->kind;
bool lower2 = b2->lower;
- for (i = 0; i < key->partnatts; i++)
+ for (i = 0; i < partnatts; i++)
{
/*
* First, handle cases where the column is unbounded, which should not
@@ -2186,8 +2193,8 @@ partition_rbound_cmp(PartitionKey key,
*/
break;
- cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[i],
- key->partcollation[i],
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[i],
+ partcollation[i],
datums1[i],
datums2[i]));
if (cmpval != 0)
@@ -2213,22 +2220,23 @@ partition_rbound_cmp(PartitionKey key,
* is <, =, or > partition key of tuple (tuple_datums)
*/
static int32
-partition_rbound_datum_cmp(PartitionKey key,
- Datum *rb_datums, PartitionRangeDatumKind *rb_kind,
+partition_rbound_datum_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, Datum *rb_datums,
+ PartitionRangeDatumKind *rb_kind,
Datum *tuple_datums)
{
int i;
int32 cmpval = -1;
- for (i = 0; i < key->partnatts; i++)
+ for (i = 0; i < partnatts; i++)
{
if (rb_kind[i] == PARTITION_RANGE_DATUM_MINVALUE)
return -1;
else if (rb_kind[i] == PARTITION_RANGE_DATUM_MAXVALUE)
return 1;
- cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[i],
- key->partcollation[i],
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[i],
+ partcollation[i],
rb_datums[i],
tuple_datums[i]));
if (cmpval != 0)
@@ -2245,17 +2253,18 @@ partition_rbound_datum_cmp(PartitionKey key,
* specified in *probe.
*/
static int32
-partition_bound_cmp(PartitionKey key, PartitionBoundInfo boundinfo,
- int offset, void *probe, bool probe_is_bound)
+partition_bound_cmp(int partnatts, FmgrInfo *partsupfunc, Oid *partcollation,
+ PartitionBoundInfo boundinfo, int offset, void *probe,
+ bool probe_is_bound)
{
Datum *bound_datums = boundinfo->datums[offset];
int32 cmpval = -1;
- switch (key->strategy)
+ switch (boundinfo->strategy)
{
case PARTITION_STRATEGY_LIST:
- cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[0],
- key->partcollation[0],
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
+ partcollation[0],
bound_datums[0],
*(Datum *) probe));
break;
@@ -2273,12 +2282,14 @@ partition_bound_cmp(PartitionKey key, PartitionBoundInfo boundinfo,
*/
bool lower = boundinfo->indexes[offset] < 0;
- cmpval = partition_rbound_cmp(key,
- bound_datums, kind, lower,
+ cmpval = partition_rbound_cmp(partnatts, partsupfunc,
+ partcollation, bound_datums,
+ kind, lower,
(PartitionRangeBound *) probe);
}
else
- cmpval = partition_rbound_datum_cmp(key,
+ cmpval = partition_rbound_datum_cmp(partnatts, partsupfunc,
+ partcollation,
bound_datums, kind,
(Datum *) probe);
break;
@@ -2286,7 +2297,7 @@ partition_bound_cmp(PartitionKey key, PartitionBoundInfo boundinfo,
default:
elog(ERROR, "unexpected partition strategy: %d",
- (int) key->strategy);
+ (int) boundinfo->strategy);
}
return cmpval;
@@ -2320,7 +2331,8 @@ partition_bound_bsearch(PartitionKey key, PartitionBoundInfo boundinfo,
int32 cmpval;
mid = (lo + hi + 1) / 2;
- cmpval = partition_bound_cmp(key, boundinfo, mid, probe,
+ cmpval = partition_bound_cmp(key->partnatts, key->partsupfunc,
+ key->partcollation, boundinfo, mid, probe,
probe_is_bound);
if (cmpval <= 0)
{
--
1.7.9.5
[text/x-patch] 0012-WIP-Partition-wise-join-for-1-1-1-0-0-1-partition-ma.patch (48.8K, ../../CAFjFpReNYx3814Twfg5rMMwCaOo8fzSmyhNLT8QmcFOnwiTJBQ@mail.gmail.com/3-0012-WIP-Partition-wise-join-for-1-1-1-0-0-1-partition-ma.patch)
download | inline diff:
From 737299aa79cc5d8e9fbf825ef6396696c485031d Mon Sep 17 00:00:00 2001
From: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
Date: Wed, 9 Aug 2017 12:30:34 +0530
Subject: [PATCH 12/12] WIP Partition-wise join for 1:1, 1:0, 0:1 partition
matching.
Earlier version of partition-wise join implementation allowed
partition-wise join between two relations with exactly same partition
bounds. This commit allows partition-wise join to be applied under
following conditions
1. the partition bounds of joining relations are such that rows from
given partition on one side join can join with rows from maximum one
partition on the other side i.e. bounds of a given partition on one
side match/overlap with those of maximum one partition on the other
side. If the mapping happens to be m:n where m > 1 or n > 1, we have
to gang multiple partition relations together into a single relation.
This means that we have to add simple relations during join
processing, something which is not supported right now. ALso, in such
a case, different pairs of joining relations can produce different
partition bounds for the same join relation, which again is not
supported right now.
2. For every partition on outer side that can contribute to the result
of an OUTER side, there exists at least one (taken along with item 1,
it means exactly one) matching partition on the inner side. To
support partition-wise join when the inner matching partition doesn't
exist, we have to add a dummy base relation corresponding to the
non-existent inner partition. We don't have support add base relations
during join processing.
This commit is not complete yet.
Ashutosh Bapat.
---
src/backend/catalog/partition.c | 1255 +++++++++++++++++++++++++++++++++
src/backend/optimizer/path/joinrels.c | 77 +-
src/backend/optimizer/util/relnode.c | 42 +-
src/include/catalog/partition.h | 6 +
4 files changed, 1349 insertions(+), 31 deletions(-)
diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index d42e1b5..2d1a905 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -141,6 +141,38 @@ static int32 partition_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
static int partition_bound_bsearch(PartitionKey key,
PartitionBoundInfo boundinfo,
void *probe, bool probe_is_bound, bool *is_equal);
+static PartitionBoundInfo partition_range_bounds_merge(int partnatts,
+ FmgrInfo *supfuncs, Oid *collations,
+ PartitionBoundInfo boundinfo1, int nparts1,
+ PartitionBoundInfo boundinfo2, int nparts2,
+ JoinType jointype, List **parts1, List **parts2);
+static PartitionBoundInfo partition_list_bounds_merge(int partnatts,
+ FmgrInfo *partsupfunc, Oid *collations,
+ PartitionBoundInfo boundinfo1, int nparts1,
+ PartitionBoundInfo boundinfo2, int nparts2,
+ JoinType jointype, List **parts1, List **parts2);
+static void generate_matching_part_pairs(int *mergemap1, int npart1,
+ int *mergemap2, int nparts2, JoinType jointype,
+ int nparts, List **parts1, List **parts2);
+static PartitionBoundInfo build_merged_partition_bounds(char strategy,
+ List *merged_datums, List *merged_indexes,
+ List *merged_contents, int null_index);
+static int map_and_merge_partitions(int *partmap1, int *mergemap1, int index1,
+ int *partmap2, int *mergemap2, int index2,
+ int *next_index);
+static int32 partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *collations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2);
+static int partition_range_cmp(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, bool *overlap);
+static bool partition_range_merge_next_lb(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes);
/*
* RelationBuildPartitionDesc
@@ -2348,3 +2380,1226 @@ partition_bound_bsearch(PartitionKey key, PartitionBoundInfo boundinfo,
return lo;
}
+
+/*
+ * Merge the given partition bounds.
+ *
+ * If given partition bounds can not be merged, return NULL.
+ *
+ * The function also returns two lists of partition indexes one for each of the
+ * joining relations. Both the lists contain the same number of elements. The
+ * partition indexes at the same positions in the list indicate partitions from
+ * each side to be joined and their position corresponds to the index of
+ * partition to which the results of the child-join belong in the partitioned
+ * join.
+ */
+extern PartitionBoundInfo
+partition_bounds_merge(int partnatts, FmgrInfo *partsupfunc, Oid *partcollation,
+ PartitionBoundInfo boundinfo1, int nparts1,
+ PartitionBoundInfo boundinfo2, int nparts2,
+ JoinType jointype, List **parts1, List **parts2)
+{
+ PartitionBoundInfo merged_bounds;
+ char strategy;
+
+ /* Bail out if partitioning strategies are different. */
+ if (boundinfo1->strategy != boundinfo2->strategy)
+ return NULL;
+
+ *parts1 = NIL;
+ *parts2 = NIL;
+ strategy = boundinfo1->strategy;
+ if (strategy == PARTITION_STRATEGY_LIST)
+ merged_bounds = partition_list_bounds_merge(partnatts, partsupfunc,
+ partcollation, boundinfo1,
+ nparts1, boundinfo2,
+ nparts2, jointype, parts1,
+ parts2);
+ else if (strategy == PARTITION_STRATEGY_RANGE)
+ merged_bounds = partition_range_bounds_merge(partnatts, partsupfunc,
+ partcollation, boundinfo1,
+ nparts1, boundinfo2,
+ nparts2, jointype, parts1,
+ parts2);
+ else
+ elog(ERROR, "unexpected partition strategy: %d", strategy);
+
+ Assert(merged_bounds || (*parts1 == NIL && *parts2 == NIL));
+ return merged_bounds;
+}
+
+/*
+ * partition_get_range_bounds
+ *
+ * Given the index of lower bound in datums array, return lower and upper
+ * bounds and the index of the partition with that lower bound.
+ */
+static int
+partition_get_range_bounds(PartitionBoundInfo bi, int lb_index,
+ PartitionRangeBound *lower,
+ PartitionRangeBound *upper)
+{
+ int part_index;
+
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The lower bound should correspond to a valid partition. */
+ part_index = bi->indexes[lb_index + 1];
+ Assert(part_index >= 0);
+
+ lower->kind = bi->kind[lb_index];
+ lower->datums = bi->datums[lb_index];
+ lower->lower = true;
+ upper->kind = bi->kind[lb_index + 1];
+ upper->datums = bi->datums[lb_index + 1];
+ upper->lower = false;
+
+ return part_index;
+}
+
+/*
+ * partition_range_get_next_lb_index
+ *
+ * Given the index of lower bound in datums array return the
+ * index of lower bound of the next partition. When the given index corresponds
+ * to the last partition, return number of datums (ndatums).
+ */
+static int
+partition_range_get_next_lb_index(PartitionBoundInfo bi, int lb_index)
+{
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The partition index corresponding to the upper bound should be valid. */
+ Assert(bi->indexes[lb_index + 1] >= 0);
+
+ /*
+ * If there are no bounds left beyond the upper bound, we have reached the
+ * last partition.
+ */
+ if (lb_index + 2 < bi->ndatums)
+ {
+ /*
+ * If the bound next to the upper bound corresponds to no partition,
+ * that's the next lower bound of the next partition. Otherwise, the
+ * current upper bound is the lower bound of the next partition.
+ */
+ if (bi->indexes[lb_index + 2] < 0)
+ return lb_index + 2;
+ else
+ return lb_index + 1;
+ }
+ else
+ return bi->ndatums;
+}
+
+static int32
+partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc, Oid *collations,
+ PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2)
+{
+ return partition_rbound_cmp(partnatts, partsupfunc, collations,
+ bound1->datums, bound1->kind, bound1->lower,
+ bound2);
+}
+
+/*
+ * partition_range_cmp
+ *
+ * Compare the bounds of two range partitions and return <, = or > 0, if the
+ * first partition's upper bound is lower than, equal to or higher than the
+ * second partition's upper bound resp.
+ *
+ * Also, set overlaps to true, if the ranges overlap, otherwise set it to
+ * false.
+ */
+static int
+partition_range_cmp(int partnatts, FmgrInfo *supfuncs, Oid *collations,
+ PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, bool *overlap)
+{
+ /*
+ * Compare upper bound of the first partition with the lower bound of the
+ * second and vice-versa. If lower bound is higher than the upper bound,
+ * the partitions are not overlapping. All other cases indicate overlapping
+ * partitions.
+ * TODO: Add a testcase which has lower and upper bound matching exactly.
+ * Lower bound is inclusive and upper bound is exclusive, so even if the
+ * datums match, the bounds do not match exactly.
+ */
+ if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ lower_bound1, upper_bound2) > 0)
+ {
+ *overlap = false;
+ return 1;
+ }
+ else if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ lower_bound2, upper_bound1) > 0)
+ {
+ *overlap = false;
+ return -1;
+ }
+ else
+ {
+ *overlap = true;
+ return partition_range_bound_cmp(partnatts, supfuncs, collations,
+ upper_bound1, upper_bound2);
+ }
+}
+
+/*
+ * partition_range_merge
+ *
+ * Merge the partition bounds of given two partitions such that the join
+ * between the given two partitions fits merged bounds.
+ *
+ * "merged_upper" will be set to one of the given upper bounds and
+ * "merged_lower" will be set to one of the given lower bounds.
+ */
+static void
+partition_range_merge(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, JoinType jointype,
+ PartitionRangeBound *left_lb,
+ PartitionRangeBound *left_ub,
+ PartitionRangeBound *right_lb,
+ PartitionRangeBound *right_ub,
+ PartitionRangeBound **merged_lb,
+ PartitionRangeBound **merged_ub)
+{
+ /*
+ * An outer join will have all the rows from the outer side, so merged
+ * bounds will be same as the outer bounds. An inner join will have rows
+ * that fit both the bounds, thus lower merged bound will be higher of two
+ * lower bounds and upper merged bound will be lower of the two upper
+ * bounds.
+ */
+ switch (jointype)
+ {
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ *merged_ub = left_ub;
+ *merged_lb = left_lb;
+ break;
+
+ case JOIN_RIGHT:
+ *merged_ub = right_ub;
+ *merged_lb = right_lb;
+ break;
+
+ case JOIN_INNER:
+ case JOIN_SEMI:
+ if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ left_ub, right_ub) < 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ left_lb, right_lb) > 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ case JOIN_FULL:
+ if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ left_ub, right_ub) > 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ left_lb, right_lb) < 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ default:
+ elog(ERROR, "Unexpected join type %d", jointype);
+ }
+
+ return;
+}
+
+/*
+ * Add the lower bound of the next range to the list of bounds, if the lower
+ * bound is higher or equal to the previous upper bound. If successful return
+ * true, otherwise false.
+ */
+static bool
+partition_range_merge_next_lb(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes)
+{
+ int cmpval;
+
+ if (!*merged_datums)
+ {
+ Assert(!*merged_kinds && !*merged_indexes);
+ cmpval = 1;
+ }
+ else
+ {
+ PartitionRangeBound prev_ub;
+
+ prev_ub.datums = llast(*merged_datums);
+ prev_ub.kind = llast(*merged_kinds);
+ prev_ub.lower = false;
+
+ /*
+ * TODO: explain why do we pass lower to be false for the next lower
+ * bound.
+ */
+ cmpval = partition_rbound_cmp(partnatts, supfuncs, collations,
+ next_lb_datums, next_lb_kind, false,
+ &prev_ub);
+ }
+
+ /*
+ * The lower bound is lower than the last upper bound, thus does not fit
+ * the bounds created so far and hence can not be merged with the existing
+ * bounds.
+ */
+ if (cmpval < 0)
+ return false;
+
+ /*
+ * Add bounds of the new merged partition. If the next lower bound is
+ * higher than the last upper bound, add new range with index
+ * corresponding to the lower bound as -1. If the merged lower bound
+ * is same as the last merged upper bound, the last upper bound will be
+ * reused as the lower bound of the next range.
+ */
+ if (cmpval > 0)
+ {
+ *merged_datums = lappend(*merged_datums, next_lb_datums);
+ *merged_kinds = lappend(*merged_kinds, next_lb_kind);
+ *merged_indexes = lappend_int(*merged_indexes, -1);
+ }
+
+ return true;
+}
+
+/*
+ * Merge given two range partition bounds.
+ *
+ * Work horse function for partition_bounds_merge() for range partitioned
+ * tables.
+ *
+ * TODO: for an anti-join, the caller is supposed to send the outer relation as
+ * left relation. May be we should rename left and right as inner and outer. We
+ * don't need to handle RIGHT joins in this function, so renaming them as outer
+ * and inner is fine.
+ */
+static PartitionBoundInfo
+partition_range_bounds_merge(int partnatts, FmgrInfo *supfuncs, Oid *collations,
+ PartitionBoundInfo left_bi, int left_nparts,
+ PartitionBoundInfo right_bi, int right_nparts,
+ JoinType jointype, List **left_parts, List **right_parts)
+{
+ int *left_pmap;
+ int *left_mmap;
+ int *right_pmap;
+ int *right_mmap;
+ int cnt1;
+ int cnt2;
+ int left_part;
+ int right_part;
+ PartitionBoundInfo merged_bounds = NULL;
+ bool merged = true; /* By default we ranges are merge-able. */
+ int left_lb_index;
+ int right_lb_index;
+ int next_index;
+ int cmpval;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ List *merged_kinds = NIL;
+
+ Assert(left_bi->strategy == right_bi->strategy &&
+ left_bi->strategy == PARTITION_STRATEGY_RANGE);
+
+ *left_parts = NIL;
+ *right_parts = NIL;
+
+ /* Allocate and initialize partition maps. */
+ left_pmap = (int *) palloc(sizeof(int) * left_nparts);
+ left_mmap = (int *) palloc(sizeof(int) * left_nparts);
+ right_pmap = (int *) palloc(sizeof(int) * right_nparts);
+ right_mmap = (int *) palloc(sizeof(int) * right_nparts);
+
+ for (cnt1 = 0; cnt1 < left_nparts; cnt1++)
+ {
+ left_pmap[cnt1] = -1;
+ left_mmap[cnt1] = -1;
+ }
+ for (cnt2 = 0; cnt2 < right_nparts; cnt2++)
+ {
+ right_pmap[cnt2] = -1;
+ right_mmap[cnt2] = -1;
+ }
+
+ left_lb_index = 0;
+ right_lb_index = 0;
+ next_index = 0;
+ while (left_lb_index < left_bi->ndatums &&
+ right_lb_index < right_bi->ndatums)
+ {
+ PartitionRangeBound left_lb;
+ PartitionRangeBound left_ub;
+ PartitionRangeBound right_lb;
+ PartitionRangeBound right_ub;
+ PartitionRangeBound *merged_lb = NULL;
+ PartitionRangeBound *merged_ub = NULL;
+ int merged_index = -1;
+ bool overlap;
+
+ /* Get the range bounds of the next partition. */
+ left_part = partition_get_range_bounds(left_bi, left_lb_index,
+ &left_lb, &left_ub);
+ right_part = partition_get_range_bounds(right_bi, right_lb_index,
+ &right_lb, &right_ub);
+
+ cmpval = partition_range_cmp(partnatts, supfuncs, collations,
+ &left_lb, &left_ub, &right_lb, &right_ub,
+ &overlap);
+
+ if (overlap)
+ {
+ /* Overlapping ranges, try merging. */
+ partition_range_merge(partnatts, supfuncs, collations, jointype,
+ &left_lb, &left_ub, &right_lb, &right_ub,
+ &merged_lb, &merged_ub);
+ merged_index = map_and_merge_partitions(left_pmap, left_mmap,
+ left_part, right_pmap,
+ right_mmap, right_part,
+ &next_index);
+
+ if (merged_index < 0)
+ {
+ merged = false;
+ break;
+ }
+ }
+
+ if (cmpval == 0)
+ {
+ Assert(overlap);
+
+ /* Move to the next pair of partitions. */
+ left_lb_index = partition_range_get_next_lb_index(left_bi,
+ left_lb_index);
+ right_lb_index = partition_range_get_next_lb_index(right_bi,
+ right_lb_index);
+ }
+ else if (cmpval < 0)
+ {
+ /*
+ * If the partition on the left was not mapped to any partition on
+ * the right. Any row from that partition will not have a matching
+ * row from the other relation. So the partition will be part of
+ * the join if it's an anti-join or the left side is the outer
+ * side.
+ */
+ if (jointype == JOIN_INNER || jointype == JOIN_SEMI ||
+ jointype == JOIN_RIGHT)
+ {
+ /* Nothing to do. */
+ }
+ else if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (left_mmap[left_part] < 0)
+ {
+ left_mmap[left_part] = next_index++;
+ merged_index = left_mmap[left_part];
+ merged_lb = &left_lb;
+ merged_ub = &left_ub;
+ }
+ }
+ else
+ {
+ /* Don't know what to do with other join types. Bail out. */
+ merged = false;
+ }
+
+ /* Move to the next partition on the left side. */
+ left_lb_index = partition_range_get_next_lb_index(left_bi,
+ left_lb_index);
+ }
+ else
+ {
+ Assert(cmpval > 0);
+
+ /*
+ * If the partition on the right was not mapped to any partition on
+ * the left. Any row from that partition will not have a matching
+ * row from the other relation. So the partition will be part of
+ * the join if the right side is the outer side.
+ */
+ if (jointype == JOIN_INNER || jointype == JOIN_SEMI ||
+ jointype == JOIN_LEFT || jointype == JOIN_ANTI)
+ {
+ /* Nothing to do. */
+ }
+ else if (jointype == JOIN_RIGHT || jointype == JOIN_FULL)
+ {
+ if (right_mmap[right_part] < 0)
+ {
+ right_mmap[right_part] = next_index++;
+ merged_index = right_mmap[right_part];
+ merged_lb = &right_lb;
+ merged_ub = &right_ub;
+ }
+ }
+ else
+ {
+ /* Don't know what to do with other join types. Bail out. */
+ merged = false;
+ }
+
+ /* Move to the next partition on the right side. */
+ right_lb_index = partition_range_get_next_lb_index(right_bi,
+ right_lb_index);
+ }
+
+ if (!merged)
+ break;
+
+ /* A skipped partition is not added to merged bounds. */
+ if (merged_index < 0)
+ continue;
+
+ /*
+ * We have a valid partition index for the next partition of join. The
+ * partition should have valid range.
+ */
+ Assert(merged_lb && merged_ub);
+
+ /* Try merging merged lower bound with the last upper bound. */
+ merged = partition_range_merge_next_lb(partnatts, supfuncs,
+ collations, merged_lb->datums,
+ merged_lb->kind, &merged_datums,
+ &merged_kinds, &merged_indexes);
+ if (merged)
+ {
+ /* Add upper bound with the merged partition index. */
+ merged_datums = lappend(merged_datums, merged_ub->datums);
+ merged_kinds = lappend(merged_kinds, merged_ub->kind);
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ }
+ else
+ break;
+ }
+
+ /*
+ * We will run the above loop till we exhaust ranges of at least one side
+ * unless we failed to merge the ranges.
+ */
+ Assert (!merged || (left_lb_index >= left_bi->ndatums ||
+ right_lb_index >= right_bi->ndatums));
+
+ /*
+ * Handle any remaining partition bounds. If remaining partitions fall on
+ * the inner side of the join, none of the rows in those partition are
+ * going to be joined with any row on the outer side and hence those
+ * partitions will not be part of the join result. Hence only consider the
+ * remaining partitions on the outer side of the join.
+ */
+ if (merged &&
+ ((left_lb_index < left_bi->ndatums &&
+ (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)) ||
+ (right_lb_index < right_bi->ndatums &&
+ (jointype == JOIN_RIGHT || jointype == JOIN_FULL))))
+ {
+ int bound_index = -1;
+ PartitionBoundInfo rem_bi = NULL;
+ int *mmap = NULL;
+ int part_index;
+
+ if (left_lb_index < left_bi->ndatums)
+ {
+ Assert(jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI);
+ bound_index = left_lb_index;
+ rem_bi = left_bi;
+ mmap = left_mmap;
+ part_index = left_part;
+ }
+ else if (right_lb_index < right_bi->ndatums)
+ {
+ Assert(jointype == JOIN_RIGHT || jointype == JOIN_FULL);
+ bound_index = right_lb_index;
+ rem_bi = right_bi;
+ mmap = right_mmap;
+ part_index = right_part;
+ }
+ Assert((bound_index >= 0 && bound_index < rem_bi->ndatums) &&
+ rem_bi && mmap && part_index >= 0);
+
+ /*
+ * If the partition corresponding to this lower bound has been already
+ * mapped to a merged partition, don't need to add it again. This may
+ * happen if the range of the last partition on the inner side overlaps
+ * with this partition's range and has upper bound lesser than upper
+ * bound of this partition's range.
+ */
+ if (mmap[part_index] >= 0)
+ bound_index = partition_range_get_next_lb_index(rem_bi, bound_index);
+
+ /*
+ * Merge lower bound of the next range with the upper bound of last
+ * range.
+ */
+ if (bound_index < rem_bi->ndatums)
+ merged = partition_range_merge_next_lb(partnatts, supfuncs,
+ collations,
+ rem_bi->datums[bound_index],
+ rem_bi->kind[bound_index],
+ &merged_datums,
+ &merged_kinds,
+ &merged_indexes);
+
+ /*
+ * Rest of the bounds correspond to valid ranges so add them after
+ * remapping their partitions as required.
+ */
+ for (bound_index++; merged && bound_index < rem_bi->ndatums;
+ bound_index++)
+ {
+ Datum *datums = rem_bi->datums[bound_index];
+ int index = rem_bi->indexes[bound_index];
+ int part_index;
+
+ /*
+ * Add lower bounds with partition index -1 and assign a new
+ * partition index to the upper bounds.
+ */
+ if (index < 0)
+ part_index = index;
+ else
+ {
+ if (mmap[index] < 0)
+ mmap[index] = next_index++;
+ part_index = mmap[index];
+ }
+
+ merged_indexes = lappend_int(merged_indexes, part_index);
+ merged_datums = lappend(merged_datums, datums);
+ merged_kinds = lappend(merged_kinds,
+ rem_bi->kind[bound_index]);
+ }
+ }
+
+ /* Create PartitionBoundInfo */
+ if (merged)
+ {
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(left_mmap, left_nparts, right_mmap,
+ right_nparts, jointype, next_index,
+ left_parts, right_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*left_parts && *right_parts)
+ {
+ Assert(list_length(*left_parts) == list_length(*right_parts));
+ Assert(list_length(*left_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(left_bi->strategy,
+ merged_datums,
+ merged_indexes,
+ merged_kinds,
+ -1);
+ }
+ }
+
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ pfree(left_pmap);
+ pfree(right_pmap);
+ pfree(left_mmap);
+ pfree(right_mmap);
+
+ /* Free any memory we used in this function. */
+ return merged_bounds;
+}
+
+/*
+ * partition_bounds_merge()'s arm for list partitioned tables.
+ *
+ * The function builds the maps of matching partitions from either relation. It
+ * builds the list of partition key values that may appear in the join result
+ * alongwith the list of indexes of partitions of join to which those values
+ * belong. It then crafts a PartitionBoundInfo structure representing the
+ * partition bounds of the join result.
+ */
+static PartitionBoundInfo
+partition_list_bounds_merge(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, PartitionBoundInfo left_bi,
+ int left_nparts, PartitionBoundInfo right_bi,
+ int right_nparts, JoinType jointype, List **left_parts,
+ List **right_parts)
+{
+ int *left_pmap; /* left to right partition map */
+ int *left_mmap; /* left to merged partition map */
+ int *right_pmap; /* right to left partition map */
+ int *right_mmap; /* right to merged partition map */
+ int cntl;
+ int cntr;
+ bool merged = true;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ int next_index = 0;
+ int null_index;
+ PartitionBoundInfo merged_bounds = NULL;
+ int *left_indexes = left_bi->indexes;
+ int *right_indexes = right_bi->indexes;
+ int left_ni = left_bi->null_index;
+ int right_ni = right_bi->null_index;
+
+ Assert(left_bi->strategy == right_bi->strategy &&
+ left_bi->strategy == PARTITION_STRATEGY_LIST);
+
+ /* List partitions do not require unbounded ranges. */
+ Assert(!left_bi->kind && !right_bi->kind);
+
+ /* Allocate and initialize partition maps. */
+ left_pmap = (int *) palloc(sizeof(int) * left_nparts);
+ left_mmap = (int *) palloc(sizeof(int) * left_nparts);
+ right_pmap = (int *) palloc(sizeof(int) * right_nparts);
+ right_mmap = (int *) palloc(sizeof(int) * right_nparts);
+
+ /* Initialize partition maps. */
+ for (cntl = 0; cntl < left_nparts; cntl++)
+ {
+ left_pmap[cntl] = -1;
+ left_mmap[cntl] = -1;
+ }
+ for (cntr = 0; cntr < right_nparts; cntr++)
+ {
+ right_pmap[cntr] = -1;
+ right_mmap[cntr] = -1;
+ }
+
+ cntl = cntr = 0;
+ while (cntl < left_bi->ndatums && cntr < right_bi->ndatums)
+ {
+ Datum *ldatums = left_bi->datums[cntl];
+ Datum *rdatums = right_bi->datums[cntr];
+ int l_index = left_indexes[cntl];
+ int r_index = right_indexes[cntr];
+ int cmpval;
+ int merged_index;
+ Datum *merged_datum;
+
+ /* Every list datum should map to a valid partition index. */
+ Assert(l_index >= 0 && r_index >= 0);
+
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
+ partcollation[0], ldatums[0],
+ rdatums[0]));
+ if (cmpval == 0)
+ {
+ /*
+ * Try matching partitions containing the matching datums. If
+ * successful, add the datum to the merged bounds with index of
+ * merged partition containing it.
+ */
+ merged_datum = ldatums;
+ merged_index = map_and_merge_partitions(left_pmap, left_mmap, l_index,
+ right_pmap, right_mmap, r_index,
+ &next_index);
+
+ if (merged_index < 0)
+ {
+ merged = false;
+ break;
+ }
+
+ /* Move to the next pair of bounds. */
+ cntl++;
+ cntr++;
+ }
+ else if (cmpval < 0)
+ {
+ /*
+ * This list datum is present in the left side but not the right
+ * side. So it will appear in the join when the left side is outer
+ * side.
+ */
+ if (jointype == JOIN_INNER || jointype == JOIN_RIGHT ||
+ jointype == JOIN_SEMI)
+ merged_index = -1;
+ else if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (left_mmap[l_index] < 0)
+ left_mmap[l_index] = next_index++;
+ merged_index = left_mmap[l_index];
+ merged_datum = ldatums;
+ }
+ else
+ {
+ /* Don't know what to do with other join types. */
+ merged = false;
+ break;
+ }
+
+ /* Move to the next datum on the left side. */
+ cntl++;
+ }
+ else
+ {
+ Assert(cmpval > 0);
+
+ /*
+ * This list datum is present in the right side but not the left
+ * side. So it will appear in the join when the right side is outer
+ * side.
+ */
+ if (jointype == JOIN_INNER || jointype == JOIN_LEFT ||
+ jointype == JOIN_SEMI || jointype == JOIN_ANTI)
+ merged_index = -1;
+ else if (jointype == JOIN_RIGHT || jointype == JOIN_FULL)
+ {
+ /*
+ * Every list value on the outer side will appear in the
+ * join. Find the merged partition to which this value
+ * belongs.
+ */
+ if (right_mmap[r_index] < 0)
+ right_mmap[r_index] = next_index++;
+ merged_index = right_mmap[r_index];
+ merged_datum = rdatums;
+ }
+ else
+ {
+ /* Don't know what to do with other join types. */
+ merged = false;
+ break;
+ }
+
+ /* Move to the next datum on the right side. */
+ cntr++;
+ }
+
+ /*
+ * Add the datum with appropriate index in the list of datums, if the
+ * rows containing that datum are deemed to be part of the join.
+ */
+ if (merged_index >= 0)
+ {
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ merged_datums = lappend(merged_datums, merged_datum);
+ }
+ }
+
+ /*
+ * If merge is unsuccessful, bail out without any further processing.
+ * That leaks the memory allocated in this function. So, try not to leak
+ * memory.
+ */
+ if (!merged)
+ goto merge_failed;
+
+ /* We should have exhausted datums on at least one side. */
+ Assert(cntr >= right_bi->ndatums || cntl >= left_bi->ndatums);
+
+ /*
+ * Add any remaining list values on the outer side, assigning partition
+ * indexes if required.
+ */
+ if (jointype == JOIN_LEFT || jointype == JOIN_FULL || jointype == JOIN_ANTI)
+ {
+ for (;cntl < left_bi->ndatums; cntl++)
+ {
+ Datum *ldatums = left_bi->datums[cntl];
+ int l_index = left_indexes[cntl];
+
+ if (left_mmap[l_index] < 0)
+ left_mmap[l_index] = next_index++;
+ merged_indexes = lappend_int(merged_indexes, left_mmap[l_index]);
+ merged_datums = lappend(merged_datums, ldatums);
+ }
+ }
+
+ if (jointype == JOIN_RIGHT || jointype == JOIN_FULL)
+ {
+ for (;cntr < right_bi->ndatums; cntr++)
+ {
+ Datum *rdatums = right_bi->datums[cntr];
+ int r_index = right_indexes[cntr];
+
+ if (right_mmap[r_index] < 0)
+ right_mmap[r_index] = next_index++;
+ merged_indexes = lappend_int(merged_indexes, right_mmap[r_index]);
+ merged_datums = lappend(merged_datums, rdatums);
+ }
+ }
+
+ /*
+ * Merge NULL partitions if any. Find the index of merged partition to
+ * which the NULL values belong in the join result. We can eliminate a NULL
+ * partition when it appears only in the inner relation.
+ */
+ if (!partition_bound_accepts_nulls(left_bi) &&
+ !partition_bound_accepts_nulls(right_bi))
+ null_index = -1;
+ else if (partition_bound_accepts_nulls(left_bi) &&
+ !partition_bound_accepts_nulls(right_bi))
+ {
+ if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (left_mmap[left_ni] < 0)
+ left_mmap[left_ni] = next_index++;
+ null_index = left_mmap[left_ni];
+ }
+ else
+ null_index = -1;
+ }
+ else if (!partition_bound_accepts_nulls(left_bi) &&
+ partition_bound_accepts_nulls(right_bi))
+ {
+ if (jointype == JOIN_RIGHT || jointype == JOIN_FULL)
+ {
+ if (right_mmap[right_ni] < 0)
+ right_mmap[right_ni] = next_index++;
+ null_index = right_mmap[right_ni];
+ }
+ else
+ null_index = -1;
+ }
+ else
+ {
+ /* Both the relations have NULL partitions, try merging them. */
+ null_index = map_and_merge_partitions(left_pmap, left_mmap,
+ left_ni, right_pmap,
+ right_mmap, right_ni,
+ &next_index);
+ if (null_index < 0)
+ merged = false;
+ }
+
+ /* If successful build the output structures. */
+ if (merged)
+ {
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(left_mmap, left_nparts, right_mmap,
+ right_nparts, jointype, next_index,
+ left_parts, right_parts);
+ /* Craft a PartitionBoundInfo to return. */
+ if (*left_parts && *right_parts)
+ {
+ Assert(list_length(*left_parts) == list_length(*right_parts));
+ Assert(list_length(*left_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(left_bi->strategy,
+ merged_datums,
+ merged_indexes, NIL,
+ null_index);
+ }
+ }
+
+merge_failed:
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ pfree(left_pmap);
+ pfree(right_pmap);
+ pfree(left_mmap);
+ pfree(right_mmap);
+
+ return merged_bounds;
+}
+
+/*
+ * map_and_merge_partitions
+ *
+ * If the two given partitions (given by index1 and index2 resp.) are already
+ * mapped to each other return the index of corresponding partition in the
+ * merged set of partitions. If they do not have a merged partition associated
+ * with them, assign a new merged partition index. If the partitions are
+ * already mapped and their mapped partitions are different from each other,
+ * they can not be merged, so return -1.
+ *
+ * partmap1[i] gives the partition of relation 2 which matches ith partition of
+ * relation 1. Similarly for partmap2.
+ *
+ * mergemap1[i] gives the partition in the merged set to which ith partition of
+ * relation 1 maps to. Similarly for mergemap2.
+ *
+ * index1 and index2 are the indexes of matching partition from respective
+ * relations.
+ *
+ * *next_index is used and incremented when the given partitions require a new
+ * merged partition.
+ */
+static int
+map_and_merge_partitions(int *partmap1, int *mergemap1, int index1,
+ int *partmap2, int *mergemap2, int index2,
+ int *next_index)
+{
+ int merged_index;
+
+ /*
+ * If both the partitions are not mapped to each other, update the
+ * maps.
+ */
+ if (partmap1[index1] < 0 && partmap2[index2] < 0)
+ {
+ partmap1[index1] = index2;
+ partmap2[index2] = index1;
+ }
+
+ /*
+ * If the given to partitions map to each other, find the corresponding
+ * merged partition index .
+ */
+ if (partmap1[index1] == index2 && partmap2[index2] == index1)
+ {
+ /*
+ * If both the partitions are mapped to the same merged partition, get
+ * the index of merged partition.
+ */
+ if (mergemap1[index1] == mergemap2[index2])
+ {
+ merged_index = mergemap1[index1];
+
+ /*
+ * If the given two partitions do not have a merged partition
+ * associated with them, allocate a new merged partition.
+ */
+ if (merged_index < 0)
+ {
+ merged_index = *next_index;
+ *next_index = *next_index + 1;
+ mergemap1[index1] = merged_index;
+ mergemap2[index2] = merged_index;
+ }
+ }
+
+ /*
+ * If partition from one relation was mapped to a merged partition but
+ * not the partition from the other relation, map the same merged
+ * partition to the partition from other relation, since matching
+ * partitions map to the same merged partition.
+ */
+ else if (mergemap1[index1] >= 0 && mergemap2[index2] < 0)
+ {
+ mergemap2[index2] = mergemap1[index1];
+ merged_index = mergemap1[index1];
+ }
+ else if (mergemap1[index1] < 0 && mergemap2[index2] >= 0)
+ {
+ mergemap1[index1] = mergemap2[index2];
+ merged_index = mergemap2[index2];
+ }
+ else
+ {
+ Assert(mergemap1[index1] != mergemap2[index2] &&
+ mergemap1[index1] >= 0 && mergemap2[index2] >= 0);
+
+ /*
+ * Both the partitions map to different merged partitions. This
+ * means that multiple partitions from one relation matches to one
+ * partition from the other relation. Partition-wise join does not
+ * handle this case right now, since it requires ganging multiple
+ * partitions together (into one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+ }
+ else
+ {
+ /*
+ * Multiple partitions from one relation map to one partition from the
+ * other relation. Partition-wise join does not handle this case right
+ * now, since it requires ganging multiple partitions together (into
+ * one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+
+ return merged_index;
+}
+
+/*
+ * generate_matching_part_pairs
+ *
+ * Given the merged partition to which partition on either side of join map,
+ * produce the list pairs of partitions which when joined produce the merged
+ * partitions in the order of merged partition indexes.
+ *
+ * If successful, the pairs of partitions are returned as two separate lists
+ * one for each side. Otherwise, those lists will be set to NIL.
+ *
+ * TODO: rename the sides as outer and inner. You may not need to support
+ * JOIN_RIGHT, since we won't see that type here.
+ */
+static void
+generate_matching_part_pairs(int *mergemap1, int nparts1, int *mergemap2,
+ int nparts2, JoinType jointype, int nparts,
+ List **parts1, List **parts2)
+{
+ bool merged = true;
+ int **matching_parts;
+ int cnt1;
+ int cnt2;
+
+ matching_parts = (int **) palloc(sizeof(int *) * 2);
+ matching_parts[0] = (int *) palloc(sizeof(int) * nparts);
+ matching_parts[1] = (int *) palloc(sizeof(int) * nparts);
+
+ *parts1 = NIL;
+ *parts2 = NIL;
+
+ for (cnt1 = 0; cnt1 < nparts; cnt1++)
+ {
+ matching_parts[0][cnt1] = -1;
+ matching_parts[1][cnt1] = -1;
+ }
+
+ /* Set pairs of matching partitions. */
+ for (cnt1 = 0; cnt1 < nparts1; cnt1++)
+ {
+ if (mergemap1[cnt1] >= 0)
+ {
+ Assert(mergemap1[cnt1] < nparts);
+ matching_parts[0][mergemap1[cnt1]] = cnt1;
+ }
+ }
+ for (cnt2 = 0; cnt2 < nparts2; cnt2++)
+ {
+ if (mergemap2[cnt2] >= 0)
+ {
+ Assert(mergemap2[cnt2] < nparts);
+ matching_parts[1][mergemap2[cnt2]] = cnt2;
+ }
+ }
+
+ /*
+ * If we have a partition missing on an inner side, we need to add a dummy
+ * relation which joins with the outer partition. If the inner relation
+ * happens to be a base relation, it will require adding a dummy child
+ * base relation during join processing. Right now, we freeze the base
+ * relation arrays like PlannerInfo::simple_rte_array after planning for
+ * base relations. Adding a new (dummy) base relation would require some
+ * changes to that. So, right now, we do not implement partition-wise join
+ * in such cases.
+ */
+ for (cnt1 = 0; cnt1 < nparts; cnt1++)
+ {
+ int part1 = matching_parts[0][cnt1];
+ int part2 = matching_parts[1][cnt1];
+
+ /* At least one of the partitions should exist. */
+ Assert(part1 >= 0 || part2 >= 0);
+
+ switch (jointype)
+ {
+ case JOIN_INNER:
+ case JOIN_SEMI:
+
+ /*
+ * An inner or semi join can not return any row when the
+ * matching partition on either side is missing. We should
+ * have eliminated all such cases while merging the bounds.
+ */
+ Assert(part1 >= 0 && part2 >= 0);
+ break;
+
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ Assert(part1 >= 0);
+ if (part2 < 0)
+ merged = false;
+ break;
+
+ case JOIN_RIGHT:
+ Assert(part2 >= 0);
+ if (part1 < 0)
+ merged = false;
+ break;
+
+ case JOIN_FULL:
+ if (part1 < 0 || part2 < 0)
+ merged = false;
+ break;
+
+ default:
+ /* We do not know what to do in this case. Bail out. */
+ merged = false;
+ }
+
+ if (!merged)
+ break;
+
+ *parts1 = lappend_int(*parts1, part1);
+ *parts2 = lappend_int(*parts2, part2);
+ }
+
+ pfree(matching_parts[0]);
+ pfree(matching_parts[1]);
+ pfree(matching_parts);
+
+ if (!merged)
+ {
+ list_free(*parts1);
+ list_free(*parts2);
+ *parts1 = NIL;
+ *parts2 = NIL;
+ }
+}
+
+static PartitionBoundInfo
+build_merged_partition_bounds(char strategy, List *merged_datums,
+ List *merged_indexes, List *merged_kinds,
+ int null_index)
+{
+ int cnt;
+ PartitionBoundInfo merged_bounds;
+ ListCell *lc;
+
+ /* We expect the same number of elements in datums and indexes lists. */
+ Assert(list_length(merged_datums) == list_length(merged_indexes));
+
+ merged_bounds = (PartitionBoundInfo) palloc(sizeof(PartitionBoundInfoData));
+ merged_bounds->strategy = strategy;
+ merged_bounds->ndatums = list_length(merged_datums);
+
+ if (strategy == PARTITION_STRATEGY_RANGE)
+ {
+ Assert(list_length(merged_datums) == list_length(merged_kinds));
+ merged_bounds->kind = (PartitionRangeDatumKind **) palloc(sizeof(PartitionRangeDatumKind *) *
+ list_length(merged_kinds));
+ cnt = 0;
+ foreach(lc, merged_kinds)
+ merged_bounds->kind[cnt++] = lfirst(lc);
+
+ /* There are ndatums+1 indexes in case of range partitions */
+ merged_indexes = lappend_int(merged_indexes, -1);
+ }
+ else
+ merged_bounds->kind = NULL;
+
+ cnt = 0;
+ merged_bounds->datums = (Datum **) palloc(sizeof(Datum *) *
+ list_length(merged_datums));
+ foreach(lc, merged_datums)
+ merged_bounds->datums[cnt++] = lfirst(lc);
+
+ merged_bounds->indexes = (int *) palloc(sizeof(int) *
+ list_length(merged_indexes));
+ cnt = 0;
+ foreach(lc, merged_indexes)
+ merged_bounds->indexes[cnt++] = lfirst_int(lc);
+
+ merged_bounds->null_index = null_index;
+
+ return merged_bounds;
+}
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 79468d2..d4e3047 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1308,8 +1308,13 @@ try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
RelOptInfo *joinrel, SpecialJoinInfo *parent_sjinfo,
List *parent_restrictlist)
{
- int nparts;
int cnt_parts;
+ PartitionScheme part_scheme;
+ PartitionBoundInfo join_boundinfo;
+ List *parts1;
+ List *parts2;
+ ListCell *lc1;
+ ListCell *lc2;
/* Guard against stack overflow due to overly deep partition hierarchy. */
check_stack_depth();
@@ -1359,39 +1364,54 @@ try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
*/
Assert(joinrel->part_scheme == rel1->part_scheme &&
joinrel->part_scheme == rel2->part_scheme);
+ part_scheme = joinrel->part_scheme;
/*
- * Since we allow partition-wise 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.
+ * Get the list of matching partitions from both sides of the join. While
+ * doing so, we also build the partition bounds of the join relation,
+ * which should match the bounds calculated for other pairs. TODO: why
+ * should every pair result in the same partition bounds?
*/
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel1->boundinfo));
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel2->boundinfo));
-
- nparts = joinrel->nparts;
-
+ join_boundinfo = partition_bounds_merge(part_scheme->partnatts,
+ part_scheme->partsupfunc,
+ part_scheme->parttypcoll,
+ rel1->boundinfo, rel1->nparts,
+ rel2->boundinfo, rel2->nparts,
+ parent_sjinfo->jointype,
+ &parts1, &parts2);
+
+ Assert(join_boundinfo);
+ Assert(partition_bounds_equal(part_scheme->partnatts,
+ part_scheme->parttyplen,
+ part_scheme->parttypbyval, join_boundinfo,
+ joinrel->boundinfo));
elog(DEBUG3, "join between relations %s and %s is considered for partition-wise join.",
bmsToString(rel1->relids), bmsToString(rel2->relids));
- /* Allocate space to hold child-joins RelOptInfos, if not already done. */
+ /*
+ * Every pair of joining relations should result in the same number of
+ * child-joins.
+ */
+ Assert(joinrel->nparts == list_length(parts1));
+ Assert(joinrel->nparts == list_length(parts2));
+
+ /* Allocate space for hold child-joins RelOptInfos, if not already done. */
if (!joinrel->part_rels)
- joinrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) * nparts);
+ joinrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+ joinrel->nparts);
/*
* Create child-join relations for this partitioned join, if those don't
* exist. Add paths to child-joins for a pair of child relations
* corresponding to the given pair of parent relations.
*/
- for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+ cnt_parts = 0;
+ forboth(lc1, parts1, lc2, parts2)
{
- RelOptInfo *child_rel1 = rel1->part_rels[cnt_parts];
- RelOptInfo *child_rel2 = rel2->part_rels[cnt_parts];
+ int part1 = lfirst_int(lc1);
+ int part2 = lfirst_int(lc2);
+ RelOptInfo *child_rel1;
+ RelOptInfo *child_rel2;
SpecialJoinInfo *child_sjinfo;
List *child_restrictlist;
RelOptInfo *child_joinrel;
@@ -1399,6 +1419,10 @@ try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
AppendRelInfo **appinfos;
int nappinfos;
+ Assert(part1 >= 0 && part2 >= 0);
+ child_rel1 = rel1->part_rels[part1];
+ child_rel2 = rel2->part_rels[part2];
+
/* We should never try to join two overlapping sets of rels. */
Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1431,6 +1455,15 @@ try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
joinrel->part_rels[cnt_parts] = child_joinrel;
}
+ /*
+ * For every pair of joining relations, the set of matching partitions
+ * would change. However, the base relation partitions constituting
+ * the given child should remain same for all the joining pairs. Since
+ * the order in which children are stored in the array of child-joins,
+ * depends upon partition bounds of the join, which are same for all
+ * the joining pairs, every joining pair yields the child-joins in the
+ * same order.
+ */
Assert(bms_equal(child_joinrel->relids, child_joinrelids));
populate_joinrel_with_paths(root, child_rel1, child_rel2,
@@ -1443,7 +1476,11 @@ try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
*/
try_partition_wise_join(root, child_rel1, child_rel2, child_joinrel,
child_sjinfo, child_restrictlist);
+
+ cnt_parts++;
}
+
+ Assert(cnt_parts == joinrel->nparts);
}
/*
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 81bc2b1..5d1992e 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1613,6 +1613,9 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
int partnatts;
int cnt;
PartitionScheme part_scheme;
+ PartitionBoundInfo join_boundinfo;
+ List *parts1;
+ List *parts2;
/* Nothing to do if partition-wise join technique is disabled. */
if (!enable_partition_wise_join)
@@ -1653,17 +1656,26 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
REL_HAS_ALL_PART_PROPS(inner_rel));
/*
- * For now, our partition matching algorithm can match partitions only
- * when the partition bounds of the joining relations are exactly same.
- * So, bail out otherwise.
+ * Every pair of joining relations would yield the same partition bounds
+ * for a given join (TODO: why?) so we compute the bounds only the first
+ * time. Then for every pair we find the pairs of matching partitions from
+ * the joining relations and join those. TODO: Needs a better explanation
+ * of why is this true. TODO: Also there is no reason to have
+ * part_indexes1 and part_indexes2 pulled here just to be freed up later.
+ * So, we might want to do something better.
*/
- if (outer_rel->nparts != inner_rel->nparts ||
- !partition_bounds_equal(part_scheme->partnatts,
- part_scheme->parttyplen,
- part_scheme->parttypbyval,
- outer_rel->boundinfo, inner_rel->boundinfo))
+ join_boundinfo = partition_bounds_merge(part_scheme->partnatts,
+ part_scheme->partsupfunc,
+ part_scheme->parttypcoll,
+ outer_rel->boundinfo,
+ outer_rel->nparts,
+ inner_rel->boundinfo,
+ inner_rel->nparts,
+ jointype, &parts1, &parts2);
+ if (!join_boundinfo)
{
Assert(!IS_PARTITIONED_REL(joinrel));
+ Assert(!parts1 && !parts2);
return;
}
@@ -1676,13 +1688,16 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
!joinrel->nullable_partexprs && !joinrel->part_rels &&
!joinrel->boundinfo);
+ Assert(list_length(parts1) == list_length(parts2));
+
/*
* Join relation is partitioned using same partitioning scheme as the
- * joining relations and has same bounds.
+ * joining relations. It will have as many partitions as the pairs of
+ * matching partitions we found.
*/
joinrel->part_scheme = part_scheme;
- joinrel->boundinfo = outer_rel->boundinfo;
- joinrel->nparts = outer_rel->nparts;
+ joinrel->nparts = list_length(parts1);
+ joinrel->boundinfo = join_boundinfo;
partnatts = joinrel->part_scheme->partnatts;
/*
@@ -1803,4 +1818,9 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
joinrel->nullable_partexprs[cnt] = nullable_partexprs;
}
}
+
+ /* TODO: OR we could actually create the child-join relations here.*/
+ list_free(parts1);
+ list_free(parts2);
+
}
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 2283c67..056a4f9 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -99,4 +99,10 @@ extern int get_partition_for_tuple(PartitionDispatch *pd,
EState *estate,
PartitionDispatchData **failed_at,
TupleTableSlot **failed_slot);
+extern PartitionBoundInfo partition_bounds_merge(int partnatts,
+ FmgrInfo *supfuncs, Oid *collations,
+ PartitionBoundInfo boundinfo1, int nparts1,
+ PartitionBoundInfo boundinfo2, int nparts2,
+ JoinType jointype, List **parts1, List **parts2);
+
#endif /* PARTITION_H */
--
1.7.9.5
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2017-09-04 12:30 ` Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Rajkumar Raghuwanshi @ 2017-09-04 12:30 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; +Cc: pgsql-hackers
On Sat, Sep 2, 2017 at 12:42 AM, Ashutosh Bapat <
ashutosh.bapat@enterprisedb.com> wrote:
> PFA the patches rebased on the latest sources. There are also fixes
> for some of the crashes and bugs reported. I haven't yet included the
> testcase patch in the main patchset.
>
> On Mon, Aug 28, 2017 at 12:44 PM, Rajkumar Raghuwanshi
> <rajkumar.raghuwanshi@enterprisedb.com> wrote:
> > On Mon, Aug 21, 2017 at 12:43 PM, Ashutosh Bapat
> > <ashutosh.bapat@enterprisedb.com> wrote:
> >>
> >> TODOs
> >> -----------
> >> 1. Add tests for advanced partition matching algorithm
> >
> >
> > Hi Ashutosh,
> >
> > I have applied all partition-wise-join patches (v26) and tested feature.
> I
> > have modified partition_join.sql file and added extra test cases to test
> > partition matching.
> >
> > Attaching WIP test case patch which as of now have some server crashes
> and a
> > data corruptions issue which is commented in the file itself and need to
> be
> > removed once issue got solved. Also some of queries is not picking or
> > picking partition-wise-join as per expectation which may need some
> > adjustment.
> >
>
I have applied v27 patches and tested feature. Also tried to reduce
regression diff with the
existing partition_join.sql by adding new partition instead of changing
original partition bounds.
Attached WIP patch have a server crash and some wrong output which need to
be fixed. I have
commented these issue in patch itself, Please take a look and let me know
if it need more
changes.
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Attachments:
[text/x-patch] advance_partition_matching_test_v1.patch (215.7K, ../../CAKcux6kinAwQFbk9Ce5_04UdKhrRm+SvpM-Cwz_Zc2Yqja+CYQ@mail.gmail.com/3-advance_partition_matching_test_v1.patch)
download | inline diff:
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index b92fbb9..0dd0b59 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -8,105 +8,159 @@ SET enable_partition_wise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 799, 3) i;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(21 rows)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
-(4 rows)
+ a | c | b | c
+------+-------+------+-------
+ -250 | -0250 | -250 | -0250
+ -100 | -0100 | -100 | -0100
+ 0 | 0000 | 0 | 0000
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+(9 rows)
-- left outer join, with whole-row reference
EXPLAIN (COSTS OFF)
SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b
-> Result
-> Append
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(22 rows)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(33 rows)
SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- t1 | t2
---------------+--------------
- (0,0,0000) | (0,0,0000)
- (50,0,0050) |
- (100,0,0100) |
- (150,0,0150) | (0,150,0150)
- (200,0,0200) |
- (250,0,0250) |
- (300,0,0300) | (0,300,0300)
- (350,0,0350) |
- (400,0,0400) |
- (450,0,0450) | (0,450,0450)
- (500,0,0500) |
- (550,0,0550) |
-(12 rows)
+ t1 | t2
+----------------+----------------
+ (-250,0,-0250) | (0,-250,-0250)
+ (-200,0,-0200) |
+ (-150,0,-0150) |
+ (-100,0,-0100) | (0,-100,-0100)
+ (-50,0,-0050) |
+ (0,0,0000) | (0,0,0000)
+ (0,0,0000) | (0,0,0000)
+ (50,0,0050) |
+ (100,0,0100) |
+ (150,0,0150) | (0,150,0150)
+ (200,0,0200) |
+ (250,0,0250) |
+ (300,0,0300) | (0,300,0300)
+ (350,0,0350) |
+ (400,0,0400) |
+ (450,0,0450) | (0,450,0450)
+ (500,0,0500) |
+ (550,0,0550) |
+ (600,0,0600) | (0,600,0600)
+ (650,0,0650) |
+ (700,0,0700) |
+ (750,0,0750) | (0,750,0750)
+(22 rows)
-- right outer join
EXPLAIN (COSTS OFF)
@@ -119,35 +173,55 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHE
-> Append
-> Hash Right Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Right Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Hash Right Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-> Nested Loop Left Join
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p3 t2_3
Filter: (a = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t2_2.b)
-(21 rows)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(33 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
- | | 75 | 0075
- | | 225 | 0225
- | | 375 | 0375
- | | 525 | 0525
-(8 rows)
+ a | c | b | c
+------+-------+------+-------
+ -250 | -0250 | -250 | -0250
+ -100 | -0100 | -100 | -0100
+ 0 | 0000 | 0 | 0000
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+ | | -175 | -0175
+ | | -25 | -0025
+ | | 75 | 0075
+ | | 225 | 0225
+ | | 375 | 0375
+ | | 525 | 0525
+ | | 675 | 0675
+(16 rows)
-- full outer join
EXPLAIN (COSTS OFF)
@@ -155,9 +229,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE prt1.b = 0) t1 FULL
QUERY PLAN
--------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b
+ Sort Key: prt1_p0.a, prt2_p0.b
-> Append
-> Hash Full Join
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ -> Seq Scan on prt1_p0
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0
+ Filter: (a = 0)
+ -> Hash Full Join
Hash Cond: (prt1_p1.a = prt2_p1.b)
-> Seq Scan on prt1_p1
Filter: (b = 0)
@@ -178,28 +259,48 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE prt1.b = 0) t1 FULL
-> Hash
-> Seq Scan on prt2_p3
Filter: (a = 0)
-(24 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+(38 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | 150 | 0150
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
- 450 | 0450 | 450 | 0450
- 500 | 0500 | |
- 550 | 0550 | |
- | | 75 | 0075
- | | 225 | 0225
- | | 375 | 0375
- | | 525 | 0525
-(16 rows)
+ a | c | b | c
+------+-------+------+-------
+ -250 | -0250 | -250 | -0250
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | -100 | -0100
+ -50 | -0050 | |
+ 0 | 0000 | 0 | 0000
+ 0 | 0000 | 0 | 0000
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | 150 | 0150
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ 450 | 0450 | 450 | 0450
+ 500 | 0500 | |
+ 550 | 0550 | |
+ 600 | 0600 | 600 | 0600
+ 650 | 0650 | |
+ 700 | 0700 | |
+ 750 | 0750 | 750 | 0750
+ | | -175 | -0175
+ | | -25 | -0025
+ | | 75 | 0075
+ | | 225 | 0225
+ | | 375 | 0375
+ | | 525 | 0525
+ | | 675 | 0675
+(29 rows)
-- Cases with non-nullable expressions in subquery results;
-- make sure these go to null as expected
@@ -208,9 +309,17 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
QUERY PLAN
------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b
+ Sort Key: prt1_p0.a, prt2_p0.b
-> Append
-> Hash Full Join
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ Filter: (((50) = prt1_p0.a) OR ((75) = prt2_p0.b))
+ -> Seq Scan on prt1_p0
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0
+ Filter: (a = 0)
+ -> Hash Full Join
Hash Cond: (prt1_p1.a = prt2_p1.b)
Filter: (((50) = prt1_p1.a) OR ((75) = prt2_p1.b))
-> Seq Scan on prt1_p1
@@ -234,7 +343,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
-> Hash
-> Seq Scan on prt2_p3
Filter: (a = 0)
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ Filter: (((50) = prt1_p4.a) OR ((75) = prt2_p4.b))
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) WHERE t1.phv = t1.a OR t2.phv = t2.b ORDER BY t1.a, t2.b;
a | c | b | c
@@ -248,10 +365,17 @@ SELECT t1.a, t1.c, t1.phv, t2.b, t2.c, t2.phv FROM (SELECT 25 phv, * FROM prt1 W
QUERY PLAN
--------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b
+ Sort Key: prt1_p0.a, prt2_p0.b
-> Result
-> Append
-> Hash Full Join
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ -> Seq Scan on prt1_p0
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0
+ Filter: (a = 0)
+ -> Hash Full Join
Hash Cond: (prt1_p1.a = prt2_p1.b)
-> Seq Scan on prt1_p1
Filter: (b = 0)
@@ -272,28 +396,48 @@ SELECT t1.a, t1.c, t1.phv, t2.b, t2.c, t2.phv FROM (SELECT 25 phv, * FROM prt1 W
-> Hash
-> Seq Scan on prt2_p3
Filter: (a = 0)
-(25 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+(39 rows)
SELECT t1.a, t1.c, t1.phv, t2.b, t2.c, t2.phv FROM (SELECT 25 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 50 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) ORDER BY t1.a, t2.b;
- a | c | phv | b | c | phv
------+------+-----+-----+------+-----
- 0 | 0000 | 25 | 0 | 0000 | 50
- 50 | 0050 | 25 | | |
- 100 | 0100 | 25 | | |
- 150 | 0150 | 25 | 150 | 0150 | 50
- 200 | 0200 | 25 | | |
- 250 | 0250 | 25 | | |
- 300 | 0300 | 25 | 300 | 0300 | 50
- 350 | 0350 | 25 | | |
- 400 | 0400 | 25 | | |
- 450 | 0450 | 25 | 450 | 0450 | 50
- 500 | 0500 | 25 | | |
- 550 | 0550 | 25 | | |
- | | | 75 | 0075 | 50
- | | | 225 | 0225 | 50
- | | | 375 | 0375 | 50
- | | | 525 | 0525 | 50
-(16 rows)
+ a | c | phv | b | c | phv
+------+-------+-----+------+-------+-----
+ -250 | -0250 | 25 | -250 | -0250 | 50
+ -200 | -0200 | 25 | | |
+ -150 | -0150 | 25 | | |
+ -100 | -0100 | 25 | -100 | -0100 | 50
+ -50 | -0050 | 25 | | |
+ 0 | 0000 | 25 | 0 | 0000 | 50
+ 0 | 0000 | 25 | 0 | 0000 | 50
+ 50 | 0050 | 25 | | |
+ 100 | 0100 | 25 | | |
+ 150 | 0150 | 25 | 150 | 0150 | 50
+ 200 | 0200 | 25 | | |
+ 250 | 0250 | 25 | | |
+ 300 | 0300 | 25 | 300 | 0300 | 50
+ 350 | 0350 | 25 | | |
+ 400 | 0400 | 25 | | |
+ 450 | 0450 | 25 | 450 | 0450 | 50
+ 500 | 0500 | 25 | | |
+ 550 | 0550 | 25 | | |
+ 600 | 0600 | 25 | 600 | 0600 | 50
+ 650 | 0650 | 25 | | |
+ 700 | 0700 | 25 | | |
+ 750 | 0750 | 25 | 750 | 0750 | 50
+ | | | -175 | -0175 | 50
+ | | | -25 | -0025 | 50
+ | | | 75 | 0075 | 50
+ | | | 225 | 0225 | 50
+ | | | 375 | 0375 | 50
+ | | | 525 | 0525 | 50
+ | | | 675 | 0675 | 50
+(29 rows)
-- Join with pruned partitions from joining relations
EXPLAIN (COSTS OFF)
@@ -323,9 +467,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
-> Hash Left Join
+ Hash Cond: (prt1_p0.a = b)
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Hash
+ -> Result
+ One-Time Filter: false
+ -> Hash Left Join
Hash Cond: (prt1_p1.a = b)
-> Seq Scan on prt1_p1
Filter: ((a < 450) AND (b = 0))
@@ -339,30 +490,44 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
-> Hash
-> Seq Scan on prt1_p2
Filter: ((a < 450) AND (b = 0))
-(17 rows)
+(24 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
-(9 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+(15 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
QUERY PLAN
------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
-> Hash Full Join
+ Hash Cond: (prt1_p0.a = b)
+ Filter: ((prt1_p0.b = 0) OR (a = 0))
+ -> Seq Scan on prt1_p0
+ Filter: (a < 450)
+ -> Hash
+ -> Result
+ One-Time Filter: false
+ -> Hash Full Join
Hash Cond: (prt1_p1.a = b)
Filter: ((prt1_p1.b = 0) OR (a = 0))
-> Seq Scan on prt1_p1
@@ -386,64 +551,157 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JO
-> Hash
-> Result
One-Time Filter: false
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt2_p4.b = a)
+ Filter: ((b = 0) OR (prt2_p4.a = 0))
+ -> Seq Scan on prt2_p4
+ Filter: (b > 250)
+ -> Hash
+ -> Result
+ One-Time Filter: false
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
- | | 375 | 0375
- | | 450 | 0450
- | | 525 | 0525
-(12 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ | | 375 | 0375
+ | | 450 | 0450
+ | | 525 | 0525
+ | | 600 | 0600
+ | | 675 | 0675
+ | | 750 | 0750
+(21 rows)
-- Semi-join
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Semi Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Semi Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Nested Loop Semi Join
- Join Filter: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Materialize
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-(24 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(39 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -250 | 0 | -0250
+ -100 | 0 | -0100
+ 0 | 0 | 0000
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(9 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p0 t2
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_2.b = t2_2.a)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p2 t2_2
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: (t1_3.b = t2_3.a)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt1_p3 t2_3
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.b = t2_4.a)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p4 t2_4
+ Filter: (b = 0)
+(37 rows)
+
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ a | b | c
+---+------+-------
+ 0 | -250 | -0250
+ 0 | -100 | -0100
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(8 rows)
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
@@ -454,25 +712,74 @@ SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS
-> Append
-> Hash Anti Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash Anti Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash Anti Join
Hash Cond: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p3 t2_2
-(17 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash Anti Join
+ Hash Cond: (t1_3.a = t2_3.b)
+ -> Seq Scan on prt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_3
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(27 rows)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
- sum | avg | sum | avg
--------+----------------------+------+---------------------
- 60000 | 300.0000000000000000 | 2400 | 12.0000000000000000
+ sum | avg | sum | avg
+-------+----------------------+------+--------------------
+ 95718 | 274.2636103151862464 | 2168 | 6.2120343839541547
+(1 row)
+
+EXPLAIN (COSTS OFF)
+SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a);
+ QUERY PLAN
+--------------------------------------------------
+ Aggregate
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Seq Scan on prt2_p0 t1
+ -> Hash
+ -> Seq Scan on prt1_p0 t2
+ -> Hash Anti Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ -> Hash Anti Join
+ Hash Cond: (t1_2.b = t2_2.a)
+ -> Seq Scan on prt2_p2 t1_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t2_2
+ -> Hash Anti Join
+ Hash Cond: (t1_3.b = t2_3.a)
+ -> Seq Scan on prt2_p3 t1_3
+ -> Hash
+ -> Seq Scan on prt1_p3 t2_3
+ -> Hash Anti Join
+ Hash Cond: (t1_4.b = t2_4.a)
+ -> Seq Scan on prt2_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t2_4
+(27 rows)
+
+SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a);
+ sum | avg | sum | avg
+------+--------------------+-------+----------------------
+ 1084 | 6.1942857142857143 | 47859 | 273.4800000000000000
(1 row)
-- lateral reference
@@ -487,49 +794,77 @@ SELECT * FROM prt1 t1 LEFT JOIN LATERAL
-> Result
-> Append
-> Nested Loop Left Join
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p1_a on prt1_p1 t2
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
Index Cond: (a = t1.a)
- -> Index Scan using iprt2_p1_b on prt2_p1 t3
+ -> Index Scan using iprt2_p0_b on prt2_p0 t3
Index Cond: (b = t2.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_1
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
Index Cond: (a = t1_1.a)
- -> Index Scan using iprt2_p2_b on prt2_p2 t3_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t3_1
Index Cond: (b = t2_1.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_2
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
Index Cond: (a = t1_2.a)
- -> Index Scan using iprt2_p3_b on prt2_p3 t3_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t3_2
Index Cond: (b = t2_2.a)
-(28 rows)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.a)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t3_3
+ Index Cond: (b = t2_3.a)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.a)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t3_4
+ Index Cond: (b = t2_4.a)
+(44 rows)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, least(t1.a,t2.a,t3.b) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.a = ss.t2a WHERE t1.b = 0 ORDER BY t1.a;
- a | b | c | t2a | t3a | least
------+---+------+-----+-----+-------
- 0 | 0 | 0000 | 0 | 0 | 0
- 50 | 0 | 0050 | | |
- 100 | 0 | 0100 | | |
- 150 | 0 | 0150 | 150 | 0 | 150
- 200 | 0 | 0200 | | |
- 250 | 0 | 0250 | | |
- 300 | 0 | 0300 | 300 | 0 | 300
- 350 | 0 | 0350 | | |
- 400 | 0 | 0400 | | |
- 450 | 0 | 0450 | 450 | 0 | 450
- 500 | 0 | 0500 | | |
- 550 | 0 | 0550 | | |
-(12 rows)
+ a | b | c | t2a | t3a | least
+------+---+-------+------+-----+-------
+ -250 | 0 | -0250 | -250 | 0 | -250
+ -200 | 0 | -0200 | | |
+ -150 | 0 | -0150 | | |
+ -100 | 0 | -0100 | -100 | 0 | -100
+ -50 | 0 | -0050 | | |
+ 0 | 0 | 0000 | 0 | 0 | 0
+ 0 | 0 | 0000 | 0 | 0 | 0
+ 0 | 0 | 0000 | 0 | 0 | 0
+ 0 | 0 | 0000 | 0 | 0 | 0
+ 50 | 0 | 0050 | | |
+ 100 | 0 | 0100 | | |
+ 150 | 0 | 0150 | 150 | 0 | 150
+ 200 | 0 | 0200 | | |
+ 250 | 0 | 0250 | | |
+ 300 | 0 | 0300 | 300 | 0 | 300
+ 350 | 0 | 0350 | | |
+ 400 | 0 | 0400 | | |
+ 450 | 0 | 0450 | 450 | 0 | 450
+ 500 | 0 | 0500 | | |
+ 550 | 0 | 0550 | | |
+ 600 | 0 | 0600 | 600 | 0 | 600
+ 650 | 0 | 0650 | | |
+ 700 | 0 | 0700 | | |
+ 750 | 0 | 0750 | 750 | 0 | 750
+(24 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
@@ -543,64 +878,98 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
Hash Cond: ((t1.c)::text = (t2.c)::text)
Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Hash Join
Hash Cond: (t2.a = t3.b)
- -> Seq Scan on prt1_p1 t2
+ -> Seq Scan on prt1_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t3
+ -> Seq Scan on prt2_p0 t3
-> Hash Join
Hash Cond: (t2_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t2_1
+ -> Seq Scan on prt1_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p1 t3_1
-> Hash Join
Hash Cond: (t2_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p2 t2_2
-> Hash
- -> Seq Scan on prt2_p3 t3_2
-(26 rows)
+ -> Seq Scan on prt2_p2 t3_2
+ -> Hash Join
+ Hash Cond: (t2_3.a = t3_3.b)
+ -> Seq Scan on prt1_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t3_3
+ -> Hash Join
+ Hash Cond: (t2_4.a = t3_4.b)
+ -> Seq Scan on prt1_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t3_4
+(38 rows)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, t2.b t2b, t2.c t2c, least(t1.a,t2.a,t3.a) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.c = ss.t2c WHERE (t1.b + coalesce(ss.t2b, 0)) = 0 ORDER BY t1.a;
- a | t2a | t2c
------+-----+------
- 0 | 0 | 0000
- 50 | |
- 100 | |
- 150 | 150 | 0150
- 200 | |
- 250 | |
- 300 | 300 | 0300
- 350 | |
- 400 | |
- 450 | 450 | 0450
- 500 | |
- 550 | |
-(12 rows)
+ a | t2a | t2c
+------+------+-------
+ -250 | -250 | -0250
+ -200 | |
+ -150 | |
+ -100 | -100 | -0100
+ -50 | |
+ 0 | 0 | 0000
+ 0 | 0 | 0000
+ 0 | 0 | 0000
+ 0 | 0 | 0000
+ 50 | |
+ 100 | |
+ 150 | 150 | 0150
+ 200 | |
+ 250 | |
+ 300 | 300 | 0300
+ 350 | |
+ 400 | |
+ 450 | 450 | 0450
+ 500 | |
+ 550 | |
+ 600 | 600 | 0600
+ 650 | |
+ 700 | |
+ 750 | 750 | 0750
+(24 rows)
--
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
@@ -611,32 +980,49 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 =
-> Append
-> Hash Join
Hash Cond: (((t2.b + t2.a) / 2) = ((t1.a + t1.b) / 2))
- -> Seq Scan on prt2_e_p1 t2
+ -> Seq Scan on prt2_e_p0 t2
-> Hash
- -> Seq Scan on prt1_e_p1 t1
+ -> Seq Scan on prt1_e_p0 t1
Filter: (c = 0)
-> Hash Join
- Hash Cond: (((t2_1.b + t2_1.a) / 2) = ((t1_1.a + t1_1.b) / 2))
- -> Seq Scan on prt2_e_p2 t2_1
+ Hash Cond: (((t1_1.a + t1_1.b) / 2) = ((t2_1.b + t2_1.a) / 2))
+ -> Seq Scan on prt1_e_p1 t1_1
+ Filter: (c = 0)
-> Hash
- -> Seq Scan on prt1_e_p2 t1_1
- Filter: (c = 0)
+ -> Seq Scan on prt2_e_p1 t2_1
-> Hash Join
Hash Cond: (((t2_2.b + t2_2.a) / 2) = ((t1_2.a + t1_2.b) / 2))
- -> Seq Scan on prt2_e_p3 t2_2
+ -> Seq Scan on prt2_e_p2 t2_2
-> Hash
- -> Seq Scan on prt1_e_p3 t1_2
+ -> Seq Scan on prt1_e_p2 t1_2
Filter: (c = 0)
-(21 rows)
+ -> Hash Join
+ Hash Cond: (((t2_3.b + t2_3.a) / 2) = ((t1_3.a + t1_3.b) / 2))
+ -> Seq Scan on prt2_e_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t1_3
+ Filter: (c = 0)
+ -> Hash Join
+ Hash Cond: (((t2_4.b + t2_4.a) / 2) = ((t1_4.a + t1_4.b) / 2))
+ -> Seq Scan on prt2_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_4
+ Filter: (c = 0)
+(33 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 150 | 0 | 150 | 0
- 300 | 0 | 300 | 0
- 450 | 0 | 450 | 0
-(4 rows)
+ a | c | b | c
+------+---+------+---
+ -250 | 0 | -250 | 0
+ -100 | 0 | -100 | 0
+ 0 | 0 | 0 | 0
+ 0 | 0 | 0 | 0
+ 150 | 0 | 150 | 0
+ 300 | 0 | 300 | 0
+ 450 | 0 | 450 | 0
+ 600 | 0 | 600 | 0
+ 750 | 0 | 750 | 0
+(9 rows)
--
-- N-way join
@@ -650,107 +1036,163 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t
-> Result
-> Append
-> Nested Loop
- Join Filter: (t1.a = ((t3.a + t3.b) / 2))
+ Join Filter: (t1.a = t2.b)
-> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p1_ab2 on prt1_e_p1 t3
- Index Cond: (((a + b) / 2) = t2.b)
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
+ Index Cond: (b = ((t3.a + t3.b) / 2))
-> Nested Loop
Join Filter: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_1
+ -> Index Scan using iprt1_e_p4_ab2 on prt1_e_p1 t3_1
Index Cond: (((a + b) / 2) = t2_1.b)
-> Nested Loop
Join Filter: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_2
Index Cond: (((a + b) / 2) = t2_2.b)
-(34 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = ((t3_3.a + t3_3.b) / 2))
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (((a + b) / 2) = t2_3.b)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t2_4.b)
+ -> Hash Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (b = ((t3_4.a + t3_4.b) / 2))
+(53 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t3 WHERE t1.a = t2.b AND t1.a = (t3.a + t3.b)/2 AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
-(4 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | -250 | -0250 | -500 | 0
+ -100 | -0100 | -100 | -0100 | -200 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(11 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
---------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Result
-> Append
-> Hash Right Join
Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_1.a + t3_1.b) / 2) = t1_1.a)
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
-> Hash
-> Hash Right Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_2.a + t3_2.b) / 2) = t1_2.a)
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
-> Hash
-> Hash Right Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (t1_3.a = ((a + b) / 2))
+ -> Hash Right Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p4 t1_4
Filter: (b = 0)
-(34 rows)
+(52 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | -250 | -0250 | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | | | -300 | 0
+ -100 | -0100 | -100 | -0100 | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(24 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
--------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Result
@@ -758,48 +1200,77 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1.a = ((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
Index Cond: (t1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t2_1
Index Cond: (t1_1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t2_2
Index Cond: (t1_2.a = b)
-(31 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t3_3.a + t3_3.b) / 2))
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Nested Loop Left Join
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = ((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (t1_4.a = b)
+(48 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | -250 | -0250 | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | | | -300 | 0
+ -100 | -0100 | -100 | -0100 | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(24 rows)
-- Cases with non-nullable expressions in subquery results;
-- make sure these go to null as expected
@@ -808,10 +1279,23 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b, ((prt1_e_p1.a + prt1_e_p1.b))
+ Sort Key: prt1_p0.a, prt2_p0.b, ((prt1_e_p0.a + prt1_e_p0.b))
-> Result
-> Append
-> Hash Full Join
+ Hash Cond: (prt1_p0.a = ((prt1_e_p0.a + prt1_e_p0.b) / 2))
+ Filter: ((prt1_p0.a = (50)) OR (prt2_p0.b = (75)) OR (((prt1_e_p0.a + prt1_e_p0.b) / 2) = (50)))
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ -> Seq Scan on prt1_p0
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_e_p0
+ Filter: (c = 0)
+ -> Hash Full Join
Hash Cond: (prt1_p1.a = ((prt1_e_p1.a + prt1_e_p1.b) / 2))
Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
-> Hash Full Join
@@ -850,7 +1334,20 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
-> Hash
-> Seq Scan on prt1_e_p3
Filter: (c = 0)
-(43 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = ((prt1_e_p4.a + prt1_e_p4.b) / 2))
+ Filter: ((prt1_p4.a = (50)) OR (prt2_p4.b = (75)) OR (((prt1_e_p4.a + prt1_e_p4.b) / 2) = (50)))
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_e_p4
+ Filter: (c = 0)
+(69 rows)
SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b)) FULL JOIN (SELECT 50 phv, * FROM prt1_e WHERE prt1_e.c = 0) t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.a = t1.phv OR t2.b = t2.phv OR (t3.a + t3.b)/2 = t3.phv ORDER BY t1.a, t2.b, t3.a + t3.b;
a | phv | b | phv | ?column? | phv
@@ -868,173 +1365,263 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHER
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = t1_3.b)
+ Join Filter: (t1.a = t1_5.b)
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Join
- Hash Cond: (((t2.a + t2.b) / 2) = t1_3.b)
- -> Seq Scan on prt1_e_p1 t2
+ Hash Cond: (((t2.a + t2.b) / 2) = t1_5.b)
+ -> Seq Scan on prt1_e_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t1_3
+ -> Seq Scan on prt2_p0 t1_5
Filter: (a = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
Index Cond: (a = ((t2.a + t2.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_1.a = t1_4.b)
+ Join Filter: (t1_1.a = t1_6.b)
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Join
- Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_4.b)
- -> Seq Scan on prt1_e_p2 t2_1
+ Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_6.b)
+ -> Seq Scan on prt1_e_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t1_4
+ -> Seq Scan on prt2_p1 t1_6
Filter: (a = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
Index Cond: (a = ((t2_1.a + t2_1.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_2.a = t1_5.b)
+ Join Filter: (t1_2.a = t1_7.b)
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Nested Loop
- -> Seq Scan on prt2_p3 t1_5
+ -> Seq Scan on prt2_p2 t1_7
Filter: (a = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_2
- Index Cond: (((a + b) / 2) = t1_5.b)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t2_2
+ Index Cond: (((a + b) / 2) = t1_7.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
Index Cond: (a = ((t2_2.a + t2_2.b) / 2))
Filter: (b = 0)
-(41 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = t1_8.b)
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t1_8
+ Filter: (a = 0)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_3
+ Index Cond: (((a + b) / 2) = t1_8.b)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t2_3.a + t2_3.b) / 2))
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t1_9.b)
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Join
+ Hash Cond: (((t2_4.a + t2_4.b) / 2) = t1_9.b)
+ -> Seq Scan on prt1_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t1_9
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = ((t2_4.a + t2_4.b) / 2))
+ Filter: (b = 0)
+(66 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHERE t1.a = 0 AND t1.b = (t2.a + t2.b)/2) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -250 | 0 | -0250
+ -100 | 0 | -0100
+ 0 | 0 | 0000
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(9 rows)
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
--------------------------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Nested Loop
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Semi Join
- Hash Cond: (t1_3.b = ((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt2_p1 t1_3
+ Hash Cond: (t1_5.b = ((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt2_p0 t1_5
-> Hash
- -> Seq Scan on prt1_e_p1 t1_6
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
- Index Cond: (a = t1_3.b)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t1_5.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Semi Join
- Hash Cond: (t1_4.b = ((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt2_p2 t1_4
+ Hash Cond: (t1_6.b = ((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt2_p1 t1_6
-> Hash
- -> Seq Scan on prt1_e_p2 t1_7
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
- Index Cond: (a = t1_4.b)
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
+ Index Cond: (a = t1_6.b)
Filter: (b = 0)
-> Nested Loop
- -> Unique
- -> Sort
- Sort Key: t1_5.b
- -> Hash Semi Join
- Hash Cond: (t1_5.b = ((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt2_p3 t1_5
- -> Hash
- -> Seq Scan on prt1_e_p3 t1_8
- Filter: (c = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t1_5.b)
+ -> HashAggregate
+ Group Key: t1_7.b
+ -> Hash Semi Join
+ Hash Cond: (t1_7.b = ((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt2_p2 t1_7
+ -> Hash
+ -> Seq Scan on prt1_e_p2 t1_12
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t1_7.b)
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t1_8
+ Index Cond: (b = t1_3.a)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t1_13
+ Index Cond: (((a + b) / 2) = t1_8.b)
+ Filter: (c = 0)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Semi Join
+ Hash Cond: (t1_9.b = ((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt2_p4 t1_9
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = t1_9.b)
Filter: (b = 0)
-(40 rows)
+(60 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -250 | 0 | -0250
+ -100 | 0 | -0100
+ 0 | 0 | 0000
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(9 rows)
-- test merge joins
SET enable_hashjoin TO off;
SET enable_nestloop TO off;
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
-----------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------
Merge Append
Sort Key: t1.a
-> Merge Semi Join
- Merge Cond: (t1.a = t1_3.b)
+ Merge Cond: (t1.a = t1_5.b)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_3.b = (((t1_6.a + t1_6.b) / 2)))
+ Merge Cond: (t1_5.b = (((t1_10.a + t1_10.b) / 2)))
-> Sort
- Sort Key: t1_3.b
- -> Seq Scan on prt2_p1 t1_3
+ Sort Key: t1_5.b
+ -> Seq Scan on prt2_p0 t1_5
-> Sort
- Sort Key: (((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt1_e_p1 t1_6
+ Sort Key: (((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_1.a = t1_4.b)
+ Merge Cond: (t1_1.a = t1_6.b)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_4.b = (((t1_7.a + t1_7.b) / 2)))
+ Merge Cond: (t1_6.b = (((t1_11.a + t1_11.b) / 2)))
-> Sort
- Sort Key: t1_4.b
- -> Seq Scan on prt2_p2 t1_4
+ Sort Key: t1_6.b
+ -> Seq Scan on prt2_p1 t1_6
-> Sort
- Sort Key: (((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt1_e_p2 t1_7
+ Sort Key: (((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_2.a = t1_5.b)
+ Merge Cond: (t1_2.a = t1_7.b)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_5.b = (((t1_8.a + t1_8.b) / 2)))
+ Merge Cond: (t1_7.b = (((t1_12.a + t1_12.b) / 2)))
-> Sort
- Sort Key: t1_5.b
- -> Seq Scan on prt2_p3 t1_5
+ Sort Key: t1_7.b
+ -> Seq Scan on prt2_p2 t1_7
+ -> Sort
+ Sort Key: (((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt1_e_p2 t1_12
+ Filter: (c = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_3.a = t1_8.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_8.b = (((t1_13.a + t1_13.b) / 2)))
-> Sort
- Sort Key: (((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt1_e_p3 t1_8
+ Sort Key: t1_8.b
+ -> Seq Scan on prt2_p3 t1_8
+ -> Sort
+ Sort Key: (((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt1_e_p3 t1_13
Filter: (c = 0)
-(47 rows)
+ -> Merge Semi Join
+ Merge Cond: (t1_4.a = t1_9.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_9.b = (((t1_14.a + t1_14.b) / 2)))
+ -> Sort
+ Sort Key: t1_9.b
+ -> Seq Scan on prt2_p4 t1_9
+ -> Sort
+ Sort Key: (((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+(77 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -250 | 0 | -0250
+ -100 | 0 | -0100
+ 0 | 0 | 0000
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(9 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
@@ -1052,14 +1639,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3.a + t3.b) / 2)) = t1.a)
-> Sort
Sort Key: (((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Sort
Sort Key: t2.b
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Merge Left Join
Merge Cond: (t1_1.a = t2_1.b)
-> Sort
@@ -1068,14 +1655,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_1.a + t3_1.b) / 2)) = t1_1.a)
-> Sort
Sort Key: (((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Sort
Sort Key: t2_1.b
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Merge Left Join
Merge Cond: (t1_2.a = t2_2.b)
-> Sort
@@ -1084,35 +1671,805 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_2.a + t3_2.b) / 2)) = t1_2.a)
-> Sort
Sort Key: (((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Sort
Sort Key: t2_2.b
- -> Seq Scan on prt2_p3 t2_2
-(52 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Merge Left Join
+ Merge Cond: (t1_3.a = t2_3.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_3.a + t3_3.b) / 2)) = t1_3.a)
+ -> Sort
+ Sort Key: (((t3_3.a + t3_3.b) / 2))
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ -> Sort
+ Sort Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ -> Merge Left Join
+ Merge Cond: (t1_4.a = t2_4.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_4.a + t3_4.b) / 2)) = t1_4.a)
+ -> Sort
+ Sort Key: (((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ -> Sort
+ Sort Key: t2_4.b
+ -> Seq Scan on prt2_p4 t2_4
+(84 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | -250 | -0250 | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | | | -300 | 0
+ -100 | -0100 | -100 | -0100 | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(24 rows)
RESET enable_hashjoin;
RESET enable_nestloop;
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -250 | -0250 | 0 | -0250
+ -100 | -0100 | 0 | -0100
+ 0 | 0000 | 0 | 0000
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 0 | 0150
+ 300 | 0300 | 0 | 0300
+ 450 | 0450 | 0 | 0450
+ 600 | 0600 | 0 | 0600
+ 750 | 0750 | 0 | 0750
+(9 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -250 | -0250 | 0 | -0250
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | 0 | -0100
+ -50 | -0050 | |
+ 0 | 0000 | 0 | 0000
+ 0 | 0000 | 0 | 0000
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | 0 | 0150
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 0 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ 450 | 0450 | 0 | 0450
+ 500 | 0500 | |
+ 550 | 0550 | |
+ 600 | 0600 | 0 | 0600
+ 650 | 0650 | |
+ 700 | 0700 | |
+ 750 | 0750 | 0 | 0750
+(22 rows)
+
+-- TODO: below query is picking partition-wise-join which is not expected
+-- also generating wrong output, need to remove comment after fix
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Result
+ -> Append
+ -> Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Hash Right Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t2_2.b)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(30 rows)
+
+SET enable_partition_wise_join to false;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -250 | -0250 | 0 | -0250
+ -100 | -0100 | 0 | -0100
+ 0 | 0000 | 0 | 0000
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 0 | 0150
+ 300 | 0300 | 0 | 0300
+ 450 | 0450 | 0 | 0450
+ 600 | 0600 | 0 | 0600
+ 750 | 0750 | 0 | 0750
+ | | 0 | 0075
+ | | 0 | 0375
+ | | 0 | 0825
+ | | 0 | -0175
+ | | 0 | 0900
+ | | 0 | 0675
+ | | 0 | -0025
+ | | 0 | 0525
+ | | 0 | 0225
+ | | 0 | 0975
+(19 rows)
+
+SET enable_partition_wise_join to true;
+-- TODO: below query is picking partition-wise-join which is not expected
+-- also generating wrong output, need to remove comment after fix
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: (t1.a = t2.b)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.a, 0)) = 0)
+ -> Seq Scan on prt1_p0 t1
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Full Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.a, 0)) = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Full Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.a, 0)) = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: (t1_3.a = t2_3.b)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.a, 0)) = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_3
+ -> Hash Full Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ Filter: ((COALESCE(t1_4.b, 0) + COALESCE(t2_4.a, 0)) = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(33 rows)
+
+SET enable_partition_wise_join to false;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+------+-------+---+-------
+ -250 | -0250 | 0 | -0250
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | 0 | -0100
+ -50 | -0050 | |
+ 0 | 0000 | 0 | 0000
+ 0 | 0000 | 0 | 0000
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | 0 | 0150
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 0 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ 450 | 0450 | 0 | 0450
+ 500 | 0500 | |
+ 550 | 0550 | |
+ 600 | 0600 | 0 | 0600
+ 650 | 0650 | |
+ 700 | 0700 | |
+ 750 | 0750 | 0 | 0750
+ | | 0 | 0825
+ | | 0 | -0175
+ | | 0 | 0900
+ | | 0 | 0675
+ | | 0 | -0025
+ | | 0 | 0525
+ | | 0 | 0225
+ | | 0 | 0975
+ | | 0 | 0075
+ | | 0 | 0375
+(32 rows)
+
+SET enable_partition_wise_join to true;
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Semi Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -250 | 0 | -0250
+ -100 | 0 | -0100
+ 0 | 0 | 0000
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(9 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Append
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
+ Index Cond: (a = t1_1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(28 rows)
+
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+---+------+-------
+ 0 | -250 | -0250
+ 0 | -100 | -0100
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(8 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Anti Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Anti Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -200 | 0 | -0200
+ -150 | 0 | -0150
+ -50 | 0 | -0050
+ 50 | 0 | 0050
+ 100 | 0 | 0100
+ 200 | 0 | 0200
+ 250 | 0 | 0250
+ 350 | 0 | 0350
+ 400 | 0 | 0400
+ 500 | 0 | 0500
+ 550 | 0 | 0550
+ 650 | 0 | 0650
+ 700 | 0 | 0700
+(13 rows)
+
+-- TODO: below query is generating wrong output, need to remove comment after fix
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
+ Index Cond: (a = t1_1.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(28 rows)
+
+SET enable_partition_wise_join to false;
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+---+------+-------
+ 0 | -175 | -0175
+ 0 | -25 | -0025
+ 0 | 75 | 0075
+ 0 | 225 | 0225
+ 0 | 375 | 0375
+ 0 | 525 | 0525
+ 0 | 675 | 0675
+ 0 | 825 | 0825
+ 0 | 900 | 0900
+ 0 | 975 | 0975
+(10 rows)
+
+SET enable_partition_wise_join to true;
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------
+ Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(22 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Join
+ Hash Cond: (t1.a = t2.b)
+ Join Filter: ((t1.b + t2.a) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
--
-- partitioned by multiple columns
--
@@ -1182,32 +2539,388 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1
--
-- tests for list partitioned tables.
--
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Result
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(28 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 470 | 0 | 0011
+(1 row)
+
--
-- list partitioned by expression
--
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
ANALYZE plt1_e;
-- test partition matching with N-way join
EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- QUERY PLAN
---------------------------------------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------------------------------------
Sort
Sort Key: t1.c, t3.c
-> HashAggregate
@@ -1215,50 +2928,1166 @@ SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, pl
-> Result
-> Append
-> Hash Join
- Hash Cond: (t1.c = t2.c)
- -> Seq Scan on plt1_p1 t1
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = ltrim(t3.c, 'A'::text))
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt1_e_p4 t3
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = ltrim(t3_1.c, 'A'::text))
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_e_p1 t3_1
-> Hash
- -> Hash Join
- Hash Cond: (t2.c = ltrim(t3.c, 'A'::text))
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_e_p1 t3
+ -> Seq Scan on plt1_p1 t1_1
-> Hash Join
- Hash Cond: (t1_1.c = t2_1.c)
- -> Seq Scan on plt1_p2 t1_1
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = ltrim(t3_2.c, 'A'::text))
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt1_e_p2 t3_2
-> Hash
- -> Hash Join
- Hash Cond: (t2_1.c = ltrim(t3_1.c, 'A'::text))
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_e_p2 t3_1
+ -> Seq Scan on plt2_p2 t2_2
-> Hash Join
- Hash Cond: (t1_2.c = t2_2.c)
- -> Seq Scan on plt1_p3 t1_2
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = ltrim(t3_3.c, 'A'::text))
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt1_e_p3 t3_3
-> Hash
- -> Hash Join
- Hash Cond: (t2_2.c = ltrim(t3_2.c, 'A'::text))
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_e_p3 t3_2
-(33 rows)
+ -> Seq Scan on plt2_p3 t2_3
+(42 rows)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- avg | avg | avg | c | c | c
-----------------------+----------------------+-----------------------+------+------+-------
- 24.0000000000000000 | 24.0000000000000000 | 48.0000000000000000 | 0000 | 0000 | A0000
- 74.0000000000000000 | 75.0000000000000000 | 148.0000000000000000 | 0001 | 0001 | A0001
- 124.0000000000000000 | 124.5000000000000000 | 248.0000000000000000 | 0002 | 0002 | A0002
- 174.0000000000000000 | 174.0000000000000000 | 348.0000000000000000 | 0003 | 0003 | A0003
- 224.0000000000000000 | 225.0000000000000000 | 448.0000000000000000 | 0004 | 0004 | A0004
- 274.0000000000000000 | 274.5000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
- 324.0000000000000000 | 324.0000000000000000 | 648.0000000000000000 | 0006 | 0006 | A0006
- 374.0000000000000000 | 375.0000000000000000 | 748.0000000000000000 | 0007 | 0007 | A0007
- 424.0000000000000000 | 424.5000000000000000 | 848.0000000000000000 | 0008 | 0008 | A0008
- 474.0000000000000000 | 474.0000000000000000 | 948.0000000000000000 | 0009 | 0009 | A0009
- 524.0000000000000000 | 525.0000000000000000 | 1048.0000000000000000 | 0010 | 0010 | A0010
- 574.0000000000000000 | 574.5000000000000000 | 1148.0000000000000000 | 0011 | 0011 | A0011
-(12 rows)
+ avg | avg | avg | c | c | c
+----------------------+---------------------+----------------------+------+------+------
+ 246.5000000000000000 | 22.4666666666666667 | 268.9666666666666667 | 0000 | 0000 | 0000
+ 248.5000000000000000 | 21.3333333333333333 | 269.8333333333333333 | 0002 | 0002 | 0002
+ 249.5000000000000000 | 22.3333333333333333 | 271.8333333333333333 | 0003 | 0003 | 0003
+ 250.5000000000000000 | 23.3333333333333333 | 273.8333333333333333 | 0004 | 0004 | 0004
+ 251.5000000000000000 | 22.7666666666666667 | 274.2666666666666667 | 0005 | 0005 | 0005
+ 252.5000000000000000 | 22.2000000000000000 | 274.7000000000000000 | 0006 | 0006 | 0006
+ 246.0000000000000000 | 23.9655172413793103 | 269.9655172413793103 | 0008 | 0008 | 0008
+ 247.0000000000000000 | 23.3448275862068966 | 270.3448275862068966 | 0009 | 0009 | 0009
+(8 rows)
+
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 470 | 0011
+ | | 235 | 0014
+(8 rows)
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 235 | 0014
+ | | 470 | 0011
+(10 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 47 | 0 | 0013
+ 235 | 0 | 0014
+ 470 | 0 | 0011
+(3 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+----------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Materialize
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(20 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Result
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(28 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Materialize
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+---
+ 470 | 0 |
+(1 row)
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(22 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(22 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(19 rows)
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
@@ -1286,16 +4115,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
-> Hash Left Join
Hash Cond: (t2.b = a)
-> Append
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p3 t2_3
Filter: (a = 0)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
Filter: (a = 0)
-> Hash
-> Result
One-Time Filter: false
-(14 rows)
+(20 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b;
@@ -1306,16 +4141,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
-> Hash Left Join
Hash Cond: (t2.b = a)
-> Append
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
Filter: (a = 0)
-> Hash
-> Result
One-Time Filter: false
-(14 rows)
+(20 rows)
--
-- multi-leveled partitions
@@ -1341,7 +4182,7 @@ CREATE TABLE prt2_l_p3_p2 PARTITION OF prt2_l_p3 FOR VALUES FROM (13) TO (25);
INSERT INTO prt2_l SELECT i % 25, i, to_char(i % 4, 'FM0000') FROM generate_series(0, 599, 3) i;
ANALYZE prt2_l;
-- inner join, qual covering only top-level partitions
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1, prt2_l t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
QUERY PLAN
-------------------------------------------------------------
@@ -1386,7 +4227,7 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1, prt2_l t2 WHERE t1.a = t2.b AND t1
(4 rows)
-- left join
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 LEFT JOIN prt2_l t2 ON t1.a = t2.b AND t1.c = t2.c WHERE t1.b = 0 ORDER BY t1.a, t2.b;
QUERY PLAN
------------------------------------------------------------------------------------
@@ -1440,7 +4281,7 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 LEFT JOIN prt2_l t2 ON t1.a = t2.b
(12 rows)
-- right join
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 RIGHT JOIN prt2_l t2 ON t1.a = t2.b AND t1.c = t2.c WHERE t2.a = 0 ORDER BY t1.a, t2.b;
QUERY PLAN
------------------------------------------------------------------------------------------
@@ -1491,7 +4332,7 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 RIGHT JOIN prt2_l t2 ON t1.a = t2.b
(8 rows)
-- full join
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_l WHERE prt1_l.b = 0) t1 FULL JOIN (SELECT * FROM prt2_l WHERE prt2_l.a = 0) t2 ON (t1.a = t2.b AND t1.c = t2.c) ORDER BY t1.a, t2.b;
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------
@@ -1552,7 +4393,7 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_l WHERE prt1_l.b = 0) t1
(16 rows)
-- lateral partition-wise join
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT * FROM prt1_l t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t2.c AS t2c, t2.b AS t2b, t3.b AS t3b, least(t1.a,t2.a,t3.b) FROM prt1_l t2 JOIN prt2_l t3 ON (t2.a = t3.b AND t2.c = t3.c)) ss
ON t1.a = ss.t2a AND t1.c = ss.t2c WHERE t1.b = 0 ORDER BY t1.a;
@@ -1626,7 +4467,7 @@ SELECT * FROM prt1_l t1 LEFT JOIN LATERAL
(12 rows)
-- join with one side empty
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_l WHERE a = 1 AND a = 2) t1 RIGHT JOIN prt2_l t2 ON t1.a = t2.b AND t1.b = t2.a AND t1.c = t2.c;
QUERY PLAN
-------------------------------------------------------------------------
@@ -1676,64 +4517,70 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2 WHERE t1.a = t2.a;
Hash Join
Hash Cond: (t1.a = t2.a)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Seq Scan on prt4_n_p1 t2
-> Seq Scan on prt4_n_p2 t2_1
-> Seq Scan on prt4_n_p3 t2_2
-(11 rows)
+(13 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2, prt2 t3 WHERE t1.a = t2.a and t1.a = t3.b;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------
Hash Join
- Hash Cond: (t2.a = t1.a)
+ Hash Cond: (t3.b = t1.a)
-> Append
- -> Seq Scan on prt4_n_p1 t2
- -> Seq Scan on prt4_n_p2 t2_1
- -> Seq Scan on prt4_n_p3 t2_2
+ -> Seq Scan on prt2_p0 t3
+ -> Seq Scan on prt2_p1 t3_1
+ -> Seq Scan on prt2_p2 t3_2
+ -> Seq Scan on prt2_p3 t3_3
+ -> Seq Scan on prt2_p4 t3_4
+ -> Seq Scan on prt2_p5 t3_5
-> Hash
- -> Append
- -> Hash Join
- Hash Cond: (t1.a = t3.b)
- -> Seq Scan on prt1_p1 t1
- -> Hash
- -> Seq Scan on prt2_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t1_1
- -> Hash
- -> Seq Scan on prt2_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t1_2
- -> Hash
- -> Seq Scan on prt2_p3 t3_2
+ -> Hash Join
+ Hash Cond: (t1.a = t2.a)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt4_n_p1 t2
+ -> Seq Scan on prt4_n_p2 t2_1
+ -> Seq Scan on prt4_n_p3 t2_2
(23 rows)
-- partition-wise join can not be applied if there are no equi-join conditions
-- between partition keys
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON (t1.a < t2.b);
- QUERY PLAN
----------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------
Nested Loop Left Join
+ Join Filter: (t1.a < t2.b)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
- -> Append
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
- Index Cond: (t1.a < b)
-(12 rows)
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Materialize
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(16 rows)
-- equi-join with join condition on partial keys does not qualify for
-- partition-wise join
@@ -1819,16 +4666,17 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 JOIN prt2_n t2 ON (t1.c = t2.c) JOI
-> Seq Scan on prt2_n_p2 t2_1
-> Hash
-> Hash Join
- Hash Cond: (t3.c = (t1.c)::text)
+ Hash Cond: ((t3.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on plt1_p1 t3
- -> Seq Scan on plt1_p2 t3_1
- -> Seq Scan on plt1_p3 t3_2
+ -> Seq Scan on plt1_p4 t3
+ -> Seq Scan on plt1_p1 t3_1
+ -> Seq Scan on plt1_p2 t3_2
+ -> Seq Scan on plt1_p3 t3_3
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(16 rows)
+(17 rows)
-- partition-wise join can not be applied for a join between list and range
-- partitioned table
@@ -1839,12 +4687,14 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 FULL JOIN prt1 t2 ON (t1.c = t2.c);
Hash Full Join
Hash Cond: ((t2.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on prt1_p1 t2
- -> Seq Scan on prt1_p2 t2_1
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(10 rows)
+(12 rows)
diff --git a/src/test/regress/sql/partition_join.sql b/src/test/regress/sql/partition_join.sql
index cd54ea0..8f099a8 100644
--- a/src/test/regress/sql/partition_join.sql
+++ b/src/test/regress/sql/partition_join.sql
@@ -10,25 +10,43 @@ SET enable_partition_wise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 799, 3) i;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
@@ -77,11 +95,19 @@ EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
+EXPLAIN (COSTS OFF)
+SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a);
+SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a);
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -103,20 +129,30 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
@@ -168,6 +204,104 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
RESET enable_hashjoin;
RESET enable_nestloop;
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- TODO: below query is picking partition-wise-join which is not expected
+-- also generating wrong output, need to remove comment after fix
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+SET enable_partition_wise_join to false;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a;
+SET enable_partition_wise_join to true;
+
+-- TODO: below query is picking partition-wise-join which is not expected
+-- also generating wrong output, need to remove comment after fix
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+SET enable_partition_wise_join to false;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+SET enable_partition_wise_join to true;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- TODO: below query is generating wrong output, need to remove comment after fix
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+SET enable_partition_wise_join to false;
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+SET enable_partition_wise_join to true;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
--
-- partitioned by multiple columns
--
@@ -192,28 +326,79 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1
--
-- tests for list partitioned tables.
--
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
--
-- list partitioned by expression
--
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
ANALYZE plt1_e;
-- test partition matching with N-way join
@@ -221,6 +406,175 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.a = 1 AND t1.a = 2;
@@ -260,27 +614,27 @@ INSERT INTO prt2_l SELECT i % 25, i, to_char(i % 4, 'FM0000') FROM generate_seri
ANALYZE prt2_l;
-- inner join, qual covering only top-level partitions
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1, prt2_l t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1, prt2_l t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
-- left join
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 LEFT JOIN prt2_l t2 ON t1.a = t2.b AND t1.c = t2.c WHERE t1.b = 0 ORDER BY t1.a, t2.b;
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 LEFT JOIN prt2_l t2 ON t1.a = t2.b AND t1.c = t2.c WHERE t1.b = 0 ORDER BY t1.a, t2.b;
-- right join
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 RIGHT JOIN prt2_l t2 ON t1.a = t2.b AND t1.c = t2.c WHERE t2.a = 0 ORDER BY t1.a, t2.b;
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_l t1 RIGHT JOIN prt2_l t2 ON t1.a = t2.b AND t1.c = t2.c WHERE t2.a = 0 ORDER BY t1.a, t2.b;
-- full join
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_l WHERE prt1_l.b = 0) t1 FULL JOIN (SELECT * FROM prt2_l WHERE prt2_l.a = 0) t2 ON (t1.a = t2.b AND t1.c = t2.c) ORDER BY t1.a, t2.b;
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_l WHERE prt1_l.b = 0) t1 FULL JOIN (SELECT * FROM prt2_l WHERE prt2_l.a = 0) t2 ON (t1.a = t2.b AND t1.c = t2.c) ORDER BY t1.a, t2.b;
-- lateral partition-wise join
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT * FROM prt1_l t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t2.c AS t2c, t2.b AS t2b, t3.b AS t3b, least(t1.a,t2.a,t3.b) FROM prt1_l t2 JOIN prt2_l t3 ON (t2.a = t3.b AND t2.c = t3.c)) ss
ON t1.a = ss.t2a AND t1.c = ss.t2c WHERE t1.b = 0 ORDER BY t1.a;
@@ -289,7 +643,7 @@ SELECT * FROM prt1_l t1 LEFT JOIN LATERAL
ON t1.a = ss.t2a AND t1.c = ss.t2c WHERE t1.b = 0 ORDER BY t1.a;
-- join with one side empty
-EXPLAIN(COSTS OFF)
+EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_l WHERE a = 1 AND a = 2) t1 RIGHT JOIN prt2_l t2 ON t1.a = t2.b AND t1.b = t2.a AND t1.c = t2.c;
--
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
@ 2017-09-05 11:04 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-05 11:55 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
0 siblings, 2 replies; 154+ messages in thread
From: Ashutosh Bapat @ 2017-09-05 11:04 UTC (permalink / raw)
To: Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; +Cc: pgsql-hackers
>
> I have applied v27 patches and tested feature. Also tried to reduce
> regression diff with the
> existing partition_join.sql by adding new partition instead of changing
> original partition bounds.
>
> Attached WIP patch have a server crash and some wrong output which need to
> be fixed. I have
> commented these issue in patch itself, Please take a look and let me know if
> it need more
> changes.
I have fixed the issues which were marked as TODOs in the attached
patches. Also, I have included your test change patch in my series of
patches. Are there any other issues you have commented out?
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Attachments:
[text/x-patch] 0011-Modify-bound-comparision-functions-to-accept-members.patch (7.5K, ../../CAFjFpRfdXpuSu0pxON3dKcr8WndJkaXLzHUVax_Laod0Tgc6UQ@mail.gmail.com/2-0011-Modify-bound-comparision-functions-to-accept-members.patch)
download | inline diff:
From b1888b037362acbc83fa00feba58624ecf62a6b9 Mon Sep 17 00:00:00 2001
From: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
Date: Thu, 6 Jul 2017 14:15:22 +0530
Subject: [PATCH 11/13] Modify bound comparision functions to accept members
of PartitionKey
Functions partition_bound_cmp(), partition_rbound_cmp() and
partition_rbound_datum_cmp() are required to merge partition bounds
from joining relations. While doing so, we do not have access to the
PartitionKey of either relations. So, modify these functions to accept
only required members of PartitionKey so that the functions can be
reused for merging bounds.
Ashutosh Bapat.
---
src/backend/catalog/partition.c | 76 ++++++++++++++++++++++-----------------
1 file changed, 44 insertions(+), 32 deletions(-)
diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 96a64ce..d42e1b5 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -126,15 +126,17 @@ static List *generate_partition_qual(Relation rel);
static PartitionRangeBound *make_one_range_bound(PartitionKey key, int index,
List *datums, bool lower);
-static int32 partition_rbound_cmp(PartitionKey key,
- Datum *datums1, PartitionRangeDatumKind *kind1,
- bool lower1, PartitionRangeBound *b2);
-static int32 partition_rbound_datum_cmp(PartitionKey key,
- Datum *rb_datums, PartitionRangeDatumKind *rb_kind,
+static int32 partition_rbound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, Datum *datums1,
+ PartitionRangeDatumKind *kind1, bool lower1,
+ PartitionRangeBound *b2);
+static int32 partition_rbound_datum_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, Datum *rb_datums,
+ PartitionRangeDatumKind *rb_kind,
Datum *tuple_datums);
-static int32 partition_bound_cmp(PartitionKey key,
- PartitionBoundInfo boundinfo,
+static int32 partition_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, PartitionBoundInfo boundinfo,
int offset, void *probe, bool probe_is_bound);
static int partition_bound_bsearch(PartitionKey key,
PartitionBoundInfo boundinfo,
@@ -719,8 +721,9 @@ check_new_partition_bound(char *relname, Relation parent,
* First check if the resulting range would be empty with
* specified lower and upper bounds
*/
- if (partition_rbound_cmp(key, lower->datums, lower->kind, true,
- upper) >= 0)
+ if (partition_rbound_cmp(key->partnatts, key->partsupfunc,
+ key->partcollation, lower->datums,
+ lower->kind, true, upper) >= 0)
{
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
@@ -771,9 +774,11 @@ check_new_partition_bound(char *relname, Relation parent,
{
int32 cmpval;
- cmpval = partition_bound_cmp(key, boundinfo,
- offset + 1, upper,
- true);
+ cmpval = partition_bound_cmp(key->partnatts,
+ key->partsupfunc,
+ key->partcollation,
+ boundinfo, offset + 1,
+ upper, true);
if (cmpval < 0)
{
/*
@@ -2138,7 +2143,9 @@ qsort_partition_rbound_cmp(const void *a, const void *b, void *arg)
PartitionRangeBound *b2 = (*(PartitionRangeBound *const *) b);
PartitionKey key = (PartitionKey) arg;
- return partition_rbound_cmp(key, b1->datums, b1->kind, b1->lower, b2);
+ return partition_rbound_cmp(key->partnatts, key->partsupfunc,
+ key->partcollation, b1->datums, b1->kind,
+ b1->lower, b2);
}
/*
@@ -2155,7 +2162,7 @@ qsort_partition_rbound_cmp(const void *a, const void *b, void *arg)
* two contiguous partitions.
*/
static int32
-partition_rbound_cmp(PartitionKey key,
+partition_rbound_cmp(int partnatts, FmgrInfo *partsupfunc, Oid *partcollation,
Datum *datums1, PartitionRangeDatumKind *kind1,
bool lower1, PartitionRangeBound *b2)
{
@@ -2165,7 +2172,7 @@ partition_rbound_cmp(PartitionKey key,
PartitionRangeDatumKind *kind2 = b2->kind;
bool lower2 = b2->lower;
- for (i = 0; i < key->partnatts; i++)
+ for (i = 0; i < partnatts; i++)
{
/*
* First, handle cases where the column is unbounded, which should not
@@ -2186,8 +2193,8 @@ partition_rbound_cmp(PartitionKey key,
*/
break;
- cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[i],
- key->partcollation[i],
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[i],
+ partcollation[i],
datums1[i],
datums2[i]));
if (cmpval != 0)
@@ -2213,22 +2220,23 @@ partition_rbound_cmp(PartitionKey key,
* is <, =, or > partition key of tuple (tuple_datums)
*/
static int32
-partition_rbound_datum_cmp(PartitionKey key,
- Datum *rb_datums, PartitionRangeDatumKind *rb_kind,
+partition_rbound_datum_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, Datum *rb_datums,
+ PartitionRangeDatumKind *rb_kind,
Datum *tuple_datums)
{
int i;
int32 cmpval = -1;
- for (i = 0; i < key->partnatts; i++)
+ for (i = 0; i < partnatts; i++)
{
if (rb_kind[i] == PARTITION_RANGE_DATUM_MINVALUE)
return -1;
else if (rb_kind[i] == PARTITION_RANGE_DATUM_MAXVALUE)
return 1;
- cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[i],
- key->partcollation[i],
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[i],
+ partcollation[i],
rb_datums[i],
tuple_datums[i]));
if (cmpval != 0)
@@ -2245,17 +2253,18 @@ partition_rbound_datum_cmp(PartitionKey key,
* specified in *probe.
*/
static int32
-partition_bound_cmp(PartitionKey key, PartitionBoundInfo boundinfo,
- int offset, void *probe, bool probe_is_bound)
+partition_bound_cmp(int partnatts, FmgrInfo *partsupfunc, Oid *partcollation,
+ PartitionBoundInfo boundinfo, int offset, void *probe,
+ bool probe_is_bound)
{
Datum *bound_datums = boundinfo->datums[offset];
int32 cmpval = -1;
- switch (key->strategy)
+ switch (boundinfo->strategy)
{
case PARTITION_STRATEGY_LIST:
- cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[0],
- key->partcollation[0],
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
+ partcollation[0],
bound_datums[0],
*(Datum *) probe));
break;
@@ -2273,12 +2282,14 @@ partition_bound_cmp(PartitionKey key, PartitionBoundInfo boundinfo,
*/
bool lower = boundinfo->indexes[offset] < 0;
- cmpval = partition_rbound_cmp(key,
- bound_datums, kind, lower,
+ cmpval = partition_rbound_cmp(partnatts, partsupfunc,
+ partcollation, bound_datums,
+ kind, lower,
(PartitionRangeBound *) probe);
}
else
- cmpval = partition_rbound_datum_cmp(key,
+ cmpval = partition_rbound_datum_cmp(partnatts, partsupfunc,
+ partcollation,
bound_datums, kind,
(Datum *) probe);
break;
@@ -2286,7 +2297,7 @@ partition_bound_cmp(PartitionKey key, PartitionBoundInfo boundinfo,
default:
elog(ERROR, "unexpected partition strategy: %d",
- (int) key->strategy);
+ (int) boundinfo->strategy);
}
return cmpval;
@@ -2320,7 +2331,8 @@ partition_bound_bsearch(PartitionKey key, PartitionBoundInfo boundinfo,
int32 cmpval;
mid = (lo + hi + 1) / 2;
- cmpval = partition_bound_cmp(key, boundinfo, mid, probe,
+ cmpval = partition_bound_cmp(key->partnatts, key->partsupfunc,
+ key->partcollation, boundinfo, mid, probe,
probe_is_bound);
if (cmpval <= 0)
{
--
1.7.9.5
[text/x-patch] 0012-WIP-Partition-wise-join-for-1-1-1-0-0-1-partition-ma.patch (48.9K, ../../CAFjFpRfdXpuSu0pxON3dKcr8WndJkaXLzHUVax_Laod0Tgc6UQ@mail.gmail.com/3-0012-WIP-Partition-wise-join-for-1-1-1-0-0-1-partition-ma.patch)
download | inline diff:
From f7c7b3817d733a78dad03ee89f86179f686d7c06 Mon Sep 17 00:00:00 2001
From: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
Date: Wed, 9 Aug 2017 12:30:34 +0530
Subject: [PATCH 12/13] WIP Partition-wise join for 1:1, 1:0, 0:1 partition
matching.
Earlier version of partition-wise join implementation allowed
partition-wise join between two relations with exactly same partition
bounds. This commit allows partition-wise join to be applied under
following conditions
1. the partition bounds of joining relations are such that rows from
given partition on one side join can join with rows from maximum one
partition on the other side i.e. bounds of a given partition on one
side match/overlap with those of maximum one partition on the other
side. If the mapping happens to be m:n where m > 1 or n > 1, we have
to gang multiple partition relations together into a single relation.
This means that we have to add simple relations during join
processing, something which is not supported right now. ALso, in such
a case, different pairs of joining relations can produce different
partition bounds for the same join relation, which again is not
supported right now.
2. For every partition on outer side that can contribute to the result
of an OUTER side, there exists at least one (taken along with item 1,
it means exactly one) matching partition on the inner side. To
support partition-wise join when the inner matching partition doesn't
exist, we have to add a dummy base relation corresponding to the
non-existent inner partition. We don't have support add base relations
during join processing.
This commit is not complete yet.
Ashutosh Bapat.
---
src/backend/catalog/partition.c | 1258 +++++++++++++++++++++++++++++++++
src/backend/optimizer/path/joinrels.c | 77 +-
src/backend/optimizer/util/relnode.c | 42 +-
src/include/catalog/partition.h | 6 +
4 files changed, 1352 insertions(+), 31 deletions(-)
diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index d42e1b5..94e48bd 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -141,6 +141,38 @@ static int32 partition_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
static int partition_bound_bsearch(PartitionKey key,
PartitionBoundInfo boundinfo,
void *probe, bool probe_is_bound, bool *is_equal);
+static PartitionBoundInfo partition_range_bounds_merge(int partnatts,
+ FmgrInfo *supfuncs, Oid *collations,
+ PartitionBoundInfo boundinfo1, int nparts1,
+ PartitionBoundInfo boundinfo2, int nparts2,
+ JoinType jointype, List **parts1, List **parts2);
+static PartitionBoundInfo partition_list_bounds_merge(int partnatts,
+ FmgrInfo *partsupfunc, Oid *collations,
+ PartitionBoundInfo boundinfo1, int nparts1,
+ PartitionBoundInfo boundinfo2, int nparts2,
+ JoinType jointype, List **parts1, List **parts2);
+static void generate_matching_part_pairs(int *mergemap1, int npart1,
+ int *mergemap2, int nparts2, JoinType jointype,
+ int nparts, List **parts1, List **parts2);
+static PartitionBoundInfo build_merged_partition_bounds(char strategy,
+ List *merged_datums, List *merged_indexes,
+ List *merged_contents, int null_index);
+static int map_and_merge_partitions(int *partmap1, int *mergemap1, int index1,
+ int *partmap2, int *mergemap2, int index2,
+ int *next_index);
+static int32 partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *collations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2);
+static int partition_range_cmp(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, bool *overlap);
+static bool partition_range_merge_next_lb(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes);
/*
* RelationBuildPartitionDesc
@@ -2348,3 +2380,1229 @@ partition_bound_bsearch(PartitionKey key, PartitionBoundInfo boundinfo,
return lo;
}
+
+/*
+ * Merge the given partition bounds.
+ *
+ * If given partition bounds can not be merged, return NULL.
+ *
+ * The function also returns two lists of partition indexes one for each of the
+ * joining relations. Both the lists contain the same number of elements. The
+ * partition indexes at the same positions in the list indicate partitions from
+ * each side to be joined and their position corresponds to the index of
+ * partition to which the results of the child-join belong in the partitioned
+ * join.
+ */
+extern PartitionBoundInfo
+partition_bounds_merge(int partnatts, FmgrInfo *partsupfunc, Oid *partcollation,
+ PartitionBoundInfo boundinfo1, int nparts1,
+ PartitionBoundInfo boundinfo2, int nparts2,
+ JoinType jointype, List **parts1, List **parts2)
+{
+ PartitionBoundInfo merged_bounds;
+ char strategy;
+
+ /* Bail out if partitioning strategies are different. */
+ if (boundinfo1->strategy != boundinfo2->strategy)
+ return NULL;
+
+ *parts1 = NIL;
+ *parts2 = NIL;
+ strategy = boundinfo1->strategy;
+ if (strategy == PARTITION_STRATEGY_LIST)
+ merged_bounds = partition_list_bounds_merge(partnatts, partsupfunc,
+ partcollation, boundinfo1,
+ nparts1, boundinfo2,
+ nparts2, jointype, parts1,
+ parts2);
+ else if (strategy == PARTITION_STRATEGY_RANGE)
+ merged_bounds = partition_range_bounds_merge(partnatts, partsupfunc,
+ partcollation, boundinfo1,
+ nparts1, boundinfo2,
+ nparts2, jointype, parts1,
+ parts2);
+ else
+ elog(ERROR, "unexpected partition strategy: %d", strategy);
+
+ Assert(merged_bounds || (*parts1 == NIL && *parts2 == NIL));
+ return merged_bounds;
+}
+
+/*
+ * partition_get_range_bounds
+ *
+ * Given the index of lower bound in datums array, return lower and upper
+ * bounds and the index of the partition with that lower bound.
+ */
+static int
+partition_get_range_bounds(PartitionBoundInfo bi, int lb_index,
+ PartitionRangeBound *lower,
+ PartitionRangeBound *upper)
+{
+ int part_index;
+
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The lower bound should correspond to a valid partition. */
+ part_index = bi->indexes[lb_index + 1];
+ Assert(part_index >= 0);
+
+ lower->kind = bi->kind[lb_index];
+ lower->datums = bi->datums[lb_index];
+ lower->lower = true;
+ upper->kind = bi->kind[lb_index + 1];
+ upper->datums = bi->datums[lb_index + 1];
+ upper->lower = false;
+
+ return part_index;
+}
+
+/*
+ * partition_range_get_next_lb_index
+ *
+ * Given the index of lower bound in datums array return the
+ * index of lower bound of the next partition. When the given index corresponds
+ * to the last partition, return number of datums (ndatums).
+ */
+static int
+partition_range_get_next_lb_index(PartitionBoundInfo bi, int lb_index)
+{
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The partition index corresponding to the upper bound should be valid. */
+ Assert(bi->indexes[lb_index + 1] >= 0);
+
+ /*
+ * If there are no bounds left beyond the upper bound, we have reached the
+ * last partition.
+ */
+ if (lb_index + 2 < bi->ndatums)
+ {
+ /*
+ * If the bound next to the upper bound corresponds to no partition,
+ * that's the next lower bound of the next partition. Otherwise, the
+ * current upper bound is the lower bound of the next partition.
+ */
+ if (bi->indexes[lb_index + 2] < 0)
+ return lb_index + 2;
+ else
+ return lb_index + 1;
+ }
+ else
+ return bi->ndatums;
+}
+
+static int32
+partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc, Oid *collations,
+ PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2)
+{
+ return partition_rbound_cmp(partnatts, partsupfunc, collations,
+ bound1->datums, bound1->kind, bound1->lower,
+ bound2);
+}
+
+/*
+ * partition_range_cmp
+ *
+ * Compare the bounds of two range partitions and return <, = or > 0, if the
+ * first partition's upper bound is lower than, equal to or higher than the
+ * second partition's upper bound resp.
+ *
+ * Also, set overlaps to true, if the ranges overlap, otherwise set it to
+ * false.
+ */
+static int
+partition_range_cmp(int partnatts, FmgrInfo *supfuncs, Oid *collations,
+ PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, bool *overlap)
+{
+ /*
+ * Compare upper bound of the first partition with the lower bound of the
+ * second and vice-versa. If lower bound is higher than the upper bound,
+ * the partitions are not overlapping. All other cases indicate overlapping
+ * partitions.
+ * TODO: Add a testcase which has lower and upper bound matching exactly.
+ * Lower bound is inclusive and upper bound is exclusive, so even if the
+ * datums match, the bounds do not match exactly.
+ */
+ if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ lower_bound1, upper_bound2) > 0)
+ {
+ *overlap = false;
+ return 1;
+ }
+ else if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ lower_bound2, upper_bound1) > 0)
+ {
+ *overlap = false;
+ return -1;
+ }
+ else
+ {
+ *overlap = true;
+ return partition_range_bound_cmp(partnatts, supfuncs, collations,
+ upper_bound1, upper_bound2);
+ }
+}
+
+/*
+ * partition_range_merge
+ *
+ * Merge the partition bounds of given two partitions such that the join
+ * between the given two partitions fits merged bounds.
+ *
+ * "merged_upper" will be set to one of the given upper bounds and
+ * "merged_lower" will be set to one of the given lower bounds.
+ */
+static void
+partition_range_merge(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, JoinType jointype,
+ PartitionRangeBound *left_lb,
+ PartitionRangeBound *left_ub,
+ PartitionRangeBound *right_lb,
+ PartitionRangeBound *right_ub,
+ PartitionRangeBound **merged_lb,
+ PartitionRangeBound **merged_ub)
+{
+ /*
+ * An outer join will have all the rows from the outer side, so merged
+ * bounds will be same as the outer bounds. An inner join will have rows
+ * that fit both the bounds, thus lower merged bound will be higher of two
+ * lower bounds and upper merged bound will be lower of the two upper
+ * bounds.
+ */
+ switch (jointype)
+ {
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ *merged_ub = left_ub;
+ *merged_lb = left_lb;
+ break;
+
+ case JOIN_RIGHT:
+ *merged_ub = right_ub;
+ *merged_lb = right_lb;
+ break;
+
+ case JOIN_INNER:
+ case JOIN_SEMI:
+ if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ left_ub, right_ub) < 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ left_lb, right_lb) > 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ case JOIN_FULL:
+ if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ left_ub, right_ub) > 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ left_lb, right_lb) < 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ default:
+ elog(ERROR, "Unexpected join type %d", jointype);
+ }
+
+ return;
+}
+
+/*
+ * Add the lower bound of the next range to the list of bounds, if the lower
+ * bound is higher or equal to the previous upper bound. If successful return
+ * true, otherwise false.
+ */
+static bool
+partition_range_merge_next_lb(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes)
+{
+ int cmpval;
+
+ if (!*merged_datums)
+ {
+ Assert(!*merged_kinds && !*merged_indexes);
+ cmpval = 1;
+ }
+ else
+ {
+ PartitionRangeBound prev_ub;
+
+ prev_ub.datums = llast(*merged_datums);
+ prev_ub.kind = llast(*merged_kinds);
+ prev_ub.lower = false;
+
+ /*
+ * TODO: explain why do we pass lower to be false for the next lower
+ * bound.
+ */
+ cmpval = partition_rbound_cmp(partnatts, supfuncs, collations,
+ next_lb_datums, next_lb_kind, false,
+ &prev_ub);
+ }
+
+ /*
+ * The lower bound is lower than the last upper bound, thus does not fit
+ * the bounds created so far and hence can not be merged with the existing
+ * bounds.
+ */
+ if (cmpval < 0)
+ return false;
+
+ /*
+ * Add bounds of the new merged partition. If the next lower bound is
+ * higher than the last upper bound, add new range with index
+ * corresponding to the lower bound as -1. If the merged lower bound
+ * is same as the last merged upper bound, the last upper bound will be
+ * reused as the lower bound of the next range.
+ */
+ if (cmpval > 0)
+ {
+ *merged_datums = lappend(*merged_datums, next_lb_datums);
+ *merged_kinds = lappend(*merged_kinds, next_lb_kind);
+ *merged_indexes = lappend_int(*merged_indexes, -1);
+ }
+
+ return true;
+}
+
+/*
+ * Merge given two range partition bounds.
+ *
+ * Work horse function for partition_bounds_merge() for range partitioned
+ * tables.
+ *
+ * TODO: for an anti-join, the caller is supposed to send the outer relation as
+ * left relation. May be we should rename left and right as inner and outer. We
+ * don't need to handle RIGHT joins in this function, so renaming them as outer
+ * and inner is fine.
+ */
+static PartitionBoundInfo
+partition_range_bounds_merge(int partnatts, FmgrInfo *supfuncs, Oid *collations,
+ PartitionBoundInfo left_bi, int left_nparts,
+ PartitionBoundInfo right_bi, int right_nparts,
+ JoinType jointype, List **left_parts, List **right_parts)
+{
+ int *left_pmap;
+ int *left_mmap;
+ int *right_pmap;
+ int *right_mmap;
+ int cnt1;
+ int cnt2;
+ int left_part;
+ int right_part;
+ PartitionBoundInfo merged_bounds = NULL;
+ bool merged = true; /* By default we ranges are merge-able. */
+ int left_lb_index;
+ int right_lb_index;
+ int next_index;
+ int cmpval;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ List *merged_kinds = NIL;
+
+ Assert(left_bi->strategy == right_bi->strategy &&
+ left_bi->strategy == PARTITION_STRATEGY_RANGE);
+
+ *left_parts = NIL;
+ *right_parts = NIL;
+
+ /* Allocate and initialize partition maps. */
+ left_pmap = (int *) palloc(sizeof(int) * left_nparts);
+ left_mmap = (int *) palloc(sizeof(int) * left_nparts);
+ right_pmap = (int *) palloc(sizeof(int) * right_nparts);
+ right_mmap = (int *) palloc(sizeof(int) * right_nparts);
+
+ for (cnt1 = 0; cnt1 < left_nparts; cnt1++)
+ {
+ left_pmap[cnt1] = -1;
+ left_mmap[cnt1] = -1;
+ }
+ for (cnt2 = 0; cnt2 < right_nparts; cnt2++)
+ {
+ right_pmap[cnt2] = -1;
+ right_mmap[cnt2] = -1;
+ }
+
+ left_lb_index = 0;
+ right_lb_index = 0;
+ next_index = 0;
+ while (left_lb_index < left_bi->ndatums &&
+ right_lb_index < right_bi->ndatums)
+ {
+ PartitionRangeBound left_lb;
+ PartitionRangeBound left_ub;
+ PartitionRangeBound right_lb;
+ PartitionRangeBound right_ub;
+ PartitionRangeBound *merged_lb = NULL;
+ PartitionRangeBound *merged_ub = NULL;
+ int merged_index = -1;
+ bool overlap;
+
+ /* Get the range bounds of the next partition. */
+ left_part = partition_get_range_bounds(left_bi, left_lb_index,
+ &left_lb, &left_ub);
+ right_part = partition_get_range_bounds(right_bi, right_lb_index,
+ &right_lb, &right_ub);
+
+ cmpval = partition_range_cmp(partnatts, supfuncs, collations,
+ &left_lb, &left_ub, &right_lb, &right_ub,
+ &overlap);
+
+ if (overlap)
+ {
+ /* Overlapping ranges, try merging. */
+ partition_range_merge(partnatts, supfuncs, collations, jointype,
+ &left_lb, &left_ub, &right_lb, &right_ub,
+ &merged_lb, &merged_ub);
+ merged_index = map_and_merge_partitions(left_pmap, left_mmap,
+ left_part, right_pmap,
+ right_mmap, right_part,
+ &next_index);
+
+ if (merged_index < 0)
+ {
+ merged = false;
+ break;
+ }
+ }
+
+ if (cmpval == 0)
+ {
+ Assert(overlap);
+
+ /* Move to the next pair of partitions. */
+ left_lb_index = partition_range_get_next_lb_index(left_bi,
+ left_lb_index);
+ right_lb_index = partition_range_get_next_lb_index(right_bi,
+ right_lb_index);
+ }
+ else if (cmpval < 0)
+ {
+ /*
+ * If the partition on the left was not mapped to any partition on
+ * the right. Any row from that partition will not have a matching
+ * row from the other relation. So the partition will be part of
+ * the join if it's an anti-join or the left side is the outer
+ * side.
+ */
+ if (jointype == JOIN_INNER || jointype == JOIN_SEMI ||
+ jointype == JOIN_RIGHT)
+ {
+ /* Nothing to do. */
+ }
+ else if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (left_mmap[left_part] < 0)
+ {
+ left_mmap[left_part] = next_index++;
+ merged_index = left_mmap[left_part];
+ merged_lb = &left_lb;
+ merged_ub = &left_ub;
+ }
+ }
+ else
+ {
+ /* Don't know what to do with other join types. Bail out. */
+ merged = false;
+ }
+
+ /* Move to the next partition on the left side. */
+ left_lb_index = partition_range_get_next_lb_index(left_bi,
+ left_lb_index);
+ }
+ else
+ {
+ Assert(cmpval > 0);
+
+ /*
+ * If the partition on the right was not mapped to any partition on
+ * the left. Any row from that partition will not have a matching
+ * row from the other relation. So the partition will be part of
+ * the join if the right side is the outer side.
+ */
+ if (jointype == JOIN_INNER || jointype == JOIN_SEMI ||
+ jointype == JOIN_LEFT || jointype == JOIN_ANTI)
+ {
+ /* Nothing to do. */
+ }
+ else if (jointype == JOIN_RIGHT || jointype == JOIN_FULL)
+ {
+ if (right_mmap[right_part] < 0)
+ {
+ right_mmap[right_part] = next_index++;
+ merged_index = right_mmap[right_part];
+ merged_lb = &right_lb;
+ merged_ub = &right_ub;
+ }
+ }
+ else
+ {
+ /* Don't know what to do with other join types. Bail out. */
+ merged = false;
+ }
+
+ /* Move to the next partition on the right side. */
+ right_lb_index = partition_range_get_next_lb_index(right_bi,
+ right_lb_index);
+ }
+
+ if (!merged)
+ break;
+
+ /* A skipped partition is not added to merged bounds. */
+ if (merged_index < 0)
+ continue;
+
+ /*
+ * We have a valid partition index for the next partition of join. The
+ * partition should have valid range.
+ */
+ Assert(merged_lb && merged_ub);
+
+ /* Try merging merged lower bound with the last upper bound. */
+ merged = partition_range_merge_next_lb(partnatts, supfuncs,
+ collations, merged_lb->datums,
+ merged_lb->kind, &merged_datums,
+ &merged_kinds, &merged_indexes);
+ if (merged)
+ {
+ /* Add upper bound with the merged partition index. */
+ merged_datums = lappend(merged_datums, merged_ub->datums);
+ merged_kinds = lappend(merged_kinds, merged_ub->kind);
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ }
+ else
+ break;
+ }
+
+ /*
+ * We will run the above loop till we exhaust ranges of at least one side
+ * unless we failed to merge the ranges.
+ */
+ Assert (!merged || (left_lb_index >= left_bi->ndatums ||
+ right_lb_index >= right_bi->ndatums));
+
+ /*
+ * Handle any remaining partition bounds. If remaining partitions fall on
+ * the inner side of the join, none of the rows in those partition are
+ * going to be joined with any row on the outer side and hence those
+ * partitions will not be part of the join result. Hence only consider the
+ * remaining partitions on the outer side of the join.
+ */
+ if (merged &&
+ ((left_lb_index < left_bi->ndatums &&
+ (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)) ||
+ (right_lb_index < right_bi->ndatums &&
+ (jointype == JOIN_RIGHT || jointype == JOIN_FULL))))
+ {
+ int bound_index = -1;
+ PartitionBoundInfo rem_bi = NULL;
+ int *mmap = NULL;
+ int part_index;
+ PartitionRangeBound rem_lb;
+ PartitionRangeBound rem_ub;
+
+ if (left_lb_index < left_bi->ndatums)
+ {
+ Assert(jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI);
+ bound_index = left_lb_index;
+ rem_bi = left_bi;
+ mmap = left_mmap;
+ }
+ else if (right_lb_index < right_bi->ndatums)
+ {
+ Assert(jointype == JOIN_RIGHT || jointype == JOIN_FULL);
+ bound_index = right_lb_index;
+ rem_bi = right_bi;
+ mmap = right_mmap;
+ }
+ Assert((bound_index >= 0 && bound_index < rem_bi->ndatums) &&
+ rem_bi && mmap);
+
+ /*
+ * If the partition corresponding to this lower bound has been already
+ * mapped to a merged partition, don't need to add it again. This may
+ * happen if the range of the last partition on the inner side overlaps
+ * with this partition's range and has upper bound lesser than upper
+ * bound of this partition's range.
+ */
+ part_index = partition_get_range_bounds(rem_bi, bound_index, &rem_lb,
+ &rem_ub);
+ Assert(part_index >= 0);
+ if (mmap[part_index] >= 0)
+ bound_index = partition_range_get_next_lb_index(rem_bi, bound_index);
+
+ /*
+ * Merge lower bound of the next range with the upper bound of last
+ * range.
+ */
+ if (bound_index < rem_bi->ndatums)
+ merged = partition_range_merge_next_lb(partnatts, supfuncs,
+ collations,
+ rem_bi->datums[bound_index],
+ rem_bi->kind[bound_index],
+ &merged_datums,
+ &merged_kinds,
+ &merged_indexes);
+
+ /*
+ * Rest of the bounds correspond to valid ranges so add them after
+ * remapping their partitions as required.
+ */
+ for (bound_index++; merged && bound_index < rem_bi->ndatums;
+ bound_index++)
+ {
+ Datum *datums = rem_bi->datums[bound_index];
+ int index = rem_bi->indexes[bound_index];
+ int part_index;
+
+ /*
+ * Add lower bounds with partition index -1 and assign a new
+ * partition index to the upper bounds.
+ */
+ if (index < 0)
+ part_index = index;
+ else
+ {
+ if (mmap[index] < 0)
+ mmap[index] = next_index++;
+ part_index = mmap[index];
+ }
+
+ merged_indexes = lappend_int(merged_indexes, part_index);
+ merged_datums = lappend(merged_datums, datums);
+ merged_kinds = lappend(merged_kinds,
+ rem_bi->kind[bound_index]);
+ }
+ }
+
+ /* Create PartitionBoundInfo */
+ if (merged)
+ {
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(left_mmap, left_nparts, right_mmap,
+ right_nparts, jointype, next_index,
+ left_parts, right_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*left_parts && *right_parts)
+ {
+ Assert(list_length(*left_parts) == list_length(*right_parts));
+ Assert(list_length(*left_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(left_bi->strategy,
+ merged_datums,
+ merged_indexes,
+ merged_kinds,
+ -1);
+ }
+ }
+
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ pfree(left_pmap);
+ pfree(right_pmap);
+ pfree(left_mmap);
+ pfree(right_mmap);
+
+ /* Free any memory we used in this function. */
+ return merged_bounds;
+}
+
+/*
+ * partition_bounds_merge()'s arm for list partitioned tables.
+ *
+ * The function builds the maps of matching partitions from either relation. It
+ * builds the list of partition key values that may appear in the join result
+ * alongwith the list of indexes of partitions of join to which those values
+ * belong. It then crafts a PartitionBoundInfo structure representing the
+ * partition bounds of the join result.
+ */
+static PartitionBoundInfo
+partition_list_bounds_merge(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, PartitionBoundInfo left_bi,
+ int left_nparts, PartitionBoundInfo right_bi,
+ int right_nparts, JoinType jointype, List **left_parts,
+ List **right_parts)
+{
+ int *left_pmap; /* left to right partition map */
+ int *left_mmap; /* left to merged partition map */
+ int *right_pmap; /* right to left partition map */
+ int *right_mmap; /* right to merged partition map */
+ int cntl;
+ int cntr;
+ bool merged = true;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ int next_index = 0;
+ int null_index;
+ PartitionBoundInfo merged_bounds = NULL;
+ int *left_indexes = left_bi->indexes;
+ int *right_indexes = right_bi->indexes;
+ int left_ni = left_bi->null_index;
+ int right_ni = right_bi->null_index;
+
+ Assert(left_bi->strategy == right_bi->strategy &&
+ left_bi->strategy == PARTITION_STRATEGY_LIST);
+
+ /* List partitions do not require unbounded ranges. */
+ Assert(!left_bi->kind && !right_bi->kind);
+
+ /* Allocate and initialize partition maps. */
+ left_pmap = (int *) palloc(sizeof(int) * left_nparts);
+ left_mmap = (int *) palloc(sizeof(int) * left_nparts);
+ right_pmap = (int *) palloc(sizeof(int) * right_nparts);
+ right_mmap = (int *) palloc(sizeof(int) * right_nparts);
+
+ /* Initialize partition maps. */
+ for (cntl = 0; cntl < left_nparts; cntl++)
+ {
+ left_pmap[cntl] = -1;
+ left_mmap[cntl] = -1;
+ }
+ for (cntr = 0; cntr < right_nparts; cntr++)
+ {
+ right_pmap[cntr] = -1;
+ right_mmap[cntr] = -1;
+ }
+
+ cntl = cntr = 0;
+ while (cntl < left_bi->ndatums && cntr < right_bi->ndatums)
+ {
+ Datum *ldatums = left_bi->datums[cntl];
+ Datum *rdatums = right_bi->datums[cntr];
+ int l_index = left_indexes[cntl];
+ int r_index = right_indexes[cntr];
+ int cmpval;
+ int merged_index;
+ Datum *merged_datum;
+
+ /* Every list datum should map to a valid partition index. */
+ Assert(l_index >= 0 && r_index >= 0);
+
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
+ partcollation[0], ldatums[0],
+ rdatums[0]));
+ if (cmpval == 0)
+ {
+ /*
+ * Try matching partitions containing the matching datums. If
+ * successful, add the datum to the merged bounds with index of
+ * merged partition containing it.
+ */
+ merged_datum = ldatums;
+ merged_index = map_and_merge_partitions(left_pmap, left_mmap, l_index,
+ right_pmap, right_mmap, r_index,
+ &next_index);
+
+ if (merged_index < 0)
+ {
+ merged = false;
+ break;
+ }
+
+ /* Move to the next pair of bounds. */
+ cntl++;
+ cntr++;
+ }
+ else if (cmpval < 0)
+ {
+ /*
+ * This list datum is present in the left side but not the right
+ * side. So it will appear in the join when the left side is outer
+ * side.
+ */
+ if (jointype == JOIN_INNER || jointype == JOIN_RIGHT ||
+ jointype == JOIN_SEMI)
+ merged_index = -1;
+ else if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (left_mmap[l_index] < 0)
+ left_mmap[l_index] = next_index++;
+ merged_index = left_mmap[l_index];
+ merged_datum = ldatums;
+ }
+ else
+ {
+ /* Don't know what to do with other join types. */
+ merged = false;
+ break;
+ }
+
+ /* Move to the next datum on the left side. */
+ cntl++;
+ }
+ else
+ {
+ Assert(cmpval > 0);
+
+ /*
+ * This list datum is present in the right side but not the left
+ * side. So it will appear in the join when the right side is outer
+ * side.
+ */
+ if (jointype == JOIN_INNER || jointype == JOIN_LEFT ||
+ jointype == JOIN_SEMI || jointype == JOIN_ANTI)
+ merged_index = -1;
+ else if (jointype == JOIN_RIGHT || jointype == JOIN_FULL)
+ {
+ /*
+ * Every list value on the outer side will appear in the
+ * join. Find the merged partition to which this value
+ * belongs.
+ */
+ if (right_mmap[r_index] < 0)
+ right_mmap[r_index] = next_index++;
+ merged_index = right_mmap[r_index];
+ merged_datum = rdatums;
+ }
+ else
+ {
+ /* Don't know what to do with other join types. */
+ merged = false;
+ break;
+ }
+
+ /* Move to the next datum on the right side. */
+ cntr++;
+ }
+
+ /*
+ * Add the datum with appropriate index in the list of datums, if the
+ * rows containing that datum are deemed to be part of the join.
+ */
+ if (merged_index >= 0)
+ {
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ merged_datums = lappend(merged_datums, merged_datum);
+ }
+ }
+
+ /*
+ * If merge is unsuccessful, bail out without any further processing.
+ * That leaks the memory allocated in this function. So, try not to leak
+ * memory.
+ */
+ if (!merged)
+ goto merge_failed;
+
+ /* We should have exhausted datums on at least one side. */
+ Assert(cntr >= right_bi->ndatums || cntl >= left_bi->ndatums);
+
+ /*
+ * Add any remaining list values on the outer side, assigning partition
+ * indexes if required.
+ */
+ if (jointype == JOIN_LEFT || jointype == JOIN_FULL || jointype == JOIN_ANTI)
+ {
+ for (;cntl < left_bi->ndatums; cntl++)
+ {
+ Datum *ldatums = left_bi->datums[cntl];
+ int l_index = left_indexes[cntl];
+
+ if (left_mmap[l_index] < 0)
+ left_mmap[l_index] = next_index++;
+ merged_indexes = lappend_int(merged_indexes, left_mmap[l_index]);
+ merged_datums = lappend(merged_datums, ldatums);
+ }
+ }
+
+ if (jointype == JOIN_RIGHT || jointype == JOIN_FULL)
+ {
+ for (;cntr < right_bi->ndatums; cntr++)
+ {
+ Datum *rdatums = right_bi->datums[cntr];
+ int r_index = right_indexes[cntr];
+
+ if (right_mmap[r_index] < 0)
+ right_mmap[r_index] = next_index++;
+ merged_indexes = lappend_int(merged_indexes, right_mmap[r_index]);
+ merged_datums = lappend(merged_datums, rdatums);
+ }
+ }
+
+ /*
+ * Merge NULL partitions if any. Find the index of merged partition to
+ * which the NULL values belong in the join result. We can eliminate a NULL
+ * partition when it appears only in the inner relation.
+ */
+ if (!partition_bound_accepts_nulls(left_bi) &&
+ !partition_bound_accepts_nulls(right_bi))
+ null_index = -1;
+ else if (partition_bound_accepts_nulls(left_bi) &&
+ !partition_bound_accepts_nulls(right_bi))
+ {
+ if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (left_mmap[left_ni] < 0)
+ left_mmap[left_ni] = next_index++;
+ null_index = left_mmap[left_ni];
+ }
+ else
+ null_index = -1;
+ }
+ else if (!partition_bound_accepts_nulls(left_bi) &&
+ partition_bound_accepts_nulls(right_bi))
+ {
+ if (jointype == JOIN_RIGHT || jointype == JOIN_FULL)
+ {
+ if (right_mmap[right_ni] < 0)
+ right_mmap[right_ni] = next_index++;
+ null_index = right_mmap[right_ni];
+ }
+ else
+ null_index = -1;
+ }
+ else
+ {
+ /* Both the relations have NULL partitions, try merging them. */
+ null_index = map_and_merge_partitions(left_pmap, left_mmap,
+ left_ni, right_pmap,
+ right_mmap, right_ni,
+ &next_index);
+ if (null_index < 0)
+ merged = false;
+ }
+
+ /* If successful build the output structures. */
+ if (merged)
+ {
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(left_mmap, left_nparts, right_mmap,
+ right_nparts, jointype, next_index,
+ left_parts, right_parts);
+ /* Craft a PartitionBoundInfo to return. */
+ if (*left_parts && *right_parts)
+ {
+ Assert(list_length(*left_parts) == list_length(*right_parts));
+ Assert(list_length(*left_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(left_bi->strategy,
+ merged_datums,
+ merged_indexes, NIL,
+ null_index);
+ }
+ }
+
+merge_failed:
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ pfree(left_pmap);
+ pfree(right_pmap);
+ pfree(left_mmap);
+ pfree(right_mmap);
+
+ return merged_bounds;
+}
+
+/*
+ * map_and_merge_partitions
+ *
+ * If the two given partitions (given by index1 and index2 resp.) are already
+ * mapped to each other return the index of corresponding partition in the
+ * merged set of partitions. If they do not have a merged partition associated
+ * with them, assign a new merged partition index. If the partitions are
+ * already mapped and their mapped partitions are different from each other,
+ * they can not be merged, so return -1.
+ *
+ * partmap1[i] gives the partition of relation 2 which matches ith partition of
+ * relation 1. Similarly for partmap2.
+ *
+ * mergemap1[i] gives the partition in the merged set to which ith partition of
+ * relation 1 maps to. Similarly for mergemap2.
+ *
+ * index1 and index2 are the indexes of matching partition from respective
+ * relations.
+ *
+ * *next_index is used and incremented when the given partitions require a new
+ * merged partition.
+ */
+static int
+map_and_merge_partitions(int *partmap1, int *mergemap1, int index1,
+ int *partmap2, int *mergemap2, int index2,
+ int *next_index)
+{
+ int merged_index;
+
+ /*
+ * If both the partitions are not mapped to each other, update the
+ * maps.
+ */
+ if (partmap1[index1] < 0 && partmap2[index2] < 0)
+ {
+ partmap1[index1] = index2;
+ partmap2[index2] = index1;
+ }
+
+ /*
+ * If the given to partitions map to each other, find the corresponding
+ * merged partition index .
+ */
+ if (partmap1[index1] == index2 && partmap2[index2] == index1)
+ {
+ /*
+ * If both the partitions are mapped to the same merged partition, get
+ * the index of merged partition.
+ */
+ if (mergemap1[index1] == mergemap2[index2])
+ {
+ merged_index = mergemap1[index1];
+
+ /*
+ * If the given two partitions do not have a merged partition
+ * associated with them, allocate a new merged partition.
+ */
+ if (merged_index < 0)
+ {
+ merged_index = *next_index;
+ *next_index = *next_index + 1;
+ mergemap1[index1] = merged_index;
+ mergemap2[index2] = merged_index;
+ }
+ }
+
+ /*
+ * If partition from one relation was mapped to a merged partition but
+ * not the partition from the other relation, map the same merged
+ * partition to the partition from other relation, since matching
+ * partitions map to the same merged partition.
+ */
+ else if (mergemap1[index1] >= 0 && mergemap2[index2] < 0)
+ {
+ mergemap2[index2] = mergemap1[index1];
+ merged_index = mergemap1[index1];
+ }
+ else if (mergemap1[index1] < 0 && mergemap2[index2] >= 0)
+ {
+ mergemap1[index1] = mergemap2[index2];
+ merged_index = mergemap2[index2];
+ }
+ else
+ {
+ Assert(mergemap1[index1] != mergemap2[index2] &&
+ mergemap1[index1] >= 0 && mergemap2[index2] >= 0);
+
+ /*
+ * Both the partitions map to different merged partitions. This
+ * means that multiple partitions from one relation matches to one
+ * partition from the other relation. Partition-wise join does not
+ * handle this case right now, since it requires ganging multiple
+ * partitions together (into one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+ }
+ else
+ {
+ /*
+ * Multiple partitions from one relation map to one partition from the
+ * other relation. Partition-wise join does not handle this case right
+ * now, since it requires ganging multiple partitions together (into
+ * one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+
+ return merged_index;
+}
+
+/*
+ * generate_matching_part_pairs
+ *
+ * Given the merged partition to which partition on either side of join map,
+ * produce the list pairs of partitions which when joined produce the merged
+ * partitions in the order of merged partition indexes.
+ *
+ * If successful, the pairs of partitions are returned as two separate lists
+ * one for each side. Otherwise, those lists will be set to NIL.
+ *
+ * TODO: rename the sides as outer and inner. You may not need to support
+ * JOIN_RIGHT, since we won't see that type here.
+ */
+static void
+generate_matching_part_pairs(int *mergemap1, int nparts1, int *mergemap2,
+ int nparts2, JoinType jointype, int nparts,
+ List **parts1, List **parts2)
+{
+ bool merged = true;
+ int **matching_parts;
+ int cnt1;
+ int cnt2;
+
+ matching_parts = (int **) palloc(sizeof(int *) * 2);
+ matching_parts[0] = (int *) palloc(sizeof(int) * nparts);
+ matching_parts[1] = (int *) palloc(sizeof(int) * nparts);
+
+ *parts1 = NIL;
+ *parts2 = NIL;
+
+ for (cnt1 = 0; cnt1 < nparts; cnt1++)
+ {
+ matching_parts[0][cnt1] = -1;
+ matching_parts[1][cnt1] = -1;
+ }
+
+ /* Set pairs of matching partitions. */
+ for (cnt1 = 0; cnt1 < nparts1; cnt1++)
+ {
+ if (mergemap1[cnt1] >= 0)
+ {
+ Assert(mergemap1[cnt1] < nparts);
+ matching_parts[0][mergemap1[cnt1]] = cnt1;
+ }
+ }
+ for (cnt2 = 0; cnt2 < nparts2; cnt2++)
+ {
+ if (mergemap2[cnt2] >= 0)
+ {
+ Assert(mergemap2[cnt2] < nparts);
+ matching_parts[1][mergemap2[cnt2]] = cnt2;
+ }
+ }
+
+ /*
+ * If we have a partition missing on an inner side, we need to add a dummy
+ * relation which joins with the outer partition. If the inner relation
+ * happens to be a base relation, it will require adding a dummy child
+ * base relation during join processing. Right now, we freeze the base
+ * relation arrays like PlannerInfo::simple_rte_array after planning for
+ * base relations. Adding a new (dummy) base relation would require some
+ * changes to that. So, right now, we do not implement partition-wise join
+ * in such cases.
+ */
+ for (cnt1 = 0; cnt1 < nparts; cnt1++)
+ {
+ int part1 = matching_parts[0][cnt1];
+ int part2 = matching_parts[1][cnt1];
+
+ /* At least one of the partitions should exist. */
+ Assert(part1 >= 0 || part2 >= 0);
+
+ switch (jointype)
+ {
+ case JOIN_INNER:
+ case JOIN_SEMI:
+
+ /*
+ * An inner or semi join can not return any row when the
+ * matching partition on either side is missing. We should
+ * have eliminated all such cases while merging the bounds.
+ */
+ Assert(part1 >= 0 && part2 >= 0);
+ break;
+
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ Assert(part1 >= 0);
+ if (part2 < 0)
+ merged = false;
+ break;
+
+ case JOIN_RIGHT:
+ Assert(part2 >= 0);
+ if (part1 < 0)
+ merged = false;
+ break;
+
+ case JOIN_FULL:
+ if (part1 < 0 || part2 < 0)
+ merged = false;
+ break;
+
+ default:
+ /* We do not know what to do in this case. Bail out. */
+ merged = false;
+ }
+
+ if (!merged)
+ break;
+
+ *parts1 = lappend_int(*parts1, part1);
+ *parts2 = lappend_int(*parts2, part2);
+ }
+
+ pfree(matching_parts[0]);
+ pfree(matching_parts[1]);
+ pfree(matching_parts);
+
+ if (!merged)
+ {
+ list_free(*parts1);
+ list_free(*parts2);
+ *parts1 = NIL;
+ *parts2 = NIL;
+ }
+}
+
+static PartitionBoundInfo
+build_merged_partition_bounds(char strategy, List *merged_datums,
+ List *merged_indexes, List *merged_kinds,
+ int null_index)
+{
+ int cnt;
+ PartitionBoundInfo merged_bounds;
+ ListCell *lc;
+
+ /* We expect the same number of elements in datums and indexes lists. */
+ Assert(list_length(merged_datums) == list_length(merged_indexes));
+
+ merged_bounds = (PartitionBoundInfo) palloc(sizeof(PartitionBoundInfoData));
+ merged_bounds->strategy = strategy;
+ merged_bounds->ndatums = list_length(merged_datums);
+
+ if (strategy == PARTITION_STRATEGY_RANGE)
+ {
+ Assert(list_length(merged_datums) == list_length(merged_kinds));
+ merged_bounds->kind = (PartitionRangeDatumKind **) palloc(sizeof(PartitionRangeDatumKind *) *
+ list_length(merged_kinds));
+ cnt = 0;
+ foreach(lc, merged_kinds)
+ merged_bounds->kind[cnt++] = lfirst(lc);
+
+ /* There are ndatums+1 indexes in case of range partitions */
+ merged_indexes = lappend_int(merged_indexes, -1);
+ }
+ else
+ merged_bounds->kind = NULL;
+
+ cnt = 0;
+ merged_bounds->datums = (Datum **) palloc(sizeof(Datum *) *
+ list_length(merged_datums));
+ foreach(lc, merged_datums)
+ merged_bounds->datums[cnt++] = lfirst(lc);
+
+ merged_bounds->indexes = (int *) palloc(sizeof(int) *
+ list_length(merged_indexes));
+ cnt = 0;
+ foreach(lc, merged_indexes)
+ merged_bounds->indexes[cnt++] = lfirst_int(lc);
+
+ merged_bounds->null_index = null_index;
+
+ return merged_bounds;
+}
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index e3ac4de..2e39c55 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1308,8 +1308,13 @@ try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
RelOptInfo *joinrel, SpecialJoinInfo *parent_sjinfo,
List *parent_restrictlist)
{
- int nparts;
int cnt_parts;
+ PartitionScheme part_scheme;
+ PartitionBoundInfo join_boundinfo;
+ List *parts1;
+ List *parts2;
+ ListCell *lc1;
+ ListCell *lc2;
/* Guard against stack overflow due to overly deep partition hierarchy. */
check_stack_depth();
@@ -1359,39 +1364,54 @@ try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
*/
Assert(joinrel->part_scheme == rel1->part_scheme &&
joinrel->part_scheme == rel2->part_scheme);
+ part_scheme = joinrel->part_scheme;
/*
- * Since we allow partition-wise 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.
+ * Get the list of matching partitions from both sides of the join. While
+ * doing so, we also build the partition bounds of the join relation,
+ * which should match the bounds calculated for other pairs. TODO: why
+ * should every pair result in the same partition bounds?
*/
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel1->boundinfo));
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel2->boundinfo));
-
- nparts = joinrel->nparts;
-
+ join_boundinfo = partition_bounds_merge(part_scheme->partnatts,
+ part_scheme->partsupfunc,
+ part_scheme->parttypcoll,
+ rel1->boundinfo, rel1->nparts,
+ rel2->boundinfo, rel2->nparts,
+ parent_sjinfo->jointype,
+ &parts1, &parts2);
+
+ Assert(join_boundinfo);
+ Assert(partition_bounds_equal(part_scheme->partnatts,
+ part_scheme->parttyplen,
+ part_scheme->parttypbyval, join_boundinfo,
+ joinrel->boundinfo));
elog(DEBUG3, "join between relations %s and %s is considered for partition-wise join.",
bmsToString(rel1->relids), bmsToString(rel2->relids));
- /* Allocate space to hold child-joins RelOptInfos, if not already done. */
+ /*
+ * Every pair of joining relations should result in the same number of
+ * child-joins.
+ */
+ Assert(joinrel->nparts == list_length(parts1));
+ Assert(joinrel->nparts == list_length(parts2));
+
+ /* Allocate space for hold child-joins RelOptInfos, if not already done. */
if (!joinrel->part_rels)
- joinrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) * nparts);
+ joinrel->part_rels = (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+ joinrel->nparts);
/*
* Create child-join relations for this partitioned join, if those don't
* exist. Add paths to child-joins for a pair of child relations
* corresponding to the given pair of parent relations.
*/
- for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+ cnt_parts = 0;
+ forboth(lc1, parts1, lc2, parts2)
{
- RelOptInfo *child_rel1 = rel1->part_rels[cnt_parts];
- RelOptInfo *child_rel2 = rel2->part_rels[cnt_parts];
+ int part1 = lfirst_int(lc1);
+ int part2 = lfirst_int(lc2);
+ RelOptInfo *child_rel1;
+ RelOptInfo *child_rel2;
SpecialJoinInfo *child_sjinfo;
List *child_restrictlist;
RelOptInfo *child_joinrel;
@@ -1399,6 +1419,10 @@ try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
AppendRelInfo **appinfos;
int nappinfos;
+ Assert(part1 >= 0 && part2 >= 0);
+ child_rel1 = rel1->part_rels[part1];
+ child_rel2 = rel2->part_rels[part2];
+
/* We should never try to join two overlapping sets of rels. */
Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1431,6 +1455,15 @@ try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
joinrel->part_rels[cnt_parts] = child_joinrel;
}
+ /*
+ * For every pair of joining relations, the set of matching partitions
+ * would change. However, the base relation partitions constituting
+ * the given child should remain same for all the joining pairs. Since
+ * the order in which children are stored in the array of child-joins,
+ * depends upon partition bounds of the join, which are same for all
+ * the joining pairs, every joining pair yields the child-joins in the
+ * same order.
+ */
Assert(bms_equal(child_joinrel->relids, child_joinrelids));
populate_joinrel_with_paths(root, child_rel1, child_rel2,
@@ -1443,7 +1476,11 @@ try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
*/
try_partition_wise_join(root, child_rel1, child_rel2, child_joinrel,
child_sjinfo, child_restrictlist);
+
+ cnt_parts++;
}
+
+ Assert(cnt_parts == joinrel->nparts);
}
/*
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 81bc2b1..5d1992e 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1613,6 +1613,9 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
int partnatts;
int cnt;
PartitionScheme part_scheme;
+ PartitionBoundInfo join_boundinfo;
+ List *parts1;
+ List *parts2;
/* Nothing to do if partition-wise join technique is disabled. */
if (!enable_partition_wise_join)
@@ -1653,17 +1656,26 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
REL_HAS_ALL_PART_PROPS(inner_rel));
/*
- * For now, our partition matching algorithm can match partitions only
- * when the partition bounds of the joining relations are exactly same.
- * So, bail out otherwise.
+ * Every pair of joining relations would yield the same partition bounds
+ * for a given join (TODO: why?) so we compute the bounds only the first
+ * time. Then for every pair we find the pairs of matching partitions from
+ * the joining relations and join those. TODO: Needs a better explanation
+ * of why is this true. TODO: Also there is no reason to have
+ * part_indexes1 and part_indexes2 pulled here just to be freed up later.
+ * So, we might want to do something better.
*/
- if (outer_rel->nparts != inner_rel->nparts ||
- !partition_bounds_equal(part_scheme->partnatts,
- part_scheme->parttyplen,
- part_scheme->parttypbyval,
- outer_rel->boundinfo, inner_rel->boundinfo))
+ join_boundinfo = partition_bounds_merge(part_scheme->partnatts,
+ part_scheme->partsupfunc,
+ part_scheme->parttypcoll,
+ outer_rel->boundinfo,
+ outer_rel->nparts,
+ inner_rel->boundinfo,
+ inner_rel->nparts,
+ jointype, &parts1, &parts2);
+ if (!join_boundinfo)
{
Assert(!IS_PARTITIONED_REL(joinrel));
+ Assert(!parts1 && !parts2);
return;
}
@@ -1676,13 +1688,16 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
!joinrel->nullable_partexprs && !joinrel->part_rels &&
!joinrel->boundinfo);
+ Assert(list_length(parts1) == list_length(parts2));
+
/*
* Join relation is partitioned using same partitioning scheme as the
- * joining relations and has same bounds.
+ * joining relations. It will have as many partitions as the pairs of
+ * matching partitions we found.
*/
joinrel->part_scheme = part_scheme;
- joinrel->boundinfo = outer_rel->boundinfo;
- joinrel->nparts = outer_rel->nparts;
+ joinrel->nparts = list_length(parts1);
+ joinrel->boundinfo = join_boundinfo;
partnatts = joinrel->part_scheme->partnatts;
/*
@@ -1803,4 +1818,9 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
joinrel->nullable_partexprs[cnt] = nullable_partexprs;
}
}
+
+ /* TODO: OR we could actually create the child-join relations here.*/
+ list_free(parts1);
+ list_free(parts2);
+
}
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 2283c67..056a4f9 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -99,4 +99,10 @@ extern int get_partition_for_tuple(PartitionDispatch *pd,
EState *estate,
PartitionDispatchData **failed_at,
TupleTableSlot **failed_slot);
+extern PartitionBoundInfo partition_bounds_merge(int partnatts,
+ FmgrInfo *supfuncs, Oid *collations,
+ PartitionBoundInfo boundinfo1, int nparts1,
+ PartitionBoundInfo boundinfo2, int nparts2,
+ JoinType jointype, List **parts1, List **parts2);
+
#endif /* PARTITION_H */
--
1.7.9.5
[text/x-patch] 0013-Tests-for-0-1-1-1-and-1-0-partition-matching.patch (216.6K, ../../CAFjFpRfdXpuSu0pxON3dKcr8WndJkaXLzHUVax_Laod0Tgc6UQ@mail.gmail.com/4-0013-Tests-for-0-1-1-1-and-1-0-partition-matching.patch)
download | inline diff:
From 753c8981723c2ab5d9dce57257d5e1a7c85fa7b3 Mon Sep 17 00:00:00 2001
From: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
Date: Tue, 5 Sep 2017 09:51:41 +0530
Subject: [PATCH 13/13] Tests for 0:1, 1:1 and 1:0 partition matching
Rajkumar Raghuvanshi and Ashutosh Bapat.
---
src/test/regress/expected/partition_join.out | 4102 +++++++++++++++++++++-----
src/test/regress/sql/partition_join.sql | 367 ++-
2 files changed, 3752 insertions(+), 717 deletions(-)
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index f9543c8..151d70e 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -8,105 +8,152 @@ SET enable_partition_wise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(21 rows)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
-(4 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+(7 rows)
-- left outer join, with whole-row reference
EXPLAIN (COSTS OFF)
SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b
-> Result
-> Append
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(22 rows)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(33 rows)
SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- t1 | t2
---------------+--------------
- (0,0,0000) | (0,0,0000)
- (50,0,0050) |
- (100,0,0100) |
- (150,0,0150) | (0,150,0150)
- (200,0,0200) |
- (250,0,0250) |
- (300,0,0300) | (0,300,0300)
- (350,0,0350) |
- (400,0,0400) |
- (450,0,0450) | (0,450,0450)
- (500,0,0500) |
- (550,0,0550) |
-(12 rows)
+ t1 | t2
+----------------+----------------
+ (-250,0,-0250) |
+ (-200,0,-0200) |
+ (-150,0,-0150) | (0,-150,-0150)
+ (-100,0,-0100) |
+ (-50,0,-0050) |
+ (0,0,0000) | (0,0,0000)
+ (50,0,0050) |
+ (100,0,0100) |
+ (150,0,0150) | (0,150,0150)
+ (200,0,0200) |
+ (250,0,0250) |
+ (300,0,0300) | (0,300,0300)
+ (350,0,0350) |
+ (400,0,0400) |
+ (450,0,0450) | (0,450,0450)
+ (500,0,0500) |
+ (550,0,0550) |
+ (600,0,0600) | (0,600,0600)
+ (650,0,0650) |
+ (700,0,0700) |
+ (750,0,0750) | (0,750,0750)
+(21 rows)
-- right outer join
EXPLAIN (COSTS OFF)
@@ -119,35 +166,53 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHE
-> Append
-> Hash Right Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Right Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Hash Right Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-> Nested Loop Left Join
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p3 t2_3
Filter: (a = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t2_2.b)
-(21 rows)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(33 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
- | | 75 | 0075
- | | 225 | 0225
- | | 375 | 0375
- | | 525 | 0525
-(8 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+ | | -225 | -0225
+ | | -75 | -0075
+ | | 75 | 0075
+ | | 225 | 0225
+ | | 375 | 0375
+ | | 525 | 0525
+ | | 675 | 0675
+(14 rows)
-- full outer join
EXPLAIN (COSTS OFF)
@@ -155,9 +220,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE prt1.b = 0) t1 FULL
QUERY PLAN
--------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b
+ Sort Key: prt1_p0.a, prt2_p0.b
-> Append
-> Hash Full Join
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ -> Seq Scan on prt1_p0
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0
+ Filter: (a = 0)
+ -> Hash Full Join
Hash Cond: (prt1_p1.a = prt2_p1.b)
-> Seq Scan on prt1_p1
Filter: (b = 0)
@@ -178,28 +250,47 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE prt1.b = 0) t1 FULL
-> Hash
-> Seq Scan on prt2_p3
Filter: (a = 0)
-(24 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+(38 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | 150 | 0150
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
- 450 | 0450 | 450 | 0450
- 500 | 0500 | |
- 550 | 0550 | |
- | | 75 | 0075
- | | 225 | 0225
- | | 375 | 0375
- | | 525 | 0525
-(16 rows)
+ a | c | b | c
+------+-------+------+-------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | -150 | -0150
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | 0 | 0000
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | 150 | 0150
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ 450 | 0450 | 450 | 0450
+ 500 | 0500 | |
+ 550 | 0550 | |
+ 600 | 0600 | 600 | 0600
+ 650 | 0650 | |
+ 700 | 0700 | |
+ 750 | 0750 | 750 | 0750
+ | | -225 | -0225
+ | | -75 | -0075
+ | | 75 | 0075
+ | | 225 | 0225
+ | | 375 | 0375
+ | | 525 | 0525
+ | | 675 | 0675
+(28 rows)
-- Cases with non-nullable expressions in subquery results;
-- make sure these go to null as expected
@@ -208,9 +299,17 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
QUERY PLAN
------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b
+ Sort Key: prt1_p0.a, prt2_p0.b
-> Append
-> Hash Full Join
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ Filter: (((50) = prt1_p0.a) OR ((75) = prt2_p0.b))
+ -> Seq Scan on prt1_p0
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0
+ Filter: (a = 0)
+ -> Hash Full Join
Hash Cond: (prt1_p1.a = prt2_p1.b)
Filter: (((50) = prt1_p1.a) OR ((75) = prt2_p1.b))
-> Seq Scan on prt1_p1
@@ -234,7 +333,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
-> Hash
-> Seq Scan on prt2_p3
Filter: (a = 0)
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ Filter: (((50) = prt1_p4.a) OR ((75) = prt2_p4.b))
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) WHERE t1.phv = t1.a OR t2.phv = t2.b ORDER BY t1.a, t2.b;
a | c | b | c
@@ -248,10 +355,17 @@ SELECT t1.a, t1.c, t1.phv, t2.b, t2.c, t2.phv FROM (SELECT 25 phv, * FROM prt1 W
QUERY PLAN
--------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b
+ Sort Key: prt1_p0.a, prt2_p0.b
-> Result
-> Append
-> Hash Full Join
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ -> Seq Scan on prt1_p0
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0
+ Filter: (a = 0)
+ -> Hash Full Join
Hash Cond: (prt1_p1.a = prt2_p1.b)
-> Seq Scan on prt1_p1
Filter: (b = 0)
@@ -272,28 +386,47 @@ SELECT t1.a, t1.c, t1.phv, t2.b, t2.c, t2.phv FROM (SELECT 25 phv, * FROM prt1 W
-> Hash
-> Seq Scan on prt2_p3
Filter: (a = 0)
-(25 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+(39 rows)
SELECT t1.a, t1.c, t1.phv, t2.b, t2.c, t2.phv FROM (SELECT 25 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 50 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) ORDER BY t1.a, t2.b;
- a | c | phv | b | c | phv
------+------+-----+-----+------+-----
- 0 | 0000 | 25 | 0 | 0000 | 50
- 50 | 0050 | 25 | | |
- 100 | 0100 | 25 | | |
- 150 | 0150 | 25 | 150 | 0150 | 50
- 200 | 0200 | 25 | | |
- 250 | 0250 | 25 | | |
- 300 | 0300 | 25 | 300 | 0300 | 50
- 350 | 0350 | 25 | | |
- 400 | 0400 | 25 | | |
- 450 | 0450 | 25 | 450 | 0450 | 50
- 500 | 0500 | 25 | | |
- 550 | 0550 | 25 | | |
- | | | 75 | 0075 | 50
- | | | 225 | 0225 | 50
- | | | 375 | 0375 | 50
- | | | 525 | 0525 | 50
-(16 rows)
+ a | c | phv | b | c | phv
+------+-------+-----+------+-------+-----
+ -250 | -0250 | 25 | | |
+ -200 | -0200 | 25 | | |
+ -150 | -0150 | 25 | -150 | -0150 | 50
+ -100 | -0100 | 25 | | |
+ -50 | -0050 | 25 | | |
+ 0 | 0000 | 25 | 0 | 0000 | 50
+ 50 | 0050 | 25 | | |
+ 100 | 0100 | 25 | | |
+ 150 | 0150 | 25 | 150 | 0150 | 50
+ 200 | 0200 | 25 | | |
+ 250 | 0250 | 25 | | |
+ 300 | 0300 | 25 | 300 | 0300 | 50
+ 350 | 0350 | 25 | | |
+ 400 | 0400 | 25 | | |
+ 450 | 0450 | 25 | 450 | 0450 | 50
+ 500 | 0500 | 25 | | |
+ 550 | 0550 | 25 | | |
+ 600 | 0600 | 25 | 600 | 0600 | 50
+ 650 | 0650 | 25 | | |
+ 700 | 0700 | 25 | | |
+ 750 | 0750 | 25 | 750 | 0750 | 50
+ | | | -225 | -0225 | 50
+ | | | -75 | -0075 | 50
+ | | | 75 | 0075 | 50
+ | | | 225 | 0225 | 50
+ | | | 375 | 0375 | 50
+ | | | 525 | 0525 | 50
+ | | | 675 | 0675 | 50
+(28 rows)
-- Join with pruned partitions from joining relations
EXPLAIN (COSTS OFF)
@@ -323,9 +456,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
-> Hash Left Join
+ Hash Cond: (prt1_p0.a = b)
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Hash
+ -> Result
+ One-Time Filter: false
+ -> Hash Left Join
Hash Cond: (prt1_p1.a = b)
-> Seq Scan on prt1_p1
Filter: ((a < 450) AND (b = 0))
@@ -339,30 +479,43 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
-> Hash
-> Seq Scan on prt1_p2
Filter: ((a < 450) AND (b = 0))
-(17 rows)
+(24 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
-(9 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+(14 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
QUERY PLAN
------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
-> Hash Full Join
+ Hash Cond: (prt1_p0.a = b)
+ Filter: ((prt1_p0.b = 0) OR (a = 0))
+ -> Seq Scan on prt1_p0
+ Filter: (a < 450)
+ -> Hash
+ -> Result
+ One-Time Filter: false
+ -> Hash Full Join
Hash Cond: (prt1_p1.a = b)
Filter: ((prt1_p1.b = 0) OR (a = 0))
-> Seq Scan on prt1_p1
@@ -386,64 +539,153 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JO
-> Hash
-> Result
One-Time Filter: false
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt2_p4.b = a)
+ Filter: ((b = 0) OR (prt2_p4.a = 0))
+ -> Seq Scan on prt2_p4
+ Filter: (b > 250)
+ -> Hash
+ -> Result
+ One-Time Filter: false
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
- | | 375 | 0375
- | | 450 | 0450
- | | 525 | 0525
-(12 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ | | 375 | 0375
+ | | 450 | 0450
+ | | 525 | 0525
+ | | 600 | 0600
+ | | 675 | 0675
+ | | 750 | 0750
+(20 rows)
-- Semi-join
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Semi Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Semi Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Nested Loop Semi Join
- Join Filter: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Materialize
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-(24 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(39 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p0 t2
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_2.b = t2_2.a)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p2 t2_2
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: (t1_3.b = t2_3.a)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt1_p3 t2_3
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.b = t2_4.a)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p4 t2_4
+ Filter: (b = 0)
+(37 rows)
+
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
@@ -454,27 +696,82 @@ SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS
-> Append
-> Hash Anti Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash Anti Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash Anti Join
Hash Cond: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p3 t2_2
-(17 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash Anti Join
+ Hash Cond: (t1_3.a = t2_3.b)
+ -> Seq Scan on prt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_3
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(27 rows)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
- sum | avg | sum | avg
--------+----------------------+------+---------------------
- 60000 | 300.0000000000000000 | 2400 | 12.0000000000000000
+ sum | avg | sum | avg
+-------+----------------------+------+--------------------
+ 95550 | 273.0000000000000000 | 2200 | 6.2857142857142857
(1 row)
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ QUERY PLAN
+--------------------------------------------------------------
+ Append
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Hash Anti Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(27 rows)
+
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ b | c
+------+-------
+ -225 | -0225
+ -75 | -0075
+ 75 | 0075
+ 225 | 0225
+ 375 | 0375
+ 525 | 0525
+ 675 | 0675
+(7 rows)
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -487,49 +784,74 @@ SELECT * FROM prt1 t1 LEFT JOIN LATERAL
-> Result
-> Append
-> Nested Loop Left Join
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p1_a on prt1_p1 t2
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
Index Cond: (a = t1.a)
- -> Index Scan using iprt2_p1_b on prt2_p1 t3
+ -> Index Scan using iprt2_p0_b on prt2_p0 t3
Index Cond: (b = t2.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_1
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
Index Cond: (a = t1_1.a)
- -> Index Scan using iprt2_p2_b on prt2_p2 t3_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t3_1
Index Cond: (b = t2_1.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_2
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
Index Cond: (a = t1_2.a)
- -> Index Scan using iprt2_p3_b on prt2_p3 t3_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t3_2
Index Cond: (b = t2_2.a)
-(28 rows)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.a)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t3_3
+ Index Cond: (b = t2_3.a)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.a)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t3_4
+ Index Cond: (b = t2_4.a)
+(44 rows)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, least(t1.a,t2.a,t3.b) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.a = ss.t2a WHERE t1.b = 0 ORDER BY t1.a;
- a | b | c | t2a | t3a | least
------+---+------+-----+-----+-------
- 0 | 0 | 0000 | 0 | 0 | 0
- 50 | 0 | 0050 | | |
- 100 | 0 | 0100 | | |
- 150 | 0 | 0150 | 150 | 0 | 150
- 200 | 0 | 0200 | | |
- 250 | 0 | 0250 | | |
- 300 | 0 | 0300 | 300 | 0 | 300
- 350 | 0 | 0350 | | |
- 400 | 0 | 0400 | | |
- 450 | 0 | 0450 | 450 | 0 | 450
- 500 | 0 | 0500 | | |
- 550 | 0 | 0550 | | |
-(12 rows)
+ a | b | c | t2a | t3a | least
+------+---+-------+------+-----+-------
+ -250 | 0 | -0250 | | |
+ -200 | 0 | -0200 | | |
+ -150 | 0 | -0150 | -150 | 0 | -150
+ -100 | 0 | -0100 | | |
+ -50 | 0 | -0050 | | |
+ 0 | 0 | 0000 | 0 | 0 | 0
+ 50 | 0 | 0050 | | |
+ 100 | 0 | 0100 | | |
+ 150 | 0 | 0150 | 150 | 0 | 150
+ 200 | 0 | 0200 | | |
+ 250 | 0 | 0250 | | |
+ 300 | 0 | 0300 | 300 | 0 | 300
+ 350 | 0 | 0350 | | |
+ 400 | 0 | 0400 | | |
+ 450 | 0 | 0450 | 450 | 0 | 450
+ 500 | 0 | 0500 | | |
+ 550 | 0 | 0550 | | |
+ 600 | 0 | 0600 | 600 | 0 | 600
+ 650 | 0 | 0650 | | |
+ 700 | 0 | 0700 | | |
+ 750 | 0 | 0750 | 750 | 0 | 750
+(21 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
@@ -543,64 +865,95 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
Hash Cond: ((t1.c)::text = (t2.c)::text)
Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Hash Join
Hash Cond: (t2.a = t3.b)
- -> Seq Scan on prt1_p1 t2
+ -> Seq Scan on prt1_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t3
+ -> Seq Scan on prt2_p0 t3
-> Hash Join
Hash Cond: (t2_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t2_1
+ -> Seq Scan on prt1_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p1 t3_1
-> Hash Join
Hash Cond: (t2_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p2 t2_2
-> Hash
- -> Seq Scan on prt2_p3 t3_2
-(26 rows)
+ -> Seq Scan on prt2_p2 t3_2
+ -> Hash Join
+ Hash Cond: (t2_3.a = t3_3.b)
+ -> Seq Scan on prt1_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t3_3
+ -> Hash Join
+ Hash Cond: (t2_4.a = t3_4.b)
+ -> Seq Scan on prt1_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t3_4
+(38 rows)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, t2.b t2b, t2.c t2c, least(t1.a,t2.a,t3.a) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.c = ss.t2c WHERE (t1.b + coalesce(ss.t2b, 0)) = 0 ORDER BY t1.a;
- a | t2a | t2c
------+-----+------
- 0 | 0 | 0000
- 50 | |
- 100 | |
- 150 | 150 | 0150
- 200 | |
- 250 | |
- 300 | 300 | 0300
- 350 | |
- 400 | |
- 450 | 450 | 0450
- 500 | |
- 550 | |
-(12 rows)
+ a | t2a | t2c
+------+------+-------
+ -250 | |
+ -200 | |
+ -150 | -150 | -0150
+ -100 | |
+ -50 | |
+ 0 | 0 | 0000
+ 50 | |
+ 100 | |
+ 150 | 150 | 0150
+ 200 | |
+ 250 | |
+ 300 | 300 | 0300
+ 350 | |
+ 400 | |
+ 450 | 450 | 0450
+ 500 | |
+ 550 | |
+ 600 | 600 | 0600
+ 650 | |
+ 700 | |
+ 750 | 750 | 0750
+(21 rows)
--
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
@@ -611,32 +964,49 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 =
-> Append
-> Hash Join
Hash Cond: (((t2.b + t2.a) / 2) = ((t1.a + t1.b) / 2))
- -> Seq Scan on prt2_e_p1 t2
+ -> Seq Scan on prt2_e_p0 t2
-> Hash
- -> Seq Scan on prt1_e_p1 t1
+ -> Seq Scan on prt1_e_p0 t1
Filter: (c = 0)
-> Hash Join
- Hash Cond: (((t2_1.b + t2_1.a) / 2) = ((t1_1.a + t1_1.b) / 2))
- -> Seq Scan on prt2_e_p2 t2_1
+ Hash Cond: (((t1_1.a + t1_1.b) / 2) = ((t2_1.b + t2_1.a) / 2))
+ -> Seq Scan on prt1_e_p1 t1_1
+ Filter: (c = 0)
-> Hash
- -> Seq Scan on prt1_e_p2 t1_1
- Filter: (c = 0)
+ -> Seq Scan on prt2_e_p1 t2_1
-> Hash Join
Hash Cond: (((t2_2.b + t2_2.a) / 2) = ((t1_2.a + t1_2.b) / 2))
- -> Seq Scan on prt2_e_p3 t2_2
+ -> Seq Scan on prt2_e_p2 t2_2
-> Hash
- -> Seq Scan on prt1_e_p3 t1_2
+ -> Seq Scan on prt1_e_p2 t1_2
Filter: (c = 0)
-(21 rows)
+ -> Hash Join
+ Hash Cond: (((t2_3.b + t2_3.a) / 2) = ((t1_3.a + t1_3.b) / 2))
+ -> Seq Scan on prt2_e_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t1_3
+ Filter: (c = 0)
+ -> Hash Join
+ Hash Cond: (((t2_4.b + t2_4.a) / 2) = ((t1_4.a + t1_4.b) / 2))
+ -> Seq Scan on prt2_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_4
+ Filter: (c = 0)
+(33 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 150 | 0 | 150 | 0
- 300 | 0 | 300 | 0
- 450 | 0 | 450 | 0
-(4 rows)
+ a | c | b | c
+------+---+------+---
+ -250 | 0 | -250 | 0
+ -100 | 0 | -100 | 0
+ 0 | 0 | 0 | 0
+ 0 | 0 | 0 | 0
+ 150 | 0 | 150 | 0
+ 300 | 0 | 300 | 0
+ 450 | 0 | 450 | 0
+ 600 | 0 | 600 | 0
+ 750 | 0 | 750 | 0
+(9 rows)
--
-- N-way join
@@ -650,107 +1020,158 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t
-> Result
-> Append
-> Nested Loop
- Join Filter: (t1.a = ((t3.a + t3.b) / 2))
+ Join Filter: (t1.a = t2.b)
-> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p1_ab2 on prt1_e_p1 t3
- Index Cond: (((a + b) / 2) = t2.b)
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
+ Index Cond: (b = ((t3.a + t3.b) / 2))
-> Nested Loop
Join Filter: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_1
+ -> Index Scan using iprt1_e_p4_ab2 on prt1_e_p1 t3_1
Index Cond: (((a + b) / 2) = t2_1.b)
-> Nested Loop
Join Filter: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_2
Index Cond: (((a + b) / 2) = t2_2.b)
-(34 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = ((t3_3.a + t3_3.b) / 2))
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (((a + b) / 2) = t2_3.b)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t2_4.b)
+ -> Hash Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (b = ((t3_4.a + t3_4.b) / 2))
+(53 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t3 WHERE t1.a = t2.b AND t1.a = (t3.a + t3.b)/2 AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
-(4 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(8 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
---------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Result
-> Append
-> Hash Right Join
Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_1.a + t3_1.b) / 2) = t1_1.a)
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
-> Hash
-> Hash Right Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_2.a + t3_2.b) / 2) = t1_2.a)
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
-> Hash
-> Hash Right Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (t1_3.a = ((a + b) / 2))
+ -> Hash Right Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p4 t1_4
Filter: (b = 0)
-(34 rows)
+(52 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
--------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Result
@@ -758,48 +1179,75 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1.a = ((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
Index Cond: (t1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t2_1
Index Cond: (t1_1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t2_2
Index Cond: (t1_2.a = b)
-(31 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t3_3.a + t3_3.b) / 2))
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Nested Loop Left Join
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = ((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (t1_4.a = b)
+(48 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- Cases with non-nullable expressions in subquery results;
-- make sure these go to null as expected
@@ -808,23 +1256,36 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b, ((prt1_e_p1.a + prt1_e_p1.b))
+ Sort Key: prt1_p0.a, prt2_p0.b, ((prt1_e_p0.a + prt1_e_p0.b))
-> Result
-> Append
-> Hash Full Join
- Hash Cond: (prt1_p1.a = ((prt1_e_p1.a + prt1_e_p1.b) / 2))
- Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ Hash Cond: (prt1_p0.a = ((prt1_e_p0.a + prt1_e_p0.b) / 2))
+ Filter: ((prt1_p0.a = (50)) OR (prt2_p0.b = (75)) OR (((prt1_e_p0.a + prt1_e_p0.b) / 2) = (50)))
-> Hash Full Join
- Hash Cond: (prt1_p1.a = prt2_p1.b)
- -> Seq Scan on prt1_p1
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ -> Seq Scan on prt1_p0
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1
+ -> Seq Scan on prt2_p0
Filter: (a = 0)
-> Hash
- -> Seq Scan on prt1_e_p1
+ -> Seq Scan on prt1_e_p0
Filter: (c = 0)
-> Hash Full Join
+ Hash Cond: (((prt1_e_p1.a + prt1_e_p1.b) / 2) = prt1_p1.a)
+ Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ -> Seq Scan on prt1_e_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Hash Full Join
+ Hash Cond: (prt1_p1.a = prt2_p1.b)
+ -> Seq Scan on prt1_p1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1
+ Filter: (a = 0)
+ -> Hash Full Join
Hash Cond: (prt1_p2.a = ((prt1_e_p2.a + prt1_e_p2.b) / 2))
Filter: ((prt1_p2.a = (50)) OR (prt2_p2.b = (75)) OR (((prt1_e_p2.a + prt1_e_p2.b) / 2) = (50)))
-> Hash Full Join
@@ -850,7 +1311,20 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
-> Hash
-> Seq Scan on prt1_e_p3
Filter: (c = 0)
-(43 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = ((prt1_e_p4.a + prt1_e_p4.b) / 2))
+ Filter: ((prt1_p4.a = (50)) OR (prt2_p4.b = (75)) OR (((prt1_e_p4.a + prt1_e_p4.b) / 2) = (50)))
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_e_p4
+ Filter: (c = 0)
+(69 rows)
SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b)) FULL JOIN (SELECT 50 phv, * FROM prt1_e WHERE prt1_e.c = 0) t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.a = t1.phv OR t2.b = t2.phv OR (t3.a + t3.b)/2 = t3.phv ORDER BY t1.a, t2.b, t3.a + t3.b;
a | phv | b | phv | ?column? | phv
@@ -868,397 +1342,2606 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHER
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = t1_3.b)
+ Join Filter: (t1.a = t1_5.b)
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Join
- Hash Cond: (((t2.a + t2.b) / 2) = t1_3.b)
- -> Seq Scan on prt1_e_p1 t2
+ Hash Cond: (((t2.a + t2.b) / 2) = t1_5.b)
+ -> Seq Scan on prt1_e_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t1_3
+ -> Seq Scan on prt2_p0 t1_5
Filter: (a = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
Index Cond: (a = ((t2.a + t2.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_1.a = t1_4.b)
+ Join Filter: (t1_1.a = t1_6.b)
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Join
- Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_4.b)
- -> Seq Scan on prt1_e_p2 t2_1
+ Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_6.b)
+ -> Seq Scan on prt1_e_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t1_4
+ -> Seq Scan on prt2_p1 t1_6
Filter: (a = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
Index Cond: (a = ((t2_1.a + t2_1.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_2.a = t1_5.b)
+ Join Filter: (t1_2.a = t1_7.b)
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Nested Loop
- -> Seq Scan on prt2_p3 t1_5
+ -> Seq Scan on prt2_p2 t1_7
Filter: (a = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_2
- Index Cond: (((a + b) / 2) = t1_5.b)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t2_2
+ Index Cond: (((a + b) / 2) = t1_7.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
Index Cond: (a = ((t2_2.a + t2_2.b) / 2))
Filter: (b = 0)
-(41 rows)
-
-SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHERE t1.a = 0 AND t1.b = (t2.a + t2.b)/2) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
-
+ -> Nested Loop
+ Join Filter: (t1_3.a = t1_8.b)
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t1_8
+ Filter: (a = 0)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_3
+ Index Cond: (((a + b) / 2) = t1_8.b)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t2_3.a + t2_3.b) / 2))
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t1_9.b)
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Join
+ Hash Cond: (((t2_4.a + t2_4.b) / 2) = t1_9.b)
+ -> Seq Scan on prt1_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t1_9
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = ((t2_4.a + t2_4.b) / 2))
+ Filter: (b = 0)
+(66 rows)
+
+SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHERE t1.a = 0 AND t1.b = (t2.a + t2.b)/2) AND t1.b = 0 ORDER BY t1.a;
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
--------------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Nested Loop
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Semi Join
- Hash Cond: (t1_3.b = ((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt2_p1 t1_3
+ Hash Cond: (t1_5.b = ((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt2_p0 t1_5
-> Hash
- -> Seq Scan on prt1_e_p1 t1_6
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
- Index Cond: (a = t1_3.b)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t1_5.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Semi Join
- Hash Cond: (t1_4.b = ((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt2_p2 t1_4
+ Hash Cond: (t1_6.b = ((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt2_p1 t1_6
-> Hash
- -> Seq Scan on prt1_e_p2 t1_7
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
- Index Cond: (a = t1_4.b)
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
+ Index Cond: (a = t1_6.b)
+ Filter: (b = 0)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_7.b
+ -> Hash Semi Join
+ Hash Cond: (t1_7.b = ((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt2_p2 t1_7
+ -> Hash
+ -> Seq Scan on prt1_e_p2 t1_12
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t1_7.b)
Filter: (b = 0)
-> Nested Loop
-> Unique
-> Sort
- Sort Key: t1_5.b
+ Sort Key: t1_8.b
-> Hash Semi Join
- Hash Cond: (t1_5.b = ((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt2_p3 t1_5
+ Hash Cond: (t1_8.b = ((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt2_p3 t1_8
-> Hash
- -> Seq Scan on prt1_e_p3 t1_8
+ -> Seq Scan on prt1_e_p3 t1_13
Filter: (c = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t1_5.b)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t1_8.b)
+ Filter: (b = 0)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Semi Join
+ Hash Cond: (t1_9.b = ((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt2_p4 t1_9
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = t1_9.b)
Filter: (b = 0)
-(40 rows)
+(64 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+-- test merge joins
+SET enable_hashjoin TO off;
+SET enable_nestloop TO off;
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------------
+ Merge Append
+ Sort Key: t1.a
+ -> Merge Semi Join
+ Merge Cond: (t1.a = t1_5.b)
+ -> Sort
+ Sort Key: t1.a
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_5.b = (((t1_10.a + t1_10.b) / 2)))
+ -> Sort
+ Sort Key: t1_5.b
+ -> Seq Scan on prt2_p0 t1_5
+ -> Sort
+ Sort Key: (((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt1_e_p0 t1_10
+ Filter: (c = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_1.a = t1_6.b)
+ -> Sort
+ Sort Key: t1_1.a
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_6.b = (((t1_11.a + t1_11.b) / 2)))
+ -> Sort
+ Sort Key: t1_6.b
+ -> Seq Scan on prt2_p1 t1_6
+ -> Sort
+ Sort Key: (((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt1_e_p1 t1_11
+ Filter: (c = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_2.a = t1_7.b)
+ -> Sort
+ Sort Key: t1_2.a
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_7.b = (((t1_12.a + t1_12.b) / 2)))
+ -> Sort
+ Sort Key: t1_7.b
+ -> Seq Scan on prt2_p2 t1_7
+ -> Sort
+ Sort Key: (((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt1_e_p2 t1_12
+ Filter: (c = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_3.a = t1_8.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_8.b = (((t1_13.a + t1_13.b) / 2)))
+ -> Sort
+ Sort Key: t1_8.b
+ -> Seq Scan on prt2_p3 t1_8
+ -> Sort
+ Sort Key: (((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt1_e_p3 t1_13
+ Filter: (c = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_4.a = t1_9.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_9.b = (((t1_14.a + t1_14.b) / 2)))
+ -> Sort
+ Sort Key: t1_9.b
+ -> Seq Scan on prt2_p4 t1_9
+ -> Sort
+ Sort Key: (((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+(77 rows)
+
+SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
+ QUERY PLAN
+----------------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.b, ((t3.a + t3.b))
+ -> Result
+ -> Append
+ -> Merge Left Join
+ Merge Cond: (t1.a = t2.b)
+ -> Sort
+ Sort Key: t1.a
+ -> Merge Left Join
+ Merge Cond: ((((t3.a + t3.b) / 2)) = t1.a)
+ -> Sort
+ Sort Key: (((t3.a + t3.b) / 2))
+ -> Seq Scan on prt1_e_p0 t3
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1.a
+ -> Seq Scan on prt1_p0 t1
+ -> Sort
+ Sort Key: t2.b
+ -> Seq Scan on prt2_p0 t2
+ -> Merge Left Join
+ Merge Cond: (t1_1.a = t2_1.b)
+ -> Sort
+ Sort Key: t1_1.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_1.a + t3_1.b) / 2)) = t1_1.a)
+ -> Sort
+ Sort Key: (((t3_1.a + t3_1.b) / 2))
+ -> Seq Scan on prt1_e_p1 t3_1
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_1.a
+ -> Seq Scan on prt1_p1 t1_1
+ -> Sort
+ Sort Key: t2_1.b
+ -> Seq Scan on prt2_p1 t2_1
+ -> Merge Left Join
+ Merge Cond: (t1_2.a = t2_2.b)
+ -> Sort
+ Sort Key: t1_2.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_2.a + t3_2.b) / 2)) = t1_2.a)
+ -> Sort
+ Sort Key: (((t3_2.a + t3_2.b) / 2))
+ -> Seq Scan on prt1_e_p2 t3_2
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_2.a
+ -> Seq Scan on prt1_p2 t1_2
+ -> Sort
+ Sort Key: t2_2.b
+ -> Seq Scan on prt2_p2 t2_2
+ -> Merge Left Join
+ Merge Cond: (t1_3.a = t2_3.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_3.a + t3_3.b) / 2)) = t1_3.a)
+ -> Sort
+ Sort Key: (((t3_3.a + t3_3.b) / 2))
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ -> Sort
+ Sort Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ -> Merge Left Join
+ Merge Cond: (t1_4.a = t2_4.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_4.a + t3_4.b) / 2)) = t1_4.a)
+ -> Sort
+ Sort Key: (((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ -> Sort
+ Sort Key: t2_4.b
+ -> Seq Scan on prt2_p4 t2_4
+(84 rows)
+
+SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
+
+RESET enable_hashjoin;
+RESET enable_nestloop;
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -150 | -0150 | 0 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 0 | 0150
+ 300 | 0300 | 0 | 0300
+ 450 | 0450 | 0 | 0450
+ 600 | 0600 | 0 | 0600
+ 750 | 0750 | 0 | 0750
+(7 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | 0 | -0150
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | 0 | 0000
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | 0 | 0150
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 0 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ 450 | 0450 | 0 | 0450
+ 500 | 0500 | |
+ 550 | 0550 | |
+ 600 | 0600 | 0 | 0600
+ 650 | 0650 | |
+ 700 | 0700 | |
+ 750 | 0750 | 0 | 0750
+(21 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Semi Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Append
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
+ Index Cond: (a = t1_1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(28 rows)
+
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Anti Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Anti Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -250 | 0 | -0250
+ -200 | 0 | -0200
+ -100 | 0 | -0100
+ -50 | 0 | -0050
+ 50 | 0 | 0050
+ 100 | 0 | 0100
+ 200 | 0 | 0200
+ 250 | 0 | 0250
+ 350 | 0 | 0350
+ 400 | 0 | 0400
+ 500 | 0 | 0500
+ 550 | 0 | 0550
+ 650 | 0 | 0650
+ 700 | 0 | 0700
+(14 rows)
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.b
+ -> Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(24 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: (t1.a = t2.b)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.a, 0)) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------
+ Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(22 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Join
+ Hash Cond: (t1.a = t2.b)
+ Join Filter: ((t1.b + t2.a) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+--
+-- partitioned by multiple columns
+--
+CREATE TABLE prt1_m (a int, b int, c int) PARTITION BY RANGE(a, ((a + b)/2));
+CREATE TABLE prt1_m_p1 PARTITION OF prt1_m FOR VALUES FROM (0, 0) TO (250, 250);
+CREATE TABLE prt1_m_p2 PARTITION OF prt1_m FOR VALUES FROM (250, 250) TO (500, 500);
+CREATE TABLE prt1_m_p3 PARTITION OF prt1_m FOR VALUES FROM (500, 500) TO (600, 600);
+INSERT INTO prt1_m SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+ANALYZE prt1_m;
+CREATE TABLE prt2_m (a int, b int, c int) PARTITION BY RANGE(((b + a)/2), b);
+CREATE TABLE prt2_m_p1 PARTITION OF prt2_m FOR VALUES FROM (0, 0) TO (250, 250);
+CREATE TABLE prt2_m_p2 PARTITION OF prt2_m FOR VALUES FROM (250, 250) TO (500, 500);
+CREATE TABLE prt2_m_p3 PARTITION OF prt2_m FOR VALUES FROM (500, 500) TO (600, 600);
+INSERT INTO prt2_m SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+ANALYZE prt2_m;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------
+ Sort
+ Sort Key: prt1_m_p1.a, prt2_m_p1.b
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p1.a = ((prt2_m_p1.b + prt2_m_p1.a) / 2)) AND (((prt1_m_p1.a + prt1_m_p1.b) / 2) = prt2_m_p1.b))
+ -> Seq Scan on prt1_m_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p1
+ Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p2.a = ((prt2_m_p2.b + prt2_m_p2.a) / 2)) AND (((prt1_m_p2.a + prt1_m_p2.b) / 2) = prt2_m_p2.b))
+ -> Seq Scan on prt1_m_p2
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p2
+ Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p3.a = ((prt2_m_p3.b + prt2_m_p3.a) / 2)) AND (((prt1_m_p3.a + prt1_m_p3.b) / 2) = prt2_m_p3.b))
+ -> Seq Scan on prt1_m_p3
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p3
+ Filter: (c = 0)
+(24 rows)
+
+SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
+ a | c | b | c
+-----+---+-----+---
+ 0 | 0 | 0 | 0
+ 50 | 0 | |
+ 100 | 0 | |
+ 150 | 0 | 150 | 0
+ 200 | 0 | |
+ 250 | 0 | |
+ 300 | 0 | 300 | 0
+ 350 | 0 | |
+ 400 | 0 | |
+ 450 | 0 | 450 | 0
+ 500 | 0 | |
+ 550 | 0 | |
+ | | 75 | 0
+ | | 225 | 0
+ | | 375 | 0
+ | | 525 | 0
+(16 rows)
+
+--
+-- tests for list partitioned tables.
+--
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Result
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(28 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 470 | 0 | 0011
+(1 row)
+
+--
+-- list partitioned by expression
+--
+CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
+ANALYZE plt1_e;
+-- test partition matching with N-way join
+EXPLAIN (COSTS OFF)
+SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+ QUERY PLAN
+----------------------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.c, t3.c
+ -> HashAggregate
+ Group Key: t1.c, t2.c, t3.c
+ -> Result
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = ltrim(t3.c, 'A'::text))
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt1_e_p4 t3
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = ltrim(t3_1.c, 'A'::text))
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_e_p1 t3_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = ltrim(t3_2.c, 'A'::text))
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt1_e_p2 t3_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = ltrim(t3_3.c, 'A'::text))
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt1_e_p3 t3_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(42 rows)
+
+SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+ avg | avg | avg | c | c | c
+----------------------+---------------------+----------------------+------+------+------
+ 246.5000000000000000 | 22.4666666666666667 | 268.9666666666666667 | 0000 | 0000 | 0000
+ 248.5000000000000000 | 21.3333333333333333 | 269.8333333333333333 | 0002 | 0002 | 0002
+ 249.5000000000000000 | 22.3333333333333333 | 271.8333333333333333 | 0003 | 0003 | 0003
+ 250.5000000000000000 | 23.3333333333333333 | 273.8333333333333333 | 0004 | 0004 | 0004
+ 251.5000000000000000 | 22.7666666666666667 | 274.2666666666666667 | 0005 | 0005 | 0005
+ 252.5000000000000000 | 22.2000000000000000 | 274.7000000000000000 | 0006 | 0006 | 0006
+ 246.0000000000000000 | 23.9655172413793103 | 269.9655172413793103 | 0008 | 0008 | 0008
+ 247.0000000000000000 | 23.3448275862068966 | 270.3448275862068966 | 0009 | 0009 | 0009
+(8 rows)
+
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 470 | 0011
+ | | 235 | 0014
+(8 rows)
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 235 | 0014
+ | | 470 | 0011
+(10 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 47 | 0 | 0013
+ 235 | 0 | 0014
+ 470 | 0 | 0011
+(3 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+----------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Materialize
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(20 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Result
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(28 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Materialize
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+---
+ 470 | 0 |
+(1 row)
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
--- test merge joins
-SET enable_hashjoin TO off;
-SET enable_nestloop TO off;
+-- full join
EXPLAIN (COSTS OFF)
-SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
-----------------------------------------------------------------
- Merge Append
- Sort Key: t1.a
- -> Merge Semi Join
- Merge Cond: (t1.a = t1_3.b)
- -> Sort
- Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
Filter: (b = 0)
- -> Merge Semi Join
- Merge Cond: (t1_3.b = (((t1_6.a + t1_6.b) / 2)))
- -> Sort
- Sort Key: t1_3.b
- -> Seq Scan on prt2_p1 t1_3
- -> Sort
- Sort Key: (((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt1_e_p1 t1_6
- Filter: (c = 0)
- -> Merge Semi Join
- Merge Cond: (t1_1.a = t1_4.b)
- -> Sort
- Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on plt1_p1 t1_1
Filter: (b = 0)
- -> Merge Semi Join
- Merge Cond: (t1_4.b = (((t1_7.a + t1_7.b) / 2)))
- -> Sort
- Sort Key: t1_4.b
- -> Seq Scan on prt2_p2 t1_4
- -> Sort
- Sort Key: (((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt1_e_p2 t1_7
- Filter: (c = 0)
- -> Merge Semi Join
- Merge Cond: (t1_2.a = t1_5.b)
- -> Sort
- Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on plt1_p2 t1_2
Filter: (b = 0)
- -> Merge Semi Join
- Merge Cond: (t1_5.b = (((t1_8.a + t1_8.b) / 2)))
- -> Sort
- Sort Key: t1_5.b
- -> Seq Scan on prt2_p3 t1_5
- -> Sort
- Sort Key: (((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt1_e_p3 t1_8
- Filter: (c = 0)
-(47 rows)
-
-SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(22 rows)
EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
-----------------------------------------------------------------------------------
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
Sort
- Sort Key: t1.a, t2.b, ((t3.a + t3.b))
- -> Result
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
-> Append
- -> Merge Left Join
- Merge Cond: (t1.a = t2.b)
- -> Sort
- Sort Key: t1.a
- -> Merge Left Join
- Merge Cond: ((((t3.a + t3.b) / 2)) = t1.a)
- -> Sort
- Sort Key: (((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_e_p1 t3
- Filter: (c = 0)
- -> Sort
- Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
- -> Sort
- Sort Key: t2.b
- -> Seq Scan on prt2_p1 t2
- -> Merge Left Join
- Merge Cond: (t1_1.a = t2_1.b)
- -> Sort
- Sort Key: t1_1.a
- -> Merge Left Join
- Merge Cond: ((((t3_1.a + t3_1.b) / 2)) = t1_1.a)
- -> Sort
- Sort Key: (((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_e_p2 t3_1
- Filter: (c = 0)
- -> Sort
- Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
- -> Sort
- Sort Key: t2_1.b
- -> Seq Scan on prt2_p2 t2_1
- -> Merge Left Join
- Merge Cond: (t1_2.a = t2_2.b)
- -> Sort
- Sort Key: t1_2.a
- -> Merge Left Join
- Merge Cond: ((((t3_2.a + t3_2.b) / 2)) = t1_2.a)
- -> Sort
- Sort Key: (((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_e_p3 t3_2
- Filter: (c = 0)
- -> Sort
- Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
- -> Sort
- Sort Key: t2_2.b
- -> Seq Scan on prt2_p3 t2_2
-(52 rows)
-
-SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(22 rows)
-RESET enable_hashjoin;
-RESET enable_nestloop;
---
--- partitioned by multiple columns
---
-CREATE TABLE prt1_m (a int, b int, c int) PARTITION BY RANGE(a, ((a + b)/2));
-CREATE TABLE prt1_m_p1 PARTITION OF prt1_m FOR VALUES FROM (0, 0) TO (250, 250);
-CREATE TABLE prt1_m_p2 PARTITION OF prt1_m FOR VALUES FROM (250, 250) TO (500, 500);
-CREATE TABLE prt1_m_p3 PARTITION OF prt1_m FOR VALUES FROM (500, 500) TO (600, 600);
-INSERT INTO prt1_m SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
-ANALYZE prt1_m;
-CREATE TABLE prt2_m (a int, b int, c int) PARTITION BY RANGE(((b + a)/2), b);
-CREATE TABLE prt2_m_p1 PARTITION OF prt2_m FOR VALUES FROM (0, 0) TO (250, 250);
-CREATE TABLE prt2_m_p2 PARTITION OF prt2_m FOR VALUES FROM (250, 250) TO (500, 500);
-CREATE TABLE prt2_m_p3 PARTITION OF prt2_m FOR VALUES FROM (500, 500) TO (600, 600);
-INSERT INTO prt2_m SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
-ANALYZE prt2_m;
+-- anti join
EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
- QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
Sort
- Sort Key: prt1_m_p1.a, prt2_m_p1.b
- -> Append
- -> Hash Full Join
- Hash Cond: ((prt1_m_p1.a = ((prt2_m_p1.b + prt2_m_p1.a) / 2)) AND (((prt1_m_p1.a + prt1_m_p1.b) / 2) = prt2_m_p1.b))
- -> Seq Scan on prt1_m_p1
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p1
- Filter: (c = 0)
- -> Hash Full Join
- Hash Cond: ((prt1_m_p2.a = ((prt2_m_p2.b + prt2_m_p2.a) / 2)) AND (((prt1_m_p2.a + prt1_m_p2.b) / 2) = prt2_m_p2.b))
- -> Seq Scan on prt1_m_p2
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p2
- Filter: (c = 0)
- -> Hash Full Join
- Hash Cond: ((prt1_m_p3.a = ((prt2_m_p3.b + prt2_m_p3.a) / 2)) AND (((prt1_m_p3.a + prt1_m_p3.b) / 2) = prt2_m_p3.b))
- -> Seq Scan on prt1_m_p3
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p3
- Filter: (c = 0)
-(24 rows)
-
-SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 50 | 0 | |
- 100 | 0 | |
- 150 | 0 | 150 | 0
- 200 | 0 | |
- 250 | 0 | |
- 300 | 0 | 300 | 0
- 350 | 0 | |
- 400 | 0 | |
- 450 | 0 | 450 | 0
- 500 | 0 | |
- 550 | 0 | |
- | | 75 | 0
- | | 225 | 0
- | | 375 | 0
- | | 525 | 0
-(16 rows)
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(19 rows)
---
--- tests for list partitioned tables.
---
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
---
--- list partitioned by expression
---
-CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1_e;
--- test partition matching with N-way join
EXPLAIN (COSTS OFF)
-SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- QUERY PLAN
---------------------------------------------------------------------------------------
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
Sort
- Sort Key: t1.c, t3.c
- -> HashAggregate
- Group Key: t1.c, t2.c, t3.c
- -> Result
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
-> Append
- -> Hash Join
- Hash Cond: (t1.c = t2.c)
- -> Seq Scan on plt1_p1 t1
- -> Hash
- -> Hash Join
- Hash Cond: (t2.c = ltrim(t3.c, 'A'::text))
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_e_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.c = t2_1.c)
- -> Seq Scan on plt1_p2 t1_1
- -> Hash
- -> Hash Join
- Hash Cond: (t2_1.c = ltrim(t3_1.c, 'A'::text))
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_e_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.c = t2_2.c)
- -> Seq Scan on plt1_p3 t1_2
- -> Hash
- -> Hash Join
- Hash Cond: (t2_2.c = ltrim(t3_2.c, 'A'::text))
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_e_p3 t3_2
-(33 rows)
-
-SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- avg | avg | avg | c | c | c
-----------------------+----------------------+-----------------------+------+------+-------
- 24.0000000000000000 | 24.0000000000000000 | 48.0000000000000000 | 0000 | 0000 | A0000
- 74.0000000000000000 | 75.0000000000000000 | 148.0000000000000000 | 0001 | 0001 | A0001
- 124.0000000000000000 | 124.5000000000000000 | 248.0000000000000000 | 0002 | 0002 | A0002
- 174.0000000000000000 | 174.0000000000000000 | 348.0000000000000000 | 0003 | 0003 | A0003
- 224.0000000000000000 | 225.0000000000000000 | 448.0000000000000000 | 0004 | 0004 | A0004
- 274.0000000000000000 | 274.5000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
- 324.0000000000000000 | 324.0000000000000000 | 648.0000000000000000 | 0006 | 0006 | A0006
- 374.0000000000000000 | 375.0000000000000000 | 748.0000000000000000 | 0007 | 0007 | A0007
- 424.0000000000000000 | 424.5000000000000000 | 848.0000000000000000 | 0008 | 0008 | A0008
- 474.0000000000000000 | 474.0000000000000000 | 948.0000000000000000 | 0009 | 0009 | A0009
- 524.0000000000000000 | 525.0000000000000000 | 1048.0000000000000000 | 0010 | 0010 | A0010
- 574.0000000000000000 | 574.5000000000000000 | 1148.0000000000000000 | 0011 | 0011 | A0011
-(12 rows)
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(19 rows)
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
@@ -1286,16 +3969,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
-> Hash Left Join
Hash Cond: (t2.b = a)
-> Append
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
Filter: (a = 0)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p4 t2_4
Filter: (a = 0)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p5 t2_5
Filter: (a = 0)
-> Hash
-> Result
One-Time Filter: false
-(14 rows)
+(20 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b;
@@ -1306,16 +3995,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
-> Hash Left Join
Hash Cond: (t2.b = a)
-> Append
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
Filter: (a = 0)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p4 t2_4
Filter: (a = 0)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p5 t2_5
Filter: (a = 0)
-> Hash
-> Result
One-Time Filter: false
-(14 rows)
+(20 rows)
--
-- multi-leveled partitions
@@ -1676,64 +4371,70 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2 WHERE t1.a = t2.a;
Hash Join
Hash Cond: (t1.a = t2.a)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Seq Scan on prt4_n_p1 t2
-> Seq Scan on prt4_n_p2 t2_1
-> Seq Scan on prt4_n_p3 t2_2
-(11 rows)
+(13 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2, prt2 t3 WHERE t1.a = t2.a and t1.a = t3.b;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------
Hash Join
- Hash Cond: (t2.a = t1.a)
+ Hash Cond: (t3.b = t1.a)
-> Append
- -> Seq Scan on prt4_n_p1 t2
- -> Seq Scan on prt4_n_p2 t2_1
- -> Seq Scan on prt4_n_p3 t2_2
+ -> Seq Scan on prt2_p0 t3
+ -> Seq Scan on prt2_p1 t3_1
+ -> Seq Scan on prt2_p2 t3_2
+ -> Seq Scan on prt2_p3 t3_3
+ -> Seq Scan on prt2_p4 t3_4
+ -> Seq Scan on prt2_p5 t3_5
-> Hash
- -> Append
- -> Hash Join
- Hash Cond: (t1.a = t3.b)
- -> Seq Scan on prt1_p1 t1
- -> Hash
- -> Seq Scan on prt2_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t1_1
- -> Hash
- -> Seq Scan on prt2_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t1_2
- -> Hash
- -> Seq Scan on prt2_p3 t3_2
+ -> Hash Join
+ Hash Cond: (t1.a = t2.a)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt4_n_p1 t2
+ -> Seq Scan on prt4_n_p2 t2_1
+ -> Seq Scan on prt4_n_p3 t2_2
(23 rows)
-- partition-wise join can not be applied if there are no equi-join conditions
-- between partition keys
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON (t1.a < t2.b);
- QUERY PLAN
----------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------
Nested Loop Left Join
+ Join Filter: (t1.a < t2.b)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
- -> Append
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
- Index Cond: (t1.a < b)
-(12 rows)
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Materialize
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(16 rows)
-- equi-join with join condition on partial keys does not qualify for
-- partition-wise join
@@ -1819,16 +4520,17 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 JOIN prt2_n t2 ON (t1.c = t2.c) JOI
-> Seq Scan on prt2_n_p2 t2_1
-> Hash
-> Hash Join
- Hash Cond: (t3.c = (t1.c)::text)
+ Hash Cond: ((t3.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on plt1_p1 t3
- -> Seq Scan on plt1_p2 t3_1
- -> Seq Scan on plt1_p3 t3_2
+ -> Seq Scan on plt1_p4 t3
+ -> Seq Scan on plt1_p1 t3_1
+ -> Seq Scan on plt1_p2 t3_2
+ -> Seq Scan on plt1_p3 t3_3
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(16 rows)
+(17 rows)
-- partition-wise join can not be applied for a join between list and range
-- partitioned table
@@ -1839,12 +4541,14 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 FULL JOIN prt1 t2 ON (t1.c = t2.c);
Hash Full Join
Hash Cond: ((t2.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on prt1_p1 t2
- -> Seq Scan on prt1_p2 t2_1
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(10 rows)
+(12 rows)
diff --git a/src/test/regress/sql/partition_join.sql b/src/test/regress/sql/partition_join.sql
index 2bb1aff..0c7d99c 100644
--- a/src/test/regress/sql/partition_join.sql
+++ b/src/test/regress/sql/partition_join.sql
@@ -10,25 +10,39 @@ SET enable_partition_wise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
@@ -77,11 +91,19 @@ EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -103,20 +125,30 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
@@ -168,6 +200,85 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
RESET enable_hashjoin;
RESET enable_nestloop;
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
--
-- partitioned by multiple columns
--
@@ -192,28 +303,79 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1
--
-- tests for list partitioned tables.
--
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
--
-- list partitioned by expression
--
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
ANALYZE plt1_e;
-- test partition matching with N-way join
@@ -221,6 +383,175 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.a = 1 AND t1.a = 2;
--
1.7.9.5
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2017-09-05 11:55 ` Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
1 sibling, 0 replies; 154+ messages in thread
From: Rajkumar Raghuwanshi @ 2017-09-05 11:55 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; +Cc: pgsql-hackers
On Tue, Sep 5, 2017 at 4:34 PM, Ashutosh Bapat <
ashutosh.bapat@enterprisedb.com> wrote:
> I have fixed the issues which were marked as TODOs in the attached
> patches. Also, I have included your test change patch in my series of
> patches. Are there any other issues you have commented out?
>
> Thanks Ashutosh, All commented issue got fixed. I am working on some
combinations of N-way joins
to test partition matching, will send those as well once done.
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2017-09-07 14:04 ` Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
1 sibling, 1 reply; 154+ messages in thread
From: Antonin Houska @ 2017-09-07 14:04 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; +Cc: pgsql-hackers
Ashutosh Bapat <ashutosh.bapat@enterprisedb.com> wrote:
> I have fixed the issues which were marked as TODOs in the attached
> patches. Also, I have included your test change patch in my series of
> patches.
I've noticed that partition_bounds_merge() is called twice from
make_join_rel():
* build_join_rel -> build_joinrel_partition_info -> partition_bounds_merge
* try_partition_wise_join -> partition_bounds_merge
Is this intentional, or just a thinko?
--
Antonin Houska
Cybertec Schönig & Schönig GmbH
Gröhrmühlgasse 26
A-2700 Wiener Neustadt
Web: http://www.postgresql-support.de, http://www.cybertec.at
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
@ 2017-09-11 08:08 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2017-09-11 08:08 UTC (permalink / raw)
To: Antonin Houska <ah@cybertec.at>; +Cc: pgsql-hackers
On Thu, Sep 7, 2017 at 7:34 PM, Antonin Houska <ah@cybertec.at> wrote:
> Ashutosh Bapat <ashutosh.bapat@enterprisedb.com> wrote:
>
>> I have fixed the issues which were marked as TODOs in the attached
>> patches. Also, I have included your test change patch in my series of
>> patches.
>
> I've noticed that partition_bounds_merge() is called twice from
> make_join_rel():
>
> * build_join_rel -> build_joinrel_partition_info -> partition_bounds_merge
>
> * try_partition_wise_join -> partition_bounds_merge
>
> Is this intentional, or just a thinko?
>
This is expected. partition_bounds_merge() also returns the pairs of
matching partitions. So, we have to call that function for every pair
of joining relations.
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2017-10-11 11:08 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2017-10-11 11:08 UTC (permalink / raw)
To: Antonin Houska <ah@cybertec.at>; +Cc: pgsql-hackers
Here's updated patch set based on the basic partition-wise join
committed. The patchset applies on top of the patch to optimize the
case of dummy partitioned tables [1].
Right now, the advanced partition matching algorithm bails out when
either of the joining relations has a default partition.
[1] https://www.postgresql.org/message-id/CAFjFpRcPvT5ay9_p3e-k2Cwu4bW_rypON7ceJVWhsU3Uk4Nmmg@mail.gmail...
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
Attachments:
[text/x-patch] 0002-Modify-bound-comparision-functions-to-accept-members.patch (7.5K, ../../CAFjFpRfiK9jaf01O-umKRoKeAP1wuNK8D8yi9ZxSkjKKAL7tvQ@mail.gmail.com/2-0002-Modify-bound-comparision-functions-to-accept-members.patch)
download | inline diff:
From cc0b81ee8891677adb8bff3e98d80993788632dc Mon Sep 17 00:00:00 2001
From: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
Date: Thu, 6 Jul 2017 14:15:22 +0530
Subject: [PATCH 2/4] Modify bound comparision functions to accept members of
PartitionKey
Functions partition_bound_cmp(), partition_rbound_cmp() and
partition_rbound_datum_cmp() are required to merge partition bounds
from joining relations. While doing so, we do not have access to the
PartitionKey of either relations. So, modify these functions to accept
only required members of PartitionKey so that the functions can be
reused for merging bounds.
Ashutosh Bapat.
---
src/backend/catalog/partition.c | 76 ++++++++++++++++++++++-----------------
1 file changed, 44 insertions(+), 32 deletions(-)
diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index ebda85e..87b3fbc 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -134,15 +134,17 @@ static List *generate_partition_qual(Relation rel);
static PartitionRangeBound *make_one_range_bound(PartitionKey key, int index,
List *datums, bool lower);
-static int32 partition_rbound_cmp(PartitionKey key,
- Datum *datums1, PartitionRangeDatumKind *kind1,
- bool lower1, PartitionRangeBound *b2);
-static int32 partition_rbound_datum_cmp(PartitionKey key,
- Datum *rb_datums, PartitionRangeDatumKind *rb_kind,
+static int32 partition_rbound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, Datum *datums1,
+ PartitionRangeDatumKind *kind1, bool lower1,
+ PartitionRangeBound *b2);
+static int32 partition_rbound_datum_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, Datum *rb_datums,
+ PartitionRangeDatumKind *rb_kind,
Datum *tuple_datums);
-static int32 partition_bound_cmp(PartitionKey key,
- PartitionBoundInfo boundinfo,
+static int32 partition_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, PartitionBoundInfo boundinfo,
int offset, void *probe, bool probe_is_bound);
static int partition_bound_bsearch(PartitionKey key,
PartitionBoundInfo boundinfo,
@@ -859,8 +861,9 @@ check_new_partition_bound(char *relname, Relation parent,
* First check if the resulting range would be empty with
* specified lower and upper bounds
*/
- if (partition_rbound_cmp(key, lower->datums, lower->kind, true,
- upper) >= 0)
+ if (partition_rbound_cmp(key->partnatts, key->partsupfunc,
+ key->partcollation, lower->datums,
+ lower->kind, true, upper) >= 0)
{
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
@@ -913,9 +916,11 @@ check_new_partition_bound(char *relname, Relation parent,
{
int32 cmpval;
- cmpval = partition_bound_cmp(key, boundinfo,
- offset + 1, upper,
- true);
+ cmpval = partition_bound_cmp(key->partnatts,
+ key->partsupfunc,
+ key->partcollation,
+ boundinfo, offset + 1,
+ upper, true);
if (cmpval < 0)
{
/*
@@ -2595,7 +2600,9 @@ qsort_partition_rbound_cmp(const void *a, const void *b, void *arg)
PartitionRangeBound *b2 = (*(PartitionRangeBound *const *) b);
PartitionKey key = (PartitionKey) arg;
- return partition_rbound_cmp(key, b1->datums, b1->kind, b1->lower, b2);
+ return partition_rbound_cmp(key->partnatts, key->partsupfunc,
+ key->partcollation, b1->datums, b1->kind,
+ b1->lower, b2);
}
/*
@@ -2612,7 +2619,7 @@ qsort_partition_rbound_cmp(const void *a, const void *b, void *arg)
* two contiguous partitions.
*/
static int32
-partition_rbound_cmp(PartitionKey key,
+partition_rbound_cmp(int partnatts, FmgrInfo *partsupfunc, Oid *partcollation,
Datum *datums1, PartitionRangeDatumKind *kind1,
bool lower1, PartitionRangeBound *b2)
{
@@ -2622,7 +2629,7 @@ partition_rbound_cmp(PartitionKey key,
PartitionRangeDatumKind *kind2 = b2->kind;
bool lower2 = b2->lower;
- for (i = 0; i < key->partnatts; i++)
+ for (i = 0; i < partnatts; i++)
{
/*
* First, handle cases where the column is unbounded, which should not
@@ -2643,8 +2650,8 @@ partition_rbound_cmp(PartitionKey key,
*/
break;
- cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[i],
- key->partcollation[i],
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[i],
+ partcollation[i],
datums1[i],
datums2[i]));
if (cmpval != 0)
@@ -2670,22 +2677,23 @@ partition_rbound_cmp(PartitionKey key,
* is <, =, or > partition key of tuple (tuple_datums)
*/
static int32
-partition_rbound_datum_cmp(PartitionKey key,
- Datum *rb_datums, PartitionRangeDatumKind *rb_kind,
+partition_rbound_datum_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, Datum *rb_datums,
+ PartitionRangeDatumKind *rb_kind,
Datum *tuple_datums)
{
int i;
int32 cmpval = -1;
- for (i = 0; i < key->partnatts; i++)
+ for (i = 0; i < partnatts; i++)
{
if (rb_kind[i] == PARTITION_RANGE_DATUM_MINVALUE)
return -1;
else if (rb_kind[i] == PARTITION_RANGE_DATUM_MAXVALUE)
return 1;
- cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[i],
- key->partcollation[i],
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[i],
+ partcollation[i],
rb_datums[i],
tuple_datums[i]));
if (cmpval != 0)
@@ -2702,17 +2710,18 @@ partition_rbound_datum_cmp(PartitionKey key,
* specified in *probe.
*/
static int32
-partition_bound_cmp(PartitionKey key, PartitionBoundInfo boundinfo,
- int offset, void *probe, bool probe_is_bound)
+partition_bound_cmp(int partnatts, FmgrInfo *partsupfunc, Oid *partcollation,
+ PartitionBoundInfo boundinfo, int offset, void *probe,
+ bool probe_is_bound)
{
Datum *bound_datums = boundinfo->datums[offset];
int32 cmpval = -1;
- switch (key->strategy)
+ switch (boundinfo->strategy)
{
case PARTITION_STRATEGY_LIST:
- cmpval = DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[0],
- key->partcollation[0],
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
+ partcollation[0],
bound_datums[0],
*(Datum *) probe));
break;
@@ -2730,12 +2739,14 @@ partition_bound_cmp(PartitionKey key, PartitionBoundInfo boundinfo,
*/
bool lower = boundinfo->indexes[offset] < 0;
- cmpval = partition_rbound_cmp(key,
- bound_datums, kind, lower,
+ cmpval = partition_rbound_cmp(partnatts, partsupfunc,
+ partcollation, bound_datums,
+ kind, lower,
(PartitionRangeBound *) probe);
}
else
- cmpval = partition_rbound_datum_cmp(key,
+ cmpval = partition_rbound_datum_cmp(partnatts, partsupfunc,
+ partcollation,
bound_datums, kind,
(Datum *) probe);
break;
@@ -2743,7 +2754,7 @@ partition_bound_cmp(PartitionKey key, PartitionBoundInfo boundinfo,
default:
elog(ERROR, "unexpected partition strategy: %d",
- (int) key->strategy);
+ (int) boundinfo->strategy);
}
return cmpval;
@@ -2777,7 +2788,8 @@ partition_bound_bsearch(PartitionKey key, PartitionBoundInfo boundinfo,
int32 cmpval;
mid = (lo + hi + 1) / 2;
- cmpval = partition_bound_cmp(key, boundinfo, mid, probe,
+ cmpval = partition_bound_cmp(key->partnatts, key->partsupfunc,
+ key->partcollation, boundinfo, mid, probe,
probe_is_bound);
if (cmpval <= 0)
{
--
1.7.9.5
[text/x-patch] 0003-WIP-Partition-wise-join-for-1-1-1-0-0-1-partition-ma.patch (50.5K, ../../CAFjFpRfiK9jaf01O-umKRoKeAP1wuNK8D8yi9ZxSkjKKAL7tvQ@mail.gmail.com/3-0003-WIP-Partition-wise-join-for-1-1-1-0-0-1-partition-ma.patch)
download | inline diff:
From 00144d214fdfc156c50921f7fe217ad701af6f8a Mon Sep 17 00:00:00 2001
From: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
Date: Wed, 9 Aug 2017 12:30:34 +0530
Subject: [PATCH 3/4] WIP Partition-wise join for 1:1, 1:0, 0:1 partition
matching.
Earlier version of partition-wise join implementation allowed
partition-wise join between two relations with exactly same partition
bounds. This commit allows partition-wise join to be applied under
following conditions
1. the partition bounds of joining relations are such that rows from
given partition on one side join can join with rows from maximum one
partition on the other side i.e. bounds of a given partition on one
side match/overlap with those of maximum one partition on the other
side. If the mapping happens to be m:n where m > 1 or n > 1, we have
to gang multiple partition relations together into a single relation.
This means that we have to add simple relations during join
processing, something which is not supported right now. ALso, in such
a case, different pairs of joining relations can produce different
partition bounds for the same join relation, which again is not
supported right now.
2. For every partition on outer side that can contribute to the result
of an OUTER side, there exists at least one (taken along with item 1,
it means exactly one) matching partition on the inner side. To
support partition-wise join when the inner matching partition doesn't
exist, we have to add a dummy base relation corresponding to the
non-existent inner partition. We don't have support add base relations
during join processing.
This commit is not complete yet.
known TODO:
1. This patch doesn't support default partitions.
Ashutosh Bapat.
---
src/backend/catalog/partition.c | 1269 +++++++++++++++++++++++++++++++++
src/backend/optimizer/path/joinrels.c | 70 +-
src/backend/optimizer/util/plancat.c | 5 +
src/backend/optimizer/util/relnode.c | 41 +-
src/include/catalog/partition.h | 5 +
src/include/nodes/relation.h | 2 +
6 files changed, 1365 insertions(+), 27 deletions(-)
diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 87b3fbc..95a54fd 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -151,6 +151,38 @@ static int partition_bound_bsearch(PartitionKey key,
void *probe, bool probe_is_bound, bool *is_equal);
static void get_partition_dispatch_recurse(Relation rel, Relation parent,
List **pds, List **leaf_part_oids);
+static PartitionBoundInfo partition_range_bounds_merge(int partnatts,
+ FmgrInfo *supfuncs, Oid *collations,
+ PartitionBoundInfo boundinfo1, int nparts1,
+ PartitionBoundInfo boundinfo2, int nparts2,
+ JoinType jointype, List **parts1, List **parts2);
+static PartitionBoundInfo partition_list_bounds_merge(int partnatts,
+ FmgrInfo *partsupfunc, Oid *collations,
+ PartitionBoundInfo boundinfo1, int nparts1,
+ PartitionBoundInfo boundinfo2, int nparts2,
+ JoinType jointype, List **parts1, List **parts2);
+static void generate_matching_part_pairs(int *mergemap1, int npart1,
+ int *mergemap2, int nparts2, JoinType jointype,
+ int nparts, List **parts1, List **parts2);
+static PartitionBoundInfo build_merged_partition_bounds(char strategy,
+ List *merged_datums, List *merged_indexes,
+ List *merged_contents, int null_index);
+static int map_and_merge_partitions(int *partmap1, int *mergemap1, int index1,
+ int *partmap2, int *mergemap2, int index2,
+ int *next_index);
+static int32 partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *collations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2);
+static int partition_range_cmp(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, bool *overlap);
+static bool partition_range_merge_next_lb(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes);
/*
* RelationBuildPartitionDesc
@@ -2906,3 +2938,1240 @@ get_proposed_default_constraint(List *new_part_constraints)
return list_make1(defPartConstraint);
}
+
+/*
+ * Merge the given partition bounds.
+ *
+ * If given partition bounds can not be merged, return NULL.
+ *
+ * The function also returns two lists of partition indexes one for each of the
+ * joining relations. Both the lists contain the same number of elements. The
+ * partition indexes at the same positions in the list indicate partitions from
+ * each side to be joined and their position corresponds to the index of
+ * partition to which the results of the child-join belong in the partitioned
+ * join.
+ */
+extern PartitionBoundInfo
+partition_bounds_merge(int partnatts, FmgrInfo *partsupfunc, Oid *partcollation,
+ PartitionBoundInfo boundinfo1, int nparts1,
+ PartitionBoundInfo boundinfo2, int nparts2,
+ JoinType jointype, List **parts1, List **parts2)
+{
+ PartitionBoundInfo merged_bounds;
+ char strategy;
+
+ /* Bail out if partitioning strategies are different. */
+ if (boundinfo1->strategy != boundinfo2->strategy)
+ return NULL;
+
+ /*
+ * TODO: We should remove this limitation in the final version of the
+ * patch. See TODO in build_merged_partition_bounds().
+ * Bail out if there are default partitions. */
+ if (partition_bound_has_default(boundinfo1) ||
+ partition_bound_has_default(boundinfo2))
+ return NULL;
+
+ *parts1 = NIL;
+ *parts2 = NIL;
+ strategy = boundinfo1->strategy;
+ if (strategy == PARTITION_STRATEGY_LIST)
+ merged_bounds = partition_list_bounds_merge(partnatts, partsupfunc,
+ partcollation, boundinfo1,
+ nparts1, boundinfo2,
+ nparts2, jointype, parts1,
+ parts2);
+ else if (strategy == PARTITION_STRATEGY_RANGE)
+ merged_bounds = partition_range_bounds_merge(partnatts, partsupfunc,
+ partcollation, boundinfo1,
+ nparts1, boundinfo2,
+ nparts2, jointype, parts1,
+ parts2);
+ else
+ elog(ERROR, "unexpected partition strategy: %d", strategy);
+
+ Assert(merged_bounds || (*parts1 == NIL && *parts2 == NIL));
+ return merged_bounds;
+}
+
+/*
+ * partition_get_range_bounds
+ *
+ * Given the index of lower bound in datums array, return lower and upper
+ * bounds and the index of the partition with that lower bound.
+ */
+static int
+partition_get_range_bounds(PartitionBoundInfo bi, int lb_index,
+ PartitionRangeBound *lower,
+ PartitionRangeBound *upper)
+{
+ int part_index;
+
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The lower bound should correspond to a valid partition. */
+ part_index = bi->indexes[lb_index + 1];
+ Assert(part_index >= 0);
+
+ lower->kind = bi->kind[lb_index];
+ lower->datums = bi->datums[lb_index];
+ lower->lower = true;
+ upper->kind = bi->kind[lb_index + 1];
+ upper->datums = bi->datums[lb_index + 1];
+ upper->lower = false;
+
+ return part_index;
+}
+
+/*
+ * partition_range_get_next_lb_index
+ *
+ * Given the index of lower bound in datums array return the
+ * index of lower bound of the next partition. When the given index corresponds
+ * to the last partition, return number of datums (ndatums).
+ */
+static int
+partition_range_get_next_lb_index(PartitionBoundInfo bi, int lb_index)
+{
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The partition index corresponding to the upper bound should be valid. */
+ Assert(bi->indexes[lb_index + 1] >= 0);
+
+ /*
+ * If there are no bounds left beyond the upper bound, we have reached the
+ * last partition.
+ */
+ if (lb_index + 2 < bi->ndatums)
+ {
+ /*
+ * If the bound next to the upper bound corresponds to no partition,
+ * that's the next lower bound of the next partition. Otherwise, the
+ * current upper bound is the lower bound of the next partition.
+ */
+ if (bi->indexes[lb_index + 2] < 0)
+ return lb_index + 2;
+ else
+ return lb_index + 1;
+ }
+ else
+ return bi->ndatums;
+}
+
+static int32
+partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc, Oid *collations,
+ PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2)
+{
+ return partition_rbound_cmp(partnatts, partsupfunc, collations,
+ bound1->datums, bound1->kind, bound1->lower,
+ bound2);
+}
+
+/*
+ * partition_range_cmp
+ *
+ * Compare the bounds of two range partitions and return <, = or > 0, if the
+ * first partition's upper bound is lower than, equal to or higher than the
+ * second partition's upper bound resp.
+ *
+ * Also, set overlaps to true, if the ranges overlap, otherwise set it to
+ * false.
+ */
+static int
+partition_range_cmp(int partnatts, FmgrInfo *supfuncs, Oid *collations,
+ PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, bool *overlap)
+{
+ /*
+ * Compare upper bound of the first partition with the lower bound of the
+ * second and vice-versa. If lower bound is higher than the upper bound,
+ * the partitions are not overlapping. All other cases indicate overlapping
+ * partitions.
+ * TODO: Add a testcase which has lower and upper bound matching exactly.
+ * Lower bound is inclusive and upper bound is exclusive, so even if the
+ * datums match, the bounds do not match exactly.
+ */
+ if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ lower_bound1, upper_bound2) > 0)
+ {
+ *overlap = false;
+ return 1;
+ }
+ else if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ lower_bound2, upper_bound1) > 0)
+ {
+ *overlap = false;
+ return -1;
+ }
+ else
+ {
+ *overlap = true;
+ return partition_range_bound_cmp(partnatts, supfuncs, collations,
+ upper_bound1, upper_bound2);
+ }
+}
+
+/*
+ * partition_range_merge
+ *
+ * Merge the partition bounds of given two partitions such that the join
+ * between the given two partitions fits merged bounds.
+ *
+ * "merged_upper" will be set to one of the given upper bounds and
+ * "merged_lower" will be set to one of the given lower bounds.
+ */
+static void
+partition_range_merge(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, JoinType jointype,
+ PartitionRangeBound *left_lb,
+ PartitionRangeBound *left_ub,
+ PartitionRangeBound *right_lb,
+ PartitionRangeBound *right_ub,
+ PartitionRangeBound **merged_lb,
+ PartitionRangeBound **merged_ub)
+{
+ /*
+ * An outer join will have all the rows from the outer side, so merged
+ * bounds will be same as the outer bounds. An inner join will have rows
+ * that fit both the bounds, thus lower merged bound will be higher of two
+ * lower bounds and upper merged bound will be lower of the two upper
+ * bounds.
+ */
+ switch (jointype)
+ {
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ *merged_ub = left_ub;
+ *merged_lb = left_lb;
+ break;
+
+ case JOIN_RIGHT:
+ *merged_ub = right_ub;
+ *merged_lb = right_lb;
+ break;
+
+ case JOIN_INNER:
+ case JOIN_SEMI:
+ if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ left_ub, right_ub) < 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ left_lb, right_lb) > 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ case JOIN_FULL:
+ if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ left_ub, right_ub) > 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, supfuncs, collations,
+ left_lb, right_lb) < 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ default:
+ elog(ERROR, "Unexpected join type %d", jointype);
+ }
+
+ return;
+}
+
+/*
+ * Add the lower bound of the next range to the list of bounds, if the lower
+ * bound is higher or equal to the previous upper bound. If successful return
+ * true, otherwise false.
+ */
+static bool
+partition_range_merge_next_lb(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes)
+{
+ int cmpval;
+
+ if (!*merged_datums)
+ {
+ Assert(!*merged_kinds && !*merged_indexes);
+ cmpval = 1;
+ }
+ else
+ {
+ PartitionRangeBound prev_ub;
+
+ prev_ub.datums = llast(*merged_datums);
+ prev_ub.kind = llast(*merged_kinds);
+ prev_ub.lower = false;
+
+ /*
+ * TODO: explain why do we pass lower to be false for the next lower
+ * bound.
+ */
+ cmpval = partition_rbound_cmp(partnatts, supfuncs, collations,
+ next_lb_datums, next_lb_kind, false,
+ &prev_ub);
+ }
+
+ /*
+ * The lower bound is lower than the last upper bound, thus does not fit
+ * the bounds created so far and hence can not be merged with the existing
+ * bounds.
+ */
+ if (cmpval < 0)
+ return false;
+
+ /*
+ * Add bounds of the new merged partition. If the next lower bound is
+ * higher than the last upper bound, add new range with index
+ * corresponding to the lower bound as -1. If the merged lower bound
+ * is same as the last merged upper bound, the last upper bound will be
+ * reused as the lower bound of the next range.
+ */
+ if (cmpval > 0)
+ {
+ *merged_datums = lappend(*merged_datums, next_lb_datums);
+ *merged_kinds = lappend(*merged_kinds, next_lb_kind);
+ *merged_indexes = lappend_int(*merged_indexes, -1);
+ }
+
+ return true;
+}
+
+/*
+ * Merge given two range partition bounds.
+ *
+ * Work horse function for partition_bounds_merge() for range partitioned
+ * tables.
+ *
+ * TODO: for an anti-join, the caller is supposed to send the outer relation as
+ * left relation. May be we should rename left and right as inner and outer. We
+ * don't need to handle RIGHT joins in this function, so renaming them as outer
+ * and inner is fine.
+ */
+static PartitionBoundInfo
+partition_range_bounds_merge(int partnatts, FmgrInfo *supfuncs, Oid *collations,
+ PartitionBoundInfo left_bi, int left_nparts,
+ PartitionBoundInfo right_bi, int right_nparts,
+ JoinType jointype, List **left_parts, List **right_parts)
+{
+ int *left_pmap;
+ int *left_mmap;
+ int *right_pmap;
+ int *right_mmap;
+ int cnt1;
+ int cnt2;
+ int left_part;
+ int right_part;
+ PartitionBoundInfo merged_bounds = NULL;
+ bool merged = true; /* By default we ranges are merge-able. */
+ int left_lb_index;
+ int right_lb_index;
+ int next_index;
+ int cmpval;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ List *merged_kinds = NIL;
+
+ Assert(left_bi->strategy == right_bi->strategy &&
+ left_bi->strategy == PARTITION_STRATEGY_RANGE);
+
+ *left_parts = NIL;
+ *right_parts = NIL;
+
+ /* Allocate and initialize partition maps. */
+ left_pmap = (int *) palloc(sizeof(int) * left_nparts);
+ left_mmap = (int *) palloc(sizeof(int) * left_nparts);
+ right_pmap = (int *) palloc(sizeof(int) * right_nparts);
+ right_mmap = (int *) palloc(sizeof(int) * right_nparts);
+
+ for (cnt1 = 0; cnt1 < left_nparts; cnt1++)
+ {
+ left_pmap[cnt1] = -1;
+ left_mmap[cnt1] = -1;
+ }
+ for (cnt2 = 0; cnt2 < right_nparts; cnt2++)
+ {
+ right_pmap[cnt2] = -1;
+ right_mmap[cnt2] = -1;
+ }
+
+ left_lb_index = 0;
+ right_lb_index = 0;
+ next_index = 0;
+ while (left_lb_index < left_bi->ndatums &&
+ right_lb_index < right_bi->ndatums)
+ {
+ PartitionRangeBound left_lb;
+ PartitionRangeBound left_ub;
+ PartitionRangeBound right_lb;
+ PartitionRangeBound right_ub;
+ PartitionRangeBound *merged_lb = NULL;
+ PartitionRangeBound *merged_ub = NULL;
+ int merged_index = -1;
+ bool overlap;
+
+ /* Get the range bounds of the next partition. */
+ left_part = partition_get_range_bounds(left_bi, left_lb_index,
+ &left_lb, &left_ub);
+ right_part = partition_get_range_bounds(right_bi, right_lb_index,
+ &right_lb, &right_ub);
+
+ cmpval = partition_range_cmp(partnatts, supfuncs, collations,
+ &left_lb, &left_ub, &right_lb, &right_ub,
+ &overlap);
+
+ if (overlap)
+ {
+ /* Overlapping ranges, try merging. */
+ partition_range_merge(partnatts, supfuncs, collations, jointype,
+ &left_lb, &left_ub, &right_lb, &right_ub,
+ &merged_lb, &merged_ub);
+ merged_index = map_and_merge_partitions(left_pmap, left_mmap,
+ left_part, right_pmap,
+ right_mmap, right_part,
+ &next_index);
+
+ if (merged_index < 0)
+ {
+ merged = false;
+ break;
+ }
+ }
+
+ if (cmpval == 0)
+ {
+ Assert(overlap);
+
+ /* Move to the next pair of partitions. */
+ left_lb_index = partition_range_get_next_lb_index(left_bi,
+ left_lb_index);
+ right_lb_index = partition_range_get_next_lb_index(right_bi,
+ right_lb_index);
+ }
+ else if (cmpval < 0)
+ {
+ /*
+ * If the partition on the left was not mapped to any partition on
+ * the right. Any row from that partition will not have a matching
+ * row from the other relation. So the partition will be part of
+ * the join if it's an anti-join or the left side is the outer
+ * side.
+ */
+ if (jointype == JOIN_INNER || jointype == JOIN_SEMI ||
+ jointype == JOIN_RIGHT)
+ {
+ /* Nothing to do. */
+ }
+ else if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (left_mmap[left_part] < 0)
+ {
+ left_mmap[left_part] = next_index++;
+ merged_index = left_mmap[left_part];
+ merged_lb = &left_lb;
+ merged_ub = &left_ub;
+ }
+ }
+ else
+ {
+ /* Don't know what to do with other join types. Bail out. */
+ merged = false;
+ }
+
+ /* Move to the next partition on the left side. */
+ left_lb_index = partition_range_get_next_lb_index(left_bi,
+ left_lb_index);
+ }
+ else
+ {
+ Assert(cmpval > 0);
+
+ /*
+ * If the partition on the right was not mapped to any partition on
+ * the left. Any row from that partition will not have a matching
+ * row from the other relation. So the partition will be part of
+ * the join if the right side is the outer side.
+ */
+ if (jointype == JOIN_INNER || jointype == JOIN_SEMI ||
+ jointype == JOIN_LEFT || jointype == JOIN_ANTI)
+ {
+ /* Nothing to do. */
+ }
+ else if (jointype == JOIN_RIGHT || jointype == JOIN_FULL)
+ {
+ if (right_mmap[right_part] < 0)
+ {
+ right_mmap[right_part] = next_index++;
+ merged_index = right_mmap[right_part];
+ merged_lb = &right_lb;
+ merged_ub = &right_ub;
+ }
+ }
+ else
+ {
+ /* Don't know what to do with other join types. Bail out. */
+ merged = false;
+ }
+
+ /* Move to the next partition on the right side. */
+ right_lb_index = partition_range_get_next_lb_index(right_bi,
+ right_lb_index);
+ }
+
+ if (!merged)
+ break;
+
+ /* A skipped partition is not added to merged bounds. */
+ if (merged_index < 0)
+ continue;
+
+ /*
+ * We have a valid partition index for the next partition of join. The
+ * partition should have valid range.
+ */
+ Assert(merged_lb && merged_ub);
+
+ /* Try merging merged lower bound with the last upper bound. */
+ merged = partition_range_merge_next_lb(partnatts, supfuncs,
+ collations, merged_lb->datums,
+ merged_lb->kind, &merged_datums,
+ &merged_kinds, &merged_indexes);
+ if (merged)
+ {
+ /* Add upper bound with the merged partition index. */
+ merged_datums = lappend(merged_datums, merged_ub->datums);
+ merged_kinds = lappend(merged_kinds, merged_ub->kind);
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ }
+ else
+ break;
+ }
+
+ /*
+ * We will run the above loop till we exhaust ranges of at least one side
+ * unless we failed to merge the ranges.
+ */
+ Assert (!merged || (left_lb_index >= left_bi->ndatums ||
+ right_lb_index >= right_bi->ndatums));
+
+ /*
+ * Handle any remaining partition bounds. If remaining partitions fall on
+ * the inner side of the join, none of the rows in those partition are
+ * going to be joined with any row on the outer side and hence those
+ * partitions will not be part of the join result. Hence only consider the
+ * remaining partitions on the outer side of the join.
+ */
+ if (merged &&
+ ((left_lb_index < left_bi->ndatums &&
+ (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)) ||
+ (right_lb_index < right_bi->ndatums &&
+ (jointype == JOIN_RIGHT || jointype == JOIN_FULL))))
+ {
+ int bound_index = -1;
+ PartitionBoundInfo rem_bi = NULL;
+ int *mmap = NULL;
+ int part_index;
+ PartitionRangeBound rem_lb;
+ PartitionRangeBound rem_ub;
+
+ if (left_lb_index < left_bi->ndatums)
+ {
+ Assert(jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI);
+ bound_index = left_lb_index;
+ rem_bi = left_bi;
+ mmap = left_mmap;
+ }
+ else if (right_lb_index < right_bi->ndatums)
+ {
+ Assert(jointype == JOIN_RIGHT || jointype == JOIN_FULL);
+ bound_index = right_lb_index;
+ rem_bi = right_bi;
+ mmap = right_mmap;
+ }
+ Assert((bound_index >= 0 && bound_index < rem_bi->ndatums) &&
+ rem_bi && mmap);
+
+ /*
+ * If the partition corresponding to this lower bound has been already
+ * mapped to a merged partition, don't need to add it again. This may
+ * happen if the range of the last partition on the inner side overlaps
+ * with this partition's range and has upper bound lesser than upper
+ * bound of this partition's range.
+ */
+ part_index = partition_get_range_bounds(rem_bi, bound_index, &rem_lb,
+ &rem_ub);
+ Assert(part_index >= 0);
+ if (mmap[part_index] >= 0)
+ bound_index = partition_range_get_next_lb_index(rem_bi, bound_index);
+
+ /*
+ * Merge lower bound of the next range with the upper bound of last
+ * range.
+ */
+ if (bound_index < rem_bi->ndatums)
+ merged = partition_range_merge_next_lb(partnatts, supfuncs,
+ collations,
+ rem_bi->datums[bound_index],
+ rem_bi->kind[bound_index],
+ &merged_datums,
+ &merged_kinds,
+ &merged_indexes);
+
+ /*
+ * Rest of the bounds correspond to valid ranges so add them after
+ * remapping their partitions as required.
+ */
+ for (bound_index++; merged && bound_index < rem_bi->ndatums;
+ bound_index++)
+ {
+ Datum *datums = rem_bi->datums[bound_index];
+ int index = rem_bi->indexes[bound_index];
+ int part_index;
+
+ /*
+ * Add lower bounds with partition index -1 and assign a new
+ * partition index to the upper bounds.
+ */
+ if (index < 0)
+ part_index = index;
+ else
+ {
+ if (mmap[index] < 0)
+ mmap[index] = next_index++;
+ part_index = mmap[index];
+ }
+
+ merged_indexes = lappend_int(merged_indexes, part_index);
+ merged_datums = lappend(merged_datums, datums);
+ merged_kinds = lappend(merged_kinds,
+ rem_bi->kind[bound_index]);
+ }
+ }
+
+ /* Create PartitionBoundInfo */
+ if (merged)
+ {
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(left_mmap, left_nparts, right_mmap,
+ right_nparts, jointype, next_index,
+ left_parts, right_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*left_parts && *right_parts)
+ {
+ Assert(list_length(*left_parts) == list_length(*right_parts));
+ Assert(list_length(*left_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(left_bi->strategy,
+ merged_datums,
+ merged_indexes,
+ merged_kinds,
+ -1);
+ }
+ }
+
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ pfree(left_pmap);
+ pfree(right_pmap);
+ pfree(left_mmap);
+ pfree(right_mmap);
+
+ /* Free any memory we used in this function. */
+ return merged_bounds;
+}
+
+/*
+ * partition_bounds_merge()'s arm for list partitioned tables.
+ *
+ * The function builds the maps of matching partitions from either relation. It
+ * builds the list of partition key values that may appear in the join result
+ * alongwith the list of indexes of partitions of join to which those values
+ * belong. It then crafts a PartitionBoundInfo structure representing the
+ * partition bounds of the join result.
+ */
+static PartitionBoundInfo
+partition_list_bounds_merge(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, PartitionBoundInfo left_bi,
+ int left_nparts, PartitionBoundInfo right_bi,
+ int right_nparts, JoinType jointype, List **left_parts,
+ List **right_parts)
+{
+ int *left_pmap; /* left to right partition map */
+ int *left_mmap; /* left to merged partition map */
+ int *right_pmap; /* right to left partition map */
+ int *right_mmap; /* right to merged partition map */
+ int cntl;
+ int cntr;
+ bool merged = true;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ int next_index = 0;
+ int null_index;
+ PartitionBoundInfo merged_bounds = NULL;
+ int *left_indexes = left_bi->indexes;
+ int *right_indexes = right_bi->indexes;
+ int left_ni = left_bi->null_index;
+ int right_ni = right_bi->null_index;
+
+ Assert(left_bi->strategy == right_bi->strategy &&
+ left_bi->strategy == PARTITION_STRATEGY_LIST);
+
+ /* List partitions do not require unbounded ranges. */
+ Assert(!left_bi->kind && !right_bi->kind);
+
+ /* Allocate and initialize partition maps. */
+ left_pmap = (int *) palloc(sizeof(int) * left_nparts);
+ left_mmap = (int *) palloc(sizeof(int) * left_nparts);
+ right_pmap = (int *) palloc(sizeof(int) * right_nparts);
+ right_mmap = (int *) palloc(sizeof(int) * right_nparts);
+
+ /* Initialize partition maps. */
+ for (cntl = 0; cntl < left_nparts; cntl++)
+ {
+ left_pmap[cntl] = -1;
+ left_mmap[cntl] = -1;
+ }
+ for (cntr = 0; cntr < right_nparts; cntr++)
+ {
+ right_pmap[cntr] = -1;
+ right_mmap[cntr] = -1;
+ }
+
+ cntl = cntr = 0;
+ while (cntl < left_bi->ndatums && cntr < right_bi->ndatums)
+ {
+ Datum *ldatums = left_bi->datums[cntl];
+ Datum *rdatums = right_bi->datums[cntr];
+ int l_index = left_indexes[cntl];
+ int r_index = right_indexes[cntr];
+ int cmpval;
+ int merged_index;
+ Datum *merged_datum;
+
+ /* Every list datum should map to a valid partition index. */
+ Assert(l_index >= 0 && r_index >= 0);
+
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
+ partcollation[0], ldatums[0],
+ rdatums[0]));
+ if (cmpval == 0)
+ {
+ /*
+ * Try matching partitions containing the matching datums. If
+ * successful, add the datum to the merged bounds with index of
+ * merged partition containing it.
+ */
+ merged_datum = ldatums;
+ merged_index = map_and_merge_partitions(left_pmap, left_mmap, l_index,
+ right_pmap, right_mmap, r_index,
+ &next_index);
+
+ if (merged_index < 0)
+ {
+ merged = false;
+ break;
+ }
+
+ /* Move to the next pair of bounds. */
+ cntl++;
+ cntr++;
+ }
+ else if (cmpval < 0)
+ {
+ /*
+ * This list datum is present in the left side but not the right
+ * side. So it will appear in the join when the left side is outer
+ * side.
+ */
+ if (jointype == JOIN_INNER || jointype == JOIN_RIGHT ||
+ jointype == JOIN_SEMI)
+ merged_index = -1;
+ else if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (left_mmap[l_index] < 0)
+ left_mmap[l_index] = next_index++;
+ merged_index = left_mmap[l_index];
+ merged_datum = ldatums;
+ }
+ else
+ {
+ /* Don't know what to do with other join types. */
+ merged = false;
+ break;
+ }
+
+ /* Move to the next datum on the left side. */
+ cntl++;
+ }
+ else
+ {
+ Assert(cmpval > 0);
+
+ /*
+ * This list datum is present in the right side but not the left
+ * side. So it will appear in the join when the right side is outer
+ * side.
+ */
+ if (jointype == JOIN_INNER || jointype == JOIN_LEFT ||
+ jointype == JOIN_SEMI || jointype == JOIN_ANTI)
+ merged_index = -1;
+ else if (jointype == JOIN_RIGHT || jointype == JOIN_FULL)
+ {
+ /*
+ * Every list value on the outer side will appear in the
+ * join. Find the merged partition to which this value
+ * belongs.
+ */
+ if (right_mmap[r_index] < 0)
+ right_mmap[r_index] = next_index++;
+ merged_index = right_mmap[r_index];
+ merged_datum = rdatums;
+ }
+ else
+ {
+ /* Don't know what to do with other join types. */
+ merged = false;
+ break;
+ }
+
+ /* Move to the next datum on the right side. */
+ cntr++;
+ }
+
+ /*
+ * Add the datum with appropriate index in the list of datums, if the
+ * rows containing that datum are deemed to be part of the join.
+ */
+ if (merged_index >= 0)
+ {
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ merged_datums = lappend(merged_datums, merged_datum);
+ }
+ }
+
+ /*
+ * If merge is unsuccessful, bail out without any further processing.
+ * That leaks the memory allocated in this function. So, try not to leak
+ * memory.
+ */
+ if (!merged)
+ goto merge_failed;
+
+ /* We should have exhausted datums on at least one side. */
+ Assert(cntr >= right_bi->ndatums || cntl >= left_bi->ndatums);
+
+ /*
+ * Add any remaining list values on the outer side, assigning partition
+ * indexes if required.
+ */
+ if (jointype == JOIN_LEFT || jointype == JOIN_FULL || jointype == JOIN_ANTI)
+ {
+ for (;cntl < left_bi->ndatums; cntl++)
+ {
+ Datum *ldatums = left_bi->datums[cntl];
+ int l_index = left_indexes[cntl];
+
+ if (left_mmap[l_index] < 0)
+ left_mmap[l_index] = next_index++;
+ merged_indexes = lappend_int(merged_indexes, left_mmap[l_index]);
+ merged_datums = lappend(merged_datums, ldatums);
+ }
+ }
+
+ if (jointype == JOIN_RIGHT || jointype == JOIN_FULL)
+ {
+ for (;cntr < right_bi->ndatums; cntr++)
+ {
+ Datum *rdatums = right_bi->datums[cntr];
+ int r_index = right_indexes[cntr];
+
+ if (right_mmap[r_index] < 0)
+ right_mmap[r_index] = next_index++;
+ merged_indexes = lappend_int(merged_indexes, right_mmap[r_index]);
+ merged_datums = lappend(merged_datums, rdatums);
+ }
+ }
+
+ /*
+ * Merge NULL partitions if any. Find the index of merged partition to
+ * which the NULL values belong in the join result. We can eliminate a NULL
+ * partition when it appears only in the inner relation.
+ */
+ if (!partition_bound_accepts_nulls(left_bi) &&
+ !partition_bound_accepts_nulls(right_bi))
+ null_index = -1;
+ else if (partition_bound_accepts_nulls(left_bi) &&
+ !partition_bound_accepts_nulls(right_bi))
+ {
+ if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (left_mmap[left_ni] < 0)
+ left_mmap[left_ni] = next_index++;
+ null_index = left_mmap[left_ni];
+ }
+ else
+ null_index = -1;
+ }
+ else if (!partition_bound_accepts_nulls(left_bi) &&
+ partition_bound_accepts_nulls(right_bi))
+ {
+ if (jointype == JOIN_RIGHT || jointype == JOIN_FULL)
+ {
+ if (right_mmap[right_ni] < 0)
+ right_mmap[right_ni] = next_index++;
+ null_index = right_mmap[right_ni];
+ }
+ else
+ null_index = -1;
+ }
+ else
+ {
+ /* Both the relations have NULL partitions, try merging them. */
+ null_index = map_and_merge_partitions(left_pmap, left_mmap,
+ left_ni, right_pmap,
+ right_mmap, right_ni,
+ &next_index);
+ if (null_index < 0)
+ merged = false;
+ }
+
+ /* If successful build the output structures. */
+ if (merged)
+ {
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(left_mmap, left_nparts, right_mmap,
+ right_nparts, jointype, next_index,
+ left_parts, right_parts);
+ /* Craft a PartitionBoundInfo to return. */
+ if (*left_parts && *right_parts)
+ {
+ Assert(list_length(*left_parts) == list_length(*right_parts));
+ Assert(list_length(*left_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(left_bi->strategy,
+ merged_datums,
+ merged_indexes, NIL,
+ null_index);
+ }
+ }
+
+merge_failed:
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ pfree(left_pmap);
+ pfree(right_pmap);
+ pfree(left_mmap);
+ pfree(right_mmap);
+
+ return merged_bounds;
+}
+
+/*
+ * map_and_merge_partitions
+ *
+ * If the two given partitions (given by index1 and index2 resp.) are already
+ * mapped to each other return the index of corresponding partition in the
+ * merged set of partitions. If they do not have a merged partition associated
+ * with them, assign a new merged partition index. If the partitions are
+ * already mapped and their mapped partitions are different from each other,
+ * they can not be merged, so return -1.
+ *
+ * partmap1[i] gives the partition of relation 2 which matches ith partition of
+ * relation 1. Similarly for partmap2.
+ *
+ * mergemap1[i] gives the partition in the merged set to which ith partition of
+ * relation 1 maps to. Similarly for mergemap2.
+ *
+ * index1 and index2 are the indexes of matching partition from respective
+ * relations.
+ *
+ * *next_index is used and incremented when the given partitions require a new
+ * merged partition.
+ */
+static int
+map_and_merge_partitions(int *partmap1, int *mergemap1, int index1,
+ int *partmap2, int *mergemap2, int index2,
+ int *next_index)
+{
+ int merged_index;
+
+ /*
+ * If both the partitions are not mapped to each other, update the
+ * maps.
+ */
+ if (partmap1[index1] < 0 && partmap2[index2] < 0)
+ {
+ partmap1[index1] = index2;
+ partmap2[index2] = index1;
+ }
+
+ /*
+ * If the given to partitions map to each other, find the corresponding
+ * merged partition index .
+ */
+ if (partmap1[index1] == index2 && partmap2[index2] == index1)
+ {
+ /*
+ * If both the partitions are mapped to the same merged partition, get
+ * the index of merged partition.
+ */
+ if (mergemap1[index1] == mergemap2[index2])
+ {
+ merged_index = mergemap1[index1];
+
+ /*
+ * If the given two partitions do not have a merged partition
+ * associated with them, allocate a new merged partition.
+ */
+ if (merged_index < 0)
+ {
+ merged_index = *next_index;
+ *next_index = *next_index + 1;
+ mergemap1[index1] = merged_index;
+ mergemap2[index2] = merged_index;
+ }
+ }
+
+ /*
+ * If partition from one relation was mapped to a merged partition but
+ * not the partition from the other relation, map the same merged
+ * partition to the partition from other relation, since matching
+ * partitions map to the same merged partition.
+ */
+ else if (mergemap1[index1] >= 0 && mergemap2[index2] < 0)
+ {
+ mergemap2[index2] = mergemap1[index1];
+ merged_index = mergemap1[index1];
+ }
+ else if (mergemap1[index1] < 0 && mergemap2[index2] >= 0)
+ {
+ mergemap1[index1] = mergemap2[index2];
+ merged_index = mergemap2[index2];
+ }
+ else
+ {
+ Assert(mergemap1[index1] != mergemap2[index2] &&
+ mergemap1[index1] >= 0 && mergemap2[index2] >= 0);
+
+ /*
+ * Both the partitions map to different merged partitions. This
+ * means that multiple partitions from one relation matches to one
+ * partition from the other relation. Partition-wise join does not
+ * handle this case right now, since it requires ganging multiple
+ * partitions together (into one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+ }
+ else
+ {
+ /*
+ * Multiple partitions from one relation map to one partition from the
+ * other relation. Partition-wise join does not handle this case right
+ * now, since it requires ganging multiple partitions together (into
+ * one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+
+ return merged_index;
+}
+
+/*
+ * generate_matching_part_pairs
+ *
+ * Given the merged partition to which partition on either side of join map,
+ * produce the list pairs of partitions which when joined produce the merged
+ * partitions in the order of merged partition indexes.
+ *
+ * If successful, the pairs of partitions are returned as two separate lists
+ * one for each side. Otherwise, those lists will be set to NIL.
+ *
+ * TODO: rename the sides as outer and inner. You may not need to support
+ * JOIN_RIGHT, since we won't see that type here.
+ */
+static void
+generate_matching_part_pairs(int *mergemap1, int nparts1, int *mergemap2,
+ int nparts2, JoinType jointype, int nparts,
+ List **parts1, List **parts2)
+{
+ bool merged = true;
+ int **matching_parts;
+ int cnt1;
+ int cnt2;
+
+ matching_parts = (int **) palloc(sizeof(int *) * 2);
+ matching_parts[0] = (int *) palloc(sizeof(int) * nparts);
+ matching_parts[1] = (int *) palloc(sizeof(int) * nparts);
+
+ *parts1 = NIL;
+ *parts2 = NIL;
+
+ for (cnt1 = 0; cnt1 < nparts; cnt1++)
+ {
+ matching_parts[0][cnt1] = -1;
+ matching_parts[1][cnt1] = -1;
+ }
+
+ /* Set pairs of matching partitions. */
+ for (cnt1 = 0; cnt1 < nparts1; cnt1++)
+ {
+ if (mergemap1[cnt1] >= 0)
+ {
+ Assert(mergemap1[cnt1] < nparts);
+ matching_parts[0][mergemap1[cnt1]] = cnt1;
+ }
+ }
+ for (cnt2 = 0; cnt2 < nparts2; cnt2++)
+ {
+ if (mergemap2[cnt2] >= 0)
+ {
+ Assert(mergemap2[cnt2] < nparts);
+ matching_parts[1][mergemap2[cnt2]] = cnt2;
+ }
+ }
+
+ /*
+ * If we have a partition missing on an inner side, we need to add a dummy
+ * relation which joins with the outer partition. If the inner relation
+ * happens to be a base relation, it will require adding a dummy child
+ * base relation during join processing. Right now, we freeze the base
+ * relation arrays like PlannerInfo::simple_rte_array after planning for
+ * base relations. Adding a new (dummy) base relation would require some
+ * changes to that. So, right now, we do not implement partition-wise join
+ * in such cases.
+ */
+ for (cnt1 = 0; cnt1 < nparts; cnt1++)
+ {
+ int part1 = matching_parts[0][cnt1];
+ int part2 = matching_parts[1][cnt1];
+
+ /* At least one of the partitions should exist. */
+ Assert(part1 >= 0 || part2 >= 0);
+
+ switch (jointype)
+ {
+ case JOIN_INNER:
+ case JOIN_SEMI:
+
+ /*
+ * An inner or semi join can not return any row when the
+ * matching partition on either side is missing. We should
+ * have eliminated all such cases while merging the bounds.
+ */
+ Assert(part1 >= 0 && part2 >= 0);
+ break;
+
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ Assert(part1 >= 0);
+ if (part2 < 0)
+ merged = false;
+ break;
+
+ case JOIN_RIGHT:
+ Assert(part2 >= 0);
+ if (part1 < 0)
+ merged = false;
+ break;
+
+ case JOIN_FULL:
+ if (part1 < 0 || part2 < 0)
+ merged = false;
+ break;
+
+ default:
+ /* We do not know what to do in this case. Bail out. */
+ merged = false;
+ }
+
+ if (!merged)
+ break;
+
+ *parts1 = lappend_int(*parts1, part1);
+ *parts2 = lappend_int(*parts2, part2);
+ }
+
+ pfree(matching_parts[0]);
+ pfree(matching_parts[1]);
+ pfree(matching_parts);
+
+ if (!merged)
+ {
+ list_free(*parts1);
+ list_free(*parts2);
+ *parts1 = NIL;
+ *parts2 = NIL;
+ }
+}
+
+static PartitionBoundInfo
+build_merged_partition_bounds(char strategy, List *merged_datums,
+ List *merged_indexes, List *merged_kinds,
+ int null_index)
+{
+ int cnt;
+ PartitionBoundInfo merged_bounds;
+ ListCell *lc;
+
+ /* We expect the same number of elements in datums and indexes lists. */
+ Assert(list_length(merged_datums) == list_length(merged_indexes));
+
+ merged_bounds = (PartitionBoundInfo) palloc(sizeof(PartitionBoundInfoData));
+ merged_bounds->strategy = strategy;
+ merged_bounds->ndatums = list_length(merged_datums);
+
+ if (strategy == PARTITION_STRATEGY_RANGE)
+ {
+ Assert(list_length(merged_datums) == list_length(merged_kinds));
+ merged_bounds->kind = (PartitionRangeDatumKind **) palloc(sizeof(PartitionRangeDatumKind *) *
+ list_length(merged_kinds));
+ cnt = 0;
+ foreach(lc, merged_kinds)
+ merged_bounds->kind[cnt++] = lfirst(lc);
+
+ /* There are ndatums+1 indexes in case of range partitions */
+ merged_indexes = lappend_int(merged_indexes, -1);
+ }
+ else
+ merged_bounds->kind = NULL;
+
+ cnt = 0;
+ merged_bounds->datums = (Datum **) palloc(sizeof(Datum *) *
+ list_length(merged_datums));
+ foreach(lc, merged_datums)
+ merged_bounds->datums[cnt++] = lfirst(lc);
+
+ merged_bounds->indexes = (int *) palloc(sizeof(int) *
+ list_length(merged_indexes));
+ cnt = 0;
+ foreach(lc, merged_indexes)
+ merged_bounds->indexes[cnt++] = lfirst_int(lc);
+
+ merged_bounds->null_index = null_index;
+
+ /* TODO: For the time being we do not work with default partitions. */
+ merged_bounds->default_index = -1;
+
+ return merged_bounds;
+}
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 1578dea..91b976b 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1309,8 +1309,13 @@ try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
RelOptInfo *joinrel, SpecialJoinInfo *parent_sjinfo,
List *parent_restrictlist)
{
- int nparts;
int cnt_parts;
+ PartitionScheme part_scheme;
+ PartitionBoundInfo join_boundinfo;
+ List *parts1;
+ List *parts2;
+ ListCell *lc1;
+ ListCell *lc2;
/* Guard against stack overflow due to overly deep partition hierarchy. */
check_stack_depth();
@@ -1349,32 +1354,49 @@ try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
*/
Assert(joinrel->part_scheme == rel1->part_scheme &&
joinrel->part_scheme == rel2->part_scheme);
+ part_scheme = joinrel->part_scheme;
/*
- * Since we allow partition-wise 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.
+ * Get the list of matching partitions from both sides of the join. While
+ * doing so, we also build the partition bounds of the join relation,
+ * which should match the bounds calculated for other pairs. TODO: why
+ * should every pair result in the same partition bounds?
*/
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel1->boundinfo));
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel2->boundinfo));
+ join_boundinfo = partition_bounds_merge(part_scheme->partnatts,
+ part_scheme->partsupfunc,
+ part_scheme->parttypcoll,
+ rel1->boundinfo, rel1->nparts,
+ rel2->boundinfo, rel2->nparts,
+ parent_sjinfo->jointype,
+ &parts1, &parts2);
+
+ Assert(join_boundinfo);
+ Assert(partition_bounds_equal(part_scheme->partnatts,
+ part_scheme->parttyplen,
+ part_scheme->parttypbyval, join_boundinfo,
+ joinrel->boundinfo));
+ elog(DEBUG3, "join between relations %s and %s is considered for partition-wise join.",
+ bmsToString(rel1->relids), bmsToString(rel2->relids));
- nparts = joinrel->nparts;
+ /*
+ * Every pair of joining relations should result in the same number of
+ * child-joins.
+ */
+ Assert(joinrel->nparts == list_length(parts1));
+ Assert(joinrel->nparts == list_length(parts2));
/*
* Create child-join relations for this partitioned join, if those don't
* exist. Add paths to child-joins for a pair of child relations
* corresponding to the given pair of parent relations.
*/
- for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+ cnt_parts = 0;
+ forboth(lc1, parts1, lc2, parts2)
{
- RelOptInfo *child_rel1 = rel1->part_rels[cnt_parts];
- RelOptInfo *child_rel2 = rel2->part_rels[cnt_parts];
+ int part1 = lfirst_int(lc1);
+ int part2 = lfirst_int(lc2);
+ RelOptInfo *child_rel1;
+ RelOptInfo *child_rel2;
SpecialJoinInfo *child_sjinfo;
List *child_restrictlist;
RelOptInfo *child_joinrel;
@@ -1382,6 +1404,10 @@ try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
AppendRelInfo **appinfos;
int nappinfos;
+ Assert(part1 >= 0 && part2 >= 0);
+ child_rel1 = rel1->part_rels[part1];
+ child_rel2 = rel2->part_rels[part2];
+
/* We should never try to join two overlapping sets of rels. */
Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1415,12 +1441,24 @@ try_partition_wise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
joinrel->part_rels[cnt_parts] = child_joinrel;
}
+ /*
+ * For every pair of joining relations, the set of matching partitions
+ * would change. However, the base relation partitions constituting
+ * the given child should remain same for all the joining pairs. Since
+ * the order in which children are stored in the array of child-joins,
+ * depends upon partition bounds of the join, which are same for all
+ * the joining pairs, every joining pair yields the child-joins in the
+ * same order.
+ */
Assert(bms_equal(child_joinrel->relids, child_joinrelids));
populate_joinrel_with_paths(root, child_rel1, child_rel2,
child_joinrel, child_sjinfo,
child_restrictlist);
+ cnt_parts++;
}
+
+ Assert(cnt_parts == joinrel->nparts);
}
/*
diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 9d35a41..9d3df33 100644
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -1918,6 +1918,11 @@ find_partition_scheme(PlannerInfo *root, Relation relation)
memcpy(part_scheme->parttypbyval, partkey->parttypbyval,
sizeof(bool) * partnatts);
+ part_scheme->partsupfunc =
+ (FmgrInfo *) palloc(sizeof(FmgrInfo) * partnatts);
+ memcpy(part_scheme->partsupfunc, partkey->partsupfunc,
+ sizeof(FmgrInfo) * partnatts);
+
/* Add the partitioning scheme to PlannerInfo. */
root->part_schemes = lappend(root->part_schemes, part_scheme);
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 21fd29f..827ef76 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1601,6 +1601,9 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
int partnatts;
int cnt;
PartitionScheme part_scheme;
+ PartitionBoundInfo join_boundinfo;
+ List *parts1;
+ List *parts2;
/* Nothing to do if partition-wise join technique is disabled. */
if (!enable_partition_wise_join)
@@ -1634,17 +1637,26 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
REL_HAS_ALL_PART_PROPS(inner_rel));
/*
- * For now, our partition matching algorithm can match partitions only
- * when the partition bounds of the joining relations are exactly same.
- * So, bail out otherwise.
+ * Every pair of joining relations would yield the same partition bounds
+ * for a given join (TODO: why?) so we compute the bounds only the first
+ * time. Then for every pair we find the pairs of matching partitions from
+ * the joining relations and join those. TODO: Needs a better explanation
+ * of why is this true. TODO: Also there is no reason to have
+ * part_indexes1 and part_indexes2 pulled here just to be freed up later.
+ * So, we might want to do something better.
*/
- if (outer_rel->nparts != inner_rel->nparts ||
- !partition_bounds_equal(part_scheme->partnatts,
- part_scheme->parttyplen,
- part_scheme->parttypbyval,
- outer_rel->boundinfo, inner_rel->boundinfo))
+ join_boundinfo = partition_bounds_merge(part_scheme->partnatts,
+ part_scheme->partsupfunc,
+ part_scheme->parttypcoll,
+ outer_rel->boundinfo,
+ outer_rel->nparts,
+ inner_rel->boundinfo,
+ inner_rel->nparts,
+ jointype, &parts1, &parts2);
+ if (!join_boundinfo)
{
Assert(!IS_PARTITIONED_REL(joinrel));
+ Assert(!parts1 && !parts2);
return;
}
@@ -1657,13 +1669,16 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
!joinrel->nullable_partexprs && !joinrel->part_rels &&
!joinrel->boundinfo);
+ Assert(list_length(parts1) == list_length(parts2));
+
/*
* Join relation is partitioned using the same partitioning scheme as the
- * joining relations and has same bounds.
+ * joining relations and has same bounds. It will have as many partitions
+ * as the pairs of matching partitions we found.
*/
joinrel->part_scheme = part_scheme;
- joinrel->boundinfo = outer_rel->boundinfo;
- joinrel->nparts = outer_rel->nparts;
+ joinrel->nparts = list_length(parts1);
+ joinrel->boundinfo = join_boundinfo;
partnatts = joinrel->part_scheme->partnatts;
joinrel->partexprs = (List **) palloc0(sizeof(List *) * partnatts);
joinrel->nullable_partexprs =
@@ -1751,4 +1766,8 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
joinrel->part_rels =
(RelOptInfo **) palloc0(sizeof(RelOptInfo *) * joinrel->nparts);
+ /* TODO: OR we could actually create the child-join relations here.*/
+ list_free(parts1);
+ list_free(parts2);
+
}
diff --git a/src/include/catalog/partition.h b/src/include/catalog/partition.h
index 945ac02..58d62f1 100644
--- a/src/include/catalog/partition.h
+++ b/src/include/catalog/partition.h
@@ -107,5 +107,10 @@ extern void update_default_partition_oid(Oid parentId, Oid defaultPartId);
extern void check_default_allows_bound(Relation parent, Relation defaultRel,
PartitionBoundSpec *new_spec);
extern List *get_proposed_default_constraint(List *new_part_constaints);
+extern PartitionBoundInfo partition_bounds_merge(int partnatts,
+ FmgrInfo *supfuncs, Oid *collations,
+ PartitionBoundInfo boundinfo1, int nparts1,
+ PartitionBoundInfo boundinfo2, int nparts2,
+ JoinType jointype, List **parts1, List **parts2);
#endif /* PARTITION_H */
diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index e085cef..5d6e5f8 100644
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -15,6 +15,7 @@
#define RELATION_H
#include "access/sdir.h"
+#include "fmgr.h"
#include "lib/stringinfo.h"
#include "nodes/params.h"
#include "nodes/parsenodes.h"
@@ -354,6 +355,7 @@ typedef struct PartitionSchemeData
/* Cached information about partition key data types. */
int16 *parttyplen;
bool *parttypbyval;
+ FmgrInfo *partsupfunc;
} PartitionSchemeData;
typedef struct PartitionSchemeData *PartitionScheme;
--
1.7.9.5
[text/x-patch] 0004-Tests-for-0-1-1-1-and-1-0-partition-matching.patch (209.7K, ../../CAFjFpRfiK9jaf01O-umKRoKeAP1wuNK8D8yi9ZxSkjKKAL7tvQ@mail.gmail.com/4-0004-Tests-for-0-1-1-1-and-1-0-partition-matching.patch)
download | inline diff:
From 5a450f85c3ddbc953d95188f90115d3c82b91e70 Mon Sep 17 00:00:00 2001
From: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
Date: Tue, 5 Sep 2017 09:51:41 +0530
Subject: [PATCH 4/4] Tests for 0:1, 1:1 and 1:0 partition matching
Rajkumar Raghuvanshi and Ashutosh Bapat.
---
src/test/regress/expected/partition_join.out | 3891 ++++++++++++++++++++++----
src/test/regress/sql/partition_join.sql | 367 ++-
2 files changed, 3628 insertions(+), 630 deletions(-)
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index 234b8b5..bc8aa5b 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -8,105 +8,152 @@ SET enable_partition_wise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(21 rows)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
-(4 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+(7 rows)
-- left outer join, with whole-row reference
EXPLAIN (COSTS OFF)
SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b
-> Result
-> Append
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(22 rows)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(33 rows)
SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- t1 | t2
---------------+--------------
- (0,0,0000) | (0,0,0000)
- (50,0,0050) |
- (100,0,0100) |
- (150,0,0150) | (0,150,0150)
- (200,0,0200) |
- (250,0,0250) |
- (300,0,0300) | (0,300,0300)
- (350,0,0350) |
- (400,0,0400) |
- (450,0,0450) | (0,450,0450)
- (500,0,0500) |
- (550,0,0550) |
-(12 rows)
+ t1 | t2
+----------------+----------------
+ (-250,0,-0250) |
+ (-200,0,-0200) |
+ (-150,0,-0150) | (0,-150,-0150)
+ (-100,0,-0100) |
+ (-50,0,-0050) |
+ (0,0,0000) | (0,0,0000)
+ (50,0,0050) |
+ (100,0,0100) |
+ (150,0,0150) | (0,150,0150)
+ (200,0,0200) |
+ (250,0,0250) |
+ (300,0,0300) | (0,300,0300)
+ (350,0,0350) |
+ (400,0,0400) |
+ (450,0,0450) | (0,450,0450)
+ (500,0,0500) |
+ (550,0,0550) |
+ (600,0,0600) | (0,600,0600)
+ (650,0,0650) |
+ (700,0,0700) |
+ (750,0,0750) | (0,750,0750)
+(21 rows)
-- right outer join
EXPLAIN (COSTS OFF)
@@ -119,35 +166,53 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHE
-> Append
-> Hash Right Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Right Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Hash Right Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-> Nested Loop Left Join
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p3 t2_3
Filter: (a = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t2_2.b)
-(21 rows)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(33 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
- | | 75 | 0075
- | | 225 | 0225
- | | 375 | 0375
- | | 525 | 0525
-(8 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+ | | -225 | -0225
+ | | -75 | -0075
+ | | 75 | 0075
+ | | 225 | 0225
+ | | 375 | 0375
+ | | 525 | 0525
+ | | 675 | 0675
+(14 rows)
-- full outer join, with placeholder vars
EXPLAIN (COSTS OFF)
@@ -155,9 +220,17 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
QUERY PLAN
------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b
+ Sort Key: prt1_p0.a, prt2_p0.b
-> Append
-> Hash Full Join
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ Filter: (((50) = prt1_p0.a) OR ((75) = prt2_p0.b))
+ -> Seq Scan on prt1_p0
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0
+ Filter: (a = 0)
+ -> Hash Full Join
Hash Cond: (prt1_p1.a = prt2_p1.b)
Filter: (((50) = prt1_p1.a) OR ((75) = prt2_p1.b))
-> Seq Scan on prt1_p1
@@ -181,7 +254,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
-> Hash
-> Seq Scan on prt2_p3
Filter: (a = 0)
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ Filter: (((50) = prt1_p4.a) OR ((75) = prt2_p4.b))
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) WHERE t1.phv = t1.a OR t2.phv = t2.b ORDER BY t1.a, t2.b;
a | c | b | c
@@ -218,9 +299,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
-> Hash Left Join
+ Hash Cond: (prt1_p0.a = b)
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Hash
+ -> Result
+ One-Time Filter: false
+ -> Hash Left Join
Hash Cond: (prt1_p1.a = b)
-> Seq Scan on prt1_p1
Filter: ((a < 450) AND (b = 0))
@@ -234,30 +322,43 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
-> Hash
-> Seq Scan on prt1_p2
Filter: ((a < 450) AND (b = 0))
-(17 rows)
+(24 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
-(9 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+(14 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
QUERY PLAN
------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
-> Hash Full Join
+ Hash Cond: (prt1_p0.a = b)
+ Filter: ((prt1_p0.b = 0) OR (a = 0))
+ -> Seq Scan on prt1_p0
+ Filter: (a < 450)
+ -> Hash
+ -> Result
+ One-Time Filter: false
+ -> Hash Full Join
Hash Cond: (prt1_p1.a = b)
Filter: ((prt1_p1.b = 0) OR (a = 0))
-> Seq Scan on prt1_p1
@@ -281,64 +382,153 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JO
-> Hash
-> Result
One-Time Filter: false
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt2_p4.b = a)
+ Filter: ((b = 0) OR (prt2_p4.a = 0))
+ -> Seq Scan on prt2_p4
+ Filter: (b > 250)
+ -> Hash
+ -> Result
+ One-Time Filter: false
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
- | | 375 | 0375
- | | 450 | 0450
- | | 525 | 0525
-(12 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ | | 375 | 0375
+ | | 450 | 0450
+ | | 525 | 0525
+ | | 600 | 0600
+ | | 675 | 0675
+ | | 750 | 0750
+(20 rows)
-- Semi-join
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Semi Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Semi Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Nested Loop Semi Join
- Join Filter: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Materialize
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-(24 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(39 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p0 t2
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_2.b = t2_2.a)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p2 t2_2
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: (t1_3.b = t2_3.a)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt1_p3 t2_3
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.b = t2_4.a)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p4 t2_4
+ Filter: (b = 0)
+(37 rows)
+
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
@@ -349,27 +539,82 @@ SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS
-> Append
-> Hash Anti Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash Anti Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash Anti Join
Hash Cond: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p3 t2_2
-(17 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash Anti Join
+ Hash Cond: (t1_3.a = t2_3.b)
+ -> Seq Scan on prt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_3
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(27 rows)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
- sum | avg | sum | avg
--------+----------------------+------+---------------------
- 60000 | 300.0000000000000000 | 2400 | 12.0000000000000000
+ sum | avg | sum | avg
+-------+----------------------+------+--------------------
+ 95550 | 273.0000000000000000 | 2200 | 6.2857142857142857
(1 row)
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ QUERY PLAN
+--------------------------------------------------------------
+ Append
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Hash Anti Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(27 rows)
+
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ b | c
+------+-------
+ -225 | -0225
+ -75 | -0075
+ 75 | 0075
+ 225 | 0225
+ 375 | 0375
+ 525 | 0525
+ 675 | 0675
+(7 rows)
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -382,49 +627,74 @@ SELECT * FROM prt1 t1 LEFT JOIN LATERAL
-> Result
-> Append
-> Nested Loop Left Join
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p1_a on prt1_p1 t2
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
Index Cond: (a = t1.a)
- -> Index Scan using iprt2_p1_b on prt2_p1 t3
+ -> Index Scan using iprt2_p0_b on prt2_p0 t3
Index Cond: (b = t2.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_1
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
Index Cond: (a = t1_1.a)
- -> Index Scan using iprt2_p2_b on prt2_p2 t3_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t3_1
Index Cond: (b = t2_1.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_2
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
Index Cond: (a = t1_2.a)
- -> Index Scan using iprt2_p3_b on prt2_p3 t3_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t3_2
Index Cond: (b = t2_2.a)
-(28 rows)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.a)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t3_3
+ Index Cond: (b = t2_3.a)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.a)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t3_4
+ Index Cond: (b = t2_4.a)
+(44 rows)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, least(t1.a,t2.a,t3.b) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.a = ss.t2a WHERE t1.b = 0 ORDER BY t1.a;
- a | b | c | t2a | t3a | least
------+---+------+-----+-----+-------
- 0 | 0 | 0000 | 0 | 0 | 0
- 50 | 0 | 0050 | | |
- 100 | 0 | 0100 | | |
- 150 | 0 | 0150 | 150 | 0 | 150
- 200 | 0 | 0200 | | |
- 250 | 0 | 0250 | | |
- 300 | 0 | 0300 | 300 | 0 | 300
- 350 | 0 | 0350 | | |
- 400 | 0 | 0400 | | |
- 450 | 0 | 0450 | 450 | 0 | 450
- 500 | 0 | 0500 | | |
- 550 | 0 | 0550 | | |
-(12 rows)
+ a | b | c | t2a | t3a | least
+------+---+-------+------+-----+-------
+ -250 | 0 | -0250 | | |
+ -200 | 0 | -0200 | | |
+ -150 | 0 | -0150 | -150 | 0 | -150
+ -100 | 0 | -0100 | | |
+ -50 | 0 | -0050 | | |
+ 0 | 0 | 0000 | 0 | 0 | 0
+ 50 | 0 | 0050 | | |
+ 100 | 0 | 0100 | | |
+ 150 | 0 | 0150 | 150 | 0 | 150
+ 200 | 0 | 0200 | | |
+ 250 | 0 | 0250 | | |
+ 300 | 0 | 0300 | 300 | 0 | 300
+ 350 | 0 | 0350 | | |
+ 400 | 0 | 0400 | | |
+ 450 | 0 | 0450 | 450 | 0 | 450
+ 500 | 0 | 0500 | | |
+ 550 | 0 | 0550 | | |
+ 600 | 0 | 0600 | 600 | 0 | 600
+ 650 | 0 | 0650 | | |
+ 700 | 0 | 0700 | | |
+ 750 | 0 | 0750 | 750 | 0 | 750
+(21 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
@@ -438,64 +708,95 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
Hash Cond: ((t1.c)::text = (t2.c)::text)
Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Hash Join
Hash Cond: (t2.a = t3.b)
- -> Seq Scan on prt1_p1 t2
+ -> Seq Scan on prt1_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t3
+ -> Seq Scan on prt2_p0 t3
-> Hash Join
Hash Cond: (t2_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t2_1
+ -> Seq Scan on prt1_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p1 t3_1
-> Hash Join
Hash Cond: (t2_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p2 t2_2
-> Hash
- -> Seq Scan on prt2_p3 t3_2
-(26 rows)
+ -> Seq Scan on prt2_p2 t3_2
+ -> Hash Join
+ Hash Cond: (t2_3.a = t3_3.b)
+ -> Seq Scan on prt1_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t3_3
+ -> Hash Join
+ Hash Cond: (t2_4.a = t3_4.b)
+ -> Seq Scan on prt1_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t3_4
+(38 rows)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, t2.b t2b, t2.c t2c, least(t1.a,t2.a,t3.a) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.c = ss.t2c WHERE (t1.b + coalesce(ss.t2b, 0)) = 0 ORDER BY t1.a;
- a | t2a | t2c
------+-----+------
- 0 | 0 | 0000
- 50 | |
- 100 | |
- 150 | 150 | 0150
- 200 | |
- 250 | |
- 300 | 300 | 0300
- 350 | |
- 400 | |
- 450 | 450 | 0450
- 500 | |
- 550 | |
-(12 rows)
+ a | t2a | t2c
+------+------+-------
+ -250 | |
+ -200 | |
+ -150 | -150 | -0150
+ -100 | |
+ -50 | |
+ 0 | 0 | 0000
+ 50 | |
+ 100 | |
+ 150 | 150 | 0150
+ 200 | |
+ 250 | |
+ 300 | 300 | 0300
+ 350 | |
+ 400 | |
+ 450 | 450 | 0450
+ 500 | |
+ 550 | |
+ 600 | 600 | 0600
+ 650 | |
+ 700 | |
+ 750 | 750 | 0750
+(21 rows)
--
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
@@ -506,32 +807,49 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 =
-> Append
-> Hash Join
Hash Cond: (((t2.b + t2.a) / 2) = ((t1.a + t1.b) / 2))
- -> Seq Scan on prt2_e_p1 t2
+ -> Seq Scan on prt2_e_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_e_p0 t1
+ Filter: (c = 0)
+ -> Hash Join
+ Hash Cond: (((t1_1.a + t1_1.b) / 2) = ((t2_1.b + t2_1.a) / 2))
+ -> Seq Scan on prt1_e_p1 t1_1
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_e_p1 t2_1
+ -> Hash Join
+ Hash Cond: (((t2_2.b + t2_2.a) / 2) = ((t1_2.a + t1_2.b) / 2))
+ -> Seq Scan on prt2_e_p2 t2_2
-> Hash
- -> Seq Scan on prt1_e_p1 t1
+ -> Seq Scan on prt1_e_p2 t1_2
Filter: (c = 0)
-> Hash Join
- Hash Cond: (((t2_1.b + t2_1.a) / 2) = ((t1_1.a + t1_1.b) / 2))
- -> Seq Scan on prt2_e_p2 t2_1
+ Hash Cond: (((t2_3.b + t2_3.a) / 2) = ((t1_3.a + t1_3.b) / 2))
+ -> Seq Scan on prt2_e_p3 t2_3
-> Hash
- -> Seq Scan on prt1_e_p2 t1_1
+ -> Seq Scan on prt1_e_p3 t1_3
Filter: (c = 0)
-> Hash Join
- Hash Cond: (((t2_2.b + t2_2.a) / 2) = ((t1_2.a + t1_2.b) / 2))
- -> Seq Scan on prt2_e_p3 t2_2
+ Hash Cond: (((t2_4.b + t2_4.a) / 2) = ((t1_4.a + t1_4.b) / 2))
+ -> Seq Scan on prt2_e_p4 t2_4
-> Hash
- -> Seq Scan on prt1_e_p3 t1_2
+ -> Seq Scan on prt1_e_p4 t1_4
Filter: (c = 0)
-(21 rows)
+(33 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 150 | 0 | 150 | 0
- 300 | 0 | 300 | 0
- 450 | 0 | 450 | 0
-(4 rows)
+ a | c | b | c
+------+---+------+---
+ -250 | 0 | -250 | 0
+ -100 | 0 | -100 | 0
+ 0 | 0 | 0 | 0
+ 0 | 0 | 0 | 0
+ 150 | 0 | 150 | 0
+ 300 | 0 | 300 | 0
+ 450 | 0 | 450 | 0
+ 600 | 0 | 600 | 0
+ 750 | 0 | 750 | 0
+(9 rows)
--
-- N-way join
@@ -545,107 +863,158 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t
-> Result
-> Append
-> Nested Loop
- Join Filter: (t1.a = ((t3.a + t3.b) / 2))
+ Join Filter: (t1.a = t2.b)
-> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p1_ab2 on prt1_e_p1 t3
- Index Cond: (((a + b) / 2) = t2.b)
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
+ Index Cond: (b = ((t3.a + t3.b) / 2))
-> Nested Loop
Join Filter: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_1
+ -> Index Scan using iprt1_e_p4_ab2 on prt1_e_p1 t3_1
Index Cond: (((a + b) / 2) = t2_1.b)
-> Nested Loop
Join Filter: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_2
Index Cond: (((a + b) / 2) = t2_2.b)
-(34 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = ((t3_3.a + t3_3.b) / 2))
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (((a + b) / 2) = t2_3.b)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t2_4.b)
+ -> Hash Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (b = ((t3_4.a + t3_4.b) / 2))
+(53 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t3 WHERE t1.a = t2.b AND t1.a = (t3.a + t3.b)/2 AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
-(4 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(8 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
---------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Result
-> Append
-> Hash Right Join
Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_1.a + t3_1.b) / 2) = t1_1.a)
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
-> Hash
-> Hash Right Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_2.a + t3_2.b) / 2) = t1_2.a)
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
-> Hash
-> Hash Right Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (t1_3.a = ((a + b) / 2))
+ -> Hash Right Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p4 t1_4
Filter: (b = 0)
-(34 rows)
+(52 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
--------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Result
@@ -653,48 +1022,75 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1.a = ((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
Index Cond: (t1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t2_1
Index Cond: (t1_1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t2_2
Index Cond: (t1_2.a = b)
-(31 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t3_3.a + t3_3.b) / 2))
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Nested Loop Left Join
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = ((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (t1_4.a = b)
+(48 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- Cases with non-nullable expressions in subquery results;
-- make sure these go to null as expected
@@ -703,23 +1099,36 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b, ((prt1_e_p1.a + prt1_e_p1.b))
+ Sort Key: prt1_p0.a, prt2_p0.b, ((prt1_e_p0.a + prt1_e_p0.b))
-> Result
-> Append
-> Hash Full Join
- Hash Cond: (prt1_p1.a = ((prt1_e_p1.a + prt1_e_p1.b) / 2))
- Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ Hash Cond: (prt1_p0.a = ((prt1_e_p0.a + prt1_e_p0.b) / 2))
+ Filter: ((prt1_p0.a = (50)) OR (prt2_p0.b = (75)) OR (((prt1_e_p0.a + prt1_e_p0.b) / 2) = (50)))
-> Hash Full Join
- Hash Cond: (prt1_p1.a = prt2_p1.b)
- -> Seq Scan on prt1_p1
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ -> Seq Scan on prt1_p0
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1
+ -> Seq Scan on prt2_p0
Filter: (a = 0)
-> Hash
- -> Seq Scan on prt1_e_p1
+ -> Seq Scan on prt1_e_p0
Filter: (c = 0)
-> Hash Full Join
+ Hash Cond: (((prt1_e_p1.a + prt1_e_p1.b) / 2) = prt1_p1.a)
+ Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ -> Seq Scan on prt1_e_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Hash Full Join
+ Hash Cond: (prt1_p1.a = prt2_p1.b)
+ -> Seq Scan on prt1_p1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1
+ Filter: (a = 0)
+ -> Hash Full Join
Hash Cond: (prt1_p2.a = ((prt1_e_p2.a + prt1_e_p2.b) / 2))
Filter: ((prt1_p2.a = (50)) OR (prt2_p2.b = (75)) OR (((prt1_e_p2.a + prt1_e_p2.b) / 2) = (50)))
-> Hash Full Join
@@ -745,7 +1154,20 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
-> Hash
-> Seq Scan on prt1_e_p3
Filter: (c = 0)
-(43 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = ((prt1_e_p4.a + prt1_e_p4.b) / 2))
+ Filter: ((prt1_p4.a = (50)) OR (prt2_p4.b = (75)) OR (((prt1_e_p4.a + prt1_e_p4.b) / 2) = (50)))
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_e_p4
+ Filter: (c = 0)
+(69 rows)
SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b)) FULL JOIN (SELECT 50 phv, * FROM prt1_e WHERE prt1_e.c = 0) t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.a = t1.phv OR t2.b = t2.phv OR (t3.a + t3.b)/2 = t3.phv ORDER BY t1.a, t2.b, t3.a + t3.b;
a | phv | b | phv | ?column? | phv
@@ -763,173 +1185,261 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHER
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = t1_3.b)
+ Join Filter: (t1.a = t1_5.b)
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Join
- Hash Cond: (((t2.a + t2.b) / 2) = t1_3.b)
- -> Seq Scan on prt1_e_p1 t2
+ Hash Cond: (((t2.a + t2.b) / 2) = t1_5.b)
+ -> Seq Scan on prt1_e_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t1_3
+ -> Seq Scan on prt2_p0 t1_5
Filter: (a = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
Index Cond: (a = ((t2.a + t2.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_1.a = t1_4.b)
+ Join Filter: (t1_1.a = t1_6.b)
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Join
- Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_4.b)
- -> Seq Scan on prt1_e_p2 t2_1
+ Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_6.b)
+ -> Seq Scan on prt1_e_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t1_4
+ -> Seq Scan on prt2_p1 t1_6
Filter: (a = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
Index Cond: (a = ((t2_1.a + t2_1.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_2.a = t1_5.b)
+ Join Filter: (t1_2.a = t1_7.b)
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Nested Loop
- -> Seq Scan on prt2_p3 t1_5
+ -> Seq Scan on prt2_p2 t1_7
Filter: (a = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_2
- Index Cond: (((a + b) / 2) = t1_5.b)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t2_2
+ Index Cond: (((a + b) / 2) = t1_7.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
Index Cond: (a = ((t2_2.a + t2_2.b) / 2))
Filter: (b = 0)
-(41 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = t1_8.b)
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t1_8
+ Filter: (a = 0)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_3
+ Index Cond: (((a + b) / 2) = t1_8.b)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t2_3.a + t2_3.b) / 2))
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t1_9.b)
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Join
+ Hash Cond: (((t2_4.a + t2_4.b) / 2) = t1_9.b)
+ -> Seq Scan on prt1_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t1_9
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = ((t2_4.a + t2_4.b) / 2))
+ Filter: (b = 0)
+(66 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHERE t1.a = 0 AND t1.b = (t2.a + t2.b)/2) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
--------------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Nested Loop
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
+ -> Hash Semi Join
+ Hash Cond: (t1_5.b = ((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt2_p0 t1_5
+ -> Hash
+ -> Seq Scan on prt1_e_p0 t1_10
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t1_5.b)
+ Filter: (b = 0)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_6.b
-> Hash Semi Join
- Hash Cond: (t1_3.b = ((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt2_p1 t1_3
+ Hash Cond: (t1_6.b = ((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt2_p1 t1_6
-> Hash
- -> Seq Scan on prt1_e_p1 t1_6
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
- Index Cond: (a = t1_3.b)
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
+ Index Cond: (a = t1_6.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_7.b
-> Hash Semi Join
- Hash Cond: (t1_4.b = ((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt2_p2 t1_4
+ Hash Cond: (t1_7.b = ((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt2_p2 t1_7
-> Hash
- -> Seq Scan on prt1_e_p2 t1_7
+ -> Seq Scan on prt1_e_p2 t1_12
Filter: (c = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
- Index Cond: (a = t1_4.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t1_7.b)
Filter: (b = 0)
-> Nested Loop
-> Unique
-> Sort
- Sort Key: t1_5.b
+ Sort Key: t1_8.b
-> Hash Semi Join
- Hash Cond: (t1_5.b = ((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt2_p3 t1_5
+ Hash Cond: (t1_8.b = ((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt2_p3 t1_8
-> Hash
- -> Seq Scan on prt1_e_p3 t1_8
+ -> Seq Scan on prt1_e_p3 t1_13
Filter: (c = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t1_5.b)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t1_8.b)
+ Filter: (b = 0)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Semi Join
+ Hash Cond: (t1_9.b = ((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt2_p4 t1_9
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = t1_9.b)
Filter: (b = 0)
-(40 rows)
+(64 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
-- test merge joins
SET enable_hashjoin TO off;
SET enable_nestloop TO off;
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
-----------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------
Merge Append
Sort Key: t1.a
-> Merge Semi Join
- Merge Cond: (t1.a = t1_3.b)
+ Merge Cond: (t1.a = t1_5.b)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_3.b = (((t1_6.a + t1_6.b) / 2)))
+ Merge Cond: (t1_5.b = (((t1_10.a + t1_10.b) / 2)))
-> Sort
- Sort Key: t1_3.b
- -> Seq Scan on prt2_p1 t1_3
+ Sort Key: t1_5.b
+ -> Seq Scan on prt2_p0 t1_5
-> Sort
- Sort Key: (((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt1_e_p1 t1_6
+ Sort Key: (((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_1.a = t1_4.b)
+ Merge Cond: (t1_1.a = t1_6.b)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_4.b = (((t1_7.a + t1_7.b) / 2)))
+ Merge Cond: (t1_6.b = (((t1_11.a + t1_11.b) / 2)))
-> Sort
- Sort Key: t1_4.b
- -> Seq Scan on prt2_p2 t1_4
+ Sort Key: t1_6.b
+ -> Seq Scan on prt2_p1 t1_6
-> Sort
- Sort Key: (((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt1_e_p2 t1_7
+ Sort Key: (((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_2.a = t1_5.b)
+ Merge Cond: (t1_2.a = t1_7.b)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_5.b = (((t1_8.a + t1_8.b) / 2)))
+ Merge Cond: (t1_7.b = (((t1_12.a + t1_12.b) / 2)))
-> Sort
- Sort Key: t1_5.b
- -> Seq Scan on prt2_p3 t1_5
+ Sort Key: t1_7.b
+ -> Seq Scan on prt2_p2 t1_7
+ -> Sort
+ Sort Key: (((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt1_e_p2 t1_12
+ Filter: (c = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_3.a = t1_8.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_8.b = (((t1_13.a + t1_13.b) / 2)))
+ -> Sort
+ Sort Key: t1_8.b
+ -> Seq Scan on prt2_p3 t1_8
+ -> Sort
+ Sort Key: (((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt1_e_p3 t1_13
+ Filter: (c = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_4.a = t1_9.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_9.b = (((t1_14.a + t1_14.b) / 2)))
+ -> Sort
+ Sort Key: t1_9.b
+ -> Seq Scan on prt2_p4 t1_9
-> Sort
- Sort Key: (((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt1_e_p3 t1_8
+ Sort Key: (((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt1_e_p4 t1_14
Filter: (c = 0)
-(47 rows)
+(77 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
@@ -947,14 +1457,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3.a + t3.b) / 2)) = t1.a)
-> Sort
Sort Key: (((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Sort
Sort Key: t2.b
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Merge Left Join
Merge Cond: (t1_1.a = t2_1.b)
-> Sort
@@ -963,14 +1473,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_1.a + t3_1.b) / 2)) = t1_1.a)
-> Sort
Sort Key: (((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Sort
Sort Key: t2_1.b
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Merge Left Join
Merge Cond: (t1_2.a = t2_2.b)
-> Sort
@@ -979,225 +1489,2361 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_2.a + t3_2.b) / 2)) = t1_2.a)
-> Sort
Sort Key: (((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Sort
Sort Key: t2_2.b
- -> Seq Scan on prt2_p3 t2_2
-(52 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Merge Left Join
+ Merge Cond: (t1_3.a = t2_3.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_3.a + t3_3.b) / 2)) = t1_3.a)
+ -> Sort
+ Sort Key: (((t3_3.a + t3_3.b) / 2))
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ -> Sort
+ Sort Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ -> Merge Left Join
+ Merge Cond: (t1_4.a = t2_4.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_4.a + t3_4.b) / 2)) = t1_4.a)
+ -> Sort
+ Sort Key: (((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ -> Sort
+ Sort Key: t2_4.b
+ -> Seq Scan on prt2_p4 t2_4
+(84 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
+
+-- MergeAppend on nullable column
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+-----------------------------------------------------------
+ Sort
+ Sort Key: prt1_p0.a, b
+ -> Append
+ -> Merge Left Join
+ Merge Cond: (prt1_p0.a = b)
+ -> Sort
+ Sort Key: prt1_p0.a
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Sort
+ Sort Key: b
+ -> Result
+ One-Time Filter: false
+ -> Merge Left Join
+ Merge Cond: (prt1_p1.a = b)
+ -> Sort
+ Sort Key: prt1_p1.a
+ -> Seq Scan on prt1_p1
+ Filter: ((a < 450) AND (b = 0))
+ -> Sort
+ Sort Key: b
+ -> Result
+ One-Time Filter: false
+ -> Merge Left Join
+ Merge Cond: (prt1_p2.a = prt2_p2.b)
+ -> Sort
+ Sort Key: prt1_p2.a
+ -> Seq Scan on prt1_p2
+ Filter: ((a < 450) AND (b = 0))
+ -> Sort
+ Sort Key: prt2_p2.b
+ -> Seq Scan on prt2_p2
+ Filter: (b > 250)
+(33 rows)
+
+SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
+ a | b
+------+-----
+ -250 |
+ -200 |
+ -150 |
+ -100 |
+ -50 |
+ 0 |
+ 50 |
+ 100 |
+ 150 |
+ 200 |
+ 250 |
+ 300 | 300
+ 350 |
+ 400 |
+(14 rows)
+
+RESET enable_hashjoin;
+RESET enable_nestloop;
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -150 | -0150 | 0 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 0 | 0150
+ 300 | 0300 | 0 | 0300
+ 450 | 0450 | 0 | 0450
+ 600 | 0600 | 0 | 0600
+ 750 | 0750 | 0 | 0750
+(7 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | 0 | -0150
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | 0 | 0000
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | 0 | 0150
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 0 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ 450 | 0450 | 0 | 0450
+ 500 | 0500 | |
+ 550 | 0550 | |
+ 600 | 0600 | 0 | 0600
+ 650 | 0650 | |
+ 700 | 0700 | |
+ 750 | 0750 | 0 | 0750
+(21 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Semi Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Append
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
+ Index Cond: (a = t1_1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(28 rows)
+
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Anti Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Anti Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -250 | 0 | -0250
+ -200 | 0 | -0200
+ -100 | 0 | -0100
+ -50 | 0 | -0050
+ 50 | 0 | 0050
+ 100 | 0 | 0100
+ 200 | 0 | 0200
+ 250 | 0 | 0250
+ 350 | 0 | 0350
+ 400 | 0 | 0400
+ 500 | 0 | 0500
+ 550 | 0 | 0550
+ 650 | 0 | 0650
+ 700 | 0 | 0700
+(14 rows)
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.b
+ -> Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(24 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: (t1.a = t2.b)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.a, 0)) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------
+ Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(22 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Join
+ Hash Cond: (t1.a = t2.b)
+ Join Filter: ((t1.b + t2.a) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+--
+-- partitioned by multiple columns
+--
+CREATE TABLE prt1_m (a int, b int, c int) PARTITION BY RANGE(a, ((a + b)/2));
+CREATE TABLE prt1_m_p1 PARTITION OF prt1_m FOR VALUES FROM (0, 0) TO (250, 250);
+CREATE TABLE prt1_m_p2 PARTITION OF prt1_m FOR VALUES FROM (250, 250) TO (500, 500);
+CREATE TABLE prt1_m_p3 PARTITION OF prt1_m FOR VALUES FROM (500, 500) TO (600, 600);
+INSERT INTO prt1_m SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+ANALYZE prt1_m;
+CREATE TABLE prt2_m (a int, b int, c int) PARTITION BY RANGE(((b + a)/2), b);
+CREATE TABLE prt2_m_p1 PARTITION OF prt2_m FOR VALUES FROM (0, 0) TO (250, 250);
+CREATE TABLE prt2_m_p2 PARTITION OF prt2_m FOR VALUES FROM (250, 250) TO (500, 500);
+CREATE TABLE prt2_m_p3 PARTITION OF prt2_m FOR VALUES FROM (500, 500) TO (600, 600);
+INSERT INTO prt2_m SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+ANALYZE prt2_m;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------
+ Sort
+ Sort Key: prt1_m_p1.a, prt2_m_p1.b
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p1.a = ((prt2_m_p1.b + prt2_m_p1.a) / 2)) AND (((prt1_m_p1.a + prt1_m_p1.b) / 2) = prt2_m_p1.b))
+ -> Seq Scan on prt1_m_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p1
+ Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p2.a = ((prt2_m_p2.b + prt2_m_p2.a) / 2)) AND (((prt1_m_p2.a + prt1_m_p2.b) / 2) = prt2_m_p2.b))
+ -> Seq Scan on prt1_m_p2
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p2
+ Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p3.a = ((prt2_m_p3.b + prt2_m_p3.a) / 2)) AND (((prt1_m_p3.a + prt1_m_p3.b) / 2) = prt2_m_p3.b))
+ -> Seq Scan on prt1_m_p3
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p3
+ Filter: (c = 0)
+(24 rows)
+
+SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
+ a | c | b | c
+-----+---+-----+---
+ 0 | 0 | 0 | 0
+ 50 | 0 | |
+ 100 | 0 | |
+ 150 | 0 | 150 | 0
+ 200 | 0 | |
+ 250 | 0 | |
+ 300 | 0 | 300 | 0
+ 350 | 0 | |
+ 400 | 0 | |
+ 450 | 0 | 450 | 0
+ 500 | 0 | |
+ 550 | 0 | |
+ | | 75 | 0
+ | | 225 | 0
+ | | 375 | 0
+ | | 525 | 0
+(16 rows)
+
+--
+-- tests for list partitioned tables.
+--
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Result
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(28 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 470 | 0 | 0011
+(1 row)
+
+--
+-- list partitioned by expression
+--
+CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
+ANALYZE plt1_e;
+-- test partition matching with N-way join
+EXPLAIN (COSTS OFF)
+SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+ QUERY PLAN
+----------------------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.c, t3.c
+ -> HashAggregate
+ Group Key: t1.c, t2.c, t3.c
+ -> Result
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = ltrim(t3.c, 'A'::text))
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt1_e_p4 t3
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = ltrim(t3_1.c, 'A'::text))
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_e_p1 t3_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = ltrim(t3_2.c, 'A'::text))
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt1_e_p2 t3_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = ltrim(t3_3.c, 'A'::text))
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt1_e_p3 t3_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(42 rows)
+
+SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+ avg | avg | avg | c | c | c
+----------------------+---------------------+----------------------+------+------+------
+ 246.5000000000000000 | 22.4666666666666667 | 268.9666666666666667 | 0000 | 0000 | 0000
+ 248.5000000000000000 | 21.3333333333333333 | 269.8333333333333333 | 0002 | 0002 | 0002
+ 249.5000000000000000 | 22.3333333333333333 | 271.8333333333333333 | 0003 | 0003 | 0003
+ 250.5000000000000000 | 23.3333333333333333 | 273.8333333333333333 | 0004 | 0004 | 0004
+ 251.5000000000000000 | 22.7666666666666667 | 274.2666666666666667 | 0005 | 0005 | 0005
+ 252.5000000000000000 | 22.2000000000000000 | 274.7000000000000000 | 0006 | 0006 | 0006
+ 246.0000000000000000 | 23.9655172413793103 | 269.9655172413793103 | 0008 | 0008 | 0008
+ 247.0000000000000000 | 23.3448275862068966 | 270.3448275862068966 | 0009 | 0009 | 0009
+(8 rows)
+
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 470 | 0011
+ | | 235 | 0014
+(8 rows)
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 235 | 0014
+ | | 470 | 0011
+(10 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 47 | 0 | 0013
+ 235 | 0 | 0014
+ 470 | 0 | 0011
+(3 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+----------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Materialize
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(20 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Result
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(28 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Materialize
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
--- MergeAppend on nullable column
+-- anti join
EXPLAIN (COSTS OFF)
-SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
------------------------------------------------------------
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: t1.a, t1.c
-> Append
- -> Merge Left Join
- Merge Cond: (prt1_p1.a = b)
- -> Sort
- Sort Key: prt1_p1.a
- -> Seq Scan on prt1_p1
- Filter: ((a < 450) AND (b = 0))
- -> Sort
- Sort Key: b
- -> Result
- One-Time Filter: false
- -> Merge Left Join
- Merge Cond: (prt1_p2.a = prt2_p2.b)
- -> Sort
- Sort Key: prt1_p2.a
- -> Seq Scan on prt1_p2
- Filter: ((a < 450) AND (b = 0))
- -> Sort
- Sort Key: prt2_p2.b
- -> Seq Scan on prt2_p2
- Filter: (b > 250)
-(23 rows)
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
-SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | b
------+-----
- 0 |
- 50 |
- 100 |
- 150 |
- 200 |
- 250 |
- 300 | 300
- 350 |
- 400 |
-(9 rows)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
-RESET enable_hashjoin;
-RESET enable_nestloop;
---
--- partitioned by multiple columns
---
-CREATE TABLE prt1_m (a int, b int, c int) PARTITION BY RANGE(a, ((a + b)/2));
-CREATE TABLE prt1_m_p1 PARTITION OF prt1_m FOR VALUES FROM (0, 0) TO (250, 250);
-CREATE TABLE prt1_m_p2 PARTITION OF prt1_m FOR VALUES FROM (250, 250) TO (500, 500);
-CREATE TABLE prt1_m_p3 PARTITION OF prt1_m FOR VALUES FROM (500, 500) TO (600, 600);
-INSERT INTO prt1_m SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
-ANALYZE prt1_m;
-CREATE TABLE prt2_m (a int, b int, c int) PARTITION BY RANGE(((b + a)/2), b);
-CREATE TABLE prt2_m_p1 PARTITION OF prt2_m FOR VALUES FROM (0, 0) TO (250, 250);
-CREATE TABLE prt2_m_p2 PARTITION OF prt2_m FOR VALUES FROM (250, 250) TO (500, 500);
-CREATE TABLE prt2_m_p3 PARTITION OF prt2_m FOR VALUES FROM (500, 500) TO (600, 600);
-INSERT INTO prt2_m SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
-ANALYZE prt2_m;
EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
- QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
Sort
- Sort Key: prt1_m_p1.a, prt2_m_p1.b
+ Sort Key: t1.a, t1.c
-> Append
- -> Hash Full Join
- Hash Cond: ((prt1_m_p1.a = ((prt2_m_p1.b + prt2_m_p1.a) / 2)) AND (((prt1_m_p1.a + prt1_m_p1.b) / 2) = prt2_m_p1.b))
- -> Seq Scan on prt1_m_p1
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p1
- Filter: (c = 0)
- -> Hash Full Join
- Hash Cond: ((prt1_m_p2.a = ((prt2_m_p2.b + prt2_m_p2.a) / 2)) AND (((prt1_m_p2.a + prt1_m_p2.b) / 2) = prt2_m_p2.b))
- -> Seq Scan on prt1_m_p2
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p2
- Filter: (c = 0)
- -> Hash Full Join
- Hash Cond: ((prt1_m_p3.a = ((prt2_m_p3.b + prt2_m_p3.a) / 2)) AND (((prt1_m_p3.a + prt1_m_p3.b) / 2) = prt2_m_p3.b))
- -> Seq Scan on prt1_m_p3
- Filter: (c = 0)
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_m_p3
- Filter: (c = 0)
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
(24 rows)
-SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 50 | 0 | |
- 100 | 0 | |
- 150 | 0 | 150 | 0
- 200 | 0 | |
- 250 | 0 | |
- 300 | 0 | 300 | 0
- 350 | 0 | |
- 400 | 0 | |
- 450 | 0 | 450 | 0
- 500 | 0 | |
- 550 | 0 | |
- | | 75 | 0
- | | 225 | 0
- | | 375 | 0
- | | 525 | 0
-(16 rows)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+---
+ 470 | 0 |
+(1 row)
---
--- tests for list partitioned tables.
---
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
ANALYZE plt1;
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
---
--- list partitioned by expression
---
-CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1_e;
--- test partition matching with N-way join
+-- inner join
EXPLAIN (COSTS OFF)
-SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- QUERY PLAN
---------------------------------------------------------------------------------------
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
Sort
- Sort Key: t1.c, t3.c
- -> HashAggregate
- Group Key: t1.c, t2.c, t3.c
- -> Result
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
-> Append
- -> Hash Join
- Hash Cond: (t1.c = t2.c)
- -> Seq Scan on plt1_p1 t1
- -> Hash
- -> Hash Join
- Hash Cond: (t2.c = ltrim(t3.c, 'A'::text))
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_e_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.c = t2_1.c)
- -> Seq Scan on plt1_p2 t1_1
- -> Hash
- -> Hash Join
- Hash Cond: (t2_1.c = ltrim(t3_1.c, 'A'::text))
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_e_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.c = t2_2.c)
- -> Seq Scan on plt1_p3 t1_2
- -> Hash
- -> Hash Join
- Hash Cond: (t2_2.c = ltrim(t3_2.c, 'A'::text))
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_e_p3 t3_2
-(33 rows)
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
-SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- avg | avg | avg | c | c | c
-----------------------+----------------------+-----------------------+------+------+-------
- 24.0000000000000000 | 24.0000000000000000 | 48.0000000000000000 | 0000 | 0000 | A0000
- 74.0000000000000000 | 75.0000000000000000 | 148.0000000000000000 | 0001 | 0001 | A0001
- 124.0000000000000000 | 124.5000000000000000 | 248.0000000000000000 | 0002 | 0002 | A0002
- 174.0000000000000000 | 174.0000000000000000 | 348.0000000000000000 | 0003 | 0003 | A0003
- 224.0000000000000000 | 225.0000000000000000 | 448.0000000000000000 | 0004 | 0004 | A0004
- 274.0000000000000000 | 274.5000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
- 324.0000000000000000 | 324.0000000000000000 | 648.0000000000000000 | 0006 | 0006 | A0006
- 374.0000000000000000 | 375.0000000000000000 | 748.0000000000000000 | 0007 | 0007 | A0007
- 424.0000000000000000 | 424.5000000000000000 | 848.0000000000000000 | 0008 | 0008 | A0008
- 474.0000000000000000 | 474.0000000000000000 | 948.0000000000000000 | 0009 | 0009 | A0009
- 524.0000000000000000 | 525.0000000000000000 | 1048.0000000000000000 | 0010 | 0010 | A0010
- 574.0000000000000000 | 574.5000000000000000 | 1148.0000000000000000 | 0011 | 0011 | A0011
-(12 rows)
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(22 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(22 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(19 rows)
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
@@ -1225,16 +3871,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
-> Hash Left Join
Hash Cond: (t2.b = a)
-> Append
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
Filter: (a = 0)
-> Hash
-> Result
One-Time Filter: false
-(14 rows)
+(20 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b;
@@ -1245,16 +3897,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
-> Hash Left Join
Hash Cond: (t2.b = a)
-> Append
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
Filter: (a = 0)
-> Hash
-> Result
One-Time Filter: false
-(14 rows)
+(20 rows)
--
-- multiple levels of partitioning
@@ -1615,64 +4273,70 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2 WHERE t1.a = t2.a;
Hash Join
Hash Cond: (t1.a = t2.a)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Seq Scan on prt4_n_p1 t2
-> Seq Scan on prt4_n_p2 t2_1
-> Seq Scan on prt4_n_p3 t2_2
-(11 rows)
+(13 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2, prt2 t3 WHERE t1.a = t2.a and t1.a = t3.b;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------
Hash Join
- Hash Cond: (t2.a = t1.a)
+ Hash Cond: (t3.b = t1.a)
-> Append
- -> Seq Scan on prt4_n_p1 t2
- -> Seq Scan on prt4_n_p2 t2_1
- -> Seq Scan on prt4_n_p3 t2_2
+ -> Seq Scan on prt2_p0 t3
+ -> Seq Scan on prt2_p1 t3_1
+ -> Seq Scan on prt2_p2 t3_2
+ -> Seq Scan on prt2_p3 t3_3
+ -> Seq Scan on prt2_p4 t3_4
+ -> Seq Scan on prt2_p5 t3_5
-> Hash
- -> Append
- -> Hash Join
- Hash Cond: (t1.a = t3.b)
- -> Seq Scan on prt1_p1 t1
- -> Hash
- -> Seq Scan on prt2_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t1_1
- -> Hash
- -> Seq Scan on prt2_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t1_2
- -> Hash
- -> Seq Scan on prt2_p3 t3_2
+ -> Hash Join
+ Hash Cond: (t1.a = t2.a)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt4_n_p1 t2
+ -> Seq Scan on prt4_n_p2 t2_1
+ -> Seq Scan on prt4_n_p3 t2_2
(23 rows)
-- partition-wise join can not be applied if there are no equi-join conditions
-- between partition keys
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON (t1.a < t2.b);
- QUERY PLAN
----------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------
Nested Loop Left Join
+ Join Filter: (t1.a < t2.b)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
- -> Append
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
- Index Cond: (t1.a < b)
-(12 rows)
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Materialize
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(16 rows)
-- equi-join with join condition on partial keys does not qualify for
-- partition-wise join
@@ -1758,16 +4422,17 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 JOIN prt2_n t2 ON (t1.c = t2.c) JOI
-> Seq Scan on prt2_n_p2 t2_1
-> Hash
-> Hash Join
- Hash Cond: (t3.c = (t1.c)::text)
+ Hash Cond: ((t3.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on plt1_p1 t3
- -> Seq Scan on plt1_p2 t3_1
- -> Seq Scan on plt1_p3 t3_2
+ -> Seq Scan on plt1_p4 t3
+ -> Seq Scan on plt1_p1 t3_1
+ -> Seq Scan on plt1_p2 t3_2
+ -> Seq Scan on plt1_p3 t3_3
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(16 rows)
+(17 rows)
-- partition-wise join can not be applied for a join between list and range
-- partitioned table
@@ -1778,12 +4443,14 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 FULL JOIN prt1 t2 ON (t1.c = t2.c);
Hash Full Join
Hash Cond: ((t2.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on prt1_p1 t2
- -> Seq Scan on prt1_p2 t2_1
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(10 rows)
+(12 rows)
diff --git a/src/test/regress/sql/partition_join.sql b/src/test/regress/sql/partition_join.sql
index ca525d9..5812792 100644
--- a/src/test/regress/sql/partition_join.sql
+++ b/src/test/regress/sql/partition_join.sql
@@ -10,25 +10,39 @@ SET enable_partition_wise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
@@ -67,11 +81,19 @@ EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -93,20 +115,30 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
@@ -163,6 +195,85 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
RESET enable_hashjoin;
RESET enable_nestloop;
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
--
-- partitioned by multiple columns
--
@@ -187,28 +298,79 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1
--
-- tests for list partitioned tables.
--
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
--
-- list partitioned by expression
--
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
ANALYZE plt1_e;
-- test partition matching with N-way join
@@ -216,6 +378,175 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.a = 1 AND t1.a = 2;
--
1.7.9.5
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2017-10-12 16:16 ` Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Robert Haas @ 2017-10-12 16:16 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; +Cc: Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Wed, Oct 11, 2017 at 7:08 AM, Ashutosh Bapat
<ashutosh.bapat@enterprisedb.com> wrote:
> Here's updated patch set based on the basic partition-wise join
> committed. The patchset applies on top of the patch to optimize the
> case of dummy partitioned tables [1].
>
> Right now, the advanced partition matching algorithm bails out when
> either of the joining relations has a default partition.
So is that something you are going to fix?
--
Robert Haas
EnterpriseDB: http://www.enterprisedb.com
The Enterprise PostgreSQL Company
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
@ 2017-10-13 02:29 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2017-10-13 02:29 UTC (permalink / raw)
To: Robert Haas <robertmhaas@gmail.com>; +Cc: Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Thu, Oct 12, 2017 at 9:46 PM, Robert Haas <robertmhaas@gmail.com> wrote:
> On Wed, Oct 11, 2017 at 7:08 AM, Ashutosh Bapat
> <ashutosh.bapat@enterprisedb.com> wrote:
>> Here's updated patch set based on the basic partition-wise join
>> committed. The patchset applies on top of the patch to optimize the
>> case of dummy partitioned tables [1].
>>
>> Right now, the advanced partition matching algorithm bails out when
>> either of the joining relations has a default partition.
>
> So is that something you are going to fix?
>
Yes, if time permits. I had left the patch unattended while basic
partition-wise join was getting committed. Now that it's committed, I
rebased it. It still has TODOs and some work is required to improve
it. But for the patch to be really complete, we have to deal with the
problem of missing partitions described before. I am fine
collaborating if someone else wants to pick it up.
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2017-12-03 11:23 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2017-12-03 11:23 UTC (permalink / raw)
To: Robert Haas <robertmhaas@gmail.com>; +Cc: Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Fri, Oct 13, 2017 at 7:59 AM, Ashutosh Bapat
<ashutosh.bapat@enterprisedb.com> wrote:
> On Thu, Oct 12, 2017 at 9:46 PM, Robert Haas <robertmhaas@gmail.com> wrote:
>> On Wed, Oct 11, 2017 at 7:08 AM, Ashutosh Bapat
>> <ashutosh.bapat@enterprisedb.com> wrote:
>>> Here's updated patch set based on the basic partition-wise join
>>> committed. The patchset applies on top of the patch to optimize the
>>> case of dummy partitioned tables [1].
>>>
>>> Right now, the advanced partition matching algorithm bails out when
>>> either of the joining relations has a default partition.
>>
>> So is that something you are going to fix?
>>
>
> Yes, if time permits. I had left the patch unattended while basic
> partition-wise join was getting committed. Now that it's committed, I
> rebased it. It still has TODOs and some work is required to improve
> it. But for the patch to be really complete, we have to deal with the
> problem of missing partitions described before. I am fine
> collaborating if someone else wants to pick it up.
>
Here's patchset which support advanced partition matching for
partition bounds with default partition. The patchset is rebased on
the latest head.
When a list value is present in one of the joining relations and not
the other, and the other relation has default partition, match (join)
the partition containing that list value with the default partition,
since the default partition may contain rows with that list value. If
the default partition happens to be on the outer side of the join, the
resulting join partition acts as a default partition as it will
contain all the values from the default partition. If the partition
containing the list value happens to be on the outer side of the join,
the resulting join partition is associated with the list value, since
no other partition key value from the default partition makes it to
the join result.
When a range is present (completely or partly) in one of the joining
relations and not the other, and the other relation has default
partition, match (join) the partition corresponding to that range with
the default partition. If the default partition happens to be on the
outer side of the join, the resulting join partition acts as a default
partition as it will contain all the values from the default
partition. If the non-partition corresponding to the range happens to
be on the outer side of the join, the resulting join partition is
associated with that range, since partition key values from the
default partition outside that range won't make it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a non-default partition from the
inner side, if inner side has a range missing in the outer side.
If any of the above causes multiple partitions from one side to match
with one or more partitions on the other side, we won't use
partition-wise join as discussed in the first mail of this thread.
I have tested the patches for two-way join, but haven't added any test
involving default partitions to the patch itself. It needs to be
tested for N-way join as well. So, for now I have kept the two patches
supporting the default partition in case of range and list resp.
separate. Also, some of the code duplication in partition matching
functions can be avoided using macros. I will merge those patches into
the main patch and add macros once they are tested appropriately.
For hash partitioned table, we haven't implemented the advanced
partition matching, since it would be rare that somebody has hash
partitioned tables with holes (even if they are allowed).
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
Attachments:
[application/x-gzip] pg_adv_dp_join_patches_v2.tar.gz (42.4K, ../../CAFjFpReJhFSoy6DqH0ipFSHd=sLNEkSzAtz4VWCaS-w2jZL=uw@mail.gmail.com/2-pg_adv_dp_join_patches_v2.tar.gz)
download
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2018-02-07 04:51 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2018-02-07 04:51 UTC (permalink / raw)
To: Robert Haas <robertmhaas@gmail.com>; +Cc: Antonin Houska <ah@cybertec.at>; pgsql-hackers
Here's a new patchset with following changes
1. Rebased on the latest head taking care of partition bound
comparison function changes
2. Refactored the code to avoid duplication.
3. There's an extensive test (provided by Rajkumar) set added, which
is not meant to be committed. That testset has testcases which crash
or reveal a bug. I will fix those crashes and add corresponding
testcases to partition_join.sql.
TODO
1. FIx crashes/bugs in the testcases.
On Sun, Dec 3, 2017 at 4:53 PM, Ashutosh Bapat
<ashutosh.bapat@enterprisedb.com> wrote:
> On Fri, Oct 13, 2017 at 7:59 AM, Ashutosh Bapat
> <ashutosh.bapat@enterprisedb.com> wrote:
>> On Thu, Oct 12, 2017 at 9:46 PM, Robert Haas <robertmhaas@gmail.com> wrote:
>>> On Wed, Oct 11, 2017 at 7:08 AM, Ashutosh Bapat
>>> <ashutosh.bapat@enterprisedb.com> wrote:
>>>> Here's updated patch set based on the basic partition-wise join
>>>> committed. The patchset applies on top of the patch to optimize the
>>>> case of dummy partitioned tables [1].
>>>>
>>>> Right now, the advanced partition matching algorithm bails out when
>>>> either of the joining relations has a default partition.
>>>
>>> So is that something you are going to fix?
>>>
>>
>> Yes, if time permits. I had left the patch unattended while basic
>> partition-wise join was getting committed. Now that it's committed, I
>> rebased it. It still has TODOs and some work is required to improve
>> it. But for the patch to be really complete, we have to deal with the
>> problem of missing partitions described before. I am fine
>> collaborating if someone else wants to pick it up.
>>
>
> Here's patchset which support advanced partition matching for
> partition bounds with default partition. The patchset is rebased on
> the latest head.
>
> When a list value is present in one of the joining relations and not
> the other, and the other relation has default partition, match (join)
> the partition containing that list value with the default partition,
> since the default partition may contain rows with that list value. If
> the default partition happens to be on the outer side of the join, the
> resulting join partition acts as a default partition as it will
> contain all the values from the default partition. If the partition
> containing the list value happens to be on the outer side of the join,
> the resulting join partition is associated with the list value, since
> no other partition key value from the default partition makes it to
> the join result.
>
> When a range is present (completely or partly) in one of the joining
> relations and not the other, and the other relation has default
> partition, match (join) the partition corresponding to that range with
> the default partition. If the default partition happens to be on the
> outer side of the join, the resulting join partition acts as a default
> partition as it will contain all the values from the default
> partition. If the non-partition corresponding to the range happens to
> be on the outer side of the join, the resulting join partition is
> associated with that range, since partition key values from the
> default partition outside that range won't make it to the join result.
>
> If both the relations have default partition, match (join) the default
> partition with each other and deem the resulting join partition as
> default partition. If one of the relations has default partition but
> not the other, and the default partition happens to be on the outer
> side of the join, all its rows will make it to the join. Such a
> default partition may get joined to a non-default partition from the
> inner side, if inner side has a range missing in the outer side.
>
> If any of the above causes multiple partitions from one side to match
> with one or more partitions on the other side, we won't use
> partition-wise join as discussed in the first mail of this thread.
>
> I have tested the patches for two-way join, but haven't added any test
> involving default partitions to the patch itself. It needs to be
> tested for N-way join as well. So, for now I have kept the two patches
> supporting the default partition in case of range and list resp.
> separate. Also, some of the code duplication in partition matching
> functions can be avoided using macros. I will merge those patches into
> the main patch and add macros once they are tested appropriately.
>
> For hash partitioned table, we haven't implemented the advanced
> partition matching, since it would be rare that somebody has hash
> partitioned tables with holes (even if they are allowed).
>
> --
> Best Wishes,
> Ashutosh Bapat
> EnterpriseDB Corporation
> The Postgres Database Company
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
Attachments:
[application/x-gzip] pg_adv_dp_join_patches_v3.tar.gz (149.3K, ../../CAFjFpRcA=t99o1uHVC=J03KtPzs7H36HYwST8yg6kh5wCO-V2g@mail.gmail.com/2-pg_adv_dp_join_patches_v3.tar.gz)
download
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2018-02-08 02:55 ` Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-08 05:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 2 replies; 154+ messages in thread
From: Amit Langote @ 2018-02-08 02:55 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; Robert Haas <robertmhaas@gmail.com>; +Cc: Antonin Houska <ah@cybertec.at>; pgsql-hackers
Hi Ashutosh.
On 2018/02/07 13:51, Ashutosh Bapat wrote:
> Here's a new patchset with following changes
>
> 1. Rebased on the latest head taking care of partition bound
> comparison function changes
I was about to make these changes myself while revising the fast pruning
patch. Instead, I decided to take a look at your patch and try to use it
in my tree.
I looked at the patch 0001 and noticed that git diff --check says:
src/backend/catalog/partition.c:2900: trailing whitespace.
+partition_rbound_datum_cmp(FmgrInfo *partsupfunc, Oid *partcollation,
Also, might be a good idea to write briefly about the new arguments in the
header comment. Something like that they are PartitionKey elements.
Thanks,
Amit
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
@ 2018-02-08 05:11 ` Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
1 sibling, 1 reply; 154+ messages in thread
From: Amit Langote @ 2018-02-08 05:11 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; Robert Haas <robertmhaas@gmail.com>; +Cc: Antonin Houska <ah@cybertec.at>; pgsql-hackers
On 2018/02/08 11:55, Amit Langote wrote:
> Hi Ashutosh.
>
> On 2018/02/07 13:51, Ashutosh Bapat wrote:
>> Here's a new patchset with following changes
>>
>> 1. Rebased on the latest head taking care of partition bound
>> comparison function changes
>
> I was about to make these changes myself while revising the fast pruning
> patch. Instead, I decided to take a look at your patch and try to use it
> in my tree.
I also noticed that a later patch adds partsupfunc to PartitionScheme,
which the pruning patch needs too. So, perhaps would be nice to take out
that portion of the patch. That is, the changes to PartitionScheme struct
definition and those to find_partition_scheme().
Regarding the latter, wouldn't be nice to have a comment before the code
that does the copying about why we don't compare the partsupfunc field to
decide if we have a match or not. I understand it's because the
partsupfunc array contains pointers, not OIDs. But maybe, that's too
obvious to warrant a comment.
Thanks,
Amit
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-08 05:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
@ 2018-02-09 05:31 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-09 05:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2018-02-09 05:31 UTC (permalink / raw)
To: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; +Cc: Robert Haas <robertmhaas@gmail.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Thu, Feb 8, 2018 at 10:41 AM, Amit Langote
<Langote_Amit_f8@lab.ntt.co.jp> wrote:
> On 2018/02/08 11:55, Amit Langote wrote:
>> Hi Ashutosh.
>>
>> On 2018/02/07 13:51, Ashutosh Bapat wrote:
>>> Here's a new patchset with following changes
>>>
>>> 1. Rebased on the latest head taking care of partition bound
>>> comparison function changes
>>
>> I was about to make these changes myself while revising the fast pruning
>> patch. Instead, I decided to take a look at your patch and try to use it
>> in my tree.
>
> I also noticed that a later patch adds partsupfunc to PartitionScheme,
> which the pruning patch needs too. So, perhaps would be nice to take out
> that portion of the patch. That is, the changes to PartitionScheme struct
> definition and those to find_partition_scheme().
I am not sure whether a patch with just that change and without any
changes to use that member will be acceptable. So leaving this aside.
>
> Regarding the latter, wouldn't be nice to have a comment before the code
> that does the copying about why we don't compare the partsupfunc field to
> decide if we have a match or not. I understand it's because the
> partsupfunc array contains pointers, not OIDs. But maybe, that's too
> obvious to warrant a comment.
It's because partsupfuncs should point to the information of the same
function when partopfamily matches and partopcintype matches. I would
have added an assertion for that with a comment, but with the pointer
that would be risky. Or we can just assert that the oids match.
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-08 05:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2018-02-09 05:56 ` Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 06:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Amit Langote @ 2018-02-09 05:56 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On 2018/02/09 14:31, Ashutosh Bapat wrote:
>> I also noticed that a later patch adds partsupfunc to PartitionScheme,
>> which the pruning patch needs too. So, perhaps would be nice to take out
>> that portion of the patch. That is, the changes to PartitionScheme struct
>> definition and those to find_partition_scheme().
>
> I am not sure whether a patch with just that change and without any
> changes to use that member will be acceptable. So leaving this aside.
I asked, because with everything that I have now changed in the partition
pruning patch, one would need to pass these FmgrInfo pointers down to
partition bound searching functions from the optimizer. If the changes to
add partsupfunc to the optimizer were taken out from your main patch, the
pruning patch could just start using it. For now, I'm making those
changes part of the pruning patch.
Thanks,
Amit
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-08 05:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-09 05:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
@ 2018-02-09 06:05 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 0 replies; 154+ messages in thread
From: Ashutosh Bapat @ 2018-02-09 06:05 UTC (permalink / raw)
To: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; +Cc: Robert Haas <robertmhaas@gmail.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Fri, Feb 9, 2018 at 11:26 AM, Amit Langote
<Langote_Amit_f8@lab.ntt.co.jp> wrote:
> On 2018/02/09 14:31, Ashutosh Bapat wrote:
>>> I also noticed that a later patch adds partsupfunc to PartitionScheme,
>>> which the pruning patch needs too. So, perhaps would be nice to take out
>>> that portion of the patch. That is, the changes to PartitionScheme struct
>>> definition and those to find_partition_scheme().
>>
>> I am not sure whether a patch with just that change and without any
>> changes to use that member will be acceptable. So leaving this aside.
>
> I asked, because with everything that I have now changed in the partition
> pruning patch, one would need to pass these FmgrInfo pointers down to
> partition bound searching functions from the optimizer. If the changes to
> add partsupfunc to the optimizer were taken out from your main patch, the
> pruning patch could just start using it. For now, I'm making those
> changes part of the pruning patch.
That's fine. Someone's patch will be committed first and the other
will just take out those changes. But I am open to separate those
changes into other patch if a committer feels so.
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
@ 2018-02-09 05:27 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
1 sibling, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2018-02-09 05:27 UTC (permalink / raw)
To: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; +Cc: Robert Haas <robertmhaas@gmail.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Thu, Feb 8, 2018 at 8:25 AM, Amit Langote
<Langote_Amit_f8@lab.ntt.co.jp> wrote:
> Hi Ashutosh.
>
> On 2018/02/07 13:51, Ashutosh Bapat wrote:
>> Here's a new patchset with following changes
>>
>> 1. Rebased on the latest head taking care of partition bound
>> comparison function changes
>
> I was about to make these changes myself while revising the fast pruning
> patch. Instead, I decided to take a look at your patch and try to use it
> in my tree.
>
> I looked at the patch 0001 and noticed that git diff --check says:
>
> src/backend/catalog/partition.c:2900: trailing whitespace.
> +partition_rbound_datum_cmp(FmgrInfo *partsupfunc, Oid *partcollation,
Thanks. Fixed.
>
> Also, might be a good idea to write briefly about the new arguments in the
> header comment. Something like that they are PartitionKey elements.
Here's updated patch set with those comments added.
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
Attachments:
[application/x-gzip] pg_adv_dp_join_patches_v4.tar.gz (149.5K, ../../CAFjFpRctst136uN2BvbWLAkS7w278XmKY4_PUB+xk-+NezNq8g@mail.gmail.com/2-pg_adv_dp_join_patches_v4.tar.gz)
download
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2018-02-15 09:11 ` Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Amit Langote @ 2018-02-15 09:11 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
Hi Ashutosh.
On 2018/02/09 14:27, Ashutosh Bapat wrote:
> Here's updated patch set with those comments added.
I looked at patches 0002 and 0003.
In 0002:
+ * In case of hash partition we store modulus and remainder in datums array
In case of hash partitioned table?
+ * which has the same data type irrespective of the number of partition keys
+ * and their data types. Hence we can compare the hash bound collection
without
+ * any partition key specific information.
"has the same data type" sounds like it means a Postgres data type,
whereas I think you mean that they are simple int32 values, so we don't
need any PartitionKey information to compare them.
In 0003:
A portion of code in both partition_range_bounds_merge(),
partition_list_bounds_merge(), and merge_null_partitions() has an extra
semi-colon at the end of a line starting with else if:
if (default_index < 0)
default_index = merged_index;
else if(default_index != merged_index);
{
which emits warnings like this:
partition.c: In function ‘partition_range_bounds_merge’:
partition.c:4192:11: warning: this ‘if’ clause does not guard...
[-Wmisleading-indentation]
else if(default_index != merged_index);
^~
partition.c: In function ‘partition_list_bounds_merge’:
partition.c:4261:11: warning: this ‘if’ clause does not guard...
[-Wmisleading-indentation]
else if(default_index != merged_index);
^~
Also, get this warning.
partition.c:3955:1: warning: ‘is_next_range_continuous’ defined but not
used [-Wunused-function]
I'm trying to understand the optimizer side of this patch. In your commit
message, I read:
This commit allows partition-wise join to be applied under
following conditions
1. the partition bounds of joining relations are such that rows from
given partition on one side join can join with rows from maximum one
partition on the other side i.e. bounds of a given partition on one
side match/overlap with those of maximum one partition on the other
side. If the mapping happens to be m:n where m > 1 or n > 1, we have
to gang multiple partition relations together into a single relation.
This means that we have to add simple relations during join
processing, something which is not supported right now. ALso, in such
a case, different pairs of joining relations can produce different
partition bounds for the same join relation, which again is not
supported right now.
So, is the currently allowed case (partition bounds on both sides match
exactly) a special case of this new feature which tries to match
partitions in a more generalized manner? I see that this patch removes
the partition_bound_equal(outer_rel->boundinfo, inner_rel->boundinfo)
check in build_joinrel_partition_info() in favor of reconciling any
differences in the representation of the partition bounds by calling
partition_bounds_merge() from try_partition_wise_join().
2. For every partition on outer side that can contribute to the result
of an OUTER side, there exists at least one (taken along with item 1,
it means exactly one) matching partition on the inner side. To
support partition-wise join when the inner matching partition doesn't
exist, we have to add a dummy base relation corresponding to the
non-existent inner partition. We don't have support add base relations
during join processing.
Sorry but I'm a bit confused by the last sentence; does it mean we're not
able to allow partition-wise join to happen in this case? But this is in
the list of the new cases that the patch makes partition-wise join to
happen for.
Looking at the code changes under src/backend/optimizer:
+ else
+ {
+ Assert(partition_bounds_equal(part_scheme->partnatts,
+ part_scheme->parttyplen,
+ part_scheme->parttypbyval,
+ join_boundinfo, joinrel->boundinfo));
IIUC, this else block would run when try_partition_wise_join() is called
again for the same pair of relations.
+ /*
+ * Every pair of joining relations should result in the same number
+ * of child-joins.
+ */
Sorry if I'm misreading this, but does it mean: a given pair of joining
relations should always result in the same number of (set of, too?)
child-joins?
In the new comment in build_joinrel_partition_info():
+ * Because of restrictions in partition_bounds_merge(), not every pair of
+ * joining relation
joining relations
I will try to hop into partition_bounds_merge() from now...
Thanks,
Amit
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
@ 2018-02-16 05:14 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2018-02-16 05:14 UTC (permalink / raw)
To: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; +Cc: Robert Haas <robertmhaas@gmail.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Thu, Feb 15, 2018 at 2:41 PM, Amit Langote
<Langote_Amit_f8@lab.ntt.co.jp> wrote:
> Hi Ashutosh.
>
> On 2018/02/09 14:27, Ashutosh Bapat wrote:
>
> In 0002:
>
> + * In case of hash partition we store modulus and remainder in datums array
>
> In case of hash partitioned table?
>
> + * which has the same data type irrespective of the number of partition keys
> + * and their data types. Hence we can compare the hash bound collection
> without
> + * any partition key specific information.
>
> "has the same data type" sounds like it means a Postgres data type,
> whereas I think you mean that they are simple int32 values, so we don't
> need any PartitionKey information to compare them.
Modified this comment to read
+ * Hash partition bounds store modulus and remainder in datums array which are
+ * always integers irrespective of the number of partition keys and their data
+ * types. Hence we can compare the hash bound collection without any partition
+ * key specific information. Separating this logic in a function which does not
+ * require partition key specific information allows it be called from places
+ * where the partition key specific information is not completely available.
Let me know if that looks good.
>
> In 0003:
>
> A portion of code in both partition_range_bounds_merge(),
> partition_list_bounds_merge(), and merge_null_partitions() has an extra
> semi-colon at the end of a line starting with else if:
>
> if (default_index < 0)
> default_index = merged_index;
> else if(default_index != merged_index);
> {
>
> which emits warnings like this:
>
> partition.c: In function ‘partition_range_bounds_merge’:
> partition.c:4192:11: warning: this ‘if’ clause does not guard...
> [-Wmisleading-indentation]
> else if(default_index != merged_index);
>
> ^~
> partition.c: In function ‘partition_list_bounds_merge’:
> partition.c:4261:11: warning: this ‘if’ clause does not guard...
> [-Wmisleading-indentation]
> else if(default_index != merged_index);
>
Thanks for catching those. They will cause bugs.
> Also, get this warning.
>
> partition.c:3955:1: warning: ‘is_next_range_continuous’ defined but not
> used [-Wunused-function]
I had added that function earlier, but it's no more useful in the
patch. But I have kept it there in case we need it again. I will
remove it in the final patch.
>
> I'm trying to understand the optimizer side of this patch. In your commit
> message, I read:
>
> This commit allows partition-wise join to be applied under
> following conditions
>
> 1. the partition bounds of joining relations are such that rows from
> given partition on one side join can join with rows from maximum one
> partition on the other side i.e. bounds of a given partition on one
> side match/overlap with those of maximum one partition on the other
> side. If the mapping happens to be m:n where m > 1 or n > 1, we have
> to gang multiple partition relations together into a single relation.
> This means that we have to add simple relations during join
> processing, something which is not supported right now. ALso, in such
> a case, different pairs of joining relations can produce different
> partition bounds for the same join relation, which again is not
> supported right now.
>
>
> So, is the currently allowed case (partition bounds on both sides match
> exactly) a special case of this new feature which tries to match
> partitions in a more generalized manner?
Right.
>
> 2. For every partition on outer side that can contribute to the result
> of an OUTER side, there exists at least one (taken along with item 1,
> it means exactly one) matching partition on the inner side. To
> support partition-wise join when the inner matching partition doesn't
> exist, we have to add a dummy base relation corresponding to the
> non-existent inner partition. We don't have support add base relations
> during join processing.
>
> Sorry but I'm a bit confused by the last sentence; does it mean we're not
> able to allow partition-wise join to happen in this case? But this is in
> the list of the new cases that the patch makes partition-wise join to
> happen for.
>
Consider two cases for partitioned tables t1(p1, p3, p4), t2 (p1, p2,
p3). Assume that the bounds of any pk across t1 and t2 are same when k
matches. So, p2 is missing from t1 and p4 from t2. This case will not
be handled by current partition-wise join. With these set of patches,
we will be able to handle some joins between t1 and t2. The matching
algorithm will output pairs as (p1, p1), (-, p2), (p3, p3), (p4, -).
In an inner join between t1 and t2, (-, p2), (p4, -) would not
contribute any result, so we can eliminate those. Thus t1 INNER JOIN
t2 is just (p1, p1), (p3, p3). t1 LEFT JOIN t2 will not have any
result from (-, p2), so we can eliminate it. If there would not have
been p4, we will be able to compute t1 LEFT JOIN t2. Such cases are
not handled right now.
Fixed some grammar and typos in the paragraph.
>
> Looking at the code changes under src/backend/optimizer:
>
> + else
> + {
> + Assert(partition_bounds_equal(part_scheme->partnatts,
> + part_scheme->parttyplen,
> + part_scheme->parttypbyval,
> + join_boundinfo, joinrel->boundinfo));
>
> IIUC, this else block would run when try_partition_wise_join() is called
> again for the same pair of relations.
Yes, it's all Asserts, so effectively, we run nothing in a binary
without asserts.
>
> + /*
> + * Every pair of joining relations should result in the same number
> + * of child-joins.
> + */
>
> Sorry if I'm misreading this, but does it mean: a given pair of joining
> relations should always result in the same number of (set of, too?)
> child-joins?
The assert there just check for number so the comment doesn't mention
set. But you are correct, it's the same set. We check it when we
actually deal with them by checking their relids.
>
> In the new comment in build_joinrel_partition_info():
>
> + * Because of restrictions in partition_bounds_merge(), not every pair of
> + * joining relation
>
> joining relations
Fixed.
>
>
> I will try to hop into partition_bounds_merge() from now...
Appreciate you taking time for review.
PFA updated version.
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
Attachments:
[application/x-gzip] pg_adv_dp_join_patches_v5.tar.gz (149.5K, ../../CAFjFpRdRA9rHiTiFAHu2b4+v=6t+o3Z-53QR2bWhtfrSjb7UOw@mail.gmail.com/2-pg_adv_dp_join_patches_v5.tar.gz)
download
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2018-02-23 14:05 ` Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Robert Haas @ 2018-02-23 14:05 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; +Cc: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Fri, Feb 16, 2018 at 12:14 AM, Ashutosh Bapat
<ashutosh.bapat@enterprisedb.com> wrote:
> Appreciate you taking time for review.
>
> PFA updated version.
Committed 0001.
--
Robert Haas
EnterpriseDB: http://www.enterprisedb.com
The Enterprise PostgreSQL Company
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
@ 2018-02-26 10:03 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2018-02-26 10:03 UTC (permalink / raw)
To: Robert Haas <robertmhaas@gmail.com>; +Cc: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Fri, Feb 23, 2018 at 7:35 PM, Robert Haas <robertmhaas@gmail.com> wrote:
> On Fri, Feb 16, 2018 at 12:14 AM, Ashutosh Bapat
> <ashutosh.bapat@enterprisedb.com> wrote:
>> Appreciate you taking time for review.
>>
>> PFA updated version.
>
> Committed 0001.
Thanks.
Here's patchset rebased on the latest head. I have fixed all the
crashes and bugs reported till now.
One of the crash was related to the targetlist of child-join relation.
In basic partition-wise join, either all pairs of joining relations
can use partition-wise join technique or none can use it. So, the
joining pair which is used to create targetlist for a child-join
corresponds to the pair of joining relations used to create targetlist
for the parent join. With the restrictions related to missing
partitions discussed upthread, this isn't true with advanced partition
matching. The joining pair which is used to create targetlist for a
child-join may not correspond to the pair of joining relations used to
create targetlist for the parent join. Since these two pairs are
different build_joinrel_tlist() arranges the targetlist entries in
different order for child-join and parent-join. But for an appendrel,
we expect the parent and child targetlists in sync. So fix is: instead
of constructing the child-join targetlist from joining relations, we
construct it by translating the parent join. The basic partition-wise
join commit had changed build_joinrel_tlist() to handle child-joins
and it had changed set_append_rel_size() to compute attr_needed for
child relations so that that information can be used to built
child-join's targetlist. Both of those changes are not need because of
translation. I have added this fix as a separate patch with those two
changes reverted. When we will lift up the restrictions related to
missing partitions (I am not sure when), we will get back to a state
when joining pair which creates targetlist for child-join corresponds
to the joining pair which creates targetlist for the parent join. And
thus we don't need translation, which consumes more memory. We can use
attrs_needed information. So, may be we should retain those two
changes instead of reverting those. Any suggestions?
The extra extensive testcase advance_partition_join_test still fails
because of plan changes caused by recent changes to the append
costing. I have verified that those plan changes are fine and the
queries do not have any bugs or crashes. But that testcase has many
many queries and the plans are not stable. Since that testcase is not
meant for committing, I haven't fixed the plan diffs right now.
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
Attachments:
[application/x-gzip] pg_adv_dp_join_patches_v6.tar.gz (151.7K, ../../CAFjFpResoxfp1rnV4Op9JOnG19VNEnjvjRN5DVd8QRHD+agTDw@mail.gmail.com/2-pg_adv_dp_join_patches_v6.tar.gz)
download
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2018-03-11 19:34 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Dmitry Dolgov @ 2018-03-11 19:34 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
> On 26 February 2018 at 11:03, Ashutosh Bapat <ashutosh.bapat@enterprisedb.com> wrote:
> On Fri, Feb 23, 2018 at 7:35 PM, Robert Haas <robertmhaas@gmail.com> wrote:
>> On Fri, Feb 16, 2018 at 12:14 AM, Ashutosh Bapat
>> <ashutosh.bapat@enterprisedb.com> wrote:
>>> Appreciate you taking time for review.
>>>
>>> PFA updated version.
>>
>> Committed 0001.
>
> Thanks.
>
> Here's patchset rebased on the latest head. I have fixed all the
> crashes and bugs reported till now.
Hi,
I've stumbled upon this patch and noticed, that it's not compiled anymore after
2af28e6033, where `parttypcoll` was renamed to `partcollation`.
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
@ 2018-03-12 05:00 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2018-03-12 05:00 UTC (permalink / raw)
To: Dmitry Dolgov <9erthalion6@gmail.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Mon, Mar 12, 2018 at 1:04 AM, Dmitry Dolgov <9erthalion6@gmail.com> wrote:
>> On 26 February 2018 at 11:03, Ashutosh Bapat <ashutosh.bapat@enterprisedb.com> wrote:
>> On Fri, Feb 23, 2018 at 7:35 PM, Robert Haas <robertmhaas@gmail.com> wrote:
>>> On Fri, Feb 16, 2018 at 12:14 AM, Ashutosh Bapat
>>> <ashutosh.bapat@enterprisedb.com> wrote:
>>>> Appreciate you taking time for review.
>>>>
>>>> PFA updated version.
>>>
>>> Committed 0001.
>>
>> Thanks.
>>
>> Here's patchset rebased on the latest head. I have fixed all the
>> crashes and bugs reported till now.
>
> Hi,
>
> I've stumbled upon this patch and noticed, that it's not compiled anymore after
> 2af28e6033, where `parttypcoll` was renamed to `partcollation`.
Thanks for the note. Here are rebased patches.
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
Attachments:
[application/x-gzip] pg_adv_dp_join_patches_v7.tar.gz (151.7K, ../../CAFjFpRe6h54i6x73aKeTKqrKEA0C_yXC-Qz3WfBMM7KypFAvMQ@mail.gmail.com/2-pg_adv_dp_join_patches_v7.tar.gz)
download
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2018-03-21 23:02 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Dmitry Dolgov @ 2018-03-21 23:02 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
> On 12 March 2018 at 06:00, Ashutosh Bapat <ashutosh.bapat@enterprisedb.com> wrote:
> Thanks for the note. Here are rebased patches.
Since I started to look at this patch, I can share few random notes (although
it's not a complete review, I'm in the progress now), maybe it can be helpful.
In `partition_range_bounds_merge`
+ if (!merged)
+ break;
is a bit redundant I think, because every time `merged` set to false it
followed by break.
At the end same function
+ if (merged)
+ merged = merge_default_partitions(outer_bi, outer_pmap, outer_mmap,
+ inner_bi, inner_pmap, inner_mmap,
+ jointype, &next_index,
+ &default_index);
Looks like I misunderstand something in the algorithm, but aren't default
partitions were already processed before e.g. here:
+ /*
+ * Default partition on the outer side forms the default
+ * partition of the join result.
+ */
Also in here
+ /* Free any memory we used in this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ pfree(outer_pmap);
+ pfree(inner_pmap);
+ pfree(outer_mmap);
+ pfree(inner_mmap);
I think `merged_kinds` is missing.
I've noticed that in some places `IS_PARTITIONED_REL` was replaced
- if (!IS_PARTITIONED_REL(joinrel))
+ if (joinrel->part_scheme == NULL)
but I'm not quite follow why? Is it because `boundinfo` is not available
anymore at this point? If so, maybe it makes sense to update the commentary for
this macro and mention to not use for joinrel.
Also, as for me it would be helpful to have some commentary about this new
`partsupfunc`, what is exactly the purpose of it (but it's maybe just me
missing some obvious things from partitioning context)
+ FmgrInfo *partsupfunc;
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
@ 2018-03-22 13:18 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2018-03-22 13:18 UTC (permalink / raw)
To: Dmitry Dolgov <9erthalion6@gmail.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Thu, Mar 22, 2018 at 4:32 AM, Dmitry Dolgov <9erthalion6@gmail.com> wrote:
>> On 12 March 2018 at 06:00, Ashutosh Bapat <ashutosh.bapat@enterprisedb.com> wrote:
>> Thanks for the note. Here are rebased patches.
>
> Since I started to look at this patch, I can share few random notes (although
> it's not a complete review, I'm in the progress now), maybe it can be helpful.
>
> In `partition_range_bounds_merge`
>
> + if (!merged)
> + break;
>
> is a bit redundant I think, because every time `merged` set to false it
> followed by break.
Yes, right now. May be I should turn it into Assert(merged); What do you think?
>
> At the end same function
>
> + if (merged)
> + merged = merge_default_partitions(outer_bi, outer_pmap, outer_mmap,
> + inner_bi, inner_pmap, inner_mmap,
> + jointype, &next_index,
> + &default_index);
>
> Looks like I misunderstand something in the algorithm, but aren't default
> partitions were already processed before e.g. here:
>
> + /*
> + * Default partition on the outer side forms the default
> + * partition of the join result.
> + */
The default partition handling in the loop handles the cases of
missing partitions as explained in a comment
/*
* If a range appears in one of the joining relations but not the other
* (as a whole or part), the rows in the corresponding partition will
* not have join partners in the other relation, unless the other
* relation has a default partition.
But merge_default_partitions() tries to map the default partitions
from both the relations.
>
> Also in here
>
> + /* Free any memory we used in this function. */
> + list_free(merged_datums);
> + list_free(merged_indexes);
> + pfree(outer_pmap);
> + pfree(inner_pmap);
> + pfree(outer_mmap);
> + pfree(inner_mmap);
>
> I think `merged_kinds` is missing.
Done.
>
> I've noticed that in some places `IS_PARTITIONED_REL` was replaced
>
> - if (!IS_PARTITIONED_REL(joinrel))
> + if (joinrel->part_scheme == NULL)
>
> but I'm not quite follow why? Is it because `boundinfo` is not available
> anymore at this point? If so, maybe it makes sense to update the commentary for
> this macro and mention to not use for joinrel.
This is done in try_partitionwise_join(). As explained in the comment
/*
* Get the list of matching partitions to be joined along with the
* partition bounds of the join relation. Because of the restrictions
* imposed by partition matching algorithm, not every pair of joining
* relations for this join will be able to use partition-wise join. But all
* those pairs which can use partition-wise join will produce the same
* partition bounds for the join relation.
*/
boundinfo for the join relation is built in this function. So, we
don't have join relation's partitioning information fully set up yet.
So we can't use IS_PARTITIONED_REL() there. joinrel->part_scheme if
set tells that the joining relations have matching partition schemes
and thus the join relation can possibly use partition-wise join
technique. If it's not set, then we can't use partition-wise join.
But IS_PARTITIONED_REL() is still useful at a number of other places,
where it's known to encounter a RelOptInfo whose partitioning
properties are fully setup. So, I don't think we should change the
macro or the comments above it.
>
> Also, as for me it would be helpful to have some commentary about this new
> `partsupfunc`, what is exactly the purpose of it (but it's maybe just me
> missing some obvious things from partitioning context)
>
> + FmgrInfo *partsupfunc;
It's just copied from Relation::PartitionKey as is. It stores the
functions required to compare two partition key datums. Since we use
those functions frequently their FmgrInfo is cached.
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2018-03-28 21:23 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Dmitry Dolgov @ 2018-03-28 21:23 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
> On 22 March 2018 at 14:18, Ashutosh Bapat <ashutosh.bapat@enterprisedb.com> wrote:
> On Thu, Mar 22, 2018 at 4:32 AM, Dmitry Dolgov <9erthalion6@gmail.com> wrote:
>>> On 12 March 2018 at 06:00, Ashutosh Bapat <ashutosh.bapat@enterprisedb.com> wrote:
>>> Thanks for the note. Here are rebased patches.
>>
>> Since I started to look at this patch, I can share few random notes (although
>> it's not a complete review, I'm in the progress now), maybe it can be helpful.
>>
>> In `partition_range_bounds_merge`
>>
>> + if (!merged)
>> + break;
>>
>> is a bit redundant I think, because every time `merged` set to false it
>> followed by break.
>
> Yes, right now. May be I should turn it into Assert(merged); What do you think?
Thank you for reply. Yes, that sounds good. But actually you also mentioned
another topic that bothers me about this patch. Different parts of the
algorithm implementation (at least for functions that build maps of matching
partitions) are quite dependent on each other in terms of shared state. At
first glance in `partition_range_bounds_merge` we have about a dozen of
variables of different mutability level, that affect the control flow:
outer_lb_index
inner_lb_index
merged
merged_index
overlap
merged_lb
merged_ub
finished_outer
finished_inner
ub_cmpval
lb_cmpval
inner_has_default
outer_has_default
jointype
It looks a bit too much for me, and would require commentaries like "if you
changed the logic here, also take a look there". But I'm not saying that I have
any specific suggestions how to change it (although I'll definitely try to do
so, at least to get some better understanding of the underlying algorithm).
>>
>> I've noticed that in some places `IS_PARTITIONED_REL` was replaced
>>
>> - if (!IS_PARTITIONED_REL(joinrel))
>> + if (joinrel->part_scheme == NULL)
>>
>> but I'm not quite follow why? Is it because `boundinfo` is not available
>> anymore at this point? If so, maybe it makes sense to update the commentary for
>> this macro and mention to not use for joinrel.
>
>
> This is done in try_partitionwise_join(). As explained in the comment
>
> * Get the list of matching partitions to be joined along with the
> * partition bounds of the join relation. Because of the restrictions
> * imposed by partition matching algorithm, not every pair of joining
> * relations for this join will be able to use partition-wise join. But all
> * those pairs which can use partition-wise join will produce the same
> * partition bounds for the join relation.
>
> boundinfo for the join relation is built in this function. So, we
> don't have join relation's partitioning information fully set up yet.
> So we can't use IS_PARTITIONED_REL() there. joinrel->part_scheme if
> set tells that the joining relations have matching partition schemes
> and thus the join relation can possibly use partition-wise join
> technique. If it's not set, then we can't use partition-wise join.
>
> But IS_PARTITIONED_REL() is still useful at a number of other places,
> where it's known to encounter a RelOptInfo whose partitioning
> properties are fully setup. So, I don't think we should change the
> macro or the comments above it.
Just to make myself clear, I wanted to suggest not to change the commentary for
`IS_PARTITIONED_REL` significantly, but just add a sentence that you need to
check if given relation is fully set up.
Also, few more random notes (mostly related to readability, since I found some
parts of the patch hard to read, but of course it's arguable).
```
PartitionRangeBound outer_lb;
PartitionRangeBound outer_ub;
PartitionRangeBound inner_lb;
PartitionRangeBound inner_ub;
PartitionRangeBound *merged_lb = NULL;
PartitionRangeBound *merged_ub = NULL;
```
Maybe it would be better to not repeat the type here? Let's say:
```
PartitionRangeBound outer_lb,
outer_ub,
...
```
It's just too long and distracting.
```
partition_range_bounds_merge(int partnatts, FmgrInfo *partsupfuncs,
Oid *partcollations, PartitionBoundInfo outer_bi,
int outer_nparts, PartitionBoundInfo inner_bi,
int inner_nparts, JoinType jointype,
List **outer_parts, List **inner_parts)
```
From what I see in `partition.c` there are a lot functions that accept
`partnatts`, `partcollations` only to pass it down to, e.g.
`partition_rbound_cmp`.
What do you think about introducing a data structure to keep these arguments,
and pass only an instance of this structure instead?
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
@ 2018-03-30 14:06 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2018-03-30 14:06 UTC (permalink / raw)
To: Dmitry Dolgov <9erthalion6@gmail.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
Thanks for your review comments. They are helpful.
On Thu, Mar 29, 2018 at 2:53 AM, Dmitry Dolgov <9erthalion6@gmail.com> wrote:
> But actually you also mentioned
> another topic that bothers me about this patch. Different parts of the
> algorithm implementation (at least for functions that build maps of matching
> partitions) are quite dependent on each other in terms of shared state. At
> first glance in `partition_range_bounds_merge` we have about a dozen of
> variables of different mutability level, that affect the control flow:
>
> outer_lb_index
> inner_lb_index
> merged
> merged_index
> overlap
> merged_lb
> merged_ub
> finished_outer
> finished_inner
> ub_cmpval
> lb_cmpval
> inner_has_default
> outer_has_default
> jointype
>
> It looks a bit too much for me, and would require commentaries like "if you
> changed the logic here, also take a look there". But I'm not saying that I have
> any specific suggestions how to change it (although I'll definitely try to do
> so, at least to get some better understanding of the underlying algorithm).
I am working on commenting portions of the code to make it more clear
and readable. Will update the patches with the comments soon, mostly
this Monday.
>
> Just to make myself clear, I wanted to suggest not to change the commentary for
> `IS_PARTITIONED_REL` significantly, but just add a sentence that you need to
> check if given relation is fully set up.
For that we have REL_HAS_ALL_PART_PROPS. IS_PARTITIONED_REL is really
checking whether a relation is partitioned and following comment makes
it clear why we have to check all those things. So, I still don't see
why we need to change the comment there.
* It's not enough to test whether rel->part_scheme is set, because it might
* be that the basic partitioning properties of the input relations matched
* but the partition bounds did not.
> Also, few more random notes (mostly related to readability, since I found some
> parts of the patch hard to read, but of course it's arguable).
>
> ```
> PartitionRangeBound outer_lb;
> PartitionRangeBound outer_ub;
> PartitionRangeBound inner_lb;
> PartitionRangeBound inner_ub;
> PartitionRangeBound *merged_lb = NULL;
> PartitionRangeBound *merged_ub = NULL;
> ```
>
> Maybe it would be better to not repeat the type here? Let's say:
>
> ```
> PartitionRangeBound outer_lb,
> outer_ub,
PostgreSQL code uses both the styles, but I like declarations with the
type is right there along side the variable. It also makes it easy to
delete the variable or modify its type, without causing unnecessary
diff on adjacent lines.
> ```
> partition_range_bounds_merge(int partnatts, FmgrInfo *partsupfuncs,
> Oid *partcollations, PartitionBoundInfo outer_bi,
> int outer_nparts, PartitionBoundInfo inner_bi,
> int inner_nparts, JoinType jointype,
> List **outer_parts, List **inner_parts)
> ```
>
> From what I see in `partition.c` there are a lot functions that accept
> `partnatts`, `partcollations` only to pass it down to, e.g.
> `partition_rbound_cmp`.
> What do you think about introducing a data structure to keep these arguments,
> and pass only an instance of this structure instead?
I have discussed this in an adjacent thread, but let me repeat it
here. Those members come from PartitionKey or PartitionScheme. If we
pack those in a structure and not include it in those two
structures,we will just create a structure before calling the function
and unpack those inside the comparison function e.g.
partition_rbound_cmp(). We could argue that that will benefit
intermediate functions like partition_range_bound_cmp(), which just
pass those values down, but there is all the possibility that its
future caller may not have that packing structure available readily.
So, I am inclined not to add a new structure just for this.
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2018-04-03 13:34 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2018-04-03 13:34 UTC (permalink / raw)
To: Dmitry Dolgov <9erthalion6@gmail.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Fri, Mar 30, 2018 at 7:36 PM, Ashutosh Bapat
<ashutosh.bapat@enterprisedb.com> wrote:
>
> I am working on commenting portions of the code to make it more clear
> and readable. Will update the patches with the comments soon, mostly
> this Monday.
>
Here's set of patches rebased on the latest head. I have added a lot
of comments and revised a lot of code to avoid duplication, causing a
net reduction in the number of lines.
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
Attachments:
[application/x-gzip] pg_adv_dp_join_patches_v8.tar.gz (152.8K, ../../CAFjFpReaKE+R+D3eKQyYvmGKfZ=kXUsjvMqWNn0dxjSG=n63Qg@mail.gmail.com/2-pg_adv_dp_join_patches_v8.tar.gz)
download
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2018-05-06 19:36 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Dmitry Dolgov @ 2018-05-06 19:36 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
> On 3 April 2018 at 15:34, Ashutosh Bapat <ashutosh.bapat@enterprisedb.com> wrote:
> On Fri, Mar 30, 2018 at 7:36 PM, Ashutosh Bapat
> <ashutosh.bapat@enterprisedb.com> wrote:
>>
>> I am working on commenting portions of the code to make it more clear
>> and readable. Will update the patches with the comments soon, mostly
>> this Monday.
>>
>
> Here's set of patches rebased on the latest head. I have added a lot
> of comments and revised a lot of code to avoid duplication, causing a
> net reduction in the number of lines.
Thank you. Unfortunately, there are already few more conflicts since last time,
could you rebase again?
In the meantime, I'm a bit confused by `merge_null_partitions` and why
partitions with NULL values should be treated separately? It became even more
confusing when I looked at where this functions is used:
/* If merge is unsuccessful, bail out without any further processing. */
if (merged)
merged = merge_null_partitions(outer_bi, outer_pmap, outer_mmap,
inner_bi, inner_pmap, inner_mmap,
jointype, &next_index, &null_index,
&default_index);
Is this commentary correct?
Also, I don't see anywhere in PostgreSQL itself or in this patch a definition
of the term "NULL partition", can you add it, just to make things clear?
Another question, I see this pattern a lot here when there is a code like:
if (!outer_has_something && inner_has_something)
{
// some logic
}
else if (outer_has_something && !inner_has_something)
{
// some logic symmetric to what we have above
}
By symmetric I mean that the code is more or less the same, just "inner"
variables were changed to "outer" (and required types of joins are opposite).
Is it feasible to actually use completely the same logic, and just change
"inner"/"outer" variables instead?
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
@ 2018-05-14 11:14 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2018-05-14 11:14 UTC (permalink / raw)
To: Dmitry Dolgov <9erthalion6@gmail.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
Thanks Dmitry for your review.
On Mon, May 7, 2018 at 1:06 AM, Dmitry Dolgov <9erthalion6@gmail.com> wrote:
>
> Thank you. Unfortunately, there are already few more conflicts since last time,
> could you rebase again?
Done.
>
> In the meantime, I'm a bit confused by `merge_null_partitions` and why
> partitions with NULL values should be treated separately? It became even more
> confusing when I looked at where this functions is used:
>
> /* If merge is unsuccessful, bail out without any further processing. */
> if (merged)
> merged = merge_null_partitions(outer_bi, outer_pmap, outer_mmap,
> inner_bi, inner_pmap, inner_mmap,
> jointype, &next_index, &null_index,
> &default_index);
>
> Is this commentary correct?
I agree. It's misleading. Removed.
>
> Also, I don't see anywhere in PostgreSQL itself or in this patch a definition
> of the term "NULL partition", can you add it, just to make things clear?
By NULL partition, I mean a list partition which holds NULL values.
Added that clarification in the prologue of merge_null_partitions().
>
> Another question, I see this pattern a lot here when there is a code like:
>
> if (!outer_has_something && inner_has_something)
> {
> // some logic
> }
> else if (outer_has_something && !inner_has_something)
> {
> // some logic symmetric to what we have above
> }
>
> By symmetric I mean that the code is more or less the same, just "inner"
> variables were changed to "outer" (and required types of joins are opposite).
> Is it feasible to actually use completely the same logic, and just change
> "inner"/"outer" variables instead?
I have added handle_missing_partition() for the same purpose. But I
didn't use it in merge_null_partitions(), which I have done in the
attached patches. Now the number of such instances are just at two
places one in merge_default_partitions() and the other in
handle_missing_partition(). But they are different enough not to
extract into a common function.
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
Attachments:
[application/x-gzip] pg_adv_dp_join_patches_v9.tar.gz (152.5K, ../../CAFjFpRfx7XHF_Pn-6_zSSCmrHQ9GHROt3GqmKzJeqW4e77Auiw@mail.gmail.com/2-pg_adv_dp_join_patches_v9.tar.gz)
download
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2018-06-26 08:57 ` Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Amit Langote @ 2018-06-26 08:57 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; Dmitry Dolgov <9erthalion6@gmail.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
Hi Ashutosh,
On 2018/05/14 20:14, Ashutosh Bapat wrote:
> 0001-Hash-partition-bound-equality-refactoring.patch
> 0002-Targetlist-of-a-child-join-is-produced-by-translatin.patch
> 0003-Partition-wise-join-for-1-1-1-0-0-1-partition-matchi.patch
> 0004-Add-a-debug-message-to-notify-whether-partition-wise.patch
> 0005-Tests-for-0-1-1-1-and-1-0-partition-matching.patch
> 0006-Extra-extensive-tests-for-advanced-partition-matchin.patch
I noticed after *cleanly* applying 0001-0004 to today's HEAD that while
0005's test all pass, there are many failures in 0006's tests. Maybe, you
need to adjust something in one of the patches or adjust test outputs.
Thanks,
Amit
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
@ 2018-06-26 09:02 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2018-06-26 09:02 UTC (permalink / raw)
To: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; +Cc: Dmitry Dolgov <9erthalion6@gmail.com>; Robert Haas <robertmhaas@gmail.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Tue, Jun 26, 2018 at 2:27 PM, Amit Langote
<Langote_Amit_f8@lab.ntt.co.jp> wrote:
> Hi Ashutosh,
>
> On 2018/05/14 20:14, Ashutosh Bapat wrote:
>> 0001-Hash-partition-bound-equality-refactoring.patch
>> 0002-Targetlist-of-a-child-join-is-produced-by-translatin.patch
>> 0003-Partition-wise-join-for-1-1-1-0-0-1-partition-matchi.patch
>> 0004-Add-a-debug-message-to-notify-whether-partition-wise.patch
>> 0005-Tests-for-0-1-1-1-and-1-0-partition-matching.patch
>> 0006-Extra-extensive-tests-for-advanced-partition-matchin.patch
>
> I noticed after *cleanly* applying 0001-0004 to today's HEAD that while
> 0005's test all pass, there are many failures in 0006's tests. Maybe, you
> need to adjust something in one of the patches or adjust test outputs.
If the failures are because of plan changes, it's expected. If those
are because of crashes or changed output, those need to be fixed. I
have kept that patch to notice any crashes or output changes, in which
case, I pull that test into 0005 test set after fixing the code. Once
we are near commit, I will remove that patch from the patchset.
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2018-06-27 06:58 ` Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Amit Langote @ 2018-06-27 06:58 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; +Cc: Dmitry Dolgov <9erthalion6@gmail.com>; Robert Haas <robertmhaas@gmail.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On 2018/06/26 18:02, Ashutosh Bapat wrote:
> On Tue, Jun 26, 2018 at 2:27 PM, Amit Langote
> <Langote_Amit_f8@lab.ntt.co.jp> wrote:
>> Hi Ashutosh,
>>
>> On 2018/05/14 20:14, Ashutosh Bapat wrote:
>>> 0001-Hash-partition-bound-equality-refactoring.patch
>>> 0002-Targetlist-of-a-child-join-is-produced-by-translatin.patch
>>> 0003-Partition-wise-join-for-1-1-1-0-0-1-partition-matchi.patch
>>> 0004-Add-a-debug-message-to-notify-whether-partition-wise.patch
>>> 0005-Tests-for-0-1-1-1-and-1-0-partition-matching.patch
>>> 0006-Extra-extensive-tests-for-advanced-partition-matchin.patch
>>
>> I noticed after *cleanly* applying 0001-0004 to today's HEAD that while
>> 0005's test all pass, there are many failures in 0006's tests. Maybe, you
>> need to adjust something in one of the patches or adjust test outputs.
>
> If the failures are because of plan changes, it's expected. If those
> are because of crashes or changed output, those need to be fixed. I
> have kept that patch to notice any crashes or output changes, in which
> case, I pull that test into 0005 test set after fixing the code. Once
> we are near commit, I will remove that patch from the patchset.
Ah, okay. I thought of reporting this because I felt the errors may have
to do with changes to the related code in HEAD between May 14 when you
last posted the patches and today that you may need to account for in you
patches. For instance, there are many diffs like this:
***************
*** 90,132 ****
-- left outer join, with whole-row reference
EXPLAIN (COSTS OFF)
SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b =
0 ORDER BY t1.a, t1.b, t1.c, t2.a, t2.b, t2.c;
! QUERY PLAN
! --------------------------------------------------------
Sort
Sort Key: t1.a, t1.c, t2.a, t2.b, t2.c
! -> Result
! -> Append
! -> Hash Right Join
! Hash Cond: (t2.b = t1.a)
! -> Seq Scan on prt2_p0 t2
! -> Hash
! -> Seq Scan on prt1_p0 t1
<snip>
--- 90,131 ----
-- left outer join, with whole-row reference
EXPLAIN (COSTS OFF)
SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b =
0 ORDER BY t1.a, t1.b, t1.c, t2.a, t2.b, t2.c;
! QUERY PLAN
! --------------------------------------------------
Sort
Sort Key: t1.a, t1.c, t2.a, t2.b, t2.c
! -> Append
! -> Hash Right Join
! Hash Cond: (t2.b = t1.a)
! -> Seq Scan on prt2_p0 t2
! -> Hash
! -> Seq Scan on prt1_p0 t1
! Filter: (b = 0)
Looks like the Result node on top of Append is no longer there after
applying your patch.
Thanks,
Amit
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
@ 2018-06-27 13:21 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2018-06-27 13:21 UTC (permalink / raw)
To: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; +Cc: Dmitry Dolgov <9erthalion6@gmail.com>; Robert Haas <robertmhaas@gmail.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Wed, Jun 27, 2018 at 12:28 PM, Amit Langote
<Langote_Amit_f8@lab.ntt.co.jp> wrote:
> On 2018/06/26 18:02, Ashutosh Bapat wrote:
>> On Tue, Jun 26, 2018 at 2:27 PM, Amit Langote
>> <Langote_Amit_f8@lab.ntt.co.jp> wrote:
>>> Hi Ashutosh,
>>>
>>> On 2018/05/14 20:14, Ashutosh Bapat wrote:
>>>> 0001-Hash-partition-bound-equality-refactoring.patch
>>>> 0002-Targetlist-of-a-child-join-is-produced-by-translatin.patch
>>>> 0003-Partition-wise-join-for-1-1-1-0-0-1-partition-matchi.patch
>>>> 0004-Add-a-debug-message-to-notify-whether-partition-wise.patch
>>>> 0005-Tests-for-0-1-1-1-and-1-0-partition-matching.patch
>>>> 0006-Extra-extensive-tests-for-advanced-partition-matchin.patch
>>>
>>> I noticed after *cleanly* applying 0001-0004 to today's HEAD that while
>>> 0005's test all pass, there are many failures in 0006's tests. Maybe, you
>>> need to adjust something in one of the patches or adjust test outputs.
>>
>> If the failures are because of plan changes, it's expected. If those
>> are because of crashes or changed output, those need to be fixed. I
>> have kept that patch to notice any crashes or output changes, in which
>> case, I pull that test into 0005 test set after fixing the code. Once
>> we are near commit, I will remove that patch from the patchset.
>
> Ah, okay. I thought of reporting this because I felt the errors may have
> to do with changes to the related code in HEAD between May 14 when you
> last posted the patches and today that you may need to account for in you
> patches. For instance, there are many diffs like this:
>
> ***************
> *** 90,132 ****
> -- left outer join, with whole-row reference
> EXPLAIN (COSTS OFF)
> SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b =
> 0 ORDER BY t1.a, t1.b, t1.c, t2.a, t2.b, t2.c;
> ! QUERY PLAN
> ! --------------------------------------------------------
> Sort
> Sort Key: t1.a, t1.c, t2.a, t2.b, t2.c
> ! -> Result
> ! -> Append
> ! -> Hash Right Join
> ! Hash Cond: (t2.b = t1.a)
> ! -> Seq Scan on prt2_p0 t2
> ! -> Hash
> ! -> Seq Scan on prt1_p0 t1
> <snip>
>
> --- 90,131 ----
> -- left outer join, with whole-row reference
> EXPLAIN (COSTS OFF)
> SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b =
> 0 ORDER BY t1.a, t1.b, t1.c, t2.a, t2.b, t2.c;
> ! QUERY PLAN
> ! --------------------------------------------------
> Sort
> Sort Key: t1.a, t1.c, t2.a, t2.b, t2.c
> ! -> Append
> ! -> Hash Right Join
> ! Hash Cond: (t2.b = t1.a)
> ! -> Seq Scan on prt2_p0 t2
> ! -> Hash
> ! -> Seq Scan on prt1_p0 t1
> ! Filter: (b = 0)
>
> Looks like the Result node on top of Append is no longer there after
> applying your patch.
Yes. They are coming because of a commit which removed Result node on
top of an Append node. I don't remember exactly which.
I wouldn't worry about those diffs at this time. As I have mentioned
in earlier mails, the expected output from 0006 is quite large and is
not supposed to be committed. So, I don't see much value in fixing the
plans in that output.
Do you see that as a hindrance in reviewing the code changes and tests in 0005?
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2018-06-28 05:53 ` Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Amit Langote @ 2018-06-28 05:53 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; +Cc: Dmitry Dolgov <9erthalion6@gmail.com>; Robert Haas <robertmhaas@gmail.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On 2018/06/27 22:21, Ashutosh Bapat wrote:
> On Wed, Jun 27, 2018 at 12:28 PM, Amit Langote
>> Ah, okay. I thought of reporting this because I felt the errors may have
>> to do with changes to the related code in HEAD between May 14 when you
>> last posted the patches and today that you may need to account for in you
>> patches. For instance, there are many diffs like this:
>>
>> Looks like the Result node on top of Append is no longer there after
>> applying your patch.
>
> Yes. They are coming because of a commit which removed Result node on
> top of an Append node. I don't remember exactly which.
>
> I wouldn't worry about those diffs at this time. As I have mentioned
> in earlier mails, the expected output from 0006 is quite large and is
> not supposed to be committed. So, I don't see much value in fixing the
> plans in that output.
>
> Do you see that as a hindrance in reviewing the code changes and tests in 0005?
I think not. I'll ignore 0006 for now and focus on other patches.
Thanks,
Amit
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
@ 2018-07-15 17:43 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-16 15:01 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 2 replies; 154+ messages in thread
From: Dmitry Dolgov @ 2018-07-15 17:43 UTC (permalink / raw)
To: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; +Cc: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; Robert Haas <robertmhaas@gmail.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
> On Thu, 28 Jun 2018 at 07:54, Amit Langote <Langote_Amit_f8@lab.ntt.co.jp> wrote:
>
> On 2018/06/27 22:21, Ashutosh Bapat wrote:
> > On Wed, Jun 27, 2018 at 12:28 PM, Amit Langote
> >> Ah, okay. I thought of reporting this because I felt the errors may have
> >> to do with changes to the related code in HEAD between May 14 when you
> >> last posted the patches and today that you may need to account for in you
> >> patches. For instance, there are many diffs like this:
> >>
> >> Looks like the Result node on top of Append is no longer there after
> >> applying your patch.
> >
> > Yes. They are coming because of a commit which removed Result node on
> > top of an Append node. I don't remember exactly which.
> >
> > I wouldn't worry about those diffs at this time. As I have mentioned
> > in earlier mails, the expected output from 0006 is quite large and is
> > not supposed to be committed. So, I don't see much value in fixing the
> > plans in that output.
> >
> > Do you see that as a hindrance in reviewing the code changes and tests in 0005?
>
> I think not. I'll ignore 0006 for now and focus on other patches.
Hi,
Sorry for my irregular reviews. Unfortunately, the patch need to be rebased
again. In the meantime I have few more commentaries about range_bounds_merge:
* From what I see partition_range_bound_cmp is executed on the same bounds few
times to find whether they are overlapping and during the range merging, is
it necessary? Probably it would be enough just to compare current ranges once
per iteration.
* Just to clarify - the iterating through all the partitions, is it the best
way of finding matching ranges? Correct me if I'm wrong, but from what I see
in the comments for PartitionBoundInfoData, all the ranges are arranged in
increasing order - maybe then it's possible to use binary search for finding
a matching range?
* I'm not sure why in this case partition wise join is not applied? Maybe I'm
wrong, but I was under the impression that it should work here
=# \d+ test1;
Table "public.test1"
Column | Type | Collation | Nullable | Default | Storage |
--------+---------+-----------+----------+---------+----------+
data | jsonb | | | | extended |
id | integer | | | | plain |
Partition key: RANGE (id)
Indexes:
"test1_idx" btree (id)
Partitions: test11 FOR VALUES FROM (0) TO (100),
test12 FOR VALUES FROM (100) TO (200),
test13 FOR VALUES FROM (200) TO (300)
=# \d+ test2;
Table "public.test2"
Column | Type | Collation | Nullable | Default | Storage |
--------+---------+-----------+----------+---------+----------+
data | jsonb | | | | extended |
id | integer | | | | plain |
Partition key: RANGE (id)
Indexes:
"test2_idx" btree (id)
Partitions: test21 FOR VALUES FROM (10) TO (110),
test22 FOR VALUES FROM (110) TO (210),
test23 FOR VALUES FROM (210) TO (310)
=# set enable_partitionwise_join to true;
=# explain analyze select * from test1 t1 inner join test2 t2 using (id);
QUERY PLAN
-------------------------------------------------------------------------------
Hash Join (cost=3.25..6.56 rows=9 width=54)
(actual time=0.082..0.105 rows=3 loops=1)
Hash Cond: (t1.id = t2.id)
-> Append (cost=0.00..3.18 rows=12 width=29)
(actual time=0.026..0.047 rows=12 loops=1)
-> Seq Scan on test11 t1 (cost=0.00..1.05 rows=5 width=29)
(actual time=0.025..0.028 rows=5 loops=1)
-> Seq Scan on test12 t1_1 (cost=0.00..1.04 rows=4 width=29)
(actual time=0.006..0.0 07 rows=4 loops=1)
-> Seq Scan on test13 t1_2 (cost=0.00..1.03 rows=3 width=29)
(actual time=0.005..0.0 06 rows=3 loops=1)
-> Hash (cost=3.13..3.13 rows=9 width=29)
(actual time=0.033..0.033 rows=9 loops=1)
Buckets: 1024 Batches: 1 Memory Usage: 9kB
-> Append (cost=0.00..3.13 rows=9 width=29)
(actual time=0.006..0.022 rows=9 loops=1)
-> Seq Scan on test21 t2
(cost=0.00..1.03 rows=3 width=29)
(actual time=0.005. .0.008 rows=3 loops=1)
-> Seq Scan on test22 t2_1
(cost=0.00..1.03 rows=3 width=29)
(actual time=0.00 4..0.005 rows=3 loops=1)
-> Seq Scan on test23 t2_2
(cost=0.00..1.03 rows=3 width=29)
(actual time=0.00 3..0.004 rows=3 loops=1)
Planning Time: 0.921 ms
Execution Time: 0.261 ms
(14 rows)
=# set enable_partitionwise_join to false;
=# explain analyze select * from test1 t1 inner join test2 t2 using (id);
QUERY PLAN
-------------------------------------------------------------------------------
Hash Join (cost=3.25..6.56 rows=9 width=54)
(actual time=0.073..0.095 rows=3 loops=1)
Hash Cond: (t1.id = t2.id)
-> Append (cost=0.00..3.18 rows=12 width=29)
(actual time=0.022..0.041 rows=12 loops=1)
-> Seq Scan on test11 t1 (cost=0.00..1.05 rows=5 width=29)
(actual time=0.021..0.024 rows=5 loops=1)
-> Seq Scan on test12 t1_1 (cost=0.00..1.04 rows=4 width=29)
(actual time=0.006..0.0 07 rows=4 loops=1)
-> Seq Scan on test13 t1_2 (cost=0.00..1.03 rows=3 width=29)
(actual time=0.004..0.0 05 rows=3 loops=1)
-> Hash (cost=3.13..3.13 rows=9 width=29)
(actual time=0.031..0.031 rows=9 loops=1)
Buckets: 1024 Batches: 1 Memory Usage: 9kB
-> Append (cost=0.00..3.13 rows=9 width=29)
(actual time=0.006..0.021 rows=9 loops=1)
-> Seq Scan on test21 t2
(cost=0.00..1.03 rows=3 width=29)
(actual time=0.005. .0.008 rows=3 loops=1)
-> Seq Scan on test22 t2_1
(cost=0.00..1.03 rows=3 width=29)
(actual time=0.00 3..0.004 rows=3 loops=1)
-> Seq Scan on test23 t2_2
(cost=0.00..1.03 rows=3 width=29)
(actual time=0.00 3..0.004 rows=3 loops=1)
Planning Time: 1.154 ms
Execution Time: 0.201 ms
(14 rows)
My investigation shows that the merge function stops on the second iteration
because of this condition:
/*
* Multiple partitions from one relation map to one partition from the
* other relation. Partition-wise join does not handle this case right
* now, since it requires ganging multiple partitions together (into
* one RelOptInfo).
*/
merged_index = -1;
I'm confused, since there is only one-to-one mapping of partitions.
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
@ 2018-07-16 15:01 ` Robert Haas <robertmhaas@gmail.com>
1 sibling, 0 replies; 154+ messages in thread
From: Robert Haas @ 2018-07-16 15:01 UTC (permalink / raw)
To: Dmitry Dolgov <9erthalion6@gmail.com>; +Cc: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Sun, Jul 15, 2018 at 1:43 PM, Dmitry Dolgov <9erthalion6@gmail.com> wrote:
> Partitions: test11 FOR VALUES FROM (0) TO (100),
> test12 FOR VALUES FROM (100) TO (200),
> test13 FOR VALUES FROM (200) TO (300)
>
> Partitions: test21 FOR VALUES FROM (10) TO (110),
> test22 FOR VALUES FROM (110) TO (210),
> test23 FOR VALUES FROM (210) TO (310)
>
> I'm confused, since there is only one-to-one mapping of partitions.
No, test21 would have to be joined to both test11 and test12, since
either could contain matching rows. Also, test22 would have to be
joined to both test12 and test13.
--
Robert Haas
EnterpriseDB: http://www.enterprisedb.com
The Enterprise PostgreSQL Company
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
@ 2018-07-17 09:58 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
1 sibling, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2018-07-17 09:58 UTC (permalink / raw)
To: Dmitry Dolgov <9erthalion6@gmail.com>; +Cc: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Robert Haas <robertmhaas@gmail.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Sun, Jul 15, 2018 at 11:13 PM, Dmitry Dolgov <9erthalion6@gmail.com> wrote:
>> On Thu, 28 Jun 2018 at 07:54, Amit Langote <Langote_Amit_f8@lab.ntt.co.jp> wrote:
>>
>> On 2018/06/27 22:21, Ashutosh Bapat wrote:
>> > On Wed, Jun 27, 2018 at 12:28 PM, Amit Langote
>> >> Ah, okay. I thought of reporting this because I felt the errors may have
>> >> to do with changes to the related code in HEAD between May 14 when you
>> >> last posted the patches and today that you may need to account for in you
>> >> patches. For instance, there are many diffs like this:
>> >>
>> >> Looks like the Result node on top of Append is no longer there after
>> >> applying your patch.
>> >
>> > Yes. They are coming because of a commit which removed Result node on
>> > top of an Append node. I don't remember exactly which.
>> >
>> > I wouldn't worry about those diffs at this time. As I have mentioned
>> > in earlier mails, the expected output from 0006 is quite large and is
>> > not supposed to be committed. So, I don't see much value in fixing the
>> > plans in that output.
>> >
>> > Do you see that as a hindrance in reviewing the code changes and tests in 0005?
>>
>> I think not. I'll ignore 0006 for now and focus on other patches.
>
> Hi,
>
> Sorry for my irregular reviews. Unfortunately, the patch need to be rebased
> again.
I rebased the patches without any problem on top of commit
commit f7cb2842bf47715133b40e4a503f35dbe60d1b72
Author: Peter Eisentraut <peter_e@gmx.net>
Date: Mon Jul 16 13:35:41 2018 +0200
Add plan_cache_mode setting
This allows overriding the choice of custom or generic plan.
Author: Pavel Stehule <pavel.stehule@gmail.com>
Discussion:
https://www.postgresql.org/message-id/flat/CAFj8pRAGLaiEm8ur5DWEBo7qHRWTk9HxkuUAz00CZZtJj-LkCA%40mai...
I didn't get any problem rebasing the patches. They compiled cleanly.
The tests added by commit 4513d3a4be0bb7d0141f8b7eaf669a55c08e41b0
failed since this patch-set changes the partitions of the tables used
in the test. Adjusted those tests accordingly.
> In the meantime I have few more commentaries about range_bounds_merge:
>
> * From what I see partition_range_bound_cmp is executed on the same bounds few
> times to find whether they are overlapping and during the range merging, is
> it necessary? Probably it would be enough just to compare current ranges once
> per iteration.
The bounds that are compared in those cases are different. Any two
bounds are compared only once per iteration. Remember each range has
two bounds, thus there are total four comparisons possible. In case of
overlap, we do all four comparisons.
>
> * Just to clarify - the iterating through all the partitions, is it the best
> way of finding matching ranges? Correct me if I'm wrong, but from what I see
> in the comments for PartitionBoundInfoData, all the ranges are arranged in
> increasing order - maybe then it's possible to use binary search for finding
> a matching range?
The loop in partition_range_bounds_merge() runs as many times as the
maximum of number of datums from the given partition bounds. So the
complexity is O(n) where n is the maximum of number of datums. With
binary search the complexity will increase to O(nlogn). I might be
missing something here.
>
> * I'm not sure why in this case partition wise join is not applied? Maybe I'm
> wrong, but I was under the impression that it should work here
>
> =# \d+ test1;
> Table "public.test1"
> Column | Type | Collation | Nullable | Default | Storage |
> --------+---------+-----------+----------+---------+----------+
> data | jsonb | | | | extended |
> id | integer | | | | plain |
> Partition key: RANGE (id)
> Indexes:
> "test1_idx" btree (id)
> Partitions: test11 FOR VALUES FROM (0) TO (100),
> test12 FOR VALUES FROM (100) TO (200),
> test13 FOR VALUES FROM (200) TO (300)
>
> =# \d+ test2;
> Table "public.test2"
> Column | Type | Collation | Nullable | Default | Storage |
> --------+---------+-----------+----------+---------+----------+
> data | jsonb | | | | extended |
> id | integer | | | | plain |
> Partition key: RANGE (id)
> Indexes:
> "test2_idx" btree (id)
> Partitions: test21 FOR VALUES FROM (10) TO (110),
> test22 FOR VALUES FROM (110) TO (210),
> test23 FOR VALUES FROM (210) TO (310)
>
>
> I'm confused, since there is only one-to-one mapping of partitions.
In this case, test21 overlaps test11 (10-100) and test12 (100-110),
test22 overlaps test12 (110-200) and test13(200-210). So, there is no
one-to-one mapping.
PFA rebased patches with tests fixed as described above.
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
Attachments:
[application/gzip] pg_adv_dp_join_patches_v10.tar.gz (153.9K, ../../CAFjFpReKuV_4LRRfdy80BqX8oZfwbo+HWLQNv3CsJ5iGPSyTfA@mail.gmail.com/2-pg_adv_dp_join_patches_v10.tar.gz)
download
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2018-07-19 19:04 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Dmitry Dolgov @ 2018-07-19 19:04 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; +Cc: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Robert Haas <robertmhaas@gmail.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
> On Tue, 17 Jul 2018 at 11:58, Ashutosh Bapat <ashutosh.bapat@enterprisedb.com> wrote:
>
> On Sun, Jul 15, 2018 at 11:13 PM, Dmitry Dolgov <9erthalion6@gmail.com> wrote:
> >> On Thu, 28 Jun 2018 at 07:54, Amit Langote <Langote_Amit_f8@lab.ntt.co.jp> wrote:
> >>
> >> On 2018/06/27 22:21, Ashutosh Bapat wrote:
> >> > On Wed, Jun 27, 2018 at 12:28 PM, Amit Langote
> >> >> Ah, okay. I thought of reporting this because I felt the errors may have
> >> >> to do with changes to the related code in HEAD between May 14 when you
> >> >> last posted the patches and today that you may need to account for in you
> >> >> patches. For instance, there are many diffs like this:
> >> >>
> >> >> Looks like the Result node on top of Append is no longer there after
> >> >> applying your patch.
> >> >
> >> > Yes. They are coming because of a commit which removed Result node on
> >> > top of an Append node. I don't remember exactly which.
> >> >
> >> > I wouldn't worry about those diffs at this time. As I have mentioned
> >> > in earlier mails, the expected output from 0006 is quite large and is
> >> > not supposed to be committed. So, I don't see much value in fixing the
> >> > plans in that output.
> >> >
> >> > Do you see that as a hindrance in reviewing the code changes and tests in 0005?
> >>
> >> I think not. I'll ignore 0006 for now and focus on other patches.
> >
> > Hi,
> >
> > Sorry for my irregular reviews. Unfortunately, the patch need to be rebased
> > again.
>
> I rebased the patches without any problem on top of commit
Thanks!
> > In the meantime I have few more commentaries about range_bounds_merge:
> >
> > * From what I see partition_range_bound_cmp is executed on the same bounds few
> > times to find whether they are overlapping and during the range merging, is
> > it necessary? Probably it would be enough just to compare current ranges once
> > per iteration.
>
> The bounds that are compared in those cases are different. Any two
> bounds are compared only once per iteration. Remember each range has
> two bounds, thus there are total four comparisons possible. In case of
> overlap, we do all four comparisons.
Yep, indeed, now I see.
> > * Just to clarify - the iterating through all the partitions, is it the best
> > way of finding matching ranges? Correct me if I'm wrong, but from what I see
> > in the comments for PartitionBoundInfoData, all the ranges are arranged in
> > increasing order - maybe then it's possible to use binary search for finding
> > a matching range?
>
> The loop in partition_range_bounds_merge() runs as many times as the
> maximum of number of datums from the given partition bounds. So the
> complexity is O(n) where n is the maximum of number of datums. With
> binary search the complexity will increase to O(nlogn). I might be
> missing something here.
Now I'm confused even more. Correct me if I'm wrong, but here is what I see
right now:
* We're trying to solve the standard problem of finding overlapping intervals
from two sets of intervals
* The current implementation implicitly compares every range from one side of a
join with every range from another side, which is O(n^2).
Let's imagine we have two tables:
=# \d+ test1_overlap
Table "public.test1_overlap"
Column | Type | Collation | Nullable | Default | Storage |
--------+---------+-----------+----------+---------+----------+
id | integer | | | | plain |
data | jsonb | | | | extended |
Partition key: RANGE (id)
Partitions: test11_overlap FOR VALUES FROM (200) TO (210),
test12_overlap FOR VALUES FROM (220) TO (230),
test13_overlap FOR VALUES FROM (240) TO (250)
=# \d+ test2_overlap
Table "public.test2_overlap"
Column | Type | Collation | Nullable | Default | Storage |
--------+---------+-----------+----------+---------+----------+
id | integer | | | | plain |
data | jsonb | | | | extended |
Partition key: RANGE (id)
Partitions: test210_overlap FOR VALUES FROM (160) TO (170),
test211_overlap FOR VALUES FROM (180) TO (190),
test21_overlap FOR VALUES FROM (0) TO (10),
test22_overlap FOR VALUES FROM (20) TO (30),
test23_overlap FOR VALUES FROM (200) TO (210),
test24_overlap FOR VALUES FROM (40) TO (50),
test25_overlap FOR VALUES FROM (60) TO (70),
test26_overlap FOR VALUES FROM (80) TO (90),
test27_overlap FOR VALUES FROM (100) TO (110),
test28_overlap FOR VALUES FROM (120) TO (130),
test29_overlap FOR VALUES FROM (140) TO (150)
And the join:
select * from test1_overlap inner join test2_overlap using (id);
Partition wise join will work fine, but what will happen (I see this following
the code under gdb) is that inside the function partition_range_bounds_merge we
start from two partitions:
test11_overlap (200, 210) and test21_overlap (0, 10)
In the comparison loop we figure out that there is no overlap and go to the
ub_cmpval > 0 branch, because test11_overlap is higher that test21_overlap.
Inside this branch we think that we need to handle a missing partition case
(apparently, by mistake, but it works - in case if it's not a missing
partition, there are no any records to join with from a default one). Since in
this case there isn't any default partition, the result is merged = true. After
that partition_range_get_next_lb_index will move us to another partition pair:
test11_overlap (200, 210) and test22_overlap (20, 30)
And so on and so forth until we will reach the partition test23_overlap (200,
210), which would be actually what we're looking for. So basically as I said
above we will iterate over the all partitions, and we could skip some of them
using binary search.
> >
> > * I'm not sure why in this case partition wise join is not applied? Maybe I'm
> > wrong, but I was under the impression that it should work here
> >
> > =# \d+ test1;
> > Table "public.test1"
> > Column | Type | Collation | Nullable | Default | Storage |
> > --------+---------+-----------+----------+---------+----------+
> > data | jsonb | | | | extended |
> > id | integer | | | | plain |
> > Partition key: RANGE (id)
> > Indexes:
> > "test1_idx" btree (id)
> > Partitions: test11 FOR VALUES FROM (0) TO (100),
> > test12 FOR VALUES FROM (100) TO (200),
> > test13 FOR VALUES FROM (200) TO (300)
> >
> > =# \d+ test2;
> > Table "public.test2"
> > Column | Type | Collation | Nullable | Default | Storage |
> > --------+---------+-----------+----------+---------+----------+
> > data | jsonb | | | | extended |
> > id | integer | | | | plain |
> > Partition key: RANGE (id)
> > Indexes:
> > "test2_idx" btree (id)
> > Partitions: test21 FOR VALUES FROM (10) TO (110),
> > test22 FOR VALUES FROM (110) TO (210),
> > test23 FOR VALUES FROM (210) TO (310)
> >
> >
> > I'm confused, since there is only one-to-one mapping of partitions.
>
> In this case, test21 overlaps test11 (10-100) and test12 (100-110),
> test22 overlaps test12 (110-200) and test13(200-210). So, there is no
> one-to-one mapping.
Yep, thanks for the explanation.
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
@ 2018-07-19 21:43 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Dmitry Dolgov @ 2018-07-19 21:43 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; +Cc: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Robert Haas <robertmhaas@gmail.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
> On Thu, 19 Jul 2018 at 21:04, Dmitry Dolgov <9erthalion6@gmail.com> wrote:
>
> > > * Just to clarify - the iterating through all the partitions, is it the best
> > > way of finding matching ranges? Correct me if I'm wrong, but from what I see
> > > in the comments for PartitionBoundInfoData, all the ranges are arranged in
> > > increasing order - maybe then it's possible to use binary search for finding
> > > a matching range?
> >
> > The loop in partition_range_bounds_merge() runs as many times as the
> > maximum of number of datums from the given partition bounds. So the
> > complexity is O(n) where n is the maximum of number of datums. With
> > binary search the complexity will increase to O(nlogn). I might be
> > missing something here.
>
> Now I'm confused even more. Correct me if I'm wrong, but here is what I see
> right now:
>
> * We're trying to solve the standard problem of finding overlapping intervals
> from two sets of intervals
>
> * The current implementation implicitly compares every range from one side of a
> join with every range from another side, which is O(n^2).
It's of course wrong, it's going to be O(max(m, n)) as you said, but
the point is still valid - if we have partitions A1, A2 from one side
and B1, ..., BN on another side, we can skip necessary the
partitions from B that are between e.g. A1 and A2 faster with
binary search.
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
@ 2018-07-23 08:38 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2018-07-23 08:38 UTC (permalink / raw)
To: Dmitry Dolgov <9erthalion6@gmail.com>; +Cc: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Robert Haas <robertmhaas@gmail.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Fri, Jul 20, 2018 at 3:13 AM, Dmitry Dolgov <9erthalion6@gmail.com> wrote:
>
> It's of course wrong, it's going to be O(max(m, n)) as you said, but
> the point is still valid - if we have partitions A1, A2 from one side
> and B1, ..., BN on another side, we can skip necessary the
> partitions from B that are between e.g. A1 and A2 faster with
> binary search.
That's possible only when there is no default partition and the join
is an inner join. For an outer join, we need to include all the
partitions on the outer side, so we can't just skip over some
partitions. In case of a default partition, it can take place of a
missing partition, so we can't skip partitions using binary search.
The code right now works for all the cases and is O(n). I agree that
it can be optimized for certain cases, but
1. those cases are rare enough that we can ignore those right now. How
many times we would encounter the case you have quoted, for example?
Usually the ranges will be continuous only differing in the first or
last partition e.g time-series data.
2. The code is enough complex right now and it's also a lot. Making it
complicated further is not the worth the rare use cases. If we get
complaints from the field, we can certainly improve it in future. But
I would wait for those complaints before improving it further.
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2018-07-26 15:07 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Dmitry Dolgov @ 2018-07-26 15:07 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; +Cc: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Robert Haas <robertmhaas@gmail.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
> On Mon, 23 Jul 2018 at 10:38, Ashutosh Bapat <ashutosh.bapat@enterprisedb.com> wrote:
>
> On Fri, Jul 20, 2018 at 3:13 AM, Dmitry Dolgov <9erthalion6@gmail.com> wrote:
> >
> > It's of course wrong, it's going to be O(max(m, n)) as you said, but
> > the point is still valid - if we have partitions A1, A2 from one side
> > and B1, ..., BN on another side, we can skip necessary the
> > partitions from B that are between e.g. A1 and A2 faster with
> > binary search.
>
> That's possible only when there is no default partition and the join
> is an inner join. For an outer join, we need to include all the
> partitions on the outer side, so we can't just skip over some
> partitions. In case of a default partition, it can take place of a
> missing partition, so we can't skip partitions using binary search.
But in this case I described above (when we have a partition A3 on one side,
and another matching partition B3 from other side, but separated by some other
partitions, e.g. B1, B2) it means that we will merge A3 with a default
partition from other side without actually needing that, am I right? In this
sense it's an overhead out of nothing.
> 1. those cases are rare enough that we can ignore those right now. How
> many times we would encounter the case you have quoted, for example?
> Usually the ranges will be continuous only differing in the first or
> last partition e.g time-series data.
Well, unfortunately, I don't have enough context to discuss whether it's rare
or not.
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
@ 2018-07-27 07:17 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2018-07-27 07:17 UTC (permalink / raw)
To: Dmitry Dolgov <9erthalion6@gmail.com>; +Cc: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Robert Haas <robertmhaas@gmail.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Thu, Jul 26, 2018 at 8:37 PM, Dmitry Dolgov <9erthalion6@gmail.com> wrote:
>> On Mon, 23 Jul 2018 at 10:38, Ashutosh Bapat <ashutosh.bapat@enterprisedb.com> wrote:
>>
>> On Fri, Jul 20, 2018 at 3:13 AM, Dmitry Dolgov <9erthalion6@gmail.com> wrote:
>> >
>> > It's of course wrong, it's going to be O(max(m, n)) as you said, but
>> > the point is still valid - if we have partitions A1, A2 from one side
>> > and B1, ..., BN on another side, we can skip necessary the
>> > partitions from B that are between e.g. A1 and A2 faster with
>> > binary search.
>>
>> That's possible only when there is no default partition and the join
>> is an inner join. For an outer join, we need to include all the
>> partitions on the outer side, so we can't just skip over some
>> partitions. In case of a default partition, it can take place of a
>> missing partition, so we can't skip partitions using binary search.
>
> But in this case I described above (when we have a partition A3 on one side,
> and another matching partition B3 from other side, but separated by some other
> partitions, e.g. B1, B2) it means that we will merge A3 with a default
> partition from other side without actually needing that, am I right? In this
> sense it's an overhead out of nothing.
No. We will join A3 with B3 since they have matching bounds. We will
compare B1 and B2's bounds with A3 (assuming that there are no bounds
before A3). Since they won't be compatible we will match default of A
to B1 and B2. That will of-course fail since we will try to match
multiple partitions to a single partition, but that's not the point of
your question I think. You are right that we could skip comparing A3
with B1 and B2 and directly land on B3. Any partitions skipped in
between will be matched with A's default partition. But as I have said
this would be rare and complicating the logic for a rare case doesn't
seem practical at this stage.
Apart from the complexity there's also a possibility that this
skipping will reduce the efficiency actually in normal cases. Consider
a case where A and B have exactly matching partitions. Current
partition matching algorithm compare any given range/bound only once
and we will have O(n) algorithm. If we use a binary search, however,
for every range comparison, it will be O(n log n) algorithm. There
will be unnecessary comparisons during binary search. The current
algorithm is always O(n), whereas binary search would be O(n log(n))
with a possibility of having sub-O(n) complexity in some cases. I
would go for an algorithm which has a consistent time complexity
always and which is efficient in normal cases, rather than worrying
about some cases which are not practical.
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2018-07-27 18:13 ` Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Robert Haas @ 2018-07-27 18:13 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; +Cc: Dmitry Dolgov <9erthalion6@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Fri, Jul 27, 2018 at 3:17 AM, Ashutosh Bapat
<ashutosh.bapat@enterprisedb.com> wrote:
> Apart from the complexity there's also a possibility that this
> skipping will reduce the efficiency actually in normal cases. Consider
> a case where A and B have exactly matching partitions. Current
> partition matching algorithm compare any given range/bound only once
> and we will have O(n) algorithm. If we use a binary search, however,
> for every range comparison, it will be O(n log n) algorithm. There
> will be unnecessary comparisons during binary search. The current
> algorithm is always O(n), whereas binary search would be O(n log(n))
> with a possibility of having sub-O(n) complexity in some cases. I
> would go for an algorithm which has a consistent time complexity
> always and which is efficient in normal cases, rather than worrying
> about some cases which are not practical.
Yeah, I think that's a good point. The normal case here will be that
the partition bounds are equal, or that there are a few extra
partitions on one side that don't exist on the other. We don't want
other cases to be crazily inefficient, but I suspect in practice that
if the partitioning bounds aren't pretty close to matching up exactly,
we're going to end up failing to be able to do a partition-wise join
at all. It's not very likely that somebody happens to have a case
where they've partitioned two tables in randomly different ways, but
then they decide to join them anyway, but then it turns out that the
partition bounds happen to be compatible enough that this algorithm
works.
--
Robert Haas
EnterpriseDB: http://www.enterprisedb.com
The Enterprise PostgreSQL Company
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
@ 2018-08-23 10:31 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Dmitry Dolgov @ 2018-08-23 10:31 UTC (permalink / raw)
To: Robert Haas <robertmhaas@gmail.com>; +Cc: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
> On Fri, 27 Jul 2018 at 20:13, Robert Haas <robertmhaas@gmail.com> wrote:
>
> On Fri, Jul 27, 2018 at 3:17 AM, Ashutosh Bapat
> <ashutosh.bapat@enterprisedb.com> wrote:
> > Apart from the complexity there's also a possibility that this
> > skipping will reduce the efficiency actually in normal cases. Consider
> > a case where A and B have exactly matching partitions. Current
> > partition matching algorithm compare any given range/bound only once
> > and we will have O(n) algorithm. If we use a binary search, however,
> > for every range comparison, it will be O(n log n) algorithm. There
> > will be unnecessary comparisons during binary search. The current
> > algorithm is always O(n), whereas binary search would be O(n log(n))
> > with a possibility of having sub-O(n) complexity in some cases. I
> > would go for an algorithm which has a consistent time complexity
> > always and which is efficient in normal cases, rather than worrying
> > about some cases which are not practical.
>
> Yeah, I think that's a good point. The normal case here will be that
> the partition bounds are equal, or that there are a few extra
> partitions on one side that don't exist on the other. We don't want
> other cases to be crazily inefficient, but I suspect in practice that
> if the partitioning bounds aren't pretty close to matching up exactly,
> we're going to end up failing to be able to do a partition-wise join
> at all. It's not very likely that somebody happens to have a case
> where they've partitioned two tables in randomly different ways, but
> then they decide to join them anyway, but then it turns out that the
> partition bounds happen to be compatible enough that this algorithm
> works.
> On Mon, 23 Jul 2018 at 10:38, Ashutosh Bapat <ashutosh.bapat@enterprisedb.com> wrote:
> 1. those cases are rare enough that we can ignore those right now. How
> many times we would encounter the case you have quoted, for example?
> Usually the ranges will be continuous only differing in the first or
> last partition e.g time-series data.
Ok, but what about list partitioning? I believe the area of application for it
can be more diverse than mostly just for time-series, and in the patch almost
the same approach is used to merge list partitions.
Other than that everything seems fine from functionality point of view, and so
far I couldn't find any situation that produces a wrong plan. Some of the joins
were not that intuitive from the first glance, but at the end everything was
according to the documentation.
Taking this into account I wonder if it's possible somehow to give any hints in
an explain result about why it wasn't possible to apply partition wise join? If
something wasn't clear for me I ended up looking at the value of "merged" flag,
and to figure out actual reason one needs to trace the entire algorithm.
Besides that I checked the performance in some simple cases, no problems on
this side (but I'll also do some checks for more complicated joins).
And I still have some complaints about readability, although I can imagine that
it's just me:
* Many functions carry some unrelated arguments just to pass them through,
which obscures the purpose of a function.
* I want to suggest to introduce a new data structure for partitions mapping
instead of just keeping them in arrays (was it discussed already before?).
* What is the reason that almost everywhere in the patch there is a naming
convention "outer/inner" partition maps, and sometimes (e.g. in
generate_matching_part_pairs) it's "map1/map2"?
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
@ 2018-08-29 07:32 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2018-08-29 07:32 UTC (permalink / raw)
To: Dmitry Dolgov <9erthalion6@gmail.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Thu, Aug 23, 2018 at 4:01 PM, Dmitry Dolgov <9erthalion6@gmail.com> wrote:
>> On Fri, 27 Jul 2018 at 20:13, Robert Haas <robertmhaas@gmail.com> wrote:
>>
>> On Fri, Jul 27, 2018 at 3:17 AM, Ashutosh Bapat
>> <ashutosh.bapat@enterprisedb.com> wrote:
>> > Apart from the complexity there's also a possibility that this
>> > skipping will reduce the efficiency actually in normal cases. Consider
>> > a case where A and B have exactly matching partitions. Current
>> > partition matching algorithm compare any given range/bound only once
>> > and we will have O(n) algorithm. If we use a binary search, however,
>> > for every range comparison, it will be O(n log n) algorithm. There
>> > will be unnecessary comparisons during binary search. The current
>> > algorithm is always O(n), whereas binary search would be O(n log(n))
>> > with a possibility of having sub-O(n) complexity in some cases. I
>> > would go for an algorithm which has a consistent time complexity
>> > always and which is efficient in normal cases, rather than worrying
>> > about some cases which are not practical.
>>
>> Yeah, I think that's a good point. The normal case here will be that
>> the partition bounds are equal, or that there are a few extra
>> partitions on one side that don't exist on the other. We don't want
>> other cases to be crazily inefficient, but I suspect in practice that
>> if the partitioning bounds aren't pretty close to matching up exactly,
>> we're going to end up failing to be able to do a partition-wise join
>> at all. It's not very likely that somebody happens to have a case
>> where they've partitioned two tables in randomly different ways, but
>> then they decide to join them anyway, but then it turns out that the
>> partition bounds happen to be compatible enough that this algorithm
>> works.
>
>> On Mon, 23 Jul 2018 at 10:38, Ashutosh Bapat <ashutosh.bapat@enterprisedb.com> wrote:
>> 1. those cases are rare enough that we can ignore those right now. How
>> many times we would encounter the case you have quoted, for example?
>> Usually the ranges will be continuous only differing in the first or
>> last partition e.g time-series data.
>
> Ok, but what about list partitioning? I believe the area of application for it
> can be more diverse than mostly just for time-series, and in the patch almost
> the same approach is used to merge list partitions.
Same arguments hold for list partitioning as well. For a list
partitioned table the bounds are ordered by list datums and not
partitions, so it will be rather odd to have large runs of mismatching
datums, the case where binary search fares, from one of side of join.
So, my following argument still holds true
---
>> > I would go for an algorithm which has a consistent time complexity
>> > always and which is efficient in normal cases, rather than worrying
>> > about some cases which are not practical.
---
>
> Other than that everything seems fine from functionality point of view, and so
> far I couldn't find any situation that produces a wrong plan. Some of the joins
> were not that intuitive from the first glance, but at the end everything was
> according to the documentation.
Thanks a lot for your tests and I am glad that you didn't find any failures.
> Taking this into account I wonder if it's possible somehow to give any hints in
> an explain result about why it wasn't possible to apply partition wise join? If
> something wasn't clear for me I ended up looking at the value of "merged" flag,
> and to figure out actual reason one needs to trace the entire algorithm.
That's kind of tricky in PostgreSQL. The optimizer doesn't always
report why a particular path was not chosen. Said that we could add
trace logs printing that information, however, the main difficulty is
reporting the relations being joined.See 0004 for example.
>
> Besides that I checked the performance in some simple cases, no problems on
> this side (but I'll also do some checks for more complicated joins).
Thanks a lot.
>
> And I still have some complaints about readability, although I can imagine that
> it's just me:
>
> * Many functions carry some unrelated arguments just to pass them through,
> which obscures the purpose of a function.
Can you please provide some examples?
>
> * I want to suggest to introduce a new data structure for partitions mapping
> instead of just keeping them in arrays (was it discussed already before?).
The best I could think of was a structure with just two arrays. So,
instead of encapsulating the arrays within a structure, I thought it
best to pass bare arrays around. If you have any other ideas, please
let me know.
>
> * What is the reason that almost everywhere in the patch there is a naming
> convention "outer/inner" partition maps, and sometimes (e.g. in
> generate_matching_part_pairs) it's "map1/map2"?
You will find that the optimizer in general uses outer/inner,
rel1/rel2 nomenclature interchangeably. This patch-set just inherits
that. But yes, we should do more to straighten it out.
I won't be working on this actively in the next commitfest. I will be
glad if somebody else wants to take this up. If there's nobody,
probably we should mark this entry as "returned with feedback" in the
next commitfest.
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2018-08-30 08:53 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Dmitry Dolgov @ 2018-08-30 08:53 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
> On Wed, 29 Aug 2018 at 09:32, Ashutosh Bapat <ashutosh.bapat@enterprisedb.com> wrote:
>
> > * Many functions carry some unrelated arguments just to pass them through,
> > which obscures the purpose of a function.
>
> Can you please provide some examples?
E.g this chain with partsupfunc & collations:
partition_range_bounds_merge
-> partition_range_cmp
-> partition_range_bound_cmp
-> partition_range_merge_next_lb
I believe I already mentioned that before (although I'm not saying that I have
a solution right away, it just bothers me).
> > * I want to suggest to introduce a new data structure for partitions mapping
> > instead of just keeping them in arrays (was it discussed already before?).
>
> The best I could think of was a structure with just two arrays. So,
> instead of encapsulating the arrays within a structure, I thought it
> best to pass bare arrays around. If you have any other ideas, please
> let me know.
Well, what I had in mind is something like a structure Mapping with fields from
& to.
> > * What is the reason that almost everywhere in the patch there is a naming
> > convention "outer/inner" partition maps, and sometimes (e.g. in
> > generate_matching_part_pairs) it's "map1/map2"?
>
> You will find that the optimizer in general uses outer/inner,
> rel1/rel2 nomenclature interchangeably. This patch-set just inherits
> that. But yes, we should do more to straighten it out.
Thanks, good to know.
> I won't be working on this actively in the next commitfest. I will be
> glad if somebody else wants to take this up. If there's nobody,
> probably we should mark this entry as "returned with feedback" in the
> next commitfest.
Since I'm more or less familiar with the code and I believe it's an interesting
feature, I can try to take over it for now if you don't mind (but without any
strong commitments to make it perfectly shining for the next CF).
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
@ 2018-08-31 06:23 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2018-08-31 06:23 UTC (permalink / raw)
To: Dmitry Dolgov <9erthalion6@gmail.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Thu, Aug 30, 2018 at 2:23 PM, Dmitry Dolgov <9erthalion6@gmail.com> wrote:
>
>> I won't be working on this actively in the next commitfest. I will be
>> glad if somebody else wants to take this up. If there's nobody,
>> probably we should mark this entry as "returned with feedback" in the
>> next commitfest.
>
> Since I'm more or less familiar with the code and I believe it's an interesting
> feature, I can try to take over it for now if you don't mind (but without any
> strong commitments to make it perfectly shining for the next CF).
Please do. Thanks.
--
Best Wishes,
Ashutosh Bapat
EnterpriseDB Corporation
The Postgres Database Company
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
@ 2018-09-12 20:14 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Dmitry Dolgov @ 2018-09-12 20:14 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
> On Fri, 31 Aug 2018 at 08:23, Ashutosh Bapat <ashutosh.bapat@enterprisedb.com> wrote:
>
> On Thu, Aug 30, 2018 at 2:23 PM, Dmitry Dolgov <9erthalion6@gmail.com> wrote:
> >
> >> I won't be working on this actively in the next commitfest. I will be
> >> glad if somebody else wants to take this up. If there's nobody,
> >> probably we should mark this entry as "returned with feedback" in the
> >> next commitfest.
> >
> > Since I'm more or less familiar with the code and I believe it's an interesting
> > feature, I can try to take over it for now if you don't mind (but without any
> > strong commitments to make it perfectly shining for the next CF).
>
> Please do. Thanks.
I've noticed that the patch is outdated already, so here is the rebased
version. I also removed the last part with the extra tests since it
was something
internal and merged the debug message into the implementation part. Ashutosh,
please let me know if you're not happy with these modifications.
Other than that I haven't changed anything yet, but hope this will come soon.
And this version is more to keep it updated for those people who may be
interested.
Attachments:
[application/octet-stream] 0002-Targetlist-of-a-child-join-is-produced-by-translating-v11.patch (3.5K, ../../CA+q6zcU3X4=BfqnWXAUPBFtKK7vy0HO7-+mAW6KB2Zy_EPtC_Q@mail.gmail.com/2-0002-Targetlist-of-a-child-join-is-produced-by-translating-v11.patch)
download | inline diff:
From 45365cb382d027098636eccfee08c5f6fc831399 Mon Sep 17 00:00:00 2001
From: erthalion <9erthalion6@gmail.com>
Date: Tue, 11 Sep 2018 21:09:44 +0200
Subject: [PATCH 2/4] Targetlist of a child-join
The next patch adds more general partition matching algorithm for
partition-wise join. With that change, the first pair of joining
relations for the parent joinrel may not produce a partition-wise join
because of the restrictions in partition_bounds_merge(), to be added
in the next patch. Hence the first pair of joining relations, which
is used to build the child join and presented to
build_child_join_rel(), for the child joinrel does not correspond to
the first pair of joining relations for the parent joinrel. The
targetlist built using different pairs have the targetlist entries
arranged in different order. An appendrel expects that all its
children have their targetlists ordered in the same fashion. Hence
translate the parent's targetlist so that parent and child joinrels
have their targetlists in sync.
Basic partition-wise join commit
f49842d1ee31b976c681322f76025d7732e860f3 modified
build_joinrel_tlist() to build targetlist for child-join. With the
above changes we don't need it anymore. Similarly, the same commit
added code to set_append_rel_size() to compute attr_needed for a
child-join relation. That change too is not needed with the above
change. This commit reverts those two changes.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/optimizer/util/relnode.c | 20 ++++++++++++++++++++
1 file changed, 20 insertions(+)
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 39f5729b91..2f1137c13d 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -802,6 +802,19 @@ build_child_join_rel(PlannerInfo *root, RelOptInfo *outer_rel,
appinfos = find_appinfos_by_relids(root, joinrel->relids, &nappinfos);
+ /*
+ * The first pair of joining relations for the parent joinrel may not
+ * produce a partition-wise join because of the restrictions in
+ * partition_bounds_merge(). Hence the first pair of joining relations,
+ * which is used to build the child join and presented here, for the child
+ * joinrel does not correspond to the first pair of joining relations for
+ * the parent joinrel. The targetlist built using different pairs have the
+ * targetlist nodes arranged in different order. An appendrel expects that
+ * all its children have their targetlists ordered in the same fashion.
+ * Hence translate the parent's targetlist so that parent and child
+ * joinrels have their targetlists in sync.
+ */
+ joinrel->reltarget = copy_pathtarget(parent_joinrel->reltarget);
/* Set up reltarget struct */
build_child_join_reltarget(root, parent_joinrel, joinrel,
nappinfos, appinfos);
@@ -907,6 +920,12 @@ build_joinrel_tlist(PlannerInfo *root, RelOptInfo *joinrel,
Relids relids = joinrel->relids;
ListCell *vars;
+ /*
+ * We only see parent joins. Targetlist of a child-join is computed by
+ * translating corresponding parent join's targetlist.
+ */
+ Assert(joinrel->reloptkind == RELOPT_JOINREL);
+
foreach(vars, input_rel->reltarget->exprs)
{
Var *var = (Var *) lfirst(vars);
@@ -934,6 +953,7 @@ build_joinrel_tlist(PlannerInfo *root, RelOptInfo *joinrel,
/* Is it still needed above this joinrel? */
ndx = var->varattno - baserel->min_attr;
+
if (bms_nonempty_difference(baserel->attr_needed[ndx], relids))
{
/* Yup, add it to the output */
--
2.16.4
[application/octet-stream] 0001-Hash-partition-bound-equality-refactoring-v11.patch (5.1K, ../../CA+q6zcU3X4=BfqnWXAUPBFtKK7vy0HO7-+mAW6KB2Zy_EPtC_Q@mail.gmail.com/3-0001-Hash-partition-bound-equality-refactoring-v11.patch)
download | inline diff:
From e9cccc84246571e57aae1c91b81e4279eb3b4c64 Mon Sep 17 00:00:00 2001
From: erthalion <9erthalion6@gmail.com>
Date: Tue, 11 Sep 2018 21:08:07 +0200
Subject: [PATCH 1/4] Hash partition bound equality refactoring.
We need that to check whether two given hash bounds are equal into a
separate function, so that it can be called from multiple places. Right
now it's only caller is partition_bounds_equal() but later we will use
it for merging partition bounds.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/partitioning/partbounds.c | 95 ++++++++++++++++++++++-------------
1 file changed, 61 insertions(+), 34 deletions(-)
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index 4ed9920618..ea533090a4 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -52,6 +52,9 @@ static void get_range_key_properties(PartitionKey key, int keynum,
Expr **keyCol,
Const **lower_val, Const **upper_val);
static List *get_range_nulltest(PartitionKey key);
+static bool partition_hbounds_equal(PartitionBoundInfo b1,
+ PartitionBoundInfo b2);
+
/*
* get_qual_from_partbound
@@ -92,6 +95,63 @@ get_qual_from_partbound(Relation rel, Relation parent,
return my_qual;
}
+/*
+ * Are two hash partition bound collections logically equal?
+ *
+ * Hash partition bounds store modulus and remainder in datums array which are
+ * always integers irrespective of the number of partition keys and their data
+ * types. Hence we can compare the hash bound collection without any partition
+ * key specific information. Separating this logic in a function which does not
+ * require partition key specific information allows it be called from places
+ * where the partition key specific information is not completely available.
+ */
+static bool
+partition_hbounds_equal(PartitionBoundInfo b1, PartitionBoundInfo b2)
+{
+ int greatest_modulus = get_hash_partition_greatest_modulus(b1);
+ int i;
+
+ Assert(b1->strategy == PARTITION_STRATEGY_HASH &&
+ b2->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * If two hash partitioned tables have different greatest moduli,
+ * their partition schemes don't match. For hash partitioned table,
+ * the greatest modulus is given by the last datum and number of
+ * partitions is given by ndatums.
+ */
+ if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ return false;
+
+ /*
+ * We arrange the partitions in the ascending order of their modulus and
+ * remainders. Also every modulus is factor of next larger modulus.
+ * Therefore we can safely store index of a given partition in indexes
+ * array at remainder of that partition. Also entries at (remainder + N *
+ * modulus) positions in indexes array are all same for (modulus,
+ * remainder) specification for any partition. Thus datums array from both
+ * the given bounds are same, if and only if their indexes array will be
+ * same. So, it suffices to compare indexes array.
+ */
+ for (i = 0; i < greatest_modulus; i++)
+ if (b1->indexes[i] != b2->indexes[i])
+ return false;
+
+#ifdef USE_ASSERT_CHECKING
+
+ /*
+ * Nonetheless make sure that the bounds are indeed same when the indexes
+ * match. Hash partition bound stores modulus and remainder at
+ * b1->datums[i][0] and b1->datums[i][1] position respectively.
+ */
+ for (i = 0; i < b1->ndatums; i++)
+ Assert((b1->datums[i][0] == b2->datums[i][0] &&
+ b1->datums[i][1] == b2->datums[i][1]));
+#endif
+
+ return true;
+}
+
/*
* Are two partition bound collections logically equal?
*
@@ -120,41 +180,8 @@ partition_bounds_equal(int partnatts, int16 *parttyplen, bool *parttypbyval,
if (b1->strategy == PARTITION_STRATEGY_HASH)
{
- int greatest_modulus = get_hash_partition_greatest_modulus(b1);
-
- /*
- * If two hash partitioned tables have different greatest moduli,
- * their partition schemes don't match.
- */
- if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ if (!partition_hbounds_equal(b1, b2))
return false;
-
- /*
- * We arrange the partitions in the ascending order of their moduli
- * and remainders. Also every modulus is factor of next larger
- * modulus. Therefore we can safely store index of a given partition
- * in indexes array at remainder of that partition. Also entries at
- * (remainder + N * modulus) positions in indexes array are all same
- * for (modulus, remainder) specification for any partition. Thus
- * datums array from both the given bounds are same, if and only if
- * their indexes array will be same. So, it suffices to compare
- * indexes array.
- */
- for (i = 0; i < greatest_modulus; i++)
- if (b1->indexes[i] != b2->indexes[i])
- return false;
-
-#ifdef USE_ASSERT_CHECKING
-
- /*
- * Nonetheless make sure that the bounds are indeed same when the
- * indexes match. Hash partition bound stores modulus and remainder
- * at b1->datums[i][0] and b1->datums[i][1] position respectively.
- */
- for (i = 0; i < b1->ndatums; i++)
- Assert((b1->datums[i][0] == b2->datums[i][0] &&
- b1->datums[i][1] == b2->datums[i][1]));
-#endif
}
else
{
--
2.16.4
[application/octet-stream] 0003-Partition-wise-join-for-1-1-1-0-0-1-partition-match-v11.patch (72.6K, ../../CA+q6zcU3X4=BfqnWXAUPBFtKK7vy0HO7-+mAW6KB2Zy_EPtC_Q@mail.gmail.com/4-0003-Partition-wise-join-for-1-1-1-0-0-1-partition-match-v11.patch)
download | inline diff:
From 317079743a96dc796644ee7d22346764be56baaa Mon Sep 17 00:00:00 2001
From: erthalion <9erthalion6@gmail.com>
Date: Tue, 11 Sep 2018 21:10:46 +0200
Subject: [PATCH 3/4] Partition-wise join for 1:1, 1:0, 0:1 partition matching.
Earlier version of partition-wise join implementation allowed
partition-wise join between two relations with exactly same partition
bounds. This commit allows partition-wise join to be applied under
following conditions
1. the partition bounds of joining relations are such that rows from
given partition on one side join can join with rows from maximum one
partition on the other side i.e. bounds of a given partition on one
side match/overlap with those of maximum one partition on the other
side. If the mapping happens to be m:n where m > 1 or n > 1, we have
to gang multiple partition relations together into a single relation.
This means that we have to add simple relations during join
processing, something which is not supported right now. ALso, in such
a case, different pairs of joining relations can produce different
partition bounds for the same join relation, which again is not
supported right now.
2. For every partition on outer side that can contribute to the result
of an OUTER join, there exists at least one (taken along with item 1,
it means exactly one) matching partition on the inner side. To
support partition-wise join when the inner matching partition doesn't
exist, we have to add a dummy base relation corresponding to the
non-existent inner partition. We don't have support to add base
relations during join processing.
3. For hash partitioned tables however, we support partition-wise join
only when the bounds exactly match. For hash partitioning it's unusual
to have missing partitions and hence generic partition matching is not
required.
With advanced partition matching, we won't be able to apply
partition-wise join when there are missing matching partitions. So for
a given N-way join, some sub-joins may not be partitioned, while the
overall N-way join is partitioned. We can not try partition-wise join
when one or both of the joining relations are not partitioned in one
of the pairs of joining relation. Skip partition-wise join for that
pair.
An example is A IJ B LJ C where B has an extra partition compared to A
and C. Join B LJ C requires dummy relation to join the extra partition
from B to a missing partition from C, and hence can not use
partition-wise join right now and hence BC is not partitioned. The
extra partition in B gets eliminated in A IJ B and thus it can use
partition-wise join and is partitioned. Hence (AB)C can use
partition-wise join but not A(BC).
Not every pair of joining relation (including the one presented to
build_joinrel_partition_info()) for the same joinrel can use
partition-wise join or has both the relations partitioned. Hence we
calculate the partition bounds for the join relation in
try_partition_wise_join() instead of doing it here.
The partition bounds produced for the first pair that can use
partition-wise are saved in the RelOptInfo of the joinrel. Partition
bounds produced for subsequent pairs should match that produced by the
first pair.
Support for default partition in list partitioned tables
========================================================
When a list value is present in one of the joining relations and not
the other, and the other relation has default partition, match (join)
the partition containing that list value with the default partition.
If there are multiple matches, we can not proceed with the
partition-wise join similar to the case of matching non-default
partition. If the default partition happens to be on the outer side of
the join, the resulting join partition acts as a default partition as
it will contain all the values from the default partition. If
the partition containing the list value happens to be on the outer
side of the join, the resulting join partition is associated with the
list value, since no other partition key value from the default
partition makes it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a partition from the inner side,
if inner side has a list value that is not present in the outer side.
But if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Support for matching default partition in range partitioned tables
==================================================================
When a range is present in one of the joining relations and not the
other, and the other relation has default partition, match (join) the
partition corresponding range with the default partition. If two
ranges overlap but their ranges don't match exactly, the
non-overlapping portion from one range may join the previous
(non-overlapping portion near the lower bound, if exists), next
(non-overlapping portion near the upper bound, if exists) ranges from
the other relation or default partition from the other relation. This
causes multiple partitions on the other side to be joined with a
single partition on the first side; a case we don't support. Any range
from one side which doesn't overlap with any range on the other side,
may find its join partner in the default partition and the
corresponding range partition will need to be joined with the default
partition. If the default partition happens to be on the outer side
of the join, the resulting join partition acts as a default partition
as it will contain all the values from the default partition. If the
non-partition corresponding to the range happens to be on the outer
side of the join, the resulting join partition is associated with that
range, since partition key values from the default partition outside
that range won't make it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a non-default partition from the
inner side, if inner side has a range missing in the outer side. But
if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Even though partition-wise join paths are created, if there are costs
are higher than non-partition-wise join paths, parition-wise join is
not chosen as the final plan. The debug message in
try_partition_wise_join() helps to know whether a given pair of
joining relations used partition-wise join or not.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/optimizer/path/joinrels.c | 99 +-
src/backend/optimizer/util/relnode.c | 33 +-
src/backend/partitioning/partbounds.c | 1724 +++++++++++++++++++++++++++++++++
src/include/partitioning/partbounds.h | 6 +
4 files changed, 1817 insertions(+), 45 deletions(-)
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index d3d21fed5d..875b39e334 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1312,25 +1312,31 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
RelOptInfo *joinrel, SpecialJoinInfo *parent_sjinfo,
List *parent_restrictlist)
{
- int nparts;
int cnt_parts;
+ PartitionScheme part_scheme;
+ PartitionBoundInfo join_boundinfo;
+ List *parts1;
+ List *parts2;
+ ListCell *lc1;
+ ListCell *lc2;
/* Guard against stack overflow due to overly deep partition hierarchy. */
check_stack_depth();
/* Nothing to do, if the join relation is not partitioned. */
- if (!IS_PARTITIONED_REL(joinrel))
+ if (joinrel->part_scheme == NULL)
return;
/* The join relation should have consider_partitionwise_join set. */
Assert(joinrel->consider_partitionwise_join);
/*
- * Since this join relation is partitioned, all the base relations
- * participating in this join must be partitioned and so are all the
- * intermediate join relations.
+ * We can not perform partition-wise join if either of the joining
+ * relations is not partitioned.
*/
- Assert(IS_PARTITIONED_REL(rel1) && IS_PARTITIONED_REL(rel2));
+ if (!IS_PARTITIONED_REL(rel1) || !IS_PARTITIONED_REL(rel2))
+ return;
+
Assert(REL_HAS_ALL_PART_PROPS(rel1) && REL_HAS_ALL_PART_PROPS(rel2));
/* The joining relations should have consider_partitionwise_join set. */
@@ -1343,32 +1349,67 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
*/
Assert(joinrel->part_scheme == rel1->part_scheme &&
joinrel->part_scheme == rel2->part_scheme);
+ part_scheme = joinrel->part_scheme;
/*
- * 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.
+ * Get the list of matching partitions to be joined along with the
+ * partition bounds of the join relation. Because of the restrictions
+ * imposed by partition matching algorithm, not every pair of joining
+ * relations for this join will be able to use partition-wise join. But all
+ * those pairs which can use partition-wise join will produce the same
+ * partition bounds for the join relation.
*/
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel1->boundinfo));
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel2->boundinfo));
+ join_boundinfo = partition_bounds_merge(part_scheme->partnatts,
+ part_scheme->partsupfunc,
+ part_scheme->partcollation,
+ rel1->boundinfo, rel1->nparts,
+ rel2->boundinfo, rel2->nparts,
+ parent_sjinfo->jointype,
+ &parts1, &parts2);
+
+ if (join_boundinfo == NULL)
+ return;
+
+ if (joinrel->boundinfo == NULL)
+ {
+ Assert(joinrel->nparts == 0 && joinrel->part_rels == NULL);
+ joinrel->boundinfo = join_boundinfo;
+ joinrel->nparts = list_length(parts1);
+ Assert(joinrel->nparts == list_length(parts2));
+ joinrel->part_rels =
+ (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+ joinrel->nparts);
+ }
+ else
+ {
+ Assert(partition_bounds_equal(part_scheme->partnatts,
+ part_scheme->parttyplen,
+ part_scheme->parttypbyval,
+ join_boundinfo, joinrel->boundinfo));
+ /*
+ * Every pair of joining relations should result in the same number
+ * of child-joins.
+ */
+ Assert(joinrel->nparts == list_length(parts1));
+ Assert(joinrel->nparts == list_length(parts2));
+ Assert(joinrel->part_rels);
+ }
- nparts = joinrel->nparts;
+ elog(DEBUG3, "join between relations %s and %s is considered for partition-wise join.",
+ bmsToString(rel1->relids), bmsToString(rel2->relids));
/*
* Create child-join relations for this partitioned join, if those don't
* exist. Add paths to child-joins for a pair of child relations
* corresponding to the given pair of parent relations.
*/
- for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+ cnt_parts = 0;
+ forboth(lc1, parts1, lc2, parts2)
{
- RelOptInfo *child_rel1 = rel1->part_rels[cnt_parts];
- RelOptInfo *child_rel2 = rel2->part_rels[cnt_parts];
+ int part1 = lfirst_int(lc1);
+ int part2 = lfirst_int(lc2);
+ RelOptInfo *child_rel1;
+ RelOptInfo *child_rel2;
SpecialJoinInfo *child_sjinfo;
List *child_restrictlist;
RelOptInfo *child_joinrel;
@@ -1376,6 +1417,10 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
AppendRelInfo **appinfos;
int nappinfos;
+ Assert(part1 >= 0 && part2 >= 0);
+ child_rel1 = rel1->part_rels[part1];
+ child_rel2 = rel2->part_rels[part2];
+
/* We should never try to join two overlapping sets of rels. */
Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1409,12 +1454,24 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
joinrel->part_rels[cnt_parts] = child_joinrel;
}
+ /*
+ * For every pair of joining relations, the set of matching partitions
+ * would change. However, the base relation partitions constituting
+ * the given child should remain same for all the joining pairs. Since
+ * the order in which children are stored in the array of child-joins,
+ * depends upon partition bounds of the join, which are same for all
+ * the joining pairs, every joining pair yields the child-joins in the
+ * same order.
+ */
Assert(bms_equal(child_joinrel->relids, child_joinrelids));
populate_joinrel_with_paths(root, child_rel1, child_rel2,
child_joinrel, child_sjinfo,
child_restrictlist);
+ cnt_parts++;
}
+
+ Assert(cnt_parts == joinrel->nparts);
}
/*
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 2f1137c13d..4f15cd8e8b 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1627,7 +1627,7 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
* of the way the query planner deduces implied equalities and reorders
* the joins. Please see optimizer/README for details.
*/
- if (!IS_PARTITIONED_REL(outer_rel) || !IS_PARTITIONED_REL(inner_rel) ||
+ if (outer_rel->part_scheme == NULL || inner_rel->part_scheme == NULL ||
!outer_rel->consider_partitionwise_join ||
!inner_rel->consider_partitionwise_join ||
outer_rel->part_scheme != inner_rel->part_scheme ||
@@ -1640,24 +1640,6 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
part_scheme = outer_rel->part_scheme;
- Assert(REL_HAS_ALL_PART_PROPS(outer_rel) &&
- REL_HAS_ALL_PART_PROPS(inner_rel));
-
- /*
- * For now, our partition matching algorithm can match partitions only
- * when the partition bounds of the joining relations are exactly same.
- * So, bail out otherwise.
- */
- if (outer_rel->nparts != inner_rel->nparts ||
- !partition_bounds_equal(part_scheme->partnatts,
- part_scheme->parttyplen,
- part_scheme->parttypbyval,
- outer_rel->boundinfo, inner_rel->boundinfo))
- {
- Assert(!IS_PARTITIONED_REL(joinrel));
- return;
- }
-
/*
* This function will be called only once for each joinrel, hence it
* should not have partition scheme, partition bounds, partition key
@@ -1669,17 +1651,20 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
/*
* Join relation is partitioned using the same partitioning scheme as the
- * joining relations and has same bounds.
+ * joining relations.
+ *
+ * Because of restrictions in partition_bounds_merge(), not every pair of
+ * joining relations (including the one presented to this function) for the
+ * same joinrel can use partition-wise join or has both the relations
+ * partitioned. Hence we calculate the partition bounds, number of
+ * partitions and child-join relations of the join relation when and if we
+ * find a suitable pair in try_partition_wise_join().
*/
joinrel->part_scheme = part_scheme;
- joinrel->boundinfo = outer_rel->boundinfo;
partnatts = joinrel->part_scheme->partnatts;
joinrel->partexprs = (List **) palloc0(sizeof(List *) * partnatts);
joinrel->nullable_partexprs =
(List **) palloc0(sizeof(List *) * partnatts);
- joinrel->nparts = outer_rel->nparts;
- joinrel->part_rels =
- (RelOptInfo **) palloc0(sizeof(RelOptInfo *) * joinrel->nparts);
/*
* Set the consider_partitionwise_join flag.
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index ea533090a4..81024dc87f 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -54,6 +54,63 @@ static void get_range_key_properties(PartitionKey key, int keynum,
static List *get_range_nulltest(PartitionKey key);
static bool partition_hbounds_equal(PartitionBoundInfo b1,
PartitionBoundInfo b2);
+static PartitionBoundInfo partition_range_bounds_merge(int partnatts,
+ FmgrInfo *supfuncs, Oid *collations,
+ PartitionBoundInfo boundinfo1, int nparts1,
+ PartitionBoundInfo boundinfo2, int nparts2,
+ JoinType jointype, List **parts1, List **parts2);
+static PartitionBoundInfo partition_list_bounds_merge(int partnatts,
+ FmgrInfo *partsupfunc, Oid *collations,
+ PartitionBoundInfo boundinfo1, int nparts1,
+ PartitionBoundInfo boundinfo2, int nparts2,
+ JoinType jointype, List **parts1, List **parts2);
+static PartitionBoundInfo partition_hash_bounds_merge(int partnatts,
+ FmgrInfo *partsupfunc,
+ Oid *partcollation, PartitionBoundInfo left_bi,
+ int left_nparts, PartitionBoundInfo right_bi,
+ int right_nparts, JoinType jointype, List **left_parts,
+ List **right_parts);
+static void generate_matching_part_pairs(int *mergemap1, int npart1,
+ int *mergemap2, int nparts2, JoinType jointype,
+ int nparts, List **parts1, List **parts2);
+static PartitionBoundInfo build_merged_partition_bounds(char strategy,
+ List *merged_datums, List *merged_indexes,
+ List *merged_contents, int null_index,
+ int default_index);
+static int map_and_merge_partitions(int *partmap1, int *mergemap1, int index1,
+ int *partmap2, int *mergemap2, int index2,
+ int *next_index);
+static int32 partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *collations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2);
+static bool partition_range_cmp(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval);
+static bool partition_range_merge_next_lb(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes);
+static bool merge_default_partitions(PartitionBoundInfo outer_bi,
+ int *outer_pmap,
+ int *outer_mmap, PartitionBoundInfo inner_bi,
+ int *inner_pmap, int *inner_mmap, JoinType jointype,
+ int *next_index, int *default_index);
+static bool merge_null_partitions(PartitionBoundInfo outer_bi, int *outer_pmap,
+ int *outer_mmap, PartitionBoundInfo inner_bi,
+ int *inner_pmap, int *inner_mmap, JoinType jointype,
+ int *next_index, int *null_index, int *default_index);
+static bool handle_missing_partition(int *missing_side_pmap,
+ int *missing_side_mmap,
+ int missing_side_default, int *other_pmap,
+ int *other_mmap, int other_part,
+ bool missing_side_outer,
+ bool missing_side_inner,
+ int *next_index, int *default_index,
+ int *merged_index);
/*
@@ -2332,3 +2389,1670 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
PG_RETURN_BOOL(rowHash % modulus == remainder);
}
+
+/*
+ * partition_bounds_merge
+ *
+ * The function produces the partition bounds for a join between two relations
+ * whose partition bounds are given. The function also returns two lists of
+ * partition indexes one for each of the joining relations. Both the lists
+ * contain the same number of elements. The partition indexes at the same
+ * positions in the lists indicate the pair partitions, one from each side, to
+ * be joined and the position itself corresponds to the index of partition
+ * produced by that child-join in the partitioned join.
+ *
+ * The function returns NULL if we can not find the matching pair of
+ * partitions. This happens if 1. multiple partitions on one side match with
+ * one partition on the other side. 2. a given partition on the outer side
+ * doesn't have a matching partition on the inner side. We can not support the
+ * first case since we don't have a way to represent multiple partitions as a
+ * single relation (RelOptInfo) and then perform join using the ganged
+ * relation. We can not support the second case since the missing inner
+ * partition needs to be represented as an empty relation and we don't have a
+ * way to introduce empty relation during join planning after creating paths
+ * for all the base relations.
+ */
+extern PartitionBoundInfo
+partition_bounds_merge(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation,
+ PartitionBoundInfo outer_bi, int outer_nparts,
+ PartitionBoundInfo inner_bi, int inner_nparts,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts)
+{
+ PartitionBoundInfo merged_bounds;
+ char strategy;
+
+ /* Bail out if partitioning strategies are different. */
+ if (outer_bi->strategy != inner_bi->strategy)
+ return NULL;
+
+ if (jointype != JOIN_LEFT && jointype != JOIN_INNER &&
+ jointype != JOIN_SEMI && jointype != JOIN_ANTI &&
+ jointype != JOIN_FULL)
+ elog(ERROR, "unexpected join type %d", jointype);
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+ strategy = outer_bi->strategy;
+ switch (strategy)
+ {
+ case PARTITION_STRATEGY_LIST:
+ merged_bounds = partition_list_bounds_merge(partnatts, partsupfunc,
+ partcollation,
+ outer_bi, outer_nparts,
+ inner_bi, inner_nparts,
+ jointype, outer_parts,
+ inner_parts);
+ break;
+
+ case PARTITION_STRATEGY_RANGE:
+ merged_bounds = partition_range_bounds_merge(partnatts,
+ partsupfunc,
+ partcollation,
+ outer_bi,
+ outer_nparts,
+ inner_bi,
+ inner_nparts,
+ jointype,
+ outer_parts,
+ inner_parts);
+ break;
+
+ case PARTITION_STRATEGY_HASH:
+ merged_bounds = partition_hash_bounds_merge(partnatts,
+ partsupfunc,
+ partcollation,
+ outer_bi, outer_nparts,
+ inner_bi, inner_nparts,
+ jointype, outer_parts,
+ inner_parts);
+ break;
+
+ default:
+ elog(ERROR, "unexpected partition strategy: %d", strategy);
+ }
+
+ Assert(merged_bounds || (*outer_parts == NIL && *inner_parts == NIL));
+
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+
+ Assert((*outer_parts == NIL || *inner_parts != NIL) &&
+ (*inner_parts == NIL || *outer_parts != NIL));
+
+ return merged_bounds;
+}
+
+/*
+ * partition_get_range_bounds
+ *
+ * Given the index of lower bound in datums array, return lower and upper
+ * bounds and the index of the partition with that lower bound.
+ */
+static int
+partition_get_range_bounds(PartitionBoundInfo bi, int lb_index,
+ PartitionRangeBound *lower,
+ PartitionRangeBound *upper)
+{
+ int part_index;
+
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The lower bound should correspond to a valid partition. */
+ part_index = bi->indexes[lb_index + 1];
+ Assert(part_index >= 0);
+
+ lower->kind = bi->kind[lb_index];
+ lower->datums = bi->datums[lb_index];
+ lower->lower = true;
+ upper->kind = bi->kind[lb_index + 1];
+ upper->datums = bi->datums[lb_index + 1];
+ upper->lower = false;
+
+ return part_index;
+}
+
+/*
+ * partition_range_get_next_lb_index
+ *
+ * Given the index of lower bound in datums array return the
+ * index of lower bound of the next partition. When the given index corresponds
+ * to the last partition, return number of datums (ndatums).
+ */
+static int
+partition_range_get_next_lb_index(PartitionBoundInfo bi, int lb_index)
+{
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The partition index corresponding to the upper bound should be valid. */
+ Assert(bi->indexes[lb_index + 1] >= 0);
+
+ /*
+ * If there are no bounds left beyond the upper bound, we have reached the
+ * last partition.
+ */
+ if (lb_index + 2 < bi->ndatums)
+ {
+ /*
+ * If the bound next to the upper bound corresponds to no partition,
+ * that's the next lower bound of the next partition. Otherwise, the
+ * current upper bound is the lower bound of the next partition.
+ */
+ if (bi->indexes[lb_index + 2] < 0)
+ return lb_index + 2;
+ else
+ return lb_index + 1;
+ }
+ else
+ return bi->ndatums;
+}
+
+static int32
+partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2)
+{
+ return partition_rbound_cmp(partnatts, partsupfunc, partcollations,
+ bound1->datums, bound1->kind, bound1->lower,
+ bound2);
+}
+
+/*
+ * partition_range_cmp
+ *
+ * Compare the bounds of two range partitions. Set ub_cmpval <, = or > 0, if the
+ * first partition's upper bound is lower than, equal to or higher than the
+ * second partition's upper bound resp. Similarly set lb_cmpval <, = or > 0,
+ * if the first partition's lower bound is lower than, equal to or higher than
+ * the second partition's lower bound resp.
+ *
+ * Return true, if the ranges overlap, otherwise return false.
+ */
+static bool
+partition_range_cmp(int partnatts, FmgrInfo *partsupfuncs, Oid *partcollations,
+ PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval)
+{
+ bool overlap;
+
+ /*
+ * Compare upper bound of the first partition with the lower bound of the
+ * second and vice-versa. If lower bound is higher than the upper bound,
+ * the partitions are not overlapping. All other cases indicate overlapping
+ * partitions.
+ */
+ if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound1, upper_bound2) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = 1;
+ *lb_cmpval = 1;
+ }
+ else if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound2, upper_bound1) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = -1;
+ *lb_cmpval = -1;
+ }
+ else
+ {
+ overlap = true;
+ *ub_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, upper_bound1,
+ upper_bound2);
+ *lb_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, lower_bound1,
+ lower_bound2);
+ }
+
+ return overlap;
+}
+
+/*
+ * partition_range_merge
+ *
+ * Merge the partition bounds of given two partitions such that the join
+ * between the given two partitions fits merged bounds.
+ *
+ * "merged_upper" will be set to one of the given upper bounds and
+ * "merged_lower" will be set to one of the given lower bounds.
+ */
+static void
+partition_range_merge(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, JoinType jointype,
+ PartitionRangeBound *left_lb,
+ PartitionRangeBound *left_ub,
+ PartitionRangeBound *right_lb,
+ PartitionRangeBound *right_ub,
+ PartitionRangeBound **merged_lb,
+ PartitionRangeBound **merged_ub)
+{
+ /*
+ * An outer join will have all the rows from the outer side, so merged
+ * bounds will be same as the outer bounds. An inner join will have rows
+ * that fit both the bounds, thus lower merged bound will be higher of two
+ * lower bounds and upper merged bound will be lower of the two upper
+ * bounds.
+ */
+ switch (jointype)
+ {
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ *merged_ub = left_ub;
+ *merged_lb = left_lb;
+ break;
+
+ case JOIN_INNER:
+ case JOIN_SEMI:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) < 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) > 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ case JOIN_FULL:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) > 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) < 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ default:
+ elog(ERROR, "unexpected join type %d", jointype);
+ }
+
+ return;
+}
+
+/*
+ * Add the lower bound of the next range to the list of bounds, if the lower
+ * bound is higher or equal to the previous upper bound. If successful return
+ * true, otherwise false.
+ */
+static bool
+partition_range_merge_next_lb(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes)
+{
+ int cmpval;
+
+ if (!*merged_datums)
+ {
+ Assert(!*merged_kinds && !*merged_indexes);
+ cmpval = 1;
+ }
+ else
+ {
+ PartitionRangeBound prev_ub;
+
+ prev_ub.datums = llast(*merged_datums);
+ prev_ub.kind = llast(*merged_kinds);
+ prev_ub.lower = false;
+
+ cmpval = partition_rbound_cmp(partnatts, partsupfuncs, partcollations,
+ next_lb_datums, next_lb_kind, false,
+ &prev_ub);
+ }
+
+ /*
+ * The lower bound is lower than the last upper bound, thus does not fit
+ * the bounds created so far and hence can not be merged with the existing
+ * bounds.
+ */
+ if (cmpval < 0)
+ return false;
+
+ /*
+ * Add bounds of the new merged partition. If the next lower bound is
+ * higher than the last upper bound, add new range with index
+ * corresponding to the lower bound as -1. If the merged lower bound
+ * is same as the last merged upper bound, the last upper bound will be
+ * reused as the lower bound of the next range.
+ */
+ if (cmpval > 0)
+ {
+ *merged_datums = lappend(*merged_datums, next_lb_datums);
+ *merged_kinds = lappend(*merged_kinds, next_lb_kind);
+ *merged_indexes = lappend_int(*merged_indexes, -1);
+ }
+
+ return true;
+}
+
+/*
+ * handle_missing_partition
+ *
+ * If a range appears in one of the joining relations but not the other, a row
+ * in the corresponding partition will not have any join partner in the other
+ * relation, unless the other relation has a default partition. If a given list
+ * value is present in one joining relation but not the other, the default
+ * partition on the other side may contain that value.
+ *
+ * In both these cases, such an extra partition forms a joining pair with the
+ * default partition, if any, on the other side.
+ *
+ * If the default partition happens to be on the outer side of the join, the
+ * resultant partition will act as the default partition of the join relation.
+ * Otherwise the resultant partition will be associated with the range.
+ *
+ * When the default partition is not present in the other relation, the rows in
+ * the extra partition will be included in the bounds of the join result, if it
+ * appears on the outer side of the join, since all rows from the outer side
+ * are included in the join result.
+ *
+ * This function handles all these cases.
+ *
+ * missing_side_pmap, missing_side_mmap and missing_side_default are the
+ * partition map, merge map (See partition_range/list_bounds_merge() for
+ * details) and the index of default partition respectively corresponding the
+ * side with missing partition.
+ *
+ * other_pmap, other_mmap and other_part are the partition map, merge map (See
+ * partition_range/list_bounds_merge() for details) and the index of extra
+ * partition respectively corresponding to the side with the extra partition.
+ *
+ * It returns true if the matching succeeds, otherwise returns false.
+ */
+static bool
+handle_missing_partition(int *missing_side_pmap, int *missing_side_mmap,
+ int missing_side_default, int *other_pmap,
+ int *other_mmap, int other_part,
+ bool missing_side_outer,
+ bool missing_side_inner,
+ int *next_index, int *default_index,
+ int *merged_index)
+{
+ bool missing_has_default = (missing_side_default != -1);
+
+ if (missing_has_default)
+ {
+ *merged_index = map_and_merge_partitions(missing_side_pmap,
+ missing_side_mmap,
+ missing_side_default,
+ other_pmap, other_mmap,
+ other_part,
+ next_index);
+ if (*merged_index < 0)
+ return false;
+
+ if (missing_side_outer)
+ {
+ /*
+ * Default partition on the outer side forms the default
+ * partition of the join result.
+ */
+ if (*default_index < 0)
+ *default_index = *merged_index;
+ else if(*default_index != *merged_index)
+ {
+ /*
+ * Ended up with default partition on the outer side
+ * being joined with multiple partitions on the inner
+ * side. We don't support this case.
+ */
+ return false;
+ }
+
+ /*
+ * Since the merged partition acts as a default partition, it
+ * doesn't need a separate index.
+ */
+ *merged_index = -1;
+ }
+ }
+ else if (missing_side_inner)
+ {
+ /*
+ * If this partition has already been mapped (say because we
+ * found an overlapping range earlier), we know where does it
+ * fit in the join result. Nothing to do in that case. Else
+ * create a new merged partition.
+ */
+ if (other_mmap[other_part] < 0)
+ {
+ other_mmap[other_part] = *next_index;
+ *next_index = *next_index + 1;
+ *merged_index = other_mmap[other_part];
+ }
+ }
+
+ return true;
+}
+
+/*
+ * partition_range_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for range partitioned tables.
+ */
+static PartitionBoundInfo
+partition_range_bounds_merge(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, PartitionBoundInfo outer_bi,
+ int outer_nparts, PartitionBoundInfo inner_bi,
+ int inner_nparts, JoinType jointype,
+ List **outer_parts, List **inner_parts)
+{
+ int *outer_pmap;
+ int *outer_mmap;
+ int *inner_pmap;
+ int *inner_mmap;
+ int cnt1;
+ int cnt2;
+ int outer_part;
+ int inner_part;
+ PartitionBoundInfo merged_bounds = NULL;
+ bool merged = true;
+ int outer_lb_index;
+ int inner_lb_index;
+ int next_index;
+ int default_index = -1;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ List *merged_kinds = NIL;
+ int inner_default = inner_bi->default_index;
+ int outer_default = outer_bi->default_index;
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_RANGE);
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+
+ /*
+ * Allocate and initialize partition maps. We maintain four maps, two maps
+ * for each joining relation. pmap[i] gives the partition from the other
+ * relation which would join with ith partition of the given relation.
+ * Partition i from the given relation will join with partition pmap[i]
+ * from the other relation to produce partition mmap[i] of the join (merged
+ * partition).
+ *
+ * pmap[i] = -1 indicates that ith partition of a given relation does not
+ * have a matching partition from the other relation.
+ *
+ * mmap[i] = -1 indicates that ith partition of a given relation does not
+ * contribute to the join result. That can happen only when the given
+ * relation is the inner relation and it doesn't have a matching partition
+ * from the outer relation, hence pmap[i] should be -1.
+ *
+ * In case of an outer join, every partition of the outer join will appear
+ * in the join result, and thus has mmap[i] set for all i. But it's not
+ * necessary that every partition on the outer side will have a matching
+ * partition on the inner side. In such a case, we end up with pmap[i] = -1
+ * and mmap[i] != -1.
+ */
+ outer_pmap = (int *) palloc(sizeof(int) * outer_nparts);
+ outer_mmap = (int *) palloc(sizeof(int) * outer_nparts);
+ inner_pmap = (int *) palloc(sizeof(int) * inner_nparts);
+ inner_mmap = (int *) palloc(sizeof(int) * inner_nparts);
+
+ for (cnt1 = 0; cnt1 < outer_nparts; cnt1++)
+ {
+ outer_pmap[cnt1] = -1;
+ outer_mmap[cnt1] = -1;
+ }
+ for (cnt2 = 0; cnt2 < inner_nparts; cnt2++)
+ {
+ inner_pmap[cnt2] = -1;
+ inner_mmap[cnt2] = -1;
+ }
+
+ /*
+ * Merge the ranges (partitions) from both sides. Every iteration compares
+ * a pair of ranges, one from each side, advancing to the next range from
+ * the side with smaller upper range bound. If upper bounds of ranges from
+ * both sides match exactly, both the sides are advanced. For a given pair
+ * of ranges, we decide whether the corresponding partition match or not.
+ * lb_index, for inner or outer side, keeps track of the index of lower bound
+ * datum in PartitionBoundInfo::datums of that side.
+ */
+ outer_lb_index = 0;
+ inner_lb_index = 0;
+ next_index = 0;
+ while (outer_lb_index < outer_bi->ndatums ||
+ inner_lb_index < inner_bi->ndatums)
+ {
+ PartitionRangeBound outer_lb;
+ PartitionRangeBound outer_ub;
+ PartitionRangeBound inner_lb;
+ PartitionRangeBound inner_ub;
+ PartitionRangeBound *merged_lb = NULL;
+ PartitionRangeBound *merged_ub = NULL;
+ int merged_index = -1;
+ bool overlap;
+ bool finished_outer = false;
+ bool finished_inner = false;
+
+ /* Result of bounds comparison per partition_rbound_cmp(). */
+ int ub_cmpval; /* Upper bounds comparison result. */
+ int lb_cmpval; /* Lower bounds comparison result. */
+
+ /* Get the range bounds of the next pair of partitions. */
+ if (outer_lb_index < outer_bi->ndatums)
+ outer_part = partition_get_range_bounds(outer_bi, outer_lb_index,
+ &outer_lb, &outer_ub);
+ else
+ finished_outer = true;
+
+ if (inner_lb_index < inner_bi->ndatums)
+ inner_part = partition_get_range_bounds(inner_bi, inner_lb_index,
+ &inner_lb, &inner_ub);
+ else
+ finished_inner = true;
+
+ Assert(!finished_outer || !finished_inner);
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining partitions on the side
+ * which finishes later. For that we set the comparison parameters
+ * overlap, ub_cmpval and lb_cmpval in such a way that it appears as if
+ * the side which finishes earlier has an extra partition with lower
+ * and upper bounds higher than any other partition of the unfinished
+ * side. That way we advance the partitions on that side till all of
+ * them are exhausted.
+ */
+ if (finished_outer)
+ {
+ overlap = false;
+ ub_cmpval = 1;
+ lb_cmpval = 1;
+ }
+ else if (finished_inner)
+ {
+ overlap = false;
+ ub_cmpval = -1;
+ lb_cmpval = -1;
+ }
+ else
+ overlap = partition_range_cmp(partnatts, partsupfuncs, partcollations,
+ &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &ub_cmpval, &lb_cmpval);
+
+ if (overlap)
+ {
+ /*
+ * The rows from overlapping portion of ranges on both sides may
+ * join, hence the corresponding pair of partitions form a joining
+ * pair. Match them and produce the bounds of the joint partition
+ * and its index by merging the bounds according to the type of
+ * join.
+ */
+ partition_range_merge(partnatts, partsupfuncs, partcollations,
+ jointype, &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &merged_lb, &merged_ub);
+ merged_index = map_and_merge_partitions(outer_pmap, outer_mmap,
+ outer_part, inner_pmap,
+ inner_mmap, inner_part,
+ &next_index);
+
+ if (merged_index < 0)
+ {
+ /* Failed to match the partitions. */
+ merged = false;
+ break;
+ }
+
+ /*
+ * If the ranges overlap but don't exactly match, a row from
+ * non-overlapping portion of the range from one side of join may
+ * find its join partner in the previous or next overlapping
+ * partition or default partition on the other side , if such a
+ * partition exists. All those cases, if true, will cause one
+ * partition from that side to match at least two partitions on the
+ * other side; a case that we do not support now. Previous
+ * partition has been delt with in the previous iteration of this
+ * loop, next partition will be delt in the next iteration. We will
+ * deal with the default partition here.
+ */
+ if ((lb_cmpval < 0 && inner_has_default) ||
+ /* Non-overlapping range on the lower side of outer range. */
+ (lb_cmpval > 0 && outer_has_default) ||
+ /* Non-overlapping range on the lower side of inner range. */
+ (ub_cmpval < 0 && outer_has_default) ||
+ /* Non-overlapping range on the upper side of inner range. */
+ (ub_cmpval > 0 && inner_has_default))
+ /* Non-overlapping range on the upper side of outer range. */
+ {
+ merged = false;
+ break;
+ }
+ }
+
+ if (ub_cmpval == 0)
+ {
+ /* Upper bounds of both the ranges match. */
+ Assert(overlap);
+
+ /* Move to the next pair of partitions. */
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+ else if (ub_cmpval < 0)
+ {
+ /* Upper bound of inner range higher than that of the outer. */
+
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the inner side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &outer_lb;
+ merged_ub = &outer_ub;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+ merged = handle_missing_partition(inner_pmap, inner_mmap,
+ inner_default, outer_pmap,
+ outer_mmap, outer_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index);
+
+ if (!merged)
+ break;
+ }
+
+ /* Move to the next partition on the outer side. */
+ Assert(!finished_outer);
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ }
+ else
+ {
+ Assert(ub_cmpval > 0);
+
+ /* Upper bound of outer range higher than that of the inner. */
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the outer side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &inner_lb;
+ merged_ub = &inner_ub;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+ merged = handle_missing_partition(outer_pmap, outer_mmap,
+ outer_default, inner_pmap,
+ inner_mmap, inner_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index);
+
+ if (!merged)
+ break;
+ }
+
+ /* Move to the next partition on the inner side. */
+ Assert (!finished_inner);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+
+ Assert(merged);
+
+ if (merged_index < 0)
+ {
+ /* We didn't find a new merged partition. */
+ continue;
+ }
+
+ /*
+ * We have a valid partition index for the next partition of join. The
+ * partition should have valid range.
+ */
+ Assert(merged_lb && merged_ub);
+
+ /* Try merging new lower bound with the last upper bound. */
+ merged = partition_range_merge_next_lb(partnatts, partsupfuncs,
+ partcollations,
+ merged_lb->datums,
+ merged_lb->kind, &merged_datums,
+ &merged_kinds, &merged_indexes);
+ if (merged)
+ {
+ /* Add upper bound with the merged partition index. */
+ merged_datums = lappend(merged_datums, merged_ub->datums);
+ merged_kinds = lappend(merged_kinds, merged_ub->kind);
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ }
+ else
+ break;
+ }
+
+ if (merged)
+ merged = merge_default_partitions(outer_bi, outer_pmap, outer_mmap,
+ inner_bi, inner_pmap, inner_mmap,
+ jointype, &next_index,
+ &default_index);
+
+ /* Create PartitionBoundInfo for the join result. */
+ if (merged)
+ {
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_mmap, outer_nparts, inner_mmap,
+ inner_nparts, jointype, next_index,
+ outer_parts, inner_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes,
+ merged_kinds,
+ -1, default_index);
+ }
+ }
+
+ /* Free any memory we used in this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ list_free(merged_kinds);
+ pfree(outer_pmap);
+ pfree(inner_pmap);
+ pfree(outer_mmap);
+ pfree(inner_mmap);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_list_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for list partitioned tables.
+ *
+ */
+static PartitionBoundInfo
+partition_list_bounds_merge(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, PartitionBoundInfo outer_bi,
+ int outer_nparts, PartitionBoundInfo inner_bi,
+ int inner_nparts, JoinType jointype,
+ List **outer_parts, List **inner_parts)
+{
+ int *outer_pmap; /* outer to inner partition map */
+ int *outer_mmap; /* outer to merged partition map */
+ int *inner_pmap; /* inner to outer partition map */
+ int *inner_mmap; /* inner to merged partition map */
+ int cnto;
+ int cnti;
+ bool merged = true;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ int next_index = 0;
+ int null_index;
+ int default_index = -1;
+ PartitionBoundInfo merged_bounds = NULL;
+ int *outer_indexes = outer_bi->indexes;
+ int *inner_indexes = inner_bi->indexes;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_LIST);
+
+ /* List partitions do not require unbounded ranges. */
+ Assert(!outer_bi->kind && !inner_bi->kind);
+
+ /*
+ * Allocate and initialize partition maps. We maintain four maps, two maps
+ * for each joining relation. pmap[i] gives the partition from the other
+ * relation which would join with ith partition of the given relation.
+ * Partition i from the given relation will join with partition pmap[i]
+ * from the other relation to produce partition mmap[i] of the join (merged
+ * partition).
+ *
+ * pmap[i] = -1 indicates that ith partition of a given relation does not
+ * have a matching partition from the other relation.
+ *
+ * mmap[i] = -1 indicates that ith partition of a given relation does not
+ * contribute to the join result. That can happen only when the given
+ * relation is the inner relation and it doesn't have a matching partition
+ * from the outer relation, hence pmap[i] should be -1.
+ *
+ * In case of an outer join, every partition of the outer join will appear
+ * in the join result, and thus has mmap[i] set for all i. But it's not
+ * necessary that every partition on the outer side will have a matching
+ * partition on the inner side. In such a case, we end up with pmap[i] = -1
+ * and mmap[i] != -1.
+ */
+ outer_pmap = (int *) palloc(sizeof(int) * outer_nparts);
+ outer_mmap = (int *) palloc(sizeof(int) * outer_nparts);
+ inner_pmap = (int *) palloc(sizeof(int) * inner_nparts);
+ inner_mmap = (int *) palloc(sizeof(int) * inner_nparts);
+
+ for (cnto = 0; cnto < outer_nparts; cnto++)
+ {
+ outer_pmap[cnto] = -1;
+ outer_mmap[cnto] = -1;
+ }
+ for (cnti = 0; cnti < inner_nparts; cnti++)
+ {
+ inner_pmap[cnti] = -1;
+ inner_mmap[cnti] = -1;
+ }
+
+ /*
+ * Merge the list value datums from both sides. Every iteration compares a
+ * pair of datums, one from each side, advancing to the next datum from the
+ * side with smaller datum. If datums from both sides match exactly, both
+ * the sides are advanced. For a given pair of datums, we decide whether
+ * the corresponding partition match or not.
+ */
+ cnto = cnti = 0;
+ while (cnto < outer_bi->ndatums || cnti < inner_bi->ndatums)
+ {
+ Datum *odatums;
+ Datum *idatums;
+ int o_index;
+ int i_index;
+ int cmpval;
+ int merged_index = -1;
+ Datum *merged_datum;
+ bool finished_inner;
+ bool finished_outer;
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining datums on the side which
+ * finishes later. For that we set the comparison parameter cmpval in
+ * such a way that it appears as if the side which finishes earlier has
+ * an extra datum higher than any other datum on the unfinished side.
+ * That way we advance the datums on the unfinished side till all of
+ * its datums are exhausted.
+ */
+ if (cnto >= outer_bi->ndatums)
+ {
+ finished_outer = true;
+ odatums = NULL;
+ o_index = -1;
+ }
+ else
+ {
+ finished_outer = false;
+ odatums = outer_bi->datums[cnto];
+ o_index = outer_indexes[cnto];
+ }
+
+ if (cnti >= inner_bi->ndatums)
+ {
+ finished_inner = true;
+ idatums = NULL;
+ i_index = -1;
+ }
+ else
+ {
+ finished_inner = false;
+ idatums = inner_bi->datums[cnti];
+ i_index = inner_indexes[cnti];
+ }
+
+ /* If we exhausted both the sides, we won't enter the loop. */
+ Assert(!finished_inner || !finished_outer);
+
+ if (finished_outer)
+ cmpval = 1;
+ else if (finished_inner)
+ cmpval = -1;
+ else
+ {
+ /* Every list datum should map to a valid partition index. */
+ Assert(o_index >= 0 && i_index >= 0 &&
+ odatums != NULL && idatums != NULL);
+
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
+ partcollation[0],
+ odatums[0], idatums[0]));
+ }
+
+ if (cmpval == 0)
+ {
+ /*
+ * Datums match. Rows on either side with these datums as partition
+ * key value will join and will be part of the partition of the
+ * join result produced by joining the corresponding partitions.
+ * Match the corresponding partitions and if successful, add the
+ * datum to the list of merged datums with index of merged
+ * partition containing it.
+ */
+ merged_datum = odatums;
+ merged_index = map_and_merge_partitions(outer_pmap, outer_mmap,
+ o_index, inner_pmap,
+ inner_mmap, i_index,
+ &next_index);
+
+ if (merged_index < 0)
+ {
+ merged = false;
+ break;
+ }
+
+ /* Move to the next pair of bounds. */
+ cnto++;
+ cnti++;
+ }
+ else if (cmpval < 0)
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /* A datum missing from the inner side. */
+ merged_index = -1;
+ merged_datum = odatums;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+ merged = handle_missing_partition(inner_pmap, inner_mmap,
+ inner_default, outer_pmap,
+ outer_mmap, o_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index);
+
+ if (!merged)
+ break;
+
+ /* Move to the next datum on the outer side. */
+ Assert(!finished_outer);
+ cnto++;
+ }
+ else
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ Assert(cmpval > 0);
+
+ /* A datum missing from the outer side. */
+ merged_index = -1;
+ merged_datum = idatums;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+ merged = handle_missing_partition(outer_pmap, outer_mmap,
+ outer_default, inner_pmap,
+ inner_mmap, i_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index);
+
+ if (!merged)
+ break;
+
+ /* Move to the next datum on the right side. */
+ Assert(!finished_inner);
+ cnti++;
+ }
+
+ /*
+ * Add the list value with appropriate index in the list of datums, if
+ * we have associated a partition with this list value.
+ */
+ if (merged_index >= 0)
+ {
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ merged_datums = lappend(merged_datums, merged_datum);
+ }
+ }
+
+ if (merged)
+ merged = merge_null_partitions(outer_bi, outer_pmap, outer_mmap,
+ inner_bi, inner_pmap, inner_mmap,
+ jointype, &next_index, &null_index,
+ &default_index);
+
+ if (merged)
+ merged = merge_default_partitions(outer_bi, outer_pmap, outer_mmap,
+ inner_bi, inner_pmap, inner_mmap,
+ jointype, &next_index,
+ &default_index);
+
+ /* If successful build the output structures. */
+ if (merged)
+ {
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_mmap, outer_nparts, inner_mmap,
+ inner_nparts, jointype, next_index,
+ outer_parts, inner_parts);
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes, NIL,
+ null_index, default_index);
+ }
+ }
+
+ /* Free up all extra memory before returning from this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ pfree(outer_pmap);
+ pfree(inner_pmap);
+ pfree(outer_mmap);
+ pfree(inner_mmap);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_bounds_merge()'s arm for hash partitioned tables.
+ *
+ * If the given two hash bounds are same, the function returns the first one
+ * without any change, alongwith the lists of matching partitions. Otherwise it
+ * returns NULL.
+ *
+ * We could try merging the bounds when both the bounds have same greatest
+ * modulii. But there seems to be hardly any requirement for the same.
+ */
+static PartitionBoundInfo
+partition_hash_bounds_merge(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, PartitionBoundInfo outer_bi,
+ int outer_nparts, PartitionBoundInfo inner_bi,
+ int inner_nparts, JoinType jointype,
+ List **outer_parts, List **inner_parts)
+{
+ int nparts;
+ int cnt;
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * Hash partitioned table does not have explicit NULL accepting partition
+ * and also does not have a default partition.
+ */
+ Assert(!partition_bound_has_default(outer_bi) &&
+ !partition_bound_has_default(inner_bi));
+ Assert(!partition_bound_accepts_nulls(outer_bi) &&
+ !partition_bound_accepts_nulls(inner_bi));
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+
+ if (outer_nparts != inner_nparts)
+ return NULL;
+ nparts = outer_nparts;
+
+ if (outer_bi->ndatums != inner_bi->ndatums ||
+ !partition_hbounds_equal(outer_bi, inner_bi))
+ return NULL;
+
+ /*
+ * Cook up list of matching partitions. Since bounds are exactly same the
+ * partitions at the same position from both the relations match.
+ */
+ for (cnt = 0; cnt < nparts; cnt++)
+ {
+ *outer_parts = lappend_int(*outer_parts, cnt);
+ *inner_parts = lappend_int(*inner_parts, cnt);
+ }
+
+ return outer_bi;
+}
+
+/*
+ * map_and_merge_partitions
+ *
+ * If the two given partitions (given by index1 and index2 resp.) are already
+ * mapped to each other return the index of corresponding partition in the
+ * merged set of partitions. If they do not have a merged partition associated
+ * with them, assign a new merged partition index. If the partitions are
+ * already mapped and their mapped partitions are different from each other,
+ * they can not be merged, so return -1.
+ *
+ * partmap1[i] gives the partition of relation 2 which matches ith partition of
+ * relation 1. Similarly for partmap2.
+ *
+ * mergemap1[i] gives the partition in the merged set to which ith partition of
+ * relation 1 maps to. Similarly for mergemap2.
+ *
+ * index1 and index2 are the indexes of matching partition from respective
+ * relations.
+ *
+ * *next_index is used and incremented when the given partitions require a new
+ * merged partition.
+ */
+static int
+map_and_merge_partitions(int *partmap1, int *mergemap1, int index1,
+ int *partmap2, int *mergemap2, int index2,
+ int *next_index)
+{
+ int merged_index;
+
+ /*
+ * If both the partitions are not mapped to each other, update the
+ * maps.
+ */
+ if (partmap1[index1] < 0 && partmap2[index2] < 0)
+ {
+ partmap1[index1] = index2;
+ partmap2[index2] = index1;
+ }
+
+ /*
+ * If the given to partitions map to each other, find the corresponding
+ * merged partition index .
+ */
+ if (partmap1[index1] == index2 && partmap2[index2] == index1)
+ {
+ /*
+ * If both the partitions are mapped to the same merged partition, get
+ * the index of merged partition.
+ */
+ if (mergemap1[index1] == mergemap2[index2])
+ {
+ merged_index = mergemap1[index1];
+
+ /*
+ * If the given two partitions do not have a merged partition
+ * associated with them, allocate a new merged partition.
+ */
+ if (merged_index < 0)
+ {
+ merged_index = *next_index;
+ *next_index = *next_index + 1;
+ mergemap1[index1] = merged_index;
+ mergemap2[index2] = merged_index;
+ }
+ }
+
+ /*
+ * If partition from one relation was mapped to a merged partition but
+ * not the partition from the other relation, map the same merged
+ * partition to the partition from other relation, since matching
+ * partitions map to the same merged partition.
+ */
+ else if (mergemap1[index1] >= 0 && mergemap2[index2] < 0)
+ {
+ mergemap2[index2] = mergemap1[index1];
+ merged_index = mergemap1[index1];
+ }
+ else if (mergemap1[index1] < 0 && mergemap2[index2] >= 0)
+ {
+ mergemap1[index1] = mergemap2[index2];
+ merged_index = mergemap2[index2];
+ }
+ else
+ {
+ Assert(mergemap1[index1] != mergemap2[index2] &&
+ mergemap1[index1] >= 0 && mergemap2[index2] >= 0);
+
+ /*
+ * Both the partitions map to different merged partitions. This
+ * means that multiple partitions from one relation matches to one
+ * partition from the other relation. Partition-wise join does not
+ * handle this case right now, since it requires ganging multiple
+ * partitions together (into one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+ }
+ else
+ {
+ /*
+ * Multiple partitions from one relation map to one partition from the
+ * other relation. Partition-wise join does not handle this case right
+ * now, since it requires ganging multiple partitions together (into
+ * one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+
+ return merged_index;
+}
+
+/*
+ * generate_matching_part_pairs
+ *
+ * mergemap1 and mergemap2 map each partition from either side of the join to a
+ * merged partition resp. E.g. mergemap1[i] gives the merged partition to which
+ * ith partition of first relation maps and mergemap2[j] gives the merged
+ * partition to which jth partition of second relation maps. If mergemap1[i] =
+ * mergemap2[j], i and j form the matching pair of partitions.
+ *
+ * Given these maps this function produces the list pairs of partitions which
+ * when joined produce the merged partitions in the order of merged partition
+ * indexes.
+ *
+ * nparts1 and nparts2 are the number of partitions of the joining relations
+ * resp.
+ *
+ * nparts is the number of merged partitions.
+ *
+ * If successful, the pairs of partitions are returned as two separate lists,
+ * parts1 and parts2 resp., one for each side. Otherwise, those lists will be
+ * set to NIL.
+ */
+static void
+generate_matching_part_pairs(int *mergemap1, int nparts1, int *mergemap2,
+ int nparts2, JoinType jointype, int nparts,
+ List **parts1, List **parts2)
+{
+ bool merged = true;
+ int **matching_parts;
+ int cnt1;
+ int cnt2;
+
+ matching_parts = (int **) palloc(sizeof(int *) * 2);
+ matching_parts[0] = (int *) palloc(sizeof(int) * nparts);
+ matching_parts[1] = (int *) palloc(sizeof(int) * nparts);
+
+ *parts1 = NIL;
+ *parts2 = NIL;
+
+ for (cnt1 = 0; cnt1 < nparts; cnt1++)
+ {
+ matching_parts[0][cnt1] = -1;
+ matching_parts[1][cnt1] = -1;
+ }
+
+ /* Set pairs of matching partitions. */
+ for (cnt1 = 0; cnt1 < nparts1; cnt1++)
+ {
+ if (mergemap1[cnt1] >= 0)
+ {
+ Assert(mergemap1[cnt1] < nparts);
+ matching_parts[0][mergemap1[cnt1]] = cnt1;
+ }
+ }
+ for (cnt2 = 0; cnt2 < nparts2; cnt2++)
+ {
+ if (mergemap2[cnt2] >= 0)
+ {
+ Assert(mergemap2[cnt2] < nparts);
+ matching_parts[1][mergemap2[cnt2]] = cnt2;
+ }
+ }
+
+ /*
+ * If we have a partition missing on an inner side, we need to add a dummy
+ * relation which joins with the outer partition. If the inner relation
+ * happens to be a base relation, it will require adding a dummy child
+ * base relation during join processing. Right now, we freeze the base
+ * relation arrays like PlannerInfo::simple_rte_array after planning for
+ * base relations. Adding a new (dummy) base relation would require some
+ * changes to that. So, right now, we do not implement partition-wise join
+ * in such cases.
+ */
+ for (cnt1 = 0; cnt1 < nparts; cnt1++)
+ {
+ int part1 = matching_parts[0][cnt1];
+ int part2 = matching_parts[1][cnt1];
+
+ /* At least one of the partitions should exist. */
+ Assert(part1 >= 0 || part2 >= 0);
+
+ switch (jointype)
+ {
+ case JOIN_INNER:
+ case JOIN_SEMI:
+
+ /*
+ * An inner or semi join can not return any row when the
+ * matching partition on either side is missing. We should
+ * have eliminated all such cases while merging the bounds.
+ */
+ Assert(part1 >= 0 && part2 >= 0);
+ break;
+
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ Assert(part1 >= 0);
+ if (part2 < 0)
+ merged = false;
+ break;
+
+ case JOIN_FULL:
+ if (part1 < 0 || part2 < 0)
+ merged = false;
+ break;
+
+ default:
+ elog(ERROR, "unrecognized join type: %d", (int) jointype);
+ }
+
+ if (!merged)
+ break;
+
+ *parts1 = lappend_int(*parts1, part1);
+ *parts2 = lappend_int(*parts2, part2);
+ }
+
+ pfree(matching_parts[0]);
+ pfree(matching_parts[1]);
+ pfree(matching_parts);
+
+ if (!merged)
+ {
+ list_free(*parts1);
+ list_free(*parts2);
+ *parts1 = NIL;
+ *parts2 = NIL;
+ }
+}
+
+static PartitionBoundInfo
+build_merged_partition_bounds(char strategy, List *merged_datums,
+ List *merged_indexes, List *merged_kinds,
+ int null_index, int default_index)
+{
+ int cnt;
+ PartitionBoundInfo merged_bounds;
+ ListCell *lc;
+
+ /* We expect the same number of elements in datums and indexes lists. */
+ Assert(list_length(merged_datums) == list_length(merged_indexes));
+
+ merged_bounds = (PartitionBoundInfo) palloc(sizeof(PartitionBoundInfoData));
+ merged_bounds->strategy = strategy;
+ merged_bounds->ndatums = list_length(merged_datums);
+
+ if (strategy == PARTITION_STRATEGY_RANGE)
+ {
+ Assert(list_length(merged_datums) == list_length(merged_kinds));
+ merged_bounds->kind =
+ (PartitionRangeDatumKind **) palloc(sizeof(PartitionRangeDatumKind *) *
+ list_length(merged_kinds));
+ cnt = 0;
+ foreach(lc, merged_kinds)
+ merged_bounds->kind[cnt++] = lfirst(lc);
+
+ /* There are ndatums+1 indexes in case of range partitions */
+ merged_indexes = lappend_int(merged_indexes, -1);
+ }
+ else
+ merged_bounds->kind = NULL;
+
+ cnt = 0;
+ merged_bounds->datums = (Datum **) palloc(sizeof(Datum *) *
+ list_length(merged_datums));
+ foreach(lc, merged_datums)
+ merged_bounds->datums[cnt++] = lfirst(lc);
+
+ merged_bounds->indexes = (int *) palloc(sizeof(int) *
+ list_length(merged_indexes));
+ cnt = 0;
+ foreach(lc, merged_indexes)
+ merged_bounds->indexes[cnt++] = lfirst_int(lc);
+
+ merged_bounds->null_index = null_index;
+ merged_bounds->default_index = default_index;
+
+ return merged_bounds;
+}
+
+/*
+ * Merge default partitions from both sides, if any, and assign the default
+ * partition for the join result, if necessary.
+ *
+ * If both the relations have default partitions, try mapping those to each
+ * other. If the mapping succeeds corresponding merged partition will act as
+ * the default partition of the join result.
+ *
+ * If inner side of the join has default but not the outer side, rows in it
+ * won't appear in the join result. So don't create a default partition. If
+ * outer side of the join has default but not the inner side, rows in it will
+ * appear in the join result, so create a default merged partition.
+ */
+static bool
+merge_default_partitions(PartitionBoundInfo outer_bi, int *outer_pmap,
+ int *outer_mmap, PartitionBoundInfo inner_bi,
+ int *inner_pmap, int *inner_mmap, JoinType jointype,
+ int *next_index, int *default_index)
+{
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool merged = true;
+
+ if (!outer_has_default && !inner_has_default)
+ Assert(*default_index < 0);
+ else if (outer_has_default && !inner_has_default)
+ {
+ if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (outer_mmap[outer_default] < 0)
+ {
+ outer_mmap[outer_default] = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = outer_mmap[outer_default];
+ }
+ else
+ Assert(*default_index == outer_mmap[outer_default]);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else if (!outer_has_default && inner_has_default)
+ {
+ if (jointype == JOIN_FULL)
+ {
+ if (inner_mmap[inner_default] < 0)
+ {
+ inner_mmap[inner_default] = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = inner_mmap[inner_default];
+ }
+ else
+ Assert(*default_index == inner_mmap[inner_default]);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else
+ {
+ Assert(outer_has_default && inner_has_default);
+
+ *default_index = map_and_merge_partitions(outer_pmap, outer_mmap,
+ outer_default, inner_pmap,
+ inner_mmap, inner_default,
+ next_index);
+
+ if (*default_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
+
+/*
+ * merge_null_partitions
+ *
+ * Merge NULL partitions, i.e. a partition that can hold NULL values for a list
+ * partitioned table, if any. Find the index of merged partition to which the
+ * NULL values would belong in the join result. If one joining relation has a
+ * NULL partition but not the other, try matching it with the default partition
+ * from the other relation since the default partition may have rows with NULL
+ * partition key. We can eliminate a NULL partition when it appears only on the
+ * inner side of the join and the outer side doesn't have a default partition.
+ *
+ * When the equality operator used for join is strict, two NULL values will not
+ * be considered as equal, and thus a NULL partition can be eliminated for an
+ * inner join. But we don't check the strictness operator here.
+ */
+static bool
+merge_null_partitions(PartitionBoundInfo outer_bi, int *outer_pmap,
+ int *outer_mmap, PartitionBoundInfo inner_bi,
+ int *inner_pmap, int *inner_mmap, JoinType jointype,
+ int *next_index, int *null_index, int *default_index)
+{
+ bool outer_has_null = partition_bound_accepts_nulls(outer_bi);
+ bool inner_has_null = partition_bound_accepts_nulls(inner_bi);
+ int outer_ni = outer_bi->null_index;
+ int inner_ni = inner_bi->null_index;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool merged = true;
+
+ if (!outer_has_null && !inner_has_null)
+ *null_index = -1;
+ else if (outer_has_null && !inner_has_null)
+ {
+ int merged_index;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+
+ merged = handle_missing_partition(inner_pmap, inner_mmap,
+ inner_default, outer_pmap,
+ outer_mmap, outer_ni,
+ missing_side_outer,
+ missing_side_inner, next_index,
+ default_index, &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join to which the outer null partition maps
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = outer_mmap[outer_ni];
+ }
+ else if (!outer_has_null && inner_has_null)
+ {
+ int merged_index;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as OUTER
+ * relation. For INNER and SEMI join OUTER and INNER differentiation is
+ * immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+ merged = handle_missing_partition(outer_pmap, outer_mmap,
+ outer_default, inner_pmap,
+ inner_mmap, inner_ni,
+ missing_side_outer,
+ missing_side_inner,
+ next_index, default_index,
+ &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join, to which the outer side null partition maps,
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = inner_mmap[inner_ni];
+ }
+ else
+ {
+ /* Both the relations have NULL partitions, try merging them. */
+ *null_index = map_and_merge_partitions(outer_pmap, outer_mmap,
+ outer_ni, inner_pmap,
+ inner_mmap, inner_ni,
+ next_index);
+ if (*null_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
diff --git a/src/include/partitioning/partbounds.h b/src/include/partitioning/partbounds.h
index c7535e32fc..cb063b53d9 100644
--- a/src/include/partitioning/partbounds.h
+++ b/src/include/partitioning/partbounds.h
@@ -146,5 +146,11 @@ extern int partition_range_datum_bsearch(FmgrInfo *partsupfunc,
int nvalues, Datum *values, bool *is_equal);
extern int partition_hash_bsearch(PartitionBoundInfo boundinfo,
int modulus, int remainder);
+extern PartitionBoundInfo partition_bounds_merge(int partnatts,
+ FmgrInfo *partsupfunc, Oid *partcollation,
+ PartitionBoundInfo outer_bi, int outer_nparts,
+ PartitionBoundInfo inner_bi, int inner_nparts,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts);
#endif /* PARTBOUNDS_H */
--
2.16.4
[application/octet-stream] 0004-Tests-for-0-1-1-1-and-1-0-partition-matching-v11.patch (220.5K, ../../CA+q6zcU3X4=BfqnWXAUPBFtKK7vy0HO7-+mAW6KB2Zy_EPtC_Q@mail.gmail.com/5-0004-Tests-for-0-1-1-1-and-1-0-partition-matching-v11.patch)
download | inline diff:
From ab1fa6f9b6e6c013f3e71e6b4ae9175763749874 Mon Sep 17 00:00:00 2001
From: erthalion <9erthalion6@gmail.com>
Date: Tue, 11 Sep 2018 21:11:55 +0200
Subject: [PATCH 4/4] Tests for 0:1, 1:1 and 1:0 partition matching
Tests for 0:1, 1:1 and 1:0 partition matching
Rajkumar Raghuvanshi and Ashutosh Bapat.
---
src/test/regress/expected/partition_join.out | 4131 +++++++++++++++++++++-----
src/test/regress/sql/partition_join.sql | 427 ++-
2 files changed, 3855 insertions(+), 703 deletions(-)
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index 3ba3aaf2d8..5d6c7d2c67 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -8,59 +8,86 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(21 rows)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
-(4 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+(7 rows)
-- left outer join, with whole-row reference; partitionwise join does not apply
EXPLAIN (COSTS OFF)
@@ -72,35 +99,50 @@ SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(22 rows)
SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- t1 | t2
---------------+--------------
- (0,0,0000) | (0,0,0000)
- (50,0,0050) |
- (100,0,0100) |
- (150,0,0150) | (0,150,0150)
- (200,0,0200) |
- (250,0,0250) |
- (300,0,0300) | (0,300,0300)
- (350,0,0350) |
- (400,0,0400) |
- (450,0,0450) | (0,450,0450)
- (500,0,0500) |
- (550,0,0550) |
-(12 rows)
+ t1 | t2
+----------------+----------------
+ (-250,0,-0250) |
+ (-200,0,-0200) |
+ (-150,0,-0150) | (0,-150,-0150)
+ (-100,0,-0100) |
+ (-50,0,-0050) |
+ (0,0,0000) | (0,0,0000)
+ (50,0,0050) |
+ (100,0,0100) |
+ (150,0,0150) | (0,150,0150)
+ (200,0,0200) |
+ (250,0,0250) |
+ (300,0,0300) | (0,300,0300)
+ (350,0,0350) |
+ (400,0,0400) |
+ (450,0,0450) | (0,450,0450)
+ (500,0,0500) |
+ (550,0,0550) |
+ (600,0,0600) | (0,600,0600)
+ (650,0,0650) |
+ (700,0,0700) |
+ (750,0,0750) | (0,750,0750)
+(21 rows)
-- right outer join
EXPLAIN (COSTS OFF)
@@ -112,35 +154,53 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHE
-> Append
-> Hash Right Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Right Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Hash Right Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-> Nested Loop Left Join
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p3 t2_3
Filter: (a = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t2_2.b)
-(20 rows)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
- | | 75 | 0075
- | | 225 | 0225
- | | 375 | 0375
- | | 525 | 0525
-(8 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+ | | -225 | -0225
+ | | -75 | -0075
+ | | 75 | 0075
+ | | 225 | 0225
+ | | 375 | 0375
+ | | 525 | 0525
+ | | 675 | 0675
+(14 rows)
-- full outer join, with placeholder vars
EXPLAIN (COSTS OFF)
@@ -148,8 +208,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
QUERY PLAN
------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b
+ Sort Key: prt1_p0.a, prt2_p0.b
-> Append
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ Filter: (((50) = prt1_p0.a) OR ((75) = prt2_p0.b))
+ -> Seq Scan on prt1_p0
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p1.a = prt2_p1.b)
Filter: (((50) = prt1_p1.a) OR ((75) = prt2_p1.b))
@@ -174,7 +242,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
-> Hash
-> Seq Scan on prt2_p3
Filter: (a = 0)
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ Filter: (((50) = prt1_p4.a) OR ((75) = prt2_p4.b))
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) WHERE t1.phv = t1.a OR t2.phv = t2.b ORDER BY t1.a, t2.b;
a | c | b | c
@@ -211,8 +287,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Hash Left Join
+ Hash Cond: (prt1_p0.a = b)
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Hash
+ -> Result
+ One-Time Filter: false
-> Hash Left Join
Hash Cond: (prt1_p1.a = b)
-> Seq Scan on prt1_p1
@@ -227,29 +310,42 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
-> Hash
-> Seq Scan on prt1_p2
Filter: ((a < 450) AND (b = 0))
-(17 rows)
+(24 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
-(9 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+(14 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
QUERY PLAN
------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = b)
+ Filter: ((prt1_p0.b = 0) OR (a = 0))
+ -> Seq Scan on prt1_p0
+ Filter: (a < 450)
+ -> Hash
+ -> Result
+ One-Time Filter: false
-> Hash Full Join
Hash Cond: (prt1_p1.a = b)
Filter: ((prt1_p1.b = 0) OR (a = 0))
@@ -274,64 +370,153 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JO
-> Hash
-> Result
One-Time Filter: false
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt2_p4.b = a)
+ Filter: ((b = 0) OR (prt2_p4.a = 0))
+ -> Seq Scan on prt2_p4
+ Filter: (b > 250)
+ -> Hash
+ -> Result
+ One-Time Filter: false
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
- | | 375 | 0375
- | | 450 | 0450
- | | 525 | 0525
-(12 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ | | 375 | 0375
+ | | 450 | 0450
+ | | 525 | 0525
+ | | 600 | 0600
+ | | 675 | 0675
+ | | 750 | 0750
+(20 rows)
-- Semi-join
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Semi Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Semi Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Nested Loop Semi Join
- Join Filter: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Materialize
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-(24 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(39 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p0 t2
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_2.b = t2_2.a)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p2 t2_2
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: (t1_3.b = t2_3.a)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt1_p3 t2_3
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.b = t2_4.a)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p4 t2_4
+ Filter: (b = 0)
+(37 rows)
+
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
@@ -342,27 +527,82 @@ SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS
-> Append
-> Hash Anti Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash Anti Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash Anti Join
Hash Cond: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p3 t2_2
-(17 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash Anti Join
+ Hash Cond: (t1_3.a = t2_3.b)
+ -> Seq Scan on prt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_3
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(27 rows)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
- sum | avg | sum | avg
--------+----------------------+------+---------------------
- 60000 | 300.0000000000000000 | 2400 | 12.0000000000000000
+ sum | avg | sum | avg
+-------+----------------------+------+--------------------
+ 95550 | 273.0000000000000000 | 2200 | 6.2857142857142857
(1 row)
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ QUERY PLAN
+--------------------------------------------------------------
+ Append
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Hash Anti Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(27 rows)
+
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ b | c
+------+-------
+ -225 | -0225
+ -75 | -0075
+ 75 | 0075
+ 225 | 0225
+ 375 | 0375
+ 525 | 0525
+ 675 | 0675
+(7 rows)
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -374,49 +614,74 @@ SELECT * FROM prt1 t1 LEFT JOIN LATERAL
Sort Key: t1.a
-> Append
-> Nested Loop Left Join
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p1_a on prt1_p1 t2
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
Index Cond: (a = t1.a)
- -> Index Scan using iprt2_p1_b on prt2_p1 t3
+ -> Index Scan using iprt2_p0_b on prt2_p0 t3
Index Cond: (b = t2.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_1
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
Index Cond: (a = t1_1.a)
- -> Index Scan using iprt2_p2_b on prt2_p2 t3_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t3_1
Index Cond: (b = t2_1.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_2
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
Index Cond: (a = t1_2.a)
- -> Index Scan using iprt2_p3_b on prt2_p3 t3_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t3_2
Index Cond: (b = t2_2.a)
-(27 rows)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.a)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t3_3
+ Index Cond: (b = t2_3.a)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.a)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t3_4
+ Index Cond: (b = t2_4.a)
+(43 rows)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, least(t1.a,t2.a,t3.b) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.a = ss.t2a WHERE t1.b = 0 ORDER BY t1.a;
- a | b | c | t2a | t3a | least
------+---+------+-----+-----+-------
- 0 | 0 | 0000 | 0 | 0 | 0
- 50 | 0 | 0050 | | |
- 100 | 0 | 0100 | | |
- 150 | 0 | 0150 | 150 | 0 | 150
- 200 | 0 | 0200 | | |
- 250 | 0 | 0250 | | |
- 300 | 0 | 0300 | 300 | 0 | 300
- 350 | 0 | 0350 | | |
- 400 | 0 | 0400 | | |
- 450 | 0 | 0450 | 450 | 0 | 450
- 500 | 0 | 0500 | | |
- 550 | 0 | 0550 | | |
-(12 rows)
+ a | b | c | t2a | t3a | least
+------+---+-------+------+-----+-------
+ -250 | 0 | -0250 | | |
+ -200 | 0 | -0200 | | |
+ -150 | 0 | -0150 | -150 | 0 | -150
+ -100 | 0 | -0100 | | |
+ -50 | 0 | -0050 | | |
+ 0 | 0 | 0000 | 0 | 0 | 0
+ 50 | 0 | 0050 | | |
+ 100 | 0 | 0100 | | |
+ 150 | 0 | 0150 | 150 | 0 | 150
+ 200 | 0 | 0200 | | |
+ 250 | 0 | 0250 | | |
+ 300 | 0 | 0300 | 300 | 0 | 300
+ 350 | 0 | 0350 | | |
+ 400 | 0 | 0400 | | |
+ 450 | 0 | 0450 | 450 | 0 | 450
+ 500 | 0 | 0500 | | |
+ 550 | 0 | 0550 | | |
+ 600 | 0 | 0600 | 600 | 0 | 600
+ 650 | 0 | 0650 | | |
+ 700 | 0 | 0700 | | |
+ 750 | 0 | 0750 | 750 | 0 | 750
+(21 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
@@ -430,64 +695,95 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
Hash Cond: ((t1.c)::text = (t2.c)::text)
Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Hash Join
Hash Cond: (t2.a = t3.b)
- -> Seq Scan on prt1_p1 t2
+ -> Seq Scan on prt1_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t3
+ -> Seq Scan on prt2_p0 t3
-> Hash Join
Hash Cond: (t2_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t2_1
+ -> Seq Scan on prt1_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p1 t3_1
-> Hash Join
Hash Cond: (t2_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p2 t2_2
-> Hash
- -> Seq Scan on prt2_p3 t3_2
-(26 rows)
+ -> Seq Scan on prt2_p2 t3_2
+ -> Hash Join
+ Hash Cond: (t2_3.a = t3_3.b)
+ -> Seq Scan on prt1_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t3_3
+ -> Hash Join
+ Hash Cond: (t2_4.a = t3_4.b)
+ -> Seq Scan on prt1_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t3_4
+(38 rows)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, t2.b t2b, t2.c t2c, least(t1.a,t2.a,t3.a) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.c = ss.t2c WHERE (t1.b + coalesce(ss.t2b, 0)) = 0 ORDER BY t1.a;
- a | t2a | t2c
------+-----+------
- 0 | 0 | 0000
- 50 | |
- 100 | |
- 150 | 150 | 0150
- 200 | |
- 250 | |
- 300 | 300 | 0300
- 350 | |
- 400 | |
- 450 | 450 | 0450
- 500 | |
- 550 | |
-(12 rows)
+ a | t2a | t2c
+------+------+-------
+ -250 | |
+ -200 | |
+ -150 | -150 | -0150
+ -100 | |
+ -50 | |
+ 0 | 0 | 0000
+ 50 | |
+ 100 | |
+ 150 | 150 | 0150
+ 200 | |
+ 250 | |
+ 300 | 300 | 0300
+ 350 | |
+ 400 | |
+ 450 | 450 | 0450
+ 500 | |
+ 550 | |
+ 600 | 600 | 0600
+ 650 | |
+ 700 | |
+ 750 | 750 | 0750
+(21 rows)
--
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
@@ -498,32 +794,49 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 =
-> Append
-> Hash Join
Hash Cond: (((t2.b + t2.a) / 2) = ((t1.a + t1.b) / 2))
- -> Seq Scan on prt2_e_p1 t2
+ -> Seq Scan on prt2_e_p0 t2
-> Hash
- -> Seq Scan on prt1_e_p1 t1
+ -> Seq Scan on prt1_e_p0 t1
Filter: (c = 0)
-> Hash Join
- Hash Cond: (((t2_1.b + t2_1.a) / 2) = ((t1_1.a + t1_1.b) / 2))
- -> Seq Scan on prt2_e_p2 t2_1
+ Hash Cond: (((t1_1.a + t1_1.b) / 2) = ((t2_1.b + t2_1.a) / 2))
+ -> Seq Scan on prt1_e_p1 t1_1
+ Filter: (c = 0)
-> Hash
- -> Seq Scan on prt1_e_p2 t1_1
- Filter: (c = 0)
+ -> Seq Scan on prt2_e_p1 t2_1
-> Hash Join
Hash Cond: (((t2_2.b + t2_2.a) / 2) = ((t1_2.a + t1_2.b) / 2))
- -> Seq Scan on prt2_e_p3 t2_2
+ -> Seq Scan on prt2_e_p2 t2_2
-> Hash
- -> Seq Scan on prt1_e_p3 t1_2
+ -> Seq Scan on prt1_e_p2 t1_2
Filter: (c = 0)
-(21 rows)
+ -> Hash Join
+ Hash Cond: (((t2_3.b + t2_3.a) / 2) = ((t1_3.a + t1_3.b) / 2))
+ -> Seq Scan on prt2_e_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t1_3
+ Filter: (c = 0)
+ -> Hash Join
+ Hash Cond: (((t2_4.b + t2_4.a) / 2) = ((t1_4.a + t1_4.b) / 2))
+ -> Seq Scan on prt2_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_4
+ Filter: (c = 0)
+(33 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 150 | 0 | 150 | 0
- 300 | 0 | 300 | 0
- 450 | 0 | 450 | 0
-(4 rows)
+ a | c | b | c
+------+---+------+---
+ -250 | 0 | -250 | 0
+ -100 | 0 | -100 | 0
+ 0 | 0 | 0 | 0
+ 0 | 0 | 0 | 0
+ 150 | 0 | 150 | 0
+ 300 | 0 | 300 | 0
+ 450 | 0 | 450 | 0
+ 600 | 0 | 600 | 0
+ 750 | 0 | 750 | 0
+(9 rows)
--
-- N-way join
@@ -536,154 +849,232 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = ((t3.a + t3.b) / 2))
+ Join Filter: (t1.a = t2.b)
-> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p1_ab2 on prt1_e_p1 t3
- Index Cond: (((a + b) / 2) = t2.b)
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
+ Index Cond: (b = ((t3.a + t3.b) / 2))
-> Nested Loop
Join Filter: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_1
+ -> Index Scan using iprt1_e_p4_ab2 on prt1_e_p1 t3_1
Index Cond: (((a + b) / 2) = t2_1.b)
-> Nested Loop
Join Filter: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_2
Index Cond: (((a + b) / 2) = t2_2.b)
-(33 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = ((t3_3.a + t3_3.b) / 2))
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (((a + b) / 2) = t2_3.b)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t2_4.b)
+ -> Hash Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (b = ((t3_4.a + t3_4.b) / 2))
+(52 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t3 WHERE t1.a = t2.b AND t1.a = (t3.a + t3.b)/2 AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
-(4 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(8 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
---------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Hash Right Join
Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_1.a + t3_1.b) / 2) = t1_1.a)
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
-> Hash
-> Hash Right Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_2.a + t3_2.b) / 2) = t1_2.a)
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
-> Hash
-> Hash Right Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(33 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (t1_3.a = ((a + b) / 2))
+ -> Hash Right Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(51 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
--------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1.a = ((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
Index Cond: (t1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t2_1
Index Cond: (t1_1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t2_2
Index Cond: (t1_2.a = b)
-(30 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t3_3.a + t3_3.b) / 2))
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Nested Loop Left Join
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = ((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (t1_4.a = b)
+(47 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- Cases with non-nullable expressions in subquery results;
-- make sure these go to null as expected
@@ -692,21 +1083,34 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
QUERY PLAN
----------------------------------------------------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b, ((prt1_e_p1.a + prt1_e_p1.b))
+ Sort Key: prt1_p0.a, prt2_p0.b, ((prt1_e_p0.a + prt1_e_p0.b))
-> Append
-> Hash Full Join
- Hash Cond: (prt1_p1.a = ((prt1_e_p1.a + prt1_e_p1.b) / 2))
- Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ Hash Cond: (prt1_p0.a = ((prt1_e_p0.a + prt1_e_p0.b) / 2))
+ Filter: ((prt1_p0.a = (50)) OR (prt2_p0.b = (75)) OR (((prt1_e_p0.a + prt1_e_p0.b) / 2) = (50)))
-> Hash Full Join
- Hash Cond: (prt1_p1.a = prt2_p1.b)
- -> Seq Scan on prt1_p1
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ -> Seq Scan on prt1_p0
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1
+ -> Seq Scan on prt2_p0
Filter: (a = 0)
-> Hash
- -> Seq Scan on prt1_e_p1
+ -> Seq Scan on prt1_e_p0
Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: (((prt1_e_p1.a + prt1_e_p1.b) / 2) = prt1_p1.a)
+ Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ -> Seq Scan on prt1_e_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Hash Full Join
+ Hash Cond: (prt1_p1.a = prt2_p1.b)
+ -> Seq Scan on prt1_p1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p2.a = ((prt1_e_p2.a + prt1_e_p2.b) / 2))
Filter: ((prt1_p2.a = (50)) OR (prt2_p2.b = (75)) OR (((prt1_e_p2.a + prt1_e_p2.b) / 2) = (50)))
@@ -733,7 +1137,20 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
-> Hash
-> Seq Scan on prt1_e_p3
Filter: (c = 0)
-(42 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = ((prt1_e_p4.a + prt1_e_p4.b) / 2))
+ Filter: ((prt1_p4.a = (50)) OR (prt2_p4.b = (75)) OR (((prt1_e_p4.a + prt1_e_p4.b) / 2) = (50)))
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_e_p4
+ Filter: (c = 0)
+(68 rows)
SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b)) FULL JOIN (SELECT 50 phv, * FROM prt1_e WHERE prt1_e.c = 0) t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.a = t1.phv OR t2.b = t2.phv OR (t3.a + t3.b)/2 = t3.phv ORDER BY t1.a, t2.b, t3.a + t3.b;
a | phv | b | phv | ?column? | phv
@@ -751,173 +1168,261 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHER
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = t1_3.b)
+ Join Filter: (t1.a = t1_5.b)
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Join
- Hash Cond: (((t2.a + t2.b) / 2) = t1_3.b)
- -> Seq Scan on prt1_e_p1 t2
+ Hash Cond: (((t2.a + t2.b) / 2) = t1_5.b)
+ -> Seq Scan on prt1_e_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t1_3
+ -> Seq Scan on prt2_p0 t1_5
Filter: (a = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
Index Cond: (a = ((t2.a + t2.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_1.a = t1_4.b)
+ Join Filter: (t1_1.a = t1_6.b)
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Join
- Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_4.b)
- -> Seq Scan on prt1_e_p2 t2_1
+ Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_6.b)
+ -> Seq Scan on prt1_e_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t1_4
+ -> Seq Scan on prt2_p1 t1_6
Filter: (a = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
Index Cond: (a = ((t2_1.a + t2_1.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_2.a = t1_5.b)
+ Join Filter: (t1_2.a = t1_7.b)
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Nested Loop
- -> Seq Scan on prt2_p3 t1_5
+ -> Seq Scan on prt2_p2 t1_7
Filter: (a = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_2
- Index Cond: (((a + b) / 2) = t1_5.b)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t2_2
+ Index Cond: (((a + b) / 2) = t1_7.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
Index Cond: (a = ((t2_2.a + t2_2.b) / 2))
Filter: (b = 0)
-(41 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = t1_8.b)
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t1_8
+ Filter: (a = 0)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_3
+ Index Cond: (((a + b) / 2) = t1_8.b)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t2_3.a + t2_3.b) / 2))
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t1_9.b)
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Join
+ Hash Cond: (((t2_4.a + t2_4.b) / 2) = t1_9.b)
+ -> Seq Scan on prt1_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t1_9
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = ((t2_4.a + t2_4.b) / 2))
+ Filter: (b = 0)
+(66 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHERE t1.a = 0 AND t1.b = (t2.a + t2.b)/2) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
--------------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Nested Loop
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Semi Join
- Hash Cond: (t1_3.b = ((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt2_p1 t1_3
+ Hash Cond: (t1_5.b = ((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt2_p0 t1_5
-> Hash
- -> Seq Scan on prt1_e_p1 t1_6
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
- Index Cond: (a = t1_3.b)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t1_5.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Semi Join
- Hash Cond: (t1_4.b = ((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt2_p2 t1_4
+ Hash Cond: (t1_6.b = ((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt2_p1 t1_6
-> Hash
- -> Seq Scan on prt1_e_p2 t1_7
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
- Index Cond: (a = t1_4.b)
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
+ Index Cond: (a = t1_6.b)
+ Filter: (b = 0)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_7.b
+ -> Hash Semi Join
+ Hash Cond: (t1_7.b = ((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt2_p2 t1_7
+ -> Hash
+ -> Seq Scan on prt1_e_p2 t1_12
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t1_7.b)
Filter: (b = 0)
-> Nested Loop
-> Unique
-> Sort
- Sort Key: t1_5.b
+ Sort Key: t1_8.b
-> Hash Semi Join
- Hash Cond: (t1_5.b = ((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt2_p3 t1_5
+ Hash Cond: (t1_8.b = ((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt2_p3 t1_8
-> Hash
- -> Seq Scan on prt1_e_p3 t1_8
+ -> Seq Scan on prt1_e_p3 t1_13
Filter: (c = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t1_5.b)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t1_8.b)
+ Filter: (b = 0)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Semi Join
+ Hash Cond: (t1_9.b = ((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt2_p4 t1_9
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = t1_9.b)
Filter: (b = 0)
-(40 rows)
+(64 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
-- test merge joins
SET enable_hashjoin TO off;
SET enable_nestloop TO off;
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
-----------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------
Merge Append
Sort Key: t1.a
-> Merge Semi Join
- Merge Cond: (t1.a = t1_3.b)
+ Merge Cond: (t1.a = t1_5.b)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_3.b = (((t1_6.a + t1_6.b) / 2)))
+ Merge Cond: (t1_5.b = (((t1_10.a + t1_10.b) / 2)))
-> Sort
- Sort Key: t1_3.b
- -> Seq Scan on prt2_p1 t1_3
+ Sort Key: t1_5.b
+ -> Seq Scan on prt2_p0 t1_5
-> Sort
- Sort Key: (((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt1_e_p1 t1_6
+ Sort Key: (((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_1.a = t1_4.b)
+ Merge Cond: (t1_1.a = t1_6.b)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_4.b = (((t1_7.a + t1_7.b) / 2)))
+ Merge Cond: (t1_6.b = (((t1_11.a + t1_11.b) / 2)))
-> Sort
- Sort Key: t1_4.b
- -> Seq Scan on prt2_p2 t1_4
+ Sort Key: t1_6.b
+ -> Seq Scan on prt2_p1 t1_6
-> Sort
- Sort Key: (((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt1_e_p2 t1_7
+ Sort Key: (((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_2.a = t1_5.b)
+ Merge Cond: (t1_2.a = t1_7.b)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_5.b = (((t1_8.a + t1_8.b) / 2)))
+ Merge Cond: (t1_7.b = (((t1_12.a + t1_12.b) / 2)))
-> Sort
- Sort Key: t1_5.b
- -> Seq Scan on prt2_p3 t1_5
+ Sort Key: t1_7.b
+ -> Seq Scan on prt2_p2 t1_7
-> Sort
- Sort Key: (((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt1_e_p3 t1_8
+ Sort Key: (((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt1_e_p2 t1_12
Filter: (c = 0)
-(47 rows)
+ -> Merge Semi Join
+ Merge Cond: (t1_3.a = t1_8.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_8.b = (((t1_13.a + t1_13.b) / 2)))
+ -> Sort
+ Sort Key: t1_8.b
+ -> Seq Scan on prt2_p3 t1_8
+ -> Sort
+ Sort Key: (((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt1_e_p3 t1_13
+ Filter: (c = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_4.a = t1_9.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_9.b = (((t1_14.a + t1_14.b) / 2)))
+ -> Sort
+ Sort Key: t1_9.b
+ -> Seq Scan on prt2_p4 t1_9
+ -> Sort
+ Sort Key: (((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+(77 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
@@ -934,14 +1439,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3.a + t3.b) / 2)) = t1.a)
-> Sort
Sort Key: (((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Sort
Sort Key: t2.b
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Merge Left Join
Merge Cond: (t1_1.a = t2_1.b)
-> Sort
@@ -950,14 +1455,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_1.a + t3_1.b) / 2)) = t1_1.a)
-> Sort
Sort Key: (((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Sort
Sort Key: t2_1.b
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Merge Left Join
Merge Cond: (t1_2.a = t2_2.b)
-> Sort
@@ -966,32 +1471,74 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_2.a + t3_2.b) / 2)) = t1_2.a)
-> Sort
Sort Key: (((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Sort
Sort Key: t2_2.b
- -> Seq Scan on prt2_p3 t2_2
-(51 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Merge Left Join
+ Merge Cond: (t1_3.a = t2_3.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_3.a + t3_3.b) / 2)) = t1_3.a)
+ -> Sort
+ Sort Key: (((t3_3.a + t3_3.b) / 2))
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ -> Sort
+ Sort Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ -> Merge Left Join
+ Merge Cond: (t1_4.a = t2_4.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_4.a + t3_4.b) / 2)) = t1_4.a)
+ -> Sort
+ Sort Key: (((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ -> Sort
+ Sort Key: t2_4.b
+ -> Seq Scan on prt2_p4 t2_4
+(83 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- MergeAppend on nullable column
EXPLAIN (COSTS OFF)
@@ -999,8 +1546,18 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Merge Left Join
+ Merge Cond: (prt1_p0.a = b)
+ -> Sort
+ Sort Key: prt1_p0.a
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Sort
+ Sort Key: b
+ -> Result
+ One-Time Filter: false
-> Merge Left Join
Merge Cond: (prt1_p1.a = b)
-> Sort
@@ -1021,21 +1578,26 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
Sort Key: prt2_p2.b
-> Seq Scan on prt2_p2
Filter: (b > 250)
-(23 rows)
+(33 rows)
SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | b
------+-----
- 0 |
- 50 |
- 100 |
- 150 |
- 200 |
- 250 |
- 300 | 300
- 350 |
- 400 |
-(9 rows)
+ a | b
+------+-----
+ -250 |
+ -200 |
+ -150 |
+ -100 |
+ -50 |
+ 0 |
+ 50 |
+ 100 |
+ 150 |
+ 200 |
+ 250 |
+ 300 | 300
+ 350 |
+ 400 |
+(14 rows)
-- merge join when expression with whole-row reference needs to be sorted;
-- partitionwise join does not apply
@@ -1049,175 +1611,2412 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
Sort Key: t1.a, ((((t1.*)::prt1))::text)
-> Result
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Sort
Sort Key: t2.b, ((((t2.*)::prt2))::text)
-> Result
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
-(16 rows)
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+(20 rows)
SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.b ORDER BY t1.a;
- a | b
-----+----
- 0 | 0
- 6 | 6
- 12 | 12
- 18 | 18
- 24 | 24
-(5 rows)
+ a | b
+-----+-----
+ -24 | -24
+ -18 | -18
+ -12 | -12
+ -6 | -6
+ 0 | 0
+ 6 | 6
+ 12 | 12
+ 18 | 18
+ 24 | 24
+(9 rows)
RESET enable_hashjoin;
RESET enable_nestloop;
---
--- partitioned by multiple columns
---
-CREATE TABLE prt1_m (a int, b int, c int) PARTITION BY RANGE(a, ((a + b)/2));
-CREATE TABLE prt1_m_p1 PARTITION OF prt1_m FOR VALUES FROM (0, 0) TO (250, 250);
-CREATE TABLE prt1_m_p2 PARTITION OF prt1_m FOR VALUES FROM (250, 250) TO (500, 500);
-CREATE TABLE prt1_m_p3 PARTITION OF prt1_m FOR VALUES FROM (500, 500) TO (600, 600);
-INSERT INTO prt1_m SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
-ANALYZE prt1_m;
-CREATE TABLE prt2_m (a int, b int, c int) PARTITION BY RANGE(((b + a)/2), b);
-CREATE TABLE prt2_m_p1 PARTITION OF prt2_m FOR VALUES FROM (0, 0) TO (250, 250);
-CREATE TABLE prt2_m_p2 PARTITION OF prt2_m FOR VALUES FROM (250, 250) TO (500, 500);
-CREATE TABLE prt2_m_p3 PARTITION OF prt2_m FOR VALUES FROM (500, 500) TO (600, 600);
-INSERT INTO prt2_m SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
-ANALYZE prt2_m;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
- QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+ -> Seq Scan on prt2_p3 t2_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_4
+ Filter: (b = 0)
+(22 rows)
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p1 t2
+ -> Hash
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p2 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p3 t1_2
+ Filter: (b = 0)
+(21 rows)
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -150 | -0150 | 0 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 0 | 0150
+ 300 | 0300 | 0 | 0300
+ 450 | 0450 | 0 | 0450
+ 600 | 0600 | 0 | 0600
+ 750 | 0750 | 0 | 0750
+(7 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | 0 | -0150
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | 0 | 0000
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | 0 | 0150
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 0 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ 450 | 0450 | 0 | 0450
+ 500 | 0500 | |
+ 550 | 0550 | |
+ 600 | 0600 | 0 | 0600
+ 650 | 0650 | |
+ 700 | 0700 | |
+ 750 | 0750 | 0 | 0750
+(21 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Semi Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Append
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
+ Index Cond: (a = t1_1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(28 rows)
+
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Anti Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Anti Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -250 | 0 | -0250
+ -200 | 0 | -0200
+ -100 | 0 | -0100
+ -50 | 0 | -0050
+ 50 | 0 | 0050
+ 100 | 0 | 0100
+ 200 | 0 | 0200
+ 250 | 0 | 0250
+ 350 | 0 | 0350
+ 400 | 0 | 0400
+ 500 | 0 | 0500
+ 550 | 0 | 0550
+ 650 | 0 | 0650
+ 700 | 0 | 0700
+(14 rows)
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ QUERY PLAN
+---------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t3.c
+ -> Append
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t3
+ Index Cond: (a = t2.b)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t2.b)
+ -> Hash Right Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t3_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t3_2
+ Index Cond: (a = t2_2.b)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t2_2.b)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t3_3
+ Index Cond: (a = t2_3.b)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(47 rows)
+
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ a | a | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.b
+ -> Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(24 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: (t1.a = t2.b)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.a, 0)) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------
+ Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(22 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Join
+ Hash Cond: (t1.a = t2.b)
+ Join Filter: ((t1.b + t2.a) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+--
+-- partitioned by multiple columns
+--
+CREATE TABLE prt1_m (a int, b int, c int) PARTITION BY RANGE(a, ((a + b)/2));
+CREATE TABLE prt1_m_p1 PARTITION OF prt1_m FOR VALUES FROM (0, 0) TO (250, 250);
+CREATE TABLE prt1_m_p2 PARTITION OF prt1_m FOR VALUES FROM (250, 250) TO (500, 500);
+CREATE TABLE prt1_m_p3 PARTITION OF prt1_m FOR VALUES FROM (500, 500) TO (600, 600);
+INSERT INTO prt1_m SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+ANALYZE prt1_m;
+CREATE TABLE prt2_m (a int, b int, c int) PARTITION BY RANGE(((b + a)/2), b);
+CREATE TABLE prt2_m_p1 PARTITION OF prt2_m FOR VALUES FROM (0, 0) TO (250, 250);
+CREATE TABLE prt2_m_p2 PARTITION OF prt2_m FOR VALUES FROM (250, 250) TO (500, 500);
+CREATE TABLE prt2_m_p3 PARTITION OF prt2_m FOR VALUES FROM (500, 500) TO (600, 600);
+INSERT INTO prt2_m SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+ANALYZE prt2_m;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------
+ Sort
+ Sort Key: prt1_m_p1.a, prt2_m_p1.b
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p1.a = ((prt2_m_p1.b + prt2_m_p1.a) / 2)) AND (((prt1_m_p1.a + prt1_m_p1.b) / 2) = prt2_m_p1.b))
+ -> Seq Scan on prt1_m_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p1
+ Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p2.a = ((prt2_m_p2.b + prt2_m_p2.a) / 2)) AND (((prt1_m_p2.a + prt1_m_p2.b) / 2) = prt2_m_p2.b))
+ -> Seq Scan on prt1_m_p2
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p2
+ Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p3.a = ((prt2_m_p3.b + prt2_m_p3.a) / 2)) AND (((prt1_m_p3.a + prt1_m_p3.b) / 2) = prt2_m_p3.b))
+ -> Seq Scan on prt1_m_p3
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p3
+ Filter: (c = 0)
+(24 rows)
+
+SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
+ a | c | b | c
+-----+---+-----+---
+ 0 | 0 | 0 | 0
+ 50 | 0 | |
+ 100 | 0 | |
+ 150 | 0 | 150 | 0
+ 200 | 0 | |
+ 250 | 0 | |
+ 300 | 0 | 300 | 0
+ 350 | 0 | |
+ 400 | 0 | |
+ 450 | 0 | 450 | 0
+ 500 | 0 | |
+ 550 | 0 | |
+ | | 75 | 0
+ | | 225 | 0
+ | | 375 | 0
+ | | 525 | 0
+(16 rows)
+
+--
+-- tests for list partitioned tables.
+--
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 470 | 0 | 0011
+(1 row)
+
+--
+-- list partitioned by expression
+--
+CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
+ANALYZE plt1_e;
+-- test partition matching with N-way join
+EXPLAIN (COSTS OFF)
+SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Group Key: t1.c, t2.c, t3.c
+ -> Sort
+ Sort Key: t1.c, t3.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = ltrim(t3.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t2.b = t1.b) AND ((t2.c)::text = (t1.c)::text))
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt1_e_p4 t3
+ -> Hash Join
+ Hash Cond: ((t1_1.c)::text = ltrim(t3_1.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t1_1.b = t2_1.b) AND ((t1_1.c)::text = (t2_1.c)::text))
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_e_p1 t3_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = ltrim(t3_2.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t1_2.b = t2_2.b) AND ((t1_2.c)::text = (t2_2.c)::text))
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_e_p2 t3_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = ltrim(t3_3.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t2_3.b = t1_3.b) AND ((t2_3.c)::text = (t1_3.c)::text))
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt1_e_p3 t3_3
+(41 rows)
+
+SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+ avg | avg | avg | c | c | c
+----------------------+---------------------+----------------------+------+------+------
+ 246.5000000000000000 | 22.4666666666666667 | 268.9666666666666667 | 0000 | 0000 | 0000
+ 248.5000000000000000 | 21.3333333333333333 | 269.8333333333333333 | 0002 | 0002 | 0002
+ 249.5000000000000000 | 22.3333333333333333 | 271.8333333333333333 | 0003 | 0003 | 0003
+ 250.5000000000000000 | 23.3333333333333333 | 273.8333333333333333 | 0004 | 0004 | 0004
+ 251.5000000000000000 | 22.7666666666666667 | 274.2666666666666667 | 0005 | 0005 | 0005
+ 252.5000000000000000 | 22.2000000000000000 | 274.7000000000000000 | 0006 | 0006 | 0006
+ 246.0000000000000000 | 23.9655172413793103 | 269.9655172413793103 | 0008 | 0008 | 0008
+ 247.0000000000000000 | 23.3448275862068966 | 270.3448275862068966 | 0009 | 0009 | 0009
+(8 rows)
+
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 470 | 0011
+ | | 235 | 0014
+(8 rows)
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 235 | 0014
+ | | 470 | 0011
+(10 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 47 | 0 | 0013
+ 235 | 0 | 0014
+ 470 | 0 | 0011
+(3 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+----------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Materialize
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(20 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Materialize
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+---
+ 470 | 0 |
+(1 row)
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
Sort
- Sort Key: prt1_m_p1.a, prt2_m_p1.b
- -> Append
- -> Hash Full Join
- Hash Cond: ((prt1_m_p1.a = ((prt2_m_p1.b + prt2_m_p1.a) / 2)) AND (((prt1_m_p1.a + prt1_m_p1.b) / 2) = prt2_m_p1.b))
- -> Seq Scan on prt1_m_p1
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p1
- Filter: (c = 0)
- -> Hash Full Join
- Hash Cond: ((prt1_m_p2.a = ((prt2_m_p2.b + prt2_m_p2.a) / 2)) AND (((prt1_m_p2.a + prt1_m_p2.b) / 2) = prt2_m_p2.b))
- -> Seq Scan on prt1_m_p2
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p2
- Filter: (c = 0)
- -> Hash Full Join
- Hash Cond: ((prt1_m_p3.a = ((prt2_m_p3.b + prt2_m_p3.a) / 2)) AND (((prt1_m_p3.a + prt1_m_p3.b) / 2) = prt2_m_p3.b))
- -> Seq Scan on prt1_m_p3
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p3
- Filter: (c = 0)
-(24 rows)
+ Sort Key: t2.a
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
-SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 50 | 0 | |
- 100 | 0 | |
- 150 | 0 | 150 | 0
- 200 | 0 | |
- 250 | 0 | |
- 300 | 0 | 300 | 0
- 350 | 0 | |
- 400 | 0 | |
- 450 | 0 | 450 | 0
- 500 | 0 | |
- 550 | 0 | |
- | | 75 | 0
- | | 225 | 0
- | | 375 | 0
- | | 525 | 0
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
(16 rows)
---
--- tests for list partitioned tables.
---
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
---
--- list partitioned by expression
---
-CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1_e;
--- test partition matching with N-way join
+-- semi join
EXPLAIN (COSTS OFF)
-SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- QUERY PLAN
---------------------------------------------------------------------------------
- GroupAggregate
- Group Key: t1.c, t2.c, t3.c
- -> Sort
- Sort Key: t1.c, t3.c
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
-> Append
- -> Hash Join
- Hash Cond: (t1.c = ltrim(t3.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1.b = t2.b) AND (t1.c = t2.c))
- -> Seq Scan on plt1_p1 t1
- -> Hash
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_e_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.c = ltrim(t3_1.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1_1.b = t2_1.b) AND (t1_1.c = t2_1.c))
- -> Seq Scan on plt1_p2 t1_1
- -> Hash
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_e_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.c = ltrim(t3_2.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1_2.b = t2_2.b) AND (t1_2.c = t2_2.c))
- -> Seq Scan on plt1_p3 t1_2
- -> Hash
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_e_p3 t3_2
-(32 rows)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(22 rows)
-SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- avg | avg | avg | c | c | c
-----------------------+----------------------+-----------------------+------+------+-------
- 24.0000000000000000 | 24.0000000000000000 | 48.0000000000000000 | 0000 | 0000 | A0000
- 75.0000000000000000 | 75.0000000000000000 | 148.0000000000000000 | 0001 | 0001 | A0001
- 123.0000000000000000 | 123.0000000000000000 | 248.0000000000000000 | 0002 | 0002 | A0002
- 174.0000000000000000 | 174.0000000000000000 | 348.0000000000000000 | 0003 | 0003 | A0003
- 225.0000000000000000 | 225.0000000000000000 | 448.0000000000000000 | 0004 | 0004 | A0004
- 273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
- 324.0000000000000000 | 324.0000000000000000 | 648.0000000000000000 | 0006 | 0006 | A0006
- 375.0000000000000000 | 375.0000000000000000 | 748.0000000000000000 | 0007 | 0007 | A0007
- 423.0000000000000000 | 423.0000000000000000 | 848.0000000000000000 | 0008 | 0008 | A0008
- 474.0000000000000000 | 474.0000000000000000 | 948.0000000000000000 | 0009 | 0009 | A0009
- 525.0000000000000000 | 525.0000000000000000 | 1048.0000000000000000 | 0010 | 0010 | A0010
- 573.0000000000000000 | 573.0000000000000000 | 1148.0000000000000000 | 0011 | 0011 | A0011
-(12 rows)
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(22 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(19 rows)
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
@@ -1242,22 +4041,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
--------------------------------------------------
Hash Left Join
Hash Cond: (t2.b = a)
- -> Append
- -> Hash Join
- Hash Cond: (t3.a = t2.b)
- -> Seq Scan on prt1_p1 t3
- -> Hash
- -> Seq Scan on prt2_p1 t2
- -> Hash Join
- Hash Cond: (t3_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t3_1
- -> Hash
- -> Seq Scan on prt2_p2 t2_1
- -> Hash Join
- Hash Cond: (t3_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t3_2
- -> Hash
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash Join
+ Hash Cond: (t3.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t3
+ -> Seq Scan on prt1_p1 t3_1
+ -> Seq Scan on prt1_p2 t3_2
+ -> Seq Scan on prt1_p3 t3_3
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Result
One-Time Filter: false
@@ -1272,16 +4071,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
-> Hash Left Join
Hash Cond: (t2.b = a)
-> Append
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
Filter: (a = 0)
-> Hash
-> Result
One-Time Filter: false
-(14 rows)
+(20 rows)
--
-- tests for hash partitioned tables.
@@ -1357,41 +4162,9 @@ SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, ph
273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
(6 rows)
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
- Sort
- Sort Key: t1.a
- -> Append
- -> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
- -> Hash
- -> Seq Scan on prt1_p1 t1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
- -> Hash
- -> Seq Scan on prt1_p2 t1_1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
- -> Hash
- -> Seq Scan on prt1_p3 t1_2
- Filter: (b = 0)
-(21 rows)
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
@@ -1406,26 +4179,24 @@ SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c
Sort Key: t1.c
-> HashAggregate
Group Key: t1.c, t2.c
- -> Append
- -> Hash Join
- Hash Cond: (t2.c = t1.c)
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_p1 t1
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_1.c = t1_1.c)
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p1 t1_1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_2.c = t1_2.c)
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p2 t1_2
Filter: ((a % 25) = 0)
-(23 rows)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: ((a % 25) = 0)
+(21 rows)
--
-- multiple levels of partitioning
@@ -1827,64 +4598,70 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2 WHERE t1.a = t2.a;
Hash Join
Hash Cond: (t1.a = t2.a)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Seq Scan on prt4_n_p1 t2
-> Seq Scan on prt4_n_p2 t2_1
-> Seq Scan on prt4_n_p3 t2_2
-(11 rows)
+(13 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2, prt2 t3 WHERE t1.a = t2.a and t1.a = t3.b;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------
Hash Join
- Hash Cond: (t2.a = t1.a)
+ Hash Cond: (t3.b = t1.a)
-> Append
- -> Seq Scan on prt4_n_p1 t2
- -> Seq Scan on prt4_n_p2 t2_1
- -> Seq Scan on prt4_n_p3 t2_2
+ -> Seq Scan on prt2_p0 t3
+ -> Seq Scan on prt2_p1 t3_1
+ -> Seq Scan on prt2_p2 t3_2
+ -> Seq Scan on prt2_p3 t3_3
+ -> Seq Scan on prt2_p4 t3_4
+ -> Seq Scan on prt2_p5 t3_5
-> Hash
- -> Append
- -> Hash Join
- Hash Cond: (t1.a = t3.b)
- -> Seq Scan on prt1_p1 t1
- -> Hash
- -> Seq Scan on prt2_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t1_1
- -> Hash
- -> Seq Scan on prt2_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t1_2
- -> Hash
- -> Seq Scan on prt2_p3 t3_2
+ -> Hash Join
+ Hash Cond: (t1.a = t2.a)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt4_n_p1 t2
+ -> Seq Scan on prt4_n_p2 t2_1
+ -> Seq Scan on prt4_n_p3 t2_2
(23 rows)
-- partitionwise join can not be applied if there are no equi-join conditions
-- between partition keys
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON (t1.a < t2.b);
- QUERY PLAN
----------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------
Nested Loop Left Join
+ Join Filter: (t1.a < t2.b)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
- -> Append
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
- Index Cond: (t1.a < b)
-(12 rows)
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Materialize
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(16 rows)
-- equi-join with join condition on partial keys does not qualify for
-- partitionwise join
@@ -1970,16 +4747,17 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 JOIN prt2_n t2 ON (t1.c = t2.c) JOI
-> Seq Scan on prt2_n_p2 t2_1
-> Hash
-> Hash Join
- Hash Cond: (t3.c = (t1.c)::text)
+ Hash Cond: ((t3.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on plt1_p1 t3
- -> Seq Scan on plt1_p2 t3_1
- -> Seq Scan on plt1_p3 t3_2
+ -> Seq Scan on plt1_p4 t3
+ -> Seq Scan on plt1_p1 t3_1
+ -> Seq Scan on plt1_p2 t3_2
+ -> Seq Scan on plt1_p3 t3_3
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(16 rows)
+(17 rows)
-- partitionwise join can not be applied for a join between list and range
-- partitioned table
@@ -1990,14 +4768,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 FULL JOIN prt1 t2 ON (t1.c = t2.c);
Hash Full Join
Hash Cond: ((t2.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on prt1_p1 t2
- -> Seq Scan on prt1_p2 t2_1
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(10 rows)
+(12 rows)
-- partitionwise join can not be applied if only one of joining table has
-- default partition
@@ -2013,16 +4793,23 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b =
-> Hash Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
diff --git a/src/test/regress/sql/partition_join.sql b/src/test/regress/sql/partition_join.sql
index c1c9859651..0e884835fb 100644
--- a/src/test/regress/sql/partition_join.sql
+++ b/src/test/regress/sql/partition_join.sql
@@ -10,25 +10,39 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
@@ -67,11 +81,19 @@ EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -93,20 +115,30 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
@@ -169,6 +201,128 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
RESET enable_hashjoin;
RESET enable_nestloop;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
--
-- partitioned by multiple columns
--
@@ -193,28 +347,79 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1
--
-- tests for list partitioned tables.
--
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
--
-- list partitioned by expression
--
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
ANALYZE plt1_e;
-- test partition matching with N-way join
@@ -222,6 +427,175 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.a = 1 AND t1.a = 2;
@@ -267,27 +641,18 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
ALTER TABLE plt2 DETACH PARTITION plt2_p3;
ALTER TABLE plt2 ATTACH PARTITION plt2_p3 DEFAULT;
ANALYZE plt2;
-
EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.a % 25 = 0 GROUP BY t1.c, t2.c ORDER BY t1.c, t2.c;
+
--
-- multiple levels of partitioning
--
--
2.16.4
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
@ 2018-09-17 09:20 ` Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2018-09-17 09:20 UTC (permalink / raw)
To: 9erthalion6@gmail.com; +Cc: robertmhaas@gmail.com; Langote_Amit_f8@lab.ntt.co.jp; ah@cybertec.at; pgsql-hackers
On Thu, Sep 13, 2018 at 1:45 AM Dmitry Dolgov <9erthalion6@gmail.com> wrote:
> > On Fri, 31 Aug 2018 at 08:23, Ashutosh Bapat <
> ashutosh.bapat@enterprisedb.com> wrote:
> >
> > On Thu, Aug 30, 2018 at 2:23 PM, Dmitry Dolgov <9erthalion6@gmail.com>
> wrote:
> > >
> > >> I won't be working on this actively in the next commitfest. I will be
> > >> glad if somebody else wants to take this up. If there's nobody,
> > >> probably we should mark this entry as "returned with feedback" in the
> > >> next commitfest.
> > >
> > > Since I'm more or less familiar with the code and I believe it's an
> interesting
> > > feature, I can try to take over it for now if you don't mind (but
> without any
> > > strong commitments to make it perfectly shining for the next CF).
> >
> > Please do. Thanks.
>
> I've noticed that the patch is outdated already, so here is the rebased
> version. I also removed the last part with the extra tests since it
> was something
> internal
I am fine with that. It was never meant to be committed. I used to run
those tests to make sure that any changes to the core logic do not break
any working scenarios. Whenever I found a new failure in the extra tests
which wasn't there in tests to be committed, I used to move that test from
the first to the second. Over the time, the number of new failures in extra
has reduced and recently I didn't see any extra failures. So, may be it's
time for the extra tests to be dropped. I will suggest that keep the extra
tests running from time to time and certainly around the time the feature
gets committed.
> and merged the debug message into the implementation part. Ashutosh,
> please let me know if you're not happy with these modifications.
>
Robert Haas raised objections, and I agreed to those, about a similar debug
message I had included in the basic partition-wise join patches. I think
those reasons still apply, so you will need to remove the debug message
before the patches get committed. Said that the debug message is a good
debugging aid, so keeping it around till that time is a good idea.
>
> Other than that I haven't changed anything yet, but hope this will come
> soon.
> And this version is more to keep it updated for those people who may be
> interested.
>
Thanks.
--
Best Wishes,
Ashutosh Bapat
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
@ 2018-10-25 21:19 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Dmitry Dolgov @ 2018-10-25 21:19 UTC (permalink / raw)
To: ashutosh.bapat.oss@gmail.com; +Cc: Robert Haas <robertmhaas@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
> On Mon, 17 Sep 2018 at 11:20, Ashutosh Bapat <ashutosh.bapat.oss@gmail.com> wrote:
>
> I am fine with that. It was never meant to be committed. I used to run those
> tests to make sure that any changes to the core logic do not break any
> working scenarios. Whenever I found a new failure in the extra tests which
> wasn't there in tests to be committed, I used to move that test from the
> first to the second. Over the time, the number of new failures in extra has
> reduced and recently I didn't see any extra failures. So, may be it's time
> for the extra tests to be dropped. I will suggest that keep the extra tests
> running from time to time and certainly around the time the feature gets
> committed.
Great, that's exactly what I'm doing right now - I keep these tests locally
to monitor any significant failures except any changes in plans, but without
including it into the patch series.
Since most of my complaints about the patch were related to code readability,
I modified it a bit to show more clearly what I have in mind. I haven't changed
anything about the functionality, just adjusted some parts of it:
* removed some unused arguments (looks like they were added for consistency in
all higher level branches, but not all of them were actually in use)
* replaced representation for partition mapping (instead of int arrays there is
a structure, that allows to replace 0/1 with more meaningful from/to)
* tried to make naming a bit more consistent - so, if a function doesn't
explicitely say anything about outer/inner, we have partmap1/partmap2,
otherwise outermap/innermap. I don't really like this style with
partmap1/partmap2 or index1/index2, but it seems consistent with the rest of
the code in partbounds.c
* removed some state representation flags, e.g. merged - instead, if there is a
situation when we can't merge, functions will return NULL right away
* removed questionable debugging statement
Ashutosh, can you please take a look at it and confirm (or not) that you also
think these changes have improved readability a bit. If we're on the same page
about that, I'll continue in this direction.
Attachments:
[application/octet-stream] 0001-Hash-partition-bound-equality-refactoring-v12.patch (5.1K, ../../CA+q6zcUoEnZO0WLcunr5Z3QzC-raZkF6tGOGY73M=kAbT9J-EA@mail.gmail.com/2-0001-Hash-partition-bound-equality-refactoring-v12.patch)
download | inline diff:
From 9188bbcb48d523e6df6c3e752f4f3c8b86d751da Mon Sep 17 00:00:00 2001
From: erthalion <9erthalion6@gmail.com>
Date: Tue, 11 Sep 2018 21:08:07 +0200
Subject: [PATCH 1/4] Hash partition bound equality refactoring.
Separate the code to check whether two given hash bounds are equal into a
separate function, so that it can be called from multiple places. Right now
it's only caller is partition_bounds_equal() but later we will use it for
merging partition bounds.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/partitioning/partbounds.c | 95 ++++++++++++++++++++++-------------
1 file changed, 61 insertions(+), 34 deletions(-)
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index 4ed9920618..ea533090a4 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -52,6 +52,9 @@ static void get_range_key_properties(PartitionKey key, int keynum,
Expr **keyCol,
Const **lower_val, Const **upper_val);
static List *get_range_nulltest(PartitionKey key);
+static bool partition_hbounds_equal(PartitionBoundInfo b1,
+ PartitionBoundInfo b2);
+
/*
* get_qual_from_partbound
@@ -92,6 +95,63 @@ get_qual_from_partbound(Relation rel, Relation parent,
return my_qual;
}
+/*
+ * Are two hash partition bound collections logically equal?
+ *
+ * Hash partition bounds store modulus and remainder in datums array which are
+ * always integers irrespective of the number of partition keys and their data
+ * types. Hence we can compare the hash bound collection without any partition
+ * key specific information. Separating this logic in a function which does not
+ * require partition key specific information allows it be called from places
+ * where the partition key specific information is not completely available.
+ */
+static bool
+partition_hbounds_equal(PartitionBoundInfo b1, PartitionBoundInfo b2)
+{
+ int greatest_modulus = get_hash_partition_greatest_modulus(b1);
+ int i;
+
+ Assert(b1->strategy == PARTITION_STRATEGY_HASH &&
+ b2->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * If two hash partitioned tables have different greatest moduli,
+ * their partition schemes don't match. For hash partitioned table,
+ * the greatest modulus is given by the last datum and number of
+ * partitions is given by ndatums.
+ */
+ if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ return false;
+
+ /*
+ * We arrange the partitions in the ascending order of their modulus and
+ * remainders. Also every modulus is factor of next larger modulus.
+ * Therefore we can safely store index of a given partition in indexes
+ * array at remainder of that partition. Also entries at (remainder + N *
+ * modulus) positions in indexes array are all same for (modulus,
+ * remainder) specification for any partition. Thus datums array from both
+ * the given bounds are same, if and only if their indexes array will be
+ * same. So, it suffices to compare indexes array.
+ */
+ for (i = 0; i < greatest_modulus; i++)
+ if (b1->indexes[i] != b2->indexes[i])
+ return false;
+
+#ifdef USE_ASSERT_CHECKING
+
+ /*
+ * Nonetheless make sure that the bounds are indeed same when the indexes
+ * match. Hash partition bound stores modulus and remainder at
+ * b1->datums[i][0] and b1->datums[i][1] position respectively.
+ */
+ for (i = 0; i < b1->ndatums; i++)
+ Assert((b1->datums[i][0] == b2->datums[i][0] &&
+ b1->datums[i][1] == b2->datums[i][1]));
+#endif
+
+ return true;
+}
+
/*
* Are two partition bound collections logically equal?
*
@@ -120,41 +180,8 @@ partition_bounds_equal(int partnatts, int16 *parttyplen, bool *parttypbyval,
if (b1->strategy == PARTITION_STRATEGY_HASH)
{
- int greatest_modulus = get_hash_partition_greatest_modulus(b1);
-
- /*
- * If two hash partitioned tables have different greatest moduli,
- * their partition schemes don't match.
- */
- if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ if (!partition_hbounds_equal(b1, b2))
return false;
-
- /*
- * We arrange the partitions in the ascending order of their moduli
- * and remainders. Also every modulus is factor of next larger
- * modulus. Therefore we can safely store index of a given partition
- * in indexes array at remainder of that partition. Also entries at
- * (remainder + N * modulus) positions in indexes array are all same
- * for (modulus, remainder) specification for any partition. Thus
- * datums array from both the given bounds are same, if and only if
- * their indexes array will be same. So, it suffices to compare
- * indexes array.
- */
- for (i = 0; i < greatest_modulus; i++)
- if (b1->indexes[i] != b2->indexes[i])
- return false;
-
-#ifdef USE_ASSERT_CHECKING
-
- /*
- * Nonetheless make sure that the bounds are indeed same when the
- * indexes match. Hash partition bound stores modulus and remainder
- * at b1->datums[i][0] and b1->datums[i][1] position respectively.
- */
- for (i = 0; i < b1->ndatums; i++)
- Assert((b1->datums[i][0] == b2->datums[i][0] &&
- b1->datums[i][1] == b2->datums[i][1]));
-#endif
}
else
{
--
2.16.4
[application/octet-stream] 0002-Targetlist-of-a-child-join-is-produced-by-translating-v12.patch (3.5K, ../../CA+q6zcUoEnZO0WLcunr5Z3QzC-raZkF6tGOGY73M=kAbT9J-EA@mail.gmail.com/3-0002-Targetlist-of-a-child-join-is-produced-by-translating-v12.patch)
download | inline diff:
From 63a22ab73ff205702f8aaaaf0dd3f32b8dcc6a2f Mon Sep 17 00:00:00 2001
From: erthalion <9erthalion6@gmail.com>
Date: Tue, 11 Sep 2018 21:09:44 +0200
Subject: [PATCH 2/4] Targetlist of a child-join is produced by translating
that of parent join
The next patch adds more general partition matching algorithm for
partition-wise join. With that change, the first pair of joining
relations for the parent joinrel may not produce a partition-wise join
because of the restrictions in partition_bounds_merge(), to be added
in the next patch. Hence the first pair of joining relations, which
is used to build the child join and presented to
build_child_join_rel(), for the child joinrel does not correspond to
the first pair of joining relations for the parent joinrel. The
targetlist built using different pairs have the targetlist entries
arranged in different order. An appendrel expects that all its
children have their targetlists ordered in the same fashion. Hence
translate the parent's targetlist so that parent and child joinrels
have their targetlists in sync.
Basic partition-wise join commit
f49842d1ee31b976c681322f76025d7732e860f3 modified
build_joinrel_tlist() to build targetlist for child-join. With the
above changes we don't need it anymore. Similarly, the same commit
added code to set_append_rel_size() to compute attr_needed for a
child-join relation. That change too is not needed with the above
change. This commit reverts those two changes.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/optimizer/util/relnode.c | 20 ++++++++++++++++++++
1 file changed, 20 insertions(+)
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 39f5729b91..2f1137c13d 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -802,6 +802,19 @@ build_child_join_rel(PlannerInfo *root, RelOptInfo *outer_rel,
appinfos = find_appinfos_by_relids(root, joinrel->relids, &nappinfos);
+ /*
+ * The first pair of joining relations for the parent joinrel may not
+ * produce a partition-wise join because of the restrictions in
+ * partition_bounds_merge(). Hence the first pair of joining relations,
+ * which is used to build the child join and presented here, for the child
+ * joinrel does not correspond to the first pair of joining relations for
+ * the parent joinrel. The targetlist built using different pairs have the
+ * targetlist nodes arranged in different order. An appendrel expects that
+ * all its children have their targetlists ordered in the same fashion.
+ * Hence translate the parent's targetlist so that parent and child
+ * joinrels have their targetlists in sync.
+ */
+ joinrel->reltarget = copy_pathtarget(parent_joinrel->reltarget);
/* Set up reltarget struct */
build_child_join_reltarget(root, parent_joinrel, joinrel,
nappinfos, appinfos);
@@ -907,6 +920,12 @@ build_joinrel_tlist(PlannerInfo *root, RelOptInfo *joinrel,
Relids relids = joinrel->relids;
ListCell *vars;
+ /*
+ * We only see parent joins. Targetlist of a child-join is computed by
+ * translating corresponding parent join's targetlist.
+ */
+ Assert(joinrel->reloptkind == RELOPT_JOINREL);
+
foreach(vars, input_rel->reltarget->exprs)
{
Var *var = (Var *) lfirst(vars);
@@ -934,6 +953,7 @@ build_joinrel_tlist(PlannerInfo *root, RelOptInfo *joinrel,
/* Is it still needed above this joinrel? */
ndx = var->varattno - baserel->min_attr;
+
if (bms_nonempty_difference(baserel->attr_needed[ndx], relids))
{
/* Yup, add it to the output */
--
2.16.4
[application/octet-stream] 0003-Partition-wise-join-for-1-1-1-0-0-1-partition-matching-v12.patch (69.5K, ../../CA+q6zcUoEnZO0WLcunr5Z3QzC-raZkF6tGOGY73M=kAbT9J-EA@mail.gmail.com/4-0003-Partition-wise-join-for-1-1-1-0-0-1-partition-matching-v12.patch)
download | inline diff:
From 9b649057b2224e93ce39e3b1e5bbb3c9b1cd122a Mon Sep 17 00:00:00 2001
From: erthalion <9erthalion6@gmail.com>
Date: Tue, 11 Sep 2018 21:10:46 +0200
Subject: [PATCH 3/4] Partition-wise join for 1:1, 1:0, 0:1 partition matching.
Earlier version of partition-wise join implementation allowed
partition-wise join between two relations with exactly same partition
bounds. This commit allows partition-wise join to be applied under
following conditions
1. the partition bounds of joining relations are such that rows from
given partition on one side join can join with rows from maximum one
partition on the other side i.e. bounds of a given partition on one
side match/overlap with those of maximum one partition on the other
side. If the mapping happens to be m:n where m > 1 or n > 1, we have
to gang multiple partition relations together into a single relation.
This means that we have to add simple relations during join
processing, something which is not supported right now. ALso, in such
a case, different pairs of joining relations can produce different
partition bounds for the same join relation, which again is not
supported right now.
2. For every partition on outer side that can contribute to the result
of an OUTER join, there exists at least one (taken along with item 1,
it means exactly one) matching partition on the inner side. To
support partition-wise join when the inner matching partition doesn't
exist, we have to add a dummy base relation corresponding to the
non-existent inner partition. We don't have support to add base
relations during join processing.
3. For hash partitioned tables however, we support partition-wise join
only when the bounds exactly match. For hash partitioning it's unusual
to have missing partitions and hence generic partition matching is not
required.
With advanced partition matching, we won't be able to apply
partition-wise join when there are missing matching partitions. So for
a given N-way join, some sub-joins may not be partitioned, while the
overall N-way join is partitioned. We can not try partition-wise join
when one or both of the joining relations are not partitioned in one
of the pairs of joining relation. Skip partition-wise join for that
pair.
An example is A IJ B LJ C where B has an extra partition compared to A
and C. Join B LJ C requires dummy relation to join the extra partition
from B to a missing partition from C, and hence can not use
partition-wise join right now and hence BC is not partitioned. The
extra partition in B gets eliminated in A IJ B and thus it can use
partition-wise join and is partitioned. Hence (AB)C can use
partition-wise join but not A(BC).
Not every pair of joining relation (including the one presented to
build_joinrel_partition_info()) for the same joinrel can use
partition-wise join or has both the relations partitioned. Hence we
calculate the partition bounds for the join relation in
try_partition_wise_join() instead of doing it here.
The partition bounds produced for the first pair that can use
partition-wise are saved in the RelOptInfo of the joinrel. Partition
bounds produced for subsequent pairs should match that produced by the
first pair.
Support for default partition in list partitioned tables
========================================================
When a list value is present in one of the joining relations and not
the other, and the other relation has default partition, match (join)
the partition containing that list value with the default partition.
If there are multiple matches, we can not proceed with the
partition-wise join similar to the case of matching non-default
partition. If the default partition happens to be on the outer side of
the join, the resulting join partition acts as a default partition as
it will contain all the values from the default partition. If
the partition containing the list value happens to be on the outer
side of the join, the resulting join partition is associated with the
list value, since no other partition key value from the default
partition makes it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a partition from the inner side,
if inner side has a list value that is not present in the outer side.
But if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Support for matching default partition in range partitioned tables
==================================================================
When a range is present in one of the joining relations and not the
other, and the other relation has default partition, match (join) the
partition corresponding range with the default partition. If two
ranges overlap but their ranges don't match exactly, the
non-overlapping portion from one range may join the previous
(non-overlapping portion near the lower bound, if exists), next
(non-overlapping portion near the upper bound, if exists) ranges from
the other relation or default partition from the other relation. This
causes multiple partitions on the other side to be joined with a
single partition on the first side; a case we don't support. Any range
from one side which doesn't overlap with any range on the other side,
may find its join partner in the default partition and the
corresponding range partition will need to be joined with the default
partition. If the default partition happens to be on the outer side
of the join, the resulting join partition acts as a default partition
as it will contain all the values from the default partition. If the
non-partition corresponding to the range happens to be on the outer
side of the join, the resulting join partition is associated with that
range, since partition key values from the default partition outside
that range won't make it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a non-default partition from the
inner side, if inner side has a range missing in the outer side. But
if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/optimizer/path/joinrels.c | 95 +-
src/backend/optimizer/util/relnode.c | 33 +-
src/backend/partitioning/partbounds.c | 1670 ++++++++++++++++++++++++++++++++-
src/include/partitioning/partbounds.h | 11 +
4 files changed, 1763 insertions(+), 46 deletions(-)
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index d3d21fed5d..e476079143 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1312,25 +1312,31 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
RelOptInfo *joinrel, SpecialJoinInfo *parent_sjinfo,
List *parent_restrictlist)
{
- int nparts;
int cnt_parts;
+ PartitionScheme part_scheme;
+ PartitionBoundInfo join_boundinfo;
+ List *parts1;
+ List *parts2;
+ ListCell *lc1;
+ ListCell *lc2;
/* Guard against stack overflow due to overly deep partition hierarchy. */
check_stack_depth();
/* Nothing to do, if the join relation is not partitioned. */
- if (!IS_PARTITIONED_REL(joinrel))
+ if (joinrel->part_scheme == NULL)
return;
/* The join relation should have consider_partitionwise_join set. */
Assert(joinrel->consider_partitionwise_join);
/*
- * Since this join relation is partitioned, all the base relations
- * participating in this join must be partitioned and so are all the
- * intermediate join relations.
+ * We can not perform partition-wise join if either of the joining
+ * relations is not partitioned.
*/
- Assert(IS_PARTITIONED_REL(rel1) && IS_PARTITIONED_REL(rel2));
+ if (!IS_PARTITIONED_REL(rel1) || !IS_PARTITIONED_REL(rel2))
+ return;
+
Assert(REL_HAS_ALL_PART_PROPS(rel1) && REL_HAS_ALL_PART_PROPS(rel2));
/* The joining relations should have consider_partitionwise_join set. */
@@ -1343,32 +1349,63 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
*/
Assert(joinrel->part_scheme == rel1->part_scheme &&
joinrel->part_scheme == rel2->part_scheme);
+ part_scheme = joinrel->part_scheme;
/*
- * 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.
+ * Get the list of matching partitions to be joined along with the
+ * partition bounds of the join relation. Because of the restrictions
+ * imposed by partition matching algorithm, not every pair of joining
+ * relations for this join will be able to use partition-wise join. But all
+ * those pairs which can use partition-wise join will produce the same
+ * partition bounds for the join relation.
*/
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel1->boundinfo));
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel2->boundinfo));
+ join_boundinfo = partition_bounds_merge(part_scheme->partnatts,
+ part_scheme->partsupfunc,
+ part_scheme->partcollation,
+ rel1, rel2,
+ parent_sjinfo->jointype,
+ &parts1, &parts2);
+
+ if (join_boundinfo == NULL)
+ return;
- nparts = joinrel->nparts;
+ if (joinrel->boundinfo == NULL)
+ {
+ Assert(joinrel->nparts == 0 && joinrel->part_rels == NULL);
+ joinrel->boundinfo = join_boundinfo;
+ joinrel->nparts = list_length(parts1);
+ Assert(joinrel->nparts == list_length(parts2));
+ joinrel->part_rels =
+ (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+ joinrel->nparts);
+ }
+ else
+ {
+ Assert(partition_bounds_equal(part_scheme->partnatts,
+ part_scheme->parttyplen,
+ part_scheme->parttypbyval,
+ join_boundinfo, joinrel->boundinfo));
+ /*
+ * Every pair of joining relations should result in the same number
+ * of child-joins.
+ */
+ Assert(joinrel->nparts == list_length(parts1));
+ Assert(joinrel->nparts == list_length(parts2));
+ Assert(joinrel->part_rels);
+ }
/*
* Create child-join relations for this partitioned join, if those don't
* exist. Add paths to child-joins for a pair of child relations
* corresponding to the given pair of parent relations.
*/
- for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+ cnt_parts = 0;
+ forboth(lc1, parts1, lc2, parts2)
{
- RelOptInfo *child_rel1 = rel1->part_rels[cnt_parts];
- RelOptInfo *child_rel2 = rel2->part_rels[cnt_parts];
+ int part1 = lfirst_int(lc1);
+ int part2 = lfirst_int(lc2);
+ RelOptInfo *child_rel1;
+ RelOptInfo *child_rel2;
SpecialJoinInfo *child_sjinfo;
List *child_restrictlist;
RelOptInfo *child_joinrel;
@@ -1376,6 +1413,10 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
AppendRelInfo **appinfos;
int nappinfos;
+ Assert(part1 >= 0 && part2 >= 0);
+ child_rel1 = rel1->part_rels[part1];
+ child_rel2 = rel2->part_rels[part2];
+
/* We should never try to join two overlapping sets of rels. */
Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1409,12 +1450,24 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
joinrel->part_rels[cnt_parts] = child_joinrel;
}
+ /*
+ * For every pair of joining relations, the set of matching partitions
+ * would change. However, the base relation partitions constituting
+ * the given child should remain same for all the joining pairs. Since
+ * the order in which children are stored in the array of child-joins,
+ * depends upon partition bounds of the join, which are same for all
+ * the joining pairs, every joining pair yields the child-joins in the
+ * same order.
+ */
Assert(bms_equal(child_joinrel->relids, child_joinrelids));
populate_joinrel_with_paths(root, child_rel1, child_rel2,
child_joinrel, child_sjinfo,
child_restrictlist);
+ cnt_parts++;
}
+
+ Assert(cnt_parts == joinrel->nparts);
}
/*
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 2f1137c13d..4f15cd8e8b 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1627,7 +1627,7 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
* of the way the query planner deduces implied equalities and reorders
* the joins. Please see optimizer/README for details.
*/
- if (!IS_PARTITIONED_REL(outer_rel) || !IS_PARTITIONED_REL(inner_rel) ||
+ if (outer_rel->part_scheme == NULL || inner_rel->part_scheme == NULL ||
!outer_rel->consider_partitionwise_join ||
!inner_rel->consider_partitionwise_join ||
outer_rel->part_scheme != inner_rel->part_scheme ||
@@ -1640,24 +1640,6 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
part_scheme = outer_rel->part_scheme;
- Assert(REL_HAS_ALL_PART_PROPS(outer_rel) &&
- REL_HAS_ALL_PART_PROPS(inner_rel));
-
- /*
- * For now, our partition matching algorithm can match partitions only
- * when the partition bounds of the joining relations are exactly same.
- * So, bail out otherwise.
- */
- if (outer_rel->nparts != inner_rel->nparts ||
- !partition_bounds_equal(part_scheme->partnatts,
- part_scheme->parttyplen,
- part_scheme->parttypbyval,
- outer_rel->boundinfo, inner_rel->boundinfo))
- {
- Assert(!IS_PARTITIONED_REL(joinrel));
- return;
- }
-
/*
* This function will be called only once for each joinrel, hence it
* should not have partition scheme, partition bounds, partition key
@@ -1669,17 +1651,20 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
/*
* Join relation is partitioned using the same partitioning scheme as the
- * joining relations and has same bounds.
+ * joining relations.
+ *
+ * Because of restrictions in partition_bounds_merge(), not every pair of
+ * joining relations (including the one presented to this function) for the
+ * same joinrel can use partition-wise join or has both the relations
+ * partitioned. Hence we calculate the partition bounds, number of
+ * partitions and child-join relations of the join relation when and if we
+ * find a suitable pair in try_partition_wise_join().
*/
joinrel->part_scheme = part_scheme;
- joinrel->boundinfo = outer_rel->boundinfo;
partnatts = joinrel->part_scheme->partnatts;
joinrel->partexprs = (List **) palloc0(sizeof(List *) * partnatts);
joinrel->nullable_partexprs =
(List **) palloc0(sizeof(List *) * partnatts);
- joinrel->nparts = outer_rel->nparts;
- joinrel->part_rels =
- (RelOptInfo **) palloc0(sizeof(RelOptInfo *) * joinrel->nparts);
/*
* Set the consider_partitionwise_join flag.
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index ea533090a4..68179d665d 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -54,7 +54,58 @@ static void get_range_key_properties(PartitionKey key, int keynum,
static List *get_range_nulltest(PartitionKey key);
static bool partition_hbounds_equal(PartitionBoundInfo b1,
PartitionBoundInfo b2);
-
+static PartitionBoundInfo partition_range_bounds_merge(
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype, int partnatts,
+ FmgrInfo *supfuncs, Oid *collations);
+static PartitionBoundInfo partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *collations,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype);
+static PartitionBoundInfo partition_hash_bounds_merge(RelOptInfo *outer_rel,
+ RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype);
+static void generate_matching_part_pairs(PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ int nparts1, int nparts2,
+ JoinType jointype, int nparts,
+ List **parts1, List **parts2);
+static PartitionBoundInfo build_merged_partition_bounds(char strategy,
+ List *merged_datums, List *merged_indexes,
+ List *merged_contents, int null_index,
+ int default_index);
+static int map_and_merge_partitions(PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ int index1, int index2, int *next_index);
+static int32 partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *collations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2);
+static bool partition_range_cmp(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval);
+static bool partition_range_merge_next_lb(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes);
+static bool merge_default_partitions(PartitionBoundInfo outer_bi,
+ PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ JoinType jointype,
+ int *next_index, int *default_index);
+static bool merge_null_partitions(PartitionBoundInfo outer_bi,
+ PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ JoinType jointype,
+ int *next_index, int *null_index,
+ int *default_index);
/*
* get_qual_from_partbound
@@ -2332,3 +2383,1620 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
PG_RETURN_BOOL(rowHash % modulus == remainder);
}
+
+/*
+ * partition_bounds_merge
+ *
+ * The function produces the partition bounds for a join between two relations
+ * whose partition bounds are given. The function also returns two lists of
+ * partition indexes one for each of the joining relations. Both the lists
+ * contain the same number of elements. The partition indexes at the same
+ * positions in the lists indicate the pair partitions, one from each side, to
+ * be joined and the position itself corresponds to the index of partition
+ * produced by that child-join in the partitioned join.
+ *
+ * The function returns NULL if we can not find the matching pair of
+ * partitions. This happens if 1. multiple partitions on one side match with
+ * one partition on the other side. 2. a given partition on the outer side
+ * doesn't have a matching partition on the inner side. We can not support the
+ * first case since we don't have a way to represent multiple partitions as a
+ * single relation (RelOptInfo) and then perform join using the ganged
+ * relation. We can not support the second case since the missing inner
+ * partition needs to be represented as an empty relation and we don't have a
+ * way to introduce empty relation during join planning after creating paths
+ * for all the base relations.
+ */
+extern PartitionBoundInfo
+partition_bounds_merge(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts)
+{
+ PartitionBoundInfo merged_bounds;
+ PartitionBoundInfo outer_binfo = outer_rel->boundinfo,
+ inner_binfo = inner_rel->boundinfo;
+ char strategy = outer_binfo->strategy;
+
+ /* Bail out if partitioning strategies are different. */
+ if (outer_binfo->strategy != inner_binfo->strategy)
+ return NULL;
+
+ if (jointype != JOIN_LEFT && jointype != JOIN_INNER &&
+ jointype != JOIN_SEMI && jointype != JOIN_ANTI &&
+ jointype != JOIN_FULL)
+ elog(ERROR, "unexpected join type %d", jointype);
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+ switch (strategy)
+ {
+ case PARTITION_STRATEGY_LIST:
+ merged_bounds = partition_list_bounds_merge(partsupfunc,
+ partcollation,
+ outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype);
+ break;
+
+ case PARTITION_STRATEGY_RANGE:
+ merged_bounds = partition_range_bounds_merge(outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype, partnatts,
+ partsupfunc,
+ partcollation);
+ break;
+
+ case PARTITION_STRATEGY_HASH:
+ merged_bounds = partition_hash_bounds_merge(outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype);
+ break;
+
+ default:
+ elog(ERROR, "unexpected partition strategy: %d", strategy);
+ }
+
+ Assert(merged_bounds || (*outer_parts == NIL && *inner_parts == NIL));
+
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+
+ Assert((*outer_parts == NIL || *inner_parts != NIL) &&
+ (*inner_parts == NIL || *outer_parts != NIL));
+
+ return merged_bounds;
+}
+
+/*
+ * partition_get_range_bounds
+ *
+ * Given the index of lower bound in datums array, return lower and upper
+ * bounds and the index of the partition with that lower bound.
+ */
+static int
+partition_get_range_bounds(PartitionBoundInfo bi, int lb_index,
+ PartitionRangeBound *lower,
+ PartitionRangeBound *upper)
+{
+ int part_index;
+
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The lower bound should correspond to a valid partition. */
+ part_index = bi->indexes[lb_index + 1];
+ Assert(part_index >= 0);
+
+ lower->kind = bi->kind[lb_index];
+ lower->datums = bi->datums[lb_index];
+ lower->lower = true;
+ upper->kind = bi->kind[lb_index + 1];
+ upper->datums = bi->datums[lb_index + 1];
+ upper->lower = false;
+
+ return part_index;
+}
+
+/*
+ * partition_range_get_next_lb_index
+ *
+ * Given the index of lower bound in datums array return the
+ * index of lower bound of the next partition. When the given index corresponds
+ * to the last partition, return number of datums (ndatums).
+ */
+static int
+partition_range_get_next_lb_index(PartitionBoundInfo bi, int lb_index)
+{
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The partition index corresponding to the upper bound should be valid. */
+ Assert(bi->indexes[lb_index + 1] >= 0);
+
+ /*
+ * If there are no bounds left beyond the upper bound, we have reached the
+ * last partition.
+ */
+ if (lb_index + 2 < bi->ndatums)
+ {
+ /*
+ * If the bound next to the upper bound corresponds to no partition,
+ * that's the next lower bound of the next partition. Otherwise, the
+ * current upper bound is the lower bound of the next partition.
+ */
+ if (bi->indexes[lb_index + 2] < 0)
+ return lb_index + 2;
+ else
+ return lb_index + 1;
+ }
+ else
+ return bi->ndatums;
+}
+
+static int32
+partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2)
+{
+ return partition_rbound_cmp(partnatts, partsupfunc, partcollations,
+ bound1->datums, bound1->kind, bound1->lower,
+ bound2);
+}
+
+/*
+ * partition_range_cmp
+ *
+ * Compare the bounds of two range partitions. Set ub_cmpval <, = or > 0, if the
+ * first partition's upper bound is lower than, equal to or higher than the
+ * second partition's upper bound resp. Similarly set lb_cmpval <, = or > 0,
+ * if the first partition's lower bound is lower than, equal to or higher than
+ * the second partition's lower bound resp.
+ *
+ * Return true, if the ranges overlap, otherwise return false.
+ */
+static bool
+partition_range_cmp(int partnatts, FmgrInfo *partsupfuncs, Oid *partcollations,
+ PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval)
+{
+ bool overlap;
+
+ /*
+ * Compare upper bound of the first partition with the lower bound of the
+ * second and vice-versa. If lower bound is higher than the upper bound,
+ * the partitions are not overlapping. All other cases indicate overlapping
+ * partitions.
+ */
+ if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound1, upper_bound2) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = 1;
+ *lb_cmpval = 1;
+ }
+ else if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound2, upper_bound1) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = -1;
+ *lb_cmpval = -1;
+ }
+ else
+ {
+ overlap = true;
+ *ub_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, upper_bound1,
+ upper_bound2);
+ *lb_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, lower_bound1,
+ lower_bound2);
+ }
+
+ return overlap;
+}
+
+/*
+ * partition_range_merge
+ *
+ * Merge the partition bounds of given two partitions such that the join
+ * between the given two partitions fits merged bounds.
+ *
+ * "merged_upper" will be set to one of the given upper bounds and
+ * "merged_lower" will be set to one of the given lower bounds.
+ */
+static void
+partition_range_merge(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, JoinType jointype,
+ PartitionRangeBound *left_lb,
+ PartitionRangeBound *left_ub,
+ PartitionRangeBound *right_lb,
+ PartitionRangeBound *right_ub,
+ PartitionRangeBound **merged_lb,
+ PartitionRangeBound **merged_ub)
+{
+ /*
+ * An outer join will have all the rows from the outer side, so merged
+ * bounds will be same as the outer bounds. An inner join will have rows
+ * that fit both the bounds, thus lower merged bound will be higher of two
+ * lower bounds and upper merged bound will be lower of the two upper
+ * bounds.
+ */
+ switch (jointype)
+ {
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ *merged_ub = left_ub;
+ *merged_lb = left_lb;
+ break;
+
+ case JOIN_INNER:
+ case JOIN_SEMI:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) < 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) > 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ case JOIN_FULL:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) > 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) < 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ default:
+ elog(ERROR, "unexpected join type %d", jointype);
+ }
+
+ return;
+}
+
+/*
+ * Add the lower bound of the next range to the list of bounds, if the lower
+ * bound is higher or equal to the previous upper bound. If successful return
+ * true, otherwise false.
+ */
+static bool
+partition_range_merge_next_lb(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes)
+{
+ int cmpval;
+
+ if (!*merged_datums)
+ {
+ Assert(!*merged_kinds && !*merged_indexes);
+ cmpval = 1;
+ }
+ else
+ {
+ PartitionRangeBound prev_ub;
+
+ prev_ub.datums = llast(*merged_datums);
+ prev_ub.kind = llast(*merged_kinds);
+ prev_ub.lower = false;
+
+ cmpval = partition_rbound_cmp(partnatts, partsupfuncs, partcollations,
+ next_lb_datums, next_lb_kind, false,
+ &prev_ub);
+ }
+
+ /*
+ * The lower bound is lower than the last upper bound, thus does not fit
+ * the bounds created so far and hence can not be merged with the existing
+ * bounds.
+ */
+ if (cmpval < 0)
+ return false;
+
+ /*
+ * Add bounds of the new merged partition. If the next lower bound is
+ * higher than the last upper bound, add new range with index
+ * corresponding to the lower bound as -1. If the merged lower bound
+ * is same as the last merged upper bound, the last upper bound will be
+ * reused as the lower bound of the next range.
+ */
+ if (cmpval > 0)
+ {
+ *merged_datums = lappend(*merged_datums, next_lb_datums);
+ *merged_kinds = lappend(*merged_kinds, next_lb_kind);
+ *merged_indexes = lappend_int(*merged_indexes, -1);
+ }
+
+ return true;
+}
+
+/*
+ * handle_missing_partition
+ *
+ * If a range appears in one of the joining relations but not the other, a row
+ * in the corresponding partition will not have any join partner in the other
+ * relation, unless the other relation has a default partition. If a given list
+ * value is present in one joining relation but not the other, the default
+ * partition on the other side may contain that value.
+ *
+ * In both these cases, such an extra partition forms a joining pair with the
+ * default partition, if any, on the other side.
+ *
+ * If the default partition happens to be on the outer side of the join, the
+ * resultant partition will act as the default partition of the join relation.
+ * Otherwise the resultant partition will be associated with the range.
+ *
+ * When the default partition is not present in the other relation, the rows in
+ * the extra partition will be included in the bounds of the join result, if it
+ * appears on the outer side of the join, since all rows from the outer side
+ * are included in the join result.
+ *
+ * This function handles all these cases.
+ *
+ * maps_with_missing and missing_side_default are the partition maps (See
+ * partition_range/list_bounds_merge() for details) and the index of default
+ * partition respectively corresponding the side with missing partition.
+ *
+ * maps_with_extra and extra_part are the partition maps (See
+ * partition_range/list_bounds_merge() for details) and the index of extra
+ * partition respectively corresponding to the side with the extra partition.
+ *
+ * It returns true if the matching succeeds, otherwise returns false.
+ */
+static bool
+handle_missing_partition(PartitionMap *maps_with_missing,
+ PartitionMap *maps_with_extra,
+ int missing_side_default,
+ int extra_part,
+ bool missing_side_outer,
+ bool missing_side_inner,
+ int *next_index, int *default_index,
+ int *merged_index)
+{
+ bool missing_has_default = (missing_side_default != -1);
+
+ if (missing_has_default)
+ {
+ *merged_index = map_and_merge_partitions(maps_with_missing,
+ maps_with_extra,
+ missing_side_default,
+ extra_part,
+ next_index);
+ if (*merged_index < 0)
+ return false;
+
+ if (missing_side_outer)
+ {
+ /*
+ * Default partition on the outer side forms the default
+ * partition of the join result.
+ */
+ if (*default_index < 0)
+ *default_index = *merged_index;
+ else if(*default_index != *merged_index)
+ {
+ /*
+ * Ended up with default partition on the outer side
+ * being joined with multiple partitions on the inner
+ * side. We don't support this case.
+ */
+ return false;
+ }
+
+ /*
+ * Since the merged partition acts as a default partition, it
+ * doesn't need a separate index.
+ */
+ *merged_index = -1;
+ }
+ }
+ else if (missing_side_inner)
+ {
+ /*
+ * If this partition has already been mapped (say because we
+ * found an overlapping range earlier), we know where does it
+ * fit in the join result. Nothing to do in that case. Else
+ * create a new merged partition.
+ */
+ PartitionMap *extra_map = &maps_with_extra[extra_part];
+ if (extra_map->to < 0)
+ {
+ extra_map->to = *next_index;
+ *next_index = *next_index + 1;
+ *merged_index = extra_map->to;
+ }
+ }
+
+ return true;
+}
+
+static PartitionMap*
+init_partition_map(RelOptInfo *rel)
+{
+ int i, nparts = rel->nparts;
+ PartitionMap *map;
+
+ map = (PartitionMap *) palloc(sizeof(PartitionMap) * nparts);
+
+ for (i = 0; i < nparts; i++)
+ {
+ map[i].from = -1;
+ map[i].to = -1;
+ }
+
+ return map;
+}
+
+/*
+ * Allocate and initialize partition maps. We maintain four maps, two maps
+ * for each joining relation. pmap[i] gives the partition from the other
+ * relation which would join with ith partition of the given relation.
+ * Partition i from the given relation will join with partition pmap[i]
+ * from the other relation to produce partition mmap[i] of the join (merged
+ * partition).
+ *
+ * pmap[i] = -1 indicates that ith partition of a given relation does not
+ * have a matching partition from the other relation.
+ *
+ * mmap[i] = -1 indicates that ith partition of a given relation does not
+ * contribute to the join result. That can happen only when the given
+ * relation is the inner relation and it doesn't have a matching partition
+ * from the outer relation, hence pmap[i] should be -1.
+ *
+ * In case of an outer join, every partition of the outer join will appear
+ * in the join result, and thus has mmap[i] set for all i. But it's not
+ * necessary that every partition on the outer side will have a matching
+ * partition on the inner side. In such a case, we end up with pmap[i] = -1
+ * and mmap[i] != -1.
+ */
+
+/*
+ * partition_range_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for range partitioned tables.
+ */
+static PartitionBoundInfo
+partition_range_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype, int partnatts,
+ FmgrInfo *partsupfuncs, Oid *partcollations)
+
+{
+ PartitionMap *outer_maps = NULL;
+ PartitionMap *inner_maps = NULL;
+ int outer_part = 0;
+ int inner_part = 0;
+ PartitionBoundInfo merged_bounds = NULL;
+ int outer_lb_index;
+ int inner_lb_index;
+ int next_index;
+ int default_index = -1;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ List *merged_kinds = NIL;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int inner_default = inner_bi->default_index;
+ int outer_default = outer_bi->default_index;
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_RANGE);
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ outer_maps = init_partition_map(outer_rel);
+ inner_maps = init_partition_map(inner_rel);
+
+ /*
+ * Merge the ranges (partitions) from both sides. Every iteration compares
+ * a pair of ranges, one from each side, advancing to the next range from
+ * the side with smaller upper range bound. If upper bounds of ranges from
+ * both sides match exactly, both the sides are advanced. For a given pair
+ * of ranges, we decide whether the corresponding partition match or not.
+ * lb_index, for inner or outer side, keeps track of the index of lower bound
+ * datum in PartitionBoundInfo::datums of that side.
+ */
+ outer_lb_index = 0;
+ inner_lb_index = 0;
+ next_index = 0;
+ while (outer_lb_index < outer_bi->ndatums ||
+ inner_lb_index < inner_bi->ndatums)
+ {
+ PartitionRangeBound outer_lb, outer_ub,
+ inner_lb, inner_ub,
+ *merged_lb = NULL,
+ *merged_ub = NULL;
+
+ int merged_index = -1;
+ bool overlap;
+ bool finished_outer = false;
+ bool finished_inner = false;
+
+ /* Result of bounds comparison per partition_rbound_cmp(). */
+ int ub_cmpval; /* Upper bounds comparison result. */
+ int lb_cmpval; /* Lower bounds comparison result. */
+
+ /* Get the range bounds of the next pair of partitions. */
+ if (outer_lb_index < outer_bi->ndatums)
+ outer_part = partition_get_range_bounds(outer_bi, outer_lb_index,
+ &outer_lb, &outer_ub);
+ else
+ finished_outer = true;
+
+ if (inner_lb_index < inner_bi->ndatums)
+ inner_part = partition_get_range_bounds(inner_bi, inner_lb_index,
+ &inner_lb, &inner_ub);
+ else
+ finished_inner = true;
+
+ Assert(!finished_outer || !finished_inner);
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining partitions on the side
+ * which finishes later. For that we set the comparison parameters
+ * overlap, ub_cmpval and lb_cmpval in such a way that it appears as if
+ * the side which finishes earlier has an extra partition with lower
+ * and upper bounds higher than any other partition of the unfinished
+ * side. That way we advance the partitions on that side till all of
+ * them are exhausted.
+ */
+ if (finished_outer)
+ {
+ overlap = false;
+ ub_cmpval = 1;
+ lb_cmpval = 1;
+ }
+ else if (finished_inner)
+ {
+ overlap = false;
+ ub_cmpval = -1;
+ lb_cmpval = -1;
+ }
+ else
+ overlap = partition_range_cmp(partnatts, partsupfuncs, partcollations,
+ &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &ub_cmpval, &lb_cmpval);
+
+ if (overlap)
+ {
+ /*
+ * The rows from overlapping portion of ranges on both sides may
+ * join, hence the corresponding pair of partitions form a joining
+ * pair. Match them and produce the bounds of the joint partition
+ * and its index by merging the bounds according to the type of
+ * join.
+ */
+ partition_range_merge(partnatts, partsupfuncs, partcollations,
+ jointype, &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &merged_lb, &merged_ub);
+
+ merged_index = map_and_merge_partitions(outer_maps, inner_maps,
+ outer_part, inner_part,
+ &next_index);
+
+ if (merged_index < 0)
+ {
+ /* Failed to match the partitions. */
+ return NULL;
+ }
+
+ /*
+ * If the ranges overlap but don't exactly match, a row from
+ * non-overlapping portion of the range from one side of join may
+ * find its join partner in the previous or next overlapping
+ * partition or default partition on the other side , if such a
+ * partition exists. All those cases, if true, will cause one
+ * partition from that side to match at least two partitions on the
+ * other side; a case that we do not support now. Previous
+ * partition has been delt with in the previous iteration of this
+ * loop, next partition will be delt in the next iteration. We will
+ * deal with the default partition here.
+ */
+ if ((lb_cmpval < 0 && inner_has_default) ||
+ /* Non-overlapping range on the lower side of outer range. */
+ (lb_cmpval > 0 && outer_has_default) ||
+ /* Non-overlapping range on the lower side of inner range. */
+ (ub_cmpval < 0 && outer_has_default) ||
+ /* Non-overlapping range on the upper side of inner range. */
+ (ub_cmpval > 0 && inner_has_default))
+ /* Non-overlapping range on the upper side of outer range. */
+ return NULL;
+ }
+
+ if (ub_cmpval == 0)
+ {
+ /* Upper bounds of both the ranges match. */
+ Assert(overlap);
+
+ /* Move to the next pair of partitions. */
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+ else if (ub_cmpval < 0)
+ {
+ /* Upper bound of inner range higher than that of the outer. */
+
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the inner side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &outer_lb;
+ merged_ub = &outer_ub;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+ if (!handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ outer_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+ }
+
+ /* Move to the next partition on the outer side. */
+ Assert(!finished_outer);
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ }
+ else
+ {
+ Assert(ub_cmpval > 0);
+
+ /* Upper bound of outer range higher than that of the inner. */
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the outer side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &inner_lb;
+ merged_ub = &inner_ub;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ inner_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+ }
+
+ /* Move to the next partition on the inner side. */
+ Assert (!finished_inner);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+
+ if (merged_index < 0)
+ {
+ /* We didn't find a new merged partition. */
+ continue;
+ }
+
+ /*
+ * We have a valid partition index for the next partition of join. The
+ * partition should have valid range.
+ */
+ Assert(merged_lb && merged_ub);
+
+ /* Try merging new lower bound with the last upper bound. */
+ if (!partition_range_merge_next_lb(partnatts, partsupfuncs,
+ partcollations,
+ merged_lb->datums,
+ merged_lb->kind, &merged_datums,
+ &merged_kinds, &merged_indexes))
+ return NULL;
+
+ /* Add upper bound with the merged partition index. */
+ merged_datums = lappend(merged_datums, merged_ub->datums);
+ merged_kinds = lappend(merged_kinds, merged_ub->kind);
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ }
+
+ if (!merge_default_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index,
+ &default_index))
+ return NULL;
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_maps, inner_maps,
+ outer_nparts, inner_nparts,
+ jointype, next_index,
+ outer_parts, inner_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes,
+ merged_kinds,
+ -1, default_index);
+ }
+
+ /* Free any memory we used in this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ list_free(merged_kinds);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_list_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for list partitioned tables.
+ *
+ */
+static PartitionBoundInfo
+partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype)
+{
+ PartitionMap *outer_maps = NULL;
+ PartitionMap *inner_maps = NULL;
+ int cnto;
+ int cnti;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ int next_index = 0;
+ int null_index;
+ int default_index = -1;
+ PartitionBoundInfo merged_bounds = NULL;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int *outer_indexes = outer_bi->indexes;
+ int *inner_indexes = inner_bi->indexes;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_LIST);
+
+ /* List partitions do not require unbounded ranges. */
+ Assert(!outer_bi->kind && !inner_bi->kind);
+
+ outer_maps = init_partition_map(outer_rel);
+ inner_maps = init_partition_map(inner_rel);
+
+ /*
+ * Merge the list value datums from both sides. Every iteration compares a
+ * pair of datums, one from each side, advancing to the next datum from the
+ * side with smaller datum. If datums from both sides match exactly, both
+ * the sides are advanced. For a given pair of datums, we decide whether
+ * the corresponding partition match or not.
+ */
+ cnto = cnti = 0;
+ while (cnto < outer_bi->ndatums || cnti < inner_bi->ndatums)
+ {
+ Datum *odatums;
+ Datum *idatums;
+ int o_index;
+ int i_index;
+ int cmpval;
+ int merged_index = -1;
+ Datum *merged_datum;
+ bool finished_inner;
+ bool finished_outer;
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining datums on the side which
+ * finishes later. For that we set the comparison parameter cmpval in
+ * such a way that it appears as if the side which finishes earlier has
+ * an extra datum higher than any other datum on the unfinished side.
+ * That way we advance the datums on the unfinished side till all of
+ * its datums are exhausted.
+ */
+ if (cnto >= outer_bi->ndatums)
+ {
+ finished_outer = true;
+ odatums = NULL;
+ o_index = -1;
+ }
+ else
+ {
+ finished_outer = false;
+ odatums = outer_bi->datums[cnto];
+ o_index = outer_indexes[cnto];
+ }
+
+ if (cnti >= inner_bi->ndatums)
+ {
+ finished_inner = true;
+ idatums = NULL;
+ i_index = -1;
+ }
+ else
+ {
+ finished_inner = false;
+ idatums = inner_bi->datums[cnti];
+ i_index = inner_indexes[cnti];
+ }
+
+ /* If we exhausted both the sides, we won't enter the loop. */
+ Assert(!finished_inner || !finished_outer);
+
+ if (finished_outer)
+ cmpval = 1;
+ else if (finished_inner)
+ cmpval = -1;
+ else
+ {
+ /* Every list datum should map to a valid partition index. */
+ Assert(o_index >= 0 && i_index >= 0 &&
+ odatums != NULL && idatums != NULL);
+
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
+ partcollation[0],
+ odatums[0], idatums[0]));
+ }
+
+ if (cmpval == 0)
+ {
+ /*
+ * Datums match. Rows on either side with these datums as partition
+ * key value will join and will be part of the partition of the
+ * join result produced by joining the corresponding partitions.
+ * Match the corresponding partitions and if successful, add the
+ * datum to the list of merged datums with index of merged
+ * partition containing it.
+ */
+ merged_datum = odatums;
+ merged_index = map_and_merge_partitions(outer_maps, inner_maps,
+ o_index, i_index,
+ &next_index);
+
+ if (merged_index < 0)
+ return NULL;
+
+ /* Move to the next pair of bounds. */
+ cnto++;
+ cnti++;
+ }
+ else if (cmpval < 0)
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /* A datum missing from the inner side. */
+ merged_index = -1;
+ merged_datum = odatums;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ o_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+
+ /* Move to the next datum on the outer side. */
+ Assert(!finished_outer);
+ cnto++;
+ }
+ else
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ Assert(cmpval > 0);
+
+ /* A datum missing from the outer side. */
+ merged_index = -1;
+ merged_datum = idatums;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ i_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+
+ /* Move to the next datum on the right side. */
+ Assert(!finished_inner);
+ cnti++;
+ }
+
+ /*
+ * Add the list value with appropriate index in the list of datums, if
+ * we have associated a partition with this list value.
+ */
+ if (merged_index >= 0)
+ {
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ merged_datums = lappend(merged_datums, merged_datum);
+ }
+ }
+
+ if (!merge_null_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index, &null_index,
+ &default_index))
+ return NULL;
+
+ if (!merge_default_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index,
+ &default_index))
+ return NULL;
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_maps, inner_maps,
+ outer_nparts, inner_nparts,
+ jointype, next_index,
+ outer_parts, inner_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes, NIL,
+ null_index, default_index);
+ }
+
+ /* Free up all extra memory before returning from this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_bounds_merge()'s arm for hash partitioned tables.
+ *
+ * If the given two hash bounds are same, the function returns the first one
+ * without any change, alongwith the lists of matching partitions. Otherwise it
+ * returns NULL.
+ *
+ * We could try merging the bounds when both the bounds have same greatest
+ * modulii. But there seems to be hardly any requirement for the same.
+ */
+static PartitionBoundInfo
+partition_hash_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype)
+{
+ int nparts;
+ int cnt;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * Hash partitioned table does not have explicit NULL accepting partition
+ * and also does not have a default partition.
+ */
+ Assert(!partition_bound_has_default(outer_bi) &&
+ !partition_bound_has_default(inner_bi));
+ Assert(!partition_bound_accepts_nulls(outer_bi) &&
+ !partition_bound_accepts_nulls(inner_bi));
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+
+ if (outer_nparts != inner_nparts)
+ return NULL;
+ nparts = outer_nparts;
+
+ if (outer_bi->ndatums != inner_bi->ndatums ||
+ !partition_hbounds_equal(outer_bi, inner_bi))
+ return NULL;
+
+ /*
+ * Cook up list of matching partitions. Since bounds are exactly same the
+ * partitions at the same position from both the relations match.
+ */
+ for (cnt = 0; cnt < nparts; cnt++)
+ {
+ *outer_parts = lappend_int(*outer_parts, cnt);
+ *inner_parts = lappend_int(*inner_parts, cnt);
+ }
+
+ return outer_bi;
+}
+
+/*
+ * map_and_merge_partitions
+ *
+ * If the two given partitions (given by index1 and index2 resp.) are
+ * already mapped to each other return the index of corresponding partition in
+ * the merged set of partitions. If they do not have a merged partition
+ * associated with them, assign a new merged partition index. If the
+ * partitions are already mapped and their mapped partitions are different from
+ * each other, they can not be merged, so return -1.
+ *
+ * partmaps1[i] gives the mapping of partitions for both relations. It
+ * describes which partition of relation 2 matches ith partition of relation 1,
+ * and which partition in the merged set matches ith partition of relation 1
+ * maps to. Similarly for partmap2.
+ *
+ * index1 and index2 are the indexes of matching partition from respective
+ * relations.
+ *
+ * *next_index is used and incremented when the given partitions require a new
+ * merged partition.
+ */
+
+static int
+map_and_merge_partitions(PartitionMap *partmaps1, PartitionMap *partmaps2,
+ int index1, int index2, int *next_index)
+{
+ PartitionMap *partmap1 = &partmaps1[index1];
+ PartitionMap *partmap2 = &partmaps2[index2];
+ int merged_index;
+
+ /*
+ * If both the partitions are not mapped to each other, update the
+ * maps.
+ */
+ if (partmap1->from < 0 && partmap2->from < 0)
+ {
+ partmap1->from = index2;
+ partmap2->from = index1;
+ }
+
+ /*
+ * If the given to partitions map to each other, find the corresponding
+ * merged partition index .
+ */
+ if (partmap1->from == index2 && partmap2->from == index1)
+ {
+ /*
+ * If both the partitions are mapped to the same merged partition, get
+ * the index of merged partition.
+ */
+ if (partmap1->to == partmap2->to)
+ {
+ merged_index = partmap1->to;
+
+ /*
+ * If the given two partitions do not have a merged partition
+ * associated with them, allocate a new merged partition.
+ */
+ if (merged_index < 0)
+ {
+ merged_index = *next_index;
+ *next_index = *next_index + 1;
+ partmap1->to = merged_index;
+ partmap2->to = merged_index;
+ }
+ }
+
+ /*
+ * If partition from one relation was mapped to a merged partition but
+ * not the partition from the other relation, map the same merged
+ * partition to the partition from other relation, since matching
+ * partitions map to the same merged partition.
+ */
+ else if (partmap1->to >= 0 && partmap2->to < 0)
+ {
+ partmap2->to = partmap1->to;
+ merged_index = partmap1->to;
+ }
+ else if (partmap1->to < 0 && partmap2->to >= 0)
+ {
+ partmap1->to = partmap2->to;
+ merged_index = partmap2->to;
+ }
+ else
+ {
+ Assert(partmap1->to != partmap2->to &&
+ partmap1->to >= 0 && partmap2->to >= 0);
+
+ /*
+ * Both the partitions map to different merged partitions. This
+ * means that multiple partitions from one relation matches to one
+ * partition from the other relation. Partition-wise join does not
+ * handle this case right now, since it requires ganging multiple
+ * partitions together (into one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+ }
+ else
+ {
+ /*
+ * Multiple partitions from one relation map to one partition from the
+ * other relation. Partition-wise join does not handle this case right
+ * now, since it requires ganging multiple partitions together (into
+ * one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+
+ return merged_index;
+}
+
+/*
+ * generate_matching_part_pairs
+ *
+ * partmaps1 map each partition from either side of the join to a merged
+ * partition resp. E.g. partmaps1[i].to gives the merged partition to which ith
+ * partition of first relation maps. Similarly for partmap2. If
+ * partmaps1[i].to == partmaps2[j].to, i and j form the matching pair of
+ * partitions.
+ *
+ * Given these maps this function produces the list pairs of partitions which
+ * when joined produce the merged partitions in the order of merged partition
+ * indexes.
+ *
+ * nparts1 and nparts2 are the number of partitions of the joining relations
+ * resp.
+ *
+ * nparts is the number of merged partitions.
+ *
+ * If successful, the pairs of partitions are returned as two separate lists,
+ * parts1 and parts2 resp., one for each side. Otherwise, those lists will be
+ * set to NIL.
+ */
+static void
+generate_matching_part_pairs(PartitionMap *partmaps1, PartitionMap *partmaps2,
+ int nparts1, int nparts2,
+ JoinType jointype, int nparts,
+ List **matched_parts1, List **matched_parts2)
+{
+ bool merged = true;
+ int *matching1 = (int *) palloc(sizeof(int) * nparts),
+ *matching2 = (int *) palloc(sizeof(int) * nparts);
+ int i;
+
+ *matched_parts1 = NIL;
+ *matched_parts2 = NIL;
+
+ /* Set pairs of matching partitions. */
+ for (i = 0; i < nparts; i++)
+ {
+ if (i >= nparts1)
+ matching1[i] = -1;
+ else
+ {
+ PartitionMap outer_map = partmaps1[i];
+
+ if (outer_map.to >= 0)
+ {
+ Assert(outer_map.to < nparts);
+ matching1[outer_map.to] = i;
+ }
+ }
+
+ if (i >= nparts2)
+ matching2[i] = -1;
+ else
+ {
+ PartitionMap inner_map = partmaps2[i];
+
+ if (inner_map.to >= 0)
+ {
+ Assert(inner_map.to < nparts);
+ matching2[inner_map.to] = i;
+ }
+ }
+ }
+
+ /*
+ * If we have a partition missing on an inner side, we need to add a dummy
+ * relation which joins with the outer partition. If the inner relation
+ * happens to be a base relation, it will require adding a dummy child
+ * base relation during join processing. Right now, we freeze the base
+ * relation arrays like PlannerInfo::simple_rte_array after planning for
+ * base relations. Adding a new (dummy) base relation would require some
+ * changes to that. So, right now, we do not implement partition-wise join
+ * in such cases.
+ */
+ for (i = 0; i < nparts; i++)
+ {
+ int part1 = matching1[i];
+ int part2 = matching2[i];
+
+ /* At least one of the partitions should exist. */
+ Assert(part1 >= 0 || part2 >= 0);
+
+ switch (jointype)
+ {
+ case JOIN_INNER:
+ case JOIN_SEMI:
+
+ /*
+ * An inner or semi join can not return any row when the
+ * matching partition on either side is missing. We should
+ * have eliminated all such cases while merging the bounds.
+ */
+ Assert(part1 >= 0 && part2 >= 0);
+ break;
+
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ Assert(part1 >= 0);
+ if (part2 < 0)
+ merged = false;
+ break;
+
+ case JOIN_FULL:
+ if (part1 < 0 || part2 < 0)
+ merged = false;
+ break;
+
+ default:
+ elog(ERROR, "unrecognized join type: %d", (int) jointype);
+ }
+
+ if (!merged)
+ break;
+
+ *matched_parts1 = lappend_int(*matched_parts1, part1);
+ *matched_parts2 = lappend_int(*matched_parts2, part2);
+ }
+
+ pfree(matching1);
+ pfree(matching2);
+
+ if (!merged)
+ {
+ list_free(*matched_parts1);
+ list_free(*matched_parts2);
+ *matched_parts1 = NIL;
+ *matched_parts2 = NIL;
+ }
+}
+
+static PartitionBoundInfo
+build_merged_partition_bounds(char strategy, List *merged_datums,
+ List *merged_indexes, List *merged_kinds,
+ int null_index, int default_index)
+{
+ int cnt;
+ PartitionBoundInfo merged_bounds;
+ ListCell *lc;
+
+ /* We expect the same number of elements in datums and indexes lists. */
+ Assert(list_length(merged_datums) == list_length(merged_indexes));
+
+ merged_bounds = (PartitionBoundInfo) palloc(sizeof(PartitionBoundInfoData));
+ merged_bounds->strategy = strategy;
+ merged_bounds->ndatums = list_length(merged_datums);
+
+ if (strategy == PARTITION_STRATEGY_RANGE)
+ {
+ Assert(list_length(merged_datums) == list_length(merged_kinds));
+ merged_bounds->kind =
+ (PartitionRangeDatumKind **) palloc(sizeof(PartitionRangeDatumKind *) *
+ list_length(merged_kinds));
+ cnt = 0;
+ foreach(lc, merged_kinds)
+ merged_bounds->kind[cnt++] = lfirst(lc);
+
+ /* There are ndatums+1 indexes in case of range partitions */
+ merged_indexes = lappend_int(merged_indexes, -1);
+ }
+ else
+ merged_bounds->kind = NULL;
+
+ cnt = 0;
+ merged_bounds->datums = (Datum **) palloc(sizeof(Datum *) *
+ list_length(merged_datums));
+ foreach(lc, merged_datums)
+ merged_bounds->datums[cnt++] = lfirst(lc);
+
+ merged_bounds->indexes = (int *) palloc(sizeof(int) *
+ list_length(merged_indexes));
+ cnt = 0;
+ foreach(lc, merged_indexes)
+ merged_bounds->indexes[cnt++] = lfirst_int(lc);
+
+ merged_bounds->null_index = null_index;
+ merged_bounds->default_index = default_index;
+
+ return merged_bounds;
+}
+
+/*
+ * Merge default partitions from both sides, if any, and assign the default
+ * partition for the join result, if necessary.
+ *
+ * If both the relations have default partitions, try mapping those to each
+ * other. If the mapping succeeds corresponding merged partition will act as
+ * the default partition of the join result.
+ *
+ * If inner side of the join has default but not the outer side, rows in it
+ * won't appear in the join result. So don't create a default partition. If
+ * outer side of the join has default but not the inner side, rows in it will
+ * appear in the join result, so create a default merged partition.
+ */
+static bool
+merge_default_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps, PartitionMap *inner_maps,
+ JoinType jointype, int *next_index, int *default_index)
+{
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool merged = true;
+ PartitionMap *outer_default_map = NULL;
+ PartitionMap *inner_default_map = NULL;
+
+ if (outer_has_default)
+ outer_default_map = &outer_maps[outer_default];
+
+ if (inner_has_default)
+ inner_default_map = &inner_maps[inner_default];
+
+ if (!outer_has_default && !inner_has_default)
+ Assert(*default_index < 0);
+ else if (outer_default_map != NULL && inner_default_map == NULL)
+ {
+ if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (outer_default_map->to < 0)
+ {
+ outer_default_map->to = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = outer_default_map->to;
+ }
+ else
+ Assert(*default_index == outer_default_map->to);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else if (outer_default_map == NULL && inner_default_map != NULL)
+ {
+ if (jointype == JOIN_FULL)
+ {
+ if (inner_default_map->to < 0)
+ {
+ inner_default_map->to = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = inner_default_map->to;
+ }
+ else
+ Assert(*default_index == inner_default_map->to);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else
+ {
+ Assert(outer_has_default && inner_has_default);
+
+ *default_index = map_and_merge_partitions(outer_maps, inner_maps,
+ outer_default, inner_default,
+ next_index);
+
+ if (*default_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
+
+/*
+ * merge_null_partitions
+ *
+ * Merge NULL partitions, i.e. a partition that can hold NULL values for a list
+ * partitioned table, if any. Find the index of merged partition to which the
+ * NULL values would belong in the join result. If one joining relation has a
+ * NULL partition but not the other, try matching it with the default partition
+ * from the other relation since the default partition may have rows with NULL
+ * partition key. We can eliminate a NULL partition when it appears only on the
+ * inner side of the join and the outer side doesn't have a default partition.
+ *
+ * When the equality operator used for join is strict, two NULL values will not
+ * be considered as equal, and thus a NULL partition can be eliminated for an
+ * inner join. But we don't check the strictness operator here.
+ */
+static bool
+merge_null_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps, PartitionMap *inner_maps,
+ JoinType jointype, int *next_index,
+ int *null_index, int *default_index)
+{
+ bool outer_has_null = partition_bound_accepts_nulls(outer_bi);
+ bool inner_has_null = partition_bound_accepts_nulls(inner_bi);
+ int outer_ni = outer_bi->null_index;
+ int inner_ni = inner_bi->null_index;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool merged = true;
+
+ if (!outer_has_null && !inner_has_null)
+ *null_index = -1;
+ else if (outer_has_null && !inner_has_null)
+ {
+ int merged_index;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+
+ merged = handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ outer_ni,
+ missing_side_outer,
+ missing_side_inner, next_index,
+ default_index, &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join to which the outer null partition maps
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = outer_maps[outer_ni].to;
+ }
+ else if (!outer_has_null && inner_has_null)
+ {
+ int merged_index;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as OUTER
+ * relation. For INNER and SEMI join OUTER and INNER differentiation is
+ * immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+ merged = handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ inner_ni,
+ missing_side_outer,
+ missing_side_inner,
+ next_index, default_index,
+ &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join, to which the outer side null partition maps,
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = inner_maps[inner_ni].to;
+ }
+ else
+ {
+ /* Both the relations have NULL partitions, try merging them. */
+ *null_index = map_and_merge_partitions(outer_maps,
+ inner_maps,
+ outer_ni,
+ inner_ni,
+ next_index);
+ if (*null_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
diff --git a/src/include/partitioning/partbounds.h b/src/include/partitioning/partbounds.h
index c7535e32fc..bf11713371 100644
--- a/src/include/partitioning/partbounds.h
+++ b/src/include/partitioning/partbounds.h
@@ -104,6 +104,12 @@ typedef struct PartitionRangeBound
bool lower; /* this is the lower (vs upper) bound */
} PartitionRangeBound;
+typedef struct PartitionMap
+{
+ int from;
+ int to;
+} PartitionMap;
+
extern int get_hash_partition_greatest_modulus(PartitionBoundInfo b);
extern uint64 compute_partition_hash_value(int partnatts, FmgrInfo *partsupfunc,
Datum *values, bool *isnull);
@@ -146,5 +152,10 @@ extern int partition_range_datum_bsearch(FmgrInfo *partsupfunc,
int nvalues, Datum *values, bool *is_equal);
extern int partition_hash_bsearch(PartitionBoundInfo boundinfo,
int modulus, int remainder);
+extern PartitionBoundInfo partition_bounds_merge(int partnatts,
+ FmgrInfo *partsupfunc, Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts);
#endif /* PARTBOUNDS_H */
--
2.16.4
[application/octet-stream] 0004-Tests-for-0-1-1-1-and-1-0-partition-matching-v12.patch (220.5K, ../../CA+q6zcUoEnZO0WLcunr5Z3QzC-raZkF6tGOGY73M=kAbT9J-EA@mail.gmail.com/5-0004-Tests-for-0-1-1-1-and-1-0-partition-matching-v12.patch)
download | inline diff:
From adddb61b30b19b3c16ce4594bcab543ce4aa7fa5 Mon Sep 17 00:00:00 2001
From: erthalion <9erthalion6@gmail.com>
Date: Tue, 11 Sep 2018 21:11:55 +0200
Subject: [PATCH 4/4] Tests for 0:1, 1:1 and 1:0 partition matching
Rajkumar Raghuvanshi and Ashutosh Bapat.
---
src/test/regress/expected/partition_join.out | 4131 +++++++++++++++++++++-----
src/test/regress/sql/partition_join.sql | 427 ++-
2 files changed, 3855 insertions(+), 703 deletions(-)
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index 3ba3aaf2d8..5d6c7d2c67 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -8,59 +8,86 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(21 rows)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
-(4 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+(7 rows)
-- left outer join, with whole-row reference; partitionwise join does not apply
EXPLAIN (COSTS OFF)
@@ -72,35 +99,50 @@ SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(22 rows)
SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- t1 | t2
---------------+--------------
- (0,0,0000) | (0,0,0000)
- (50,0,0050) |
- (100,0,0100) |
- (150,0,0150) | (0,150,0150)
- (200,0,0200) |
- (250,0,0250) |
- (300,0,0300) | (0,300,0300)
- (350,0,0350) |
- (400,0,0400) |
- (450,0,0450) | (0,450,0450)
- (500,0,0500) |
- (550,0,0550) |
-(12 rows)
+ t1 | t2
+----------------+----------------
+ (-250,0,-0250) |
+ (-200,0,-0200) |
+ (-150,0,-0150) | (0,-150,-0150)
+ (-100,0,-0100) |
+ (-50,0,-0050) |
+ (0,0,0000) | (0,0,0000)
+ (50,0,0050) |
+ (100,0,0100) |
+ (150,0,0150) | (0,150,0150)
+ (200,0,0200) |
+ (250,0,0250) |
+ (300,0,0300) | (0,300,0300)
+ (350,0,0350) |
+ (400,0,0400) |
+ (450,0,0450) | (0,450,0450)
+ (500,0,0500) |
+ (550,0,0550) |
+ (600,0,0600) | (0,600,0600)
+ (650,0,0650) |
+ (700,0,0700) |
+ (750,0,0750) | (0,750,0750)
+(21 rows)
-- right outer join
EXPLAIN (COSTS OFF)
@@ -112,35 +154,53 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHE
-> Append
-> Hash Right Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Right Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Hash Right Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-> Nested Loop Left Join
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p3 t2_3
Filter: (a = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t2_2.b)
-(20 rows)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
- | | 75 | 0075
- | | 225 | 0225
- | | 375 | 0375
- | | 525 | 0525
-(8 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+ | | -225 | -0225
+ | | -75 | -0075
+ | | 75 | 0075
+ | | 225 | 0225
+ | | 375 | 0375
+ | | 525 | 0525
+ | | 675 | 0675
+(14 rows)
-- full outer join, with placeholder vars
EXPLAIN (COSTS OFF)
@@ -148,8 +208,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
QUERY PLAN
------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b
+ Sort Key: prt1_p0.a, prt2_p0.b
-> Append
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ Filter: (((50) = prt1_p0.a) OR ((75) = prt2_p0.b))
+ -> Seq Scan on prt1_p0
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p1.a = prt2_p1.b)
Filter: (((50) = prt1_p1.a) OR ((75) = prt2_p1.b))
@@ -174,7 +242,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
-> Hash
-> Seq Scan on prt2_p3
Filter: (a = 0)
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ Filter: (((50) = prt1_p4.a) OR ((75) = prt2_p4.b))
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) WHERE t1.phv = t1.a OR t2.phv = t2.b ORDER BY t1.a, t2.b;
a | c | b | c
@@ -211,8 +287,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Hash Left Join
+ Hash Cond: (prt1_p0.a = b)
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Hash
+ -> Result
+ One-Time Filter: false
-> Hash Left Join
Hash Cond: (prt1_p1.a = b)
-> Seq Scan on prt1_p1
@@ -227,29 +310,42 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
-> Hash
-> Seq Scan on prt1_p2
Filter: ((a < 450) AND (b = 0))
-(17 rows)
+(24 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
-(9 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+(14 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
QUERY PLAN
------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = b)
+ Filter: ((prt1_p0.b = 0) OR (a = 0))
+ -> Seq Scan on prt1_p0
+ Filter: (a < 450)
+ -> Hash
+ -> Result
+ One-Time Filter: false
-> Hash Full Join
Hash Cond: (prt1_p1.a = b)
Filter: ((prt1_p1.b = 0) OR (a = 0))
@@ -274,64 +370,153 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JO
-> Hash
-> Result
One-Time Filter: false
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt2_p4.b = a)
+ Filter: ((b = 0) OR (prt2_p4.a = 0))
+ -> Seq Scan on prt2_p4
+ Filter: (b > 250)
+ -> Hash
+ -> Result
+ One-Time Filter: false
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
- | | 375 | 0375
- | | 450 | 0450
- | | 525 | 0525
-(12 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ | | 375 | 0375
+ | | 450 | 0450
+ | | 525 | 0525
+ | | 600 | 0600
+ | | 675 | 0675
+ | | 750 | 0750
+(20 rows)
-- Semi-join
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Semi Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Semi Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Nested Loop Semi Join
- Join Filter: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Materialize
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-(24 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(39 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p0 t2
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_2.b = t2_2.a)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p2 t2_2
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: (t1_3.b = t2_3.a)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt1_p3 t2_3
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.b = t2_4.a)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p4 t2_4
+ Filter: (b = 0)
+(37 rows)
+
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
@@ -342,27 +527,82 @@ SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS
-> Append
-> Hash Anti Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash Anti Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash Anti Join
Hash Cond: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p3 t2_2
-(17 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash Anti Join
+ Hash Cond: (t1_3.a = t2_3.b)
+ -> Seq Scan on prt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_3
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(27 rows)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
- sum | avg | sum | avg
--------+----------------------+------+---------------------
- 60000 | 300.0000000000000000 | 2400 | 12.0000000000000000
+ sum | avg | sum | avg
+-------+----------------------+------+--------------------
+ 95550 | 273.0000000000000000 | 2200 | 6.2857142857142857
(1 row)
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ QUERY PLAN
+--------------------------------------------------------------
+ Append
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Hash Anti Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(27 rows)
+
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ b | c
+------+-------
+ -225 | -0225
+ -75 | -0075
+ 75 | 0075
+ 225 | 0225
+ 375 | 0375
+ 525 | 0525
+ 675 | 0675
+(7 rows)
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -374,49 +614,74 @@ SELECT * FROM prt1 t1 LEFT JOIN LATERAL
Sort Key: t1.a
-> Append
-> Nested Loop Left Join
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p1_a on prt1_p1 t2
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
Index Cond: (a = t1.a)
- -> Index Scan using iprt2_p1_b on prt2_p1 t3
+ -> Index Scan using iprt2_p0_b on prt2_p0 t3
Index Cond: (b = t2.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_1
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
Index Cond: (a = t1_1.a)
- -> Index Scan using iprt2_p2_b on prt2_p2 t3_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t3_1
Index Cond: (b = t2_1.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_2
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
Index Cond: (a = t1_2.a)
- -> Index Scan using iprt2_p3_b on prt2_p3 t3_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t3_2
Index Cond: (b = t2_2.a)
-(27 rows)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.a)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t3_3
+ Index Cond: (b = t2_3.a)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.a)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t3_4
+ Index Cond: (b = t2_4.a)
+(43 rows)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, least(t1.a,t2.a,t3.b) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.a = ss.t2a WHERE t1.b = 0 ORDER BY t1.a;
- a | b | c | t2a | t3a | least
------+---+------+-----+-----+-------
- 0 | 0 | 0000 | 0 | 0 | 0
- 50 | 0 | 0050 | | |
- 100 | 0 | 0100 | | |
- 150 | 0 | 0150 | 150 | 0 | 150
- 200 | 0 | 0200 | | |
- 250 | 0 | 0250 | | |
- 300 | 0 | 0300 | 300 | 0 | 300
- 350 | 0 | 0350 | | |
- 400 | 0 | 0400 | | |
- 450 | 0 | 0450 | 450 | 0 | 450
- 500 | 0 | 0500 | | |
- 550 | 0 | 0550 | | |
-(12 rows)
+ a | b | c | t2a | t3a | least
+------+---+-------+------+-----+-------
+ -250 | 0 | -0250 | | |
+ -200 | 0 | -0200 | | |
+ -150 | 0 | -0150 | -150 | 0 | -150
+ -100 | 0 | -0100 | | |
+ -50 | 0 | -0050 | | |
+ 0 | 0 | 0000 | 0 | 0 | 0
+ 50 | 0 | 0050 | | |
+ 100 | 0 | 0100 | | |
+ 150 | 0 | 0150 | 150 | 0 | 150
+ 200 | 0 | 0200 | | |
+ 250 | 0 | 0250 | | |
+ 300 | 0 | 0300 | 300 | 0 | 300
+ 350 | 0 | 0350 | | |
+ 400 | 0 | 0400 | | |
+ 450 | 0 | 0450 | 450 | 0 | 450
+ 500 | 0 | 0500 | | |
+ 550 | 0 | 0550 | | |
+ 600 | 0 | 0600 | 600 | 0 | 600
+ 650 | 0 | 0650 | | |
+ 700 | 0 | 0700 | | |
+ 750 | 0 | 0750 | 750 | 0 | 750
+(21 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
@@ -430,64 +695,95 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
Hash Cond: ((t1.c)::text = (t2.c)::text)
Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Hash Join
Hash Cond: (t2.a = t3.b)
- -> Seq Scan on prt1_p1 t2
+ -> Seq Scan on prt1_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t3
+ -> Seq Scan on prt2_p0 t3
-> Hash Join
Hash Cond: (t2_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t2_1
+ -> Seq Scan on prt1_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p1 t3_1
-> Hash Join
Hash Cond: (t2_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p2 t2_2
-> Hash
- -> Seq Scan on prt2_p3 t3_2
-(26 rows)
+ -> Seq Scan on prt2_p2 t3_2
+ -> Hash Join
+ Hash Cond: (t2_3.a = t3_3.b)
+ -> Seq Scan on prt1_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t3_3
+ -> Hash Join
+ Hash Cond: (t2_4.a = t3_4.b)
+ -> Seq Scan on prt1_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t3_4
+(38 rows)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, t2.b t2b, t2.c t2c, least(t1.a,t2.a,t3.a) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.c = ss.t2c WHERE (t1.b + coalesce(ss.t2b, 0)) = 0 ORDER BY t1.a;
- a | t2a | t2c
------+-----+------
- 0 | 0 | 0000
- 50 | |
- 100 | |
- 150 | 150 | 0150
- 200 | |
- 250 | |
- 300 | 300 | 0300
- 350 | |
- 400 | |
- 450 | 450 | 0450
- 500 | |
- 550 | |
-(12 rows)
+ a | t2a | t2c
+------+------+-------
+ -250 | |
+ -200 | |
+ -150 | -150 | -0150
+ -100 | |
+ -50 | |
+ 0 | 0 | 0000
+ 50 | |
+ 100 | |
+ 150 | 150 | 0150
+ 200 | |
+ 250 | |
+ 300 | 300 | 0300
+ 350 | |
+ 400 | |
+ 450 | 450 | 0450
+ 500 | |
+ 550 | |
+ 600 | 600 | 0600
+ 650 | |
+ 700 | |
+ 750 | 750 | 0750
+(21 rows)
--
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
@@ -498,32 +794,49 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 =
-> Append
-> Hash Join
Hash Cond: (((t2.b + t2.a) / 2) = ((t1.a + t1.b) / 2))
- -> Seq Scan on prt2_e_p1 t2
+ -> Seq Scan on prt2_e_p0 t2
-> Hash
- -> Seq Scan on prt1_e_p1 t1
+ -> Seq Scan on prt1_e_p0 t1
Filter: (c = 0)
-> Hash Join
- Hash Cond: (((t2_1.b + t2_1.a) / 2) = ((t1_1.a + t1_1.b) / 2))
- -> Seq Scan on prt2_e_p2 t2_1
+ Hash Cond: (((t1_1.a + t1_1.b) / 2) = ((t2_1.b + t2_1.a) / 2))
+ -> Seq Scan on prt1_e_p1 t1_1
+ Filter: (c = 0)
-> Hash
- -> Seq Scan on prt1_e_p2 t1_1
- Filter: (c = 0)
+ -> Seq Scan on prt2_e_p1 t2_1
-> Hash Join
Hash Cond: (((t2_2.b + t2_2.a) / 2) = ((t1_2.a + t1_2.b) / 2))
- -> Seq Scan on prt2_e_p3 t2_2
+ -> Seq Scan on prt2_e_p2 t2_2
-> Hash
- -> Seq Scan on prt1_e_p3 t1_2
+ -> Seq Scan on prt1_e_p2 t1_2
Filter: (c = 0)
-(21 rows)
+ -> Hash Join
+ Hash Cond: (((t2_3.b + t2_3.a) / 2) = ((t1_3.a + t1_3.b) / 2))
+ -> Seq Scan on prt2_e_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t1_3
+ Filter: (c = 0)
+ -> Hash Join
+ Hash Cond: (((t2_4.b + t2_4.a) / 2) = ((t1_4.a + t1_4.b) / 2))
+ -> Seq Scan on prt2_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_4
+ Filter: (c = 0)
+(33 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 150 | 0 | 150 | 0
- 300 | 0 | 300 | 0
- 450 | 0 | 450 | 0
-(4 rows)
+ a | c | b | c
+------+---+------+---
+ -250 | 0 | -250 | 0
+ -100 | 0 | -100 | 0
+ 0 | 0 | 0 | 0
+ 0 | 0 | 0 | 0
+ 150 | 0 | 150 | 0
+ 300 | 0 | 300 | 0
+ 450 | 0 | 450 | 0
+ 600 | 0 | 600 | 0
+ 750 | 0 | 750 | 0
+(9 rows)
--
-- N-way join
@@ -536,154 +849,232 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = ((t3.a + t3.b) / 2))
+ Join Filter: (t1.a = t2.b)
-> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p1_ab2 on prt1_e_p1 t3
- Index Cond: (((a + b) / 2) = t2.b)
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
+ Index Cond: (b = ((t3.a + t3.b) / 2))
-> Nested Loop
Join Filter: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_1
+ -> Index Scan using iprt1_e_p4_ab2 on prt1_e_p1 t3_1
Index Cond: (((a + b) / 2) = t2_1.b)
-> Nested Loop
Join Filter: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_2
Index Cond: (((a + b) / 2) = t2_2.b)
-(33 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = ((t3_3.a + t3_3.b) / 2))
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (((a + b) / 2) = t2_3.b)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t2_4.b)
+ -> Hash Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (b = ((t3_4.a + t3_4.b) / 2))
+(52 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t3 WHERE t1.a = t2.b AND t1.a = (t3.a + t3.b)/2 AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
-(4 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(8 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
---------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Hash Right Join
Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_1.a + t3_1.b) / 2) = t1_1.a)
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
-> Hash
-> Hash Right Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_2.a + t3_2.b) / 2) = t1_2.a)
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
-> Hash
-> Hash Right Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(33 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (t1_3.a = ((a + b) / 2))
+ -> Hash Right Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(51 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
--------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1.a = ((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
Index Cond: (t1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t2_1
Index Cond: (t1_1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t2_2
Index Cond: (t1_2.a = b)
-(30 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t3_3.a + t3_3.b) / 2))
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Nested Loop Left Join
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = ((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (t1_4.a = b)
+(47 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- Cases with non-nullable expressions in subquery results;
-- make sure these go to null as expected
@@ -692,21 +1083,34 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
QUERY PLAN
----------------------------------------------------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b, ((prt1_e_p1.a + prt1_e_p1.b))
+ Sort Key: prt1_p0.a, prt2_p0.b, ((prt1_e_p0.a + prt1_e_p0.b))
-> Append
-> Hash Full Join
- Hash Cond: (prt1_p1.a = ((prt1_e_p1.a + prt1_e_p1.b) / 2))
- Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ Hash Cond: (prt1_p0.a = ((prt1_e_p0.a + prt1_e_p0.b) / 2))
+ Filter: ((prt1_p0.a = (50)) OR (prt2_p0.b = (75)) OR (((prt1_e_p0.a + prt1_e_p0.b) / 2) = (50)))
-> Hash Full Join
- Hash Cond: (prt1_p1.a = prt2_p1.b)
- -> Seq Scan on prt1_p1
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ -> Seq Scan on prt1_p0
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1
+ -> Seq Scan on prt2_p0
Filter: (a = 0)
-> Hash
- -> Seq Scan on prt1_e_p1
+ -> Seq Scan on prt1_e_p0
Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: (((prt1_e_p1.a + prt1_e_p1.b) / 2) = prt1_p1.a)
+ Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ -> Seq Scan on prt1_e_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Hash Full Join
+ Hash Cond: (prt1_p1.a = prt2_p1.b)
+ -> Seq Scan on prt1_p1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p2.a = ((prt1_e_p2.a + prt1_e_p2.b) / 2))
Filter: ((prt1_p2.a = (50)) OR (prt2_p2.b = (75)) OR (((prt1_e_p2.a + prt1_e_p2.b) / 2) = (50)))
@@ -733,7 +1137,20 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
-> Hash
-> Seq Scan on prt1_e_p3
Filter: (c = 0)
-(42 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = ((prt1_e_p4.a + prt1_e_p4.b) / 2))
+ Filter: ((prt1_p4.a = (50)) OR (prt2_p4.b = (75)) OR (((prt1_e_p4.a + prt1_e_p4.b) / 2) = (50)))
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_e_p4
+ Filter: (c = 0)
+(68 rows)
SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b)) FULL JOIN (SELECT 50 phv, * FROM prt1_e WHERE prt1_e.c = 0) t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.a = t1.phv OR t2.b = t2.phv OR (t3.a + t3.b)/2 = t3.phv ORDER BY t1.a, t2.b, t3.a + t3.b;
a | phv | b | phv | ?column? | phv
@@ -751,173 +1168,261 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHER
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = t1_3.b)
+ Join Filter: (t1.a = t1_5.b)
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Join
- Hash Cond: (((t2.a + t2.b) / 2) = t1_3.b)
- -> Seq Scan on prt1_e_p1 t2
+ Hash Cond: (((t2.a + t2.b) / 2) = t1_5.b)
+ -> Seq Scan on prt1_e_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t1_3
+ -> Seq Scan on prt2_p0 t1_5
Filter: (a = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
Index Cond: (a = ((t2.a + t2.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_1.a = t1_4.b)
+ Join Filter: (t1_1.a = t1_6.b)
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Join
- Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_4.b)
- -> Seq Scan on prt1_e_p2 t2_1
+ Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_6.b)
+ -> Seq Scan on prt1_e_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t1_4
+ -> Seq Scan on prt2_p1 t1_6
Filter: (a = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
Index Cond: (a = ((t2_1.a + t2_1.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_2.a = t1_5.b)
+ Join Filter: (t1_2.a = t1_7.b)
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Nested Loop
- -> Seq Scan on prt2_p3 t1_5
+ -> Seq Scan on prt2_p2 t1_7
Filter: (a = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_2
- Index Cond: (((a + b) / 2) = t1_5.b)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t2_2
+ Index Cond: (((a + b) / 2) = t1_7.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
Index Cond: (a = ((t2_2.a + t2_2.b) / 2))
Filter: (b = 0)
-(41 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = t1_8.b)
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t1_8
+ Filter: (a = 0)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_3
+ Index Cond: (((a + b) / 2) = t1_8.b)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t2_3.a + t2_3.b) / 2))
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t1_9.b)
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Join
+ Hash Cond: (((t2_4.a + t2_4.b) / 2) = t1_9.b)
+ -> Seq Scan on prt1_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t1_9
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = ((t2_4.a + t2_4.b) / 2))
+ Filter: (b = 0)
+(66 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHERE t1.a = 0 AND t1.b = (t2.a + t2.b)/2) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
--------------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Nested Loop
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Semi Join
- Hash Cond: (t1_3.b = ((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt2_p1 t1_3
+ Hash Cond: (t1_5.b = ((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt2_p0 t1_5
-> Hash
- -> Seq Scan on prt1_e_p1 t1_6
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
- Index Cond: (a = t1_3.b)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t1_5.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Semi Join
- Hash Cond: (t1_4.b = ((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt2_p2 t1_4
+ Hash Cond: (t1_6.b = ((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt2_p1 t1_6
-> Hash
- -> Seq Scan on prt1_e_p2 t1_7
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
- Index Cond: (a = t1_4.b)
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
+ Index Cond: (a = t1_6.b)
+ Filter: (b = 0)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_7.b
+ -> Hash Semi Join
+ Hash Cond: (t1_7.b = ((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt2_p2 t1_7
+ -> Hash
+ -> Seq Scan on prt1_e_p2 t1_12
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t1_7.b)
Filter: (b = 0)
-> Nested Loop
-> Unique
-> Sort
- Sort Key: t1_5.b
+ Sort Key: t1_8.b
-> Hash Semi Join
- Hash Cond: (t1_5.b = ((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt2_p3 t1_5
+ Hash Cond: (t1_8.b = ((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt2_p3 t1_8
-> Hash
- -> Seq Scan on prt1_e_p3 t1_8
+ -> Seq Scan on prt1_e_p3 t1_13
Filter: (c = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t1_5.b)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t1_8.b)
+ Filter: (b = 0)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Semi Join
+ Hash Cond: (t1_9.b = ((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt2_p4 t1_9
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = t1_9.b)
Filter: (b = 0)
-(40 rows)
+(64 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
-- test merge joins
SET enable_hashjoin TO off;
SET enable_nestloop TO off;
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
-----------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------
Merge Append
Sort Key: t1.a
-> Merge Semi Join
- Merge Cond: (t1.a = t1_3.b)
+ Merge Cond: (t1.a = t1_5.b)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_3.b = (((t1_6.a + t1_6.b) / 2)))
+ Merge Cond: (t1_5.b = (((t1_10.a + t1_10.b) / 2)))
-> Sort
- Sort Key: t1_3.b
- -> Seq Scan on prt2_p1 t1_3
+ Sort Key: t1_5.b
+ -> Seq Scan on prt2_p0 t1_5
-> Sort
- Sort Key: (((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt1_e_p1 t1_6
+ Sort Key: (((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_1.a = t1_4.b)
+ Merge Cond: (t1_1.a = t1_6.b)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_4.b = (((t1_7.a + t1_7.b) / 2)))
+ Merge Cond: (t1_6.b = (((t1_11.a + t1_11.b) / 2)))
-> Sort
- Sort Key: t1_4.b
- -> Seq Scan on prt2_p2 t1_4
+ Sort Key: t1_6.b
+ -> Seq Scan on prt2_p1 t1_6
-> Sort
- Sort Key: (((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt1_e_p2 t1_7
+ Sort Key: (((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_2.a = t1_5.b)
+ Merge Cond: (t1_2.a = t1_7.b)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_5.b = (((t1_8.a + t1_8.b) / 2)))
+ Merge Cond: (t1_7.b = (((t1_12.a + t1_12.b) / 2)))
-> Sort
- Sort Key: t1_5.b
- -> Seq Scan on prt2_p3 t1_5
+ Sort Key: t1_7.b
+ -> Seq Scan on prt2_p2 t1_7
-> Sort
- Sort Key: (((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt1_e_p3 t1_8
+ Sort Key: (((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt1_e_p2 t1_12
Filter: (c = 0)
-(47 rows)
+ -> Merge Semi Join
+ Merge Cond: (t1_3.a = t1_8.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_8.b = (((t1_13.a + t1_13.b) / 2)))
+ -> Sort
+ Sort Key: t1_8.b
+ -> Seq Scan on prt2_p3 t1_8
+ -> Sort
+ Sort Key: (((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt1_e_p3 t1_13
+ Filter: (c = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_4.a = t1_9.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_9.b = (((t1_14.a + t1_14.b) / 2)))
+ -> Sort
+ Sort Key: t1_9.b
+ -> Seq Scan on prt2_p4 t1_9
+ -> Sort
+ Sort Key: (((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+(77 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
@@ -934,14 +1439,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3.a + t3.b) / 2)) = t1.a)
-> Sort
Sort Key: (((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Sort
Sort Key: t2.b
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Merge Left Join
Merge Cond: (t1_1.a = t2_1.b)
-> Sort
@@ -950,14 +1455,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_1.a + t3_1.b) / 2)) = t1_1.a)
-> Sort
Sort Key: (((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Sort
Sort Key: t2_1.b
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Merge Left Join
Merge Cond: (t1_2.a = t2_2.b)
-> Sort
@@ -966,32 +1471,74 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_2.a + t3_2.b) / 2)) = t1_2.a)
-> Sort
Sort Key: (((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Sort
Sort Key: t2_2.b
- -> Seq Scan on prt2_p3 t2_2
-(51 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Merge Left Join
+ Merge Cond: (t1_3.a = t2_3.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_3.a + t3_3.b) / 2)) = t1_3.a)
+ -> Sort
+ Sort Key: (((t3_3.a + t3_3.b) / 2))
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ -> Sort
+ Sort Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ -> Merge Left Join
+ Merge Cond: (t1_4.a = t2_4.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_4.a + t3_4.b) / 2)) = t1_4.a)
+ -> Sort
+ Sort Key: (((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ -> Sort
+ Sort Key: t2_4.b
+ -> Seq Scan on prt2_p4 t2_4
+(83 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- MergeAppend on nullable column
EXPLAIN (COSTS OFF)
@@ -999,8 +1546,18 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Merge Left Join
+ Merge Cond: (prt1_p0.a = b)
+ -> Sort
+ Sort Key: prt1_p0.a
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Sort
+ Sort Key: b
+ -> Result
+ One-Time Filter: false
-> Merge Left Join
Merge Cond: (prt1_p1.a = b)
-> Sort
@@ -1021,21 +1578,26 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
Sort Key: prt2_p2.b
-> Seq Scan on prt2_p2
Filter: (b > 250)
-(23 rows)
+(33 rows)
SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | b
------+-----
- 0 |
- 50 |
- 100 |
- 150 |
- 200 |
- 250 |
- 300 | 300
- 350 |
- 400 |
-(9 rows)
+ a | b
+------+-----
+ -250 |
+ -200 |
+ -150 |
+ -100 |
+ -50 |
+ 0 |
+ 50 |
+ 100 |
+ 150 |
+ 200 |
+ 250 |
+ 300 | 300
+ 350 |
+ 400 |
+(14 rows)
-- merge join when expression with whole-row reference needs to be sorted;
-- partitionwise join does not apply
@@ -1049,175 +1611,2412 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
Sort Key: t1.a, ((((t1.*)::prt1))::text)
-> Result
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Sort
Sort Key: t2.b, ((((t2.*)::prt2))::text)
-> Result
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
-(16 rows)
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+(20 rows)
SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.b ORDER BY t1.a;
- a | b
-----+----
- 0 | 0
- 6 | 6
- 12 | 12
- 18 | 18
- 24 | 24
-(5 rows)
+ a | b
+-----+-----
+ -24 | -24
+ -18 | -18
+ -12 | -12
+ -6 | -6
+ 0 | 0
+ 6 | 6
+ 12 | 12
+ 18 | 18
+ 24 | 24
+(9 rows)
RESET enable_hashjoin;
RESET enable_nestloop;
---
--- partitioned by multiple columns
---
-CREATE TABLE prt1_m (a int, b int, c int) PARTITION BY RANGE(a, ((a + b)/2));
-CREATE TABLE prt1_m_p1 PARTITION OF prt1_m FOR VALUES FROM (0, 0) TO (250, 250);
-CREATE TABLE prt1_m_p2 PARTITION OF prt1_m FOR VALUES FROM (250, 250) TO (500, 500);
-CREATE TABLE prt1_m_p3 PARTITION OF prt1_m FOR VALUES FROM (500, 500) TO (600, 600);
-INSERT INTO prt1_m SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
-ANALYZE prt1_m;
-CREATE TABLE prt2_m (a int, b int, c int) PARTITION BY RANGE(((b + a)/2), b);
-CREATE TABLE prt2_m_p1 PARTITION OF prt2_m FOR VALUES FROM (0, 0) TO (250, 250);
-CREATE TABLE prt2_m_p2 PARTITION OF prt2_m FOR VALUES FROM (250, 250) TO (500, 500);
-CREATE TABLE prt2_m_p3 PARTITION OF prt2_m FOR VALUES FROM (500, 500) TO (600, 600);
-INSERT INTO prt2_m SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
-ANALYZE prt2_m;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
- QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+ -> Seq Scan on prt2_p3 t2_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_4
+ Filter: (b = 0)
+(22 rows)
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p1 t2
+ -> Hash
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p2 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p3 t1_2
+ Filter: (b = 0)
+(21 rows)
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -150 | -0150 | 0 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 0 | 0150
+ 300 | 0300 | 0 | 0300
+ 450 | 0450 | 0 | 0450
+ 600 | 0600 | 0 | 0600
+ 750 | 0750 | 0 | 0750
+(7 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | 0 | -0150
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | 0 | 0000
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | 0 | 0150
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 0 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ 450 | 0450 | 0 | 0450
+ 500 | 0500 | |
+ 550 | 0550 | |
+ 600 | 0600 | 0 | 0600
+ 650 | 0650 | |
+ 700 | 0700 | |
+ 750 | 0750 | 0 | 0750
+(21 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Semi Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Append
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
+ Index Cond: (a = t1_1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(28 rows)
+
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Anti Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Anti Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -250 | 0 | -0250
+ -200 | 0 | -0200
+ -100 | 0 | -0100
+ -50 | 0 | -0050
+ 50 | 0 | 0050
+ 100 | 0 | 0100
+ 200 | 0 | 0200
+ 250 | 0 | 0250
+ 350 | 0 | 0350
+ 400 | 0 | 0400
+ 500 | 0 | 0500
+ 550 | 0 | 0550
+ 650 | 0 | 0650
+ 700 | 0 | 0700
+(14 rows)
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ QUERY PLAN
+---------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t3.c
+ -> Append
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t3
+ Index Cond: (a = t2.b)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t2.b)
+ -> Hash Right Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t3_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t3_2
+ Index Cond: (a = t2_2.b)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t2_2.b)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t3_3
+ Index Cond: (a = t2_3.b)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(47 rows)
+
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ a | a | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.b
+ -> Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(24 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: (t1.a = t2.b)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.a, 0)) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------
+ Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(22 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Join
+ Hash Cond: (t1.a = t2.b)
+ Join Filter: ((t1.b + t2.a) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+--
+-- partitioned by multiple columns
+--
+CREATE TABLE prt1_m (a int, b int, c int) PARTITION BY RANGE(a, ((a + b)/2));
+CREATE TABLE prt1_m_p1 PARTITION OF prt1_m FOR VALUES FROM (0, 0) TO (250, 250);
+CREATE TABLE prt1_m_p2 PARTITION OF prt1_m FOR VALUES FROM (250, 250) TO (500, 500);
+CREATE TABLE prt1_m_p3 PARTITION OF prt1_m FOR VALUES FROM (500, 500) TO (600, 600);
+INSERT INTO prt1_m SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+ANALYZE prt1_m;
+CREATE TABLE prt2_m (a int, b int, c int) PARTITION BY RANGE(((b + a)/2), b);
+CREATE TABLE prt2_m_p1 PARTITION OF prt2_m FOR VALUES FROM (0, 0) TO (250, 250);
+CREATE TABLE prt2_m_p2 PARTITION OF prt2_m FOR VALUES FROM (250, 250) TO (500, 500);
+CREATE TABLE prt2_m_p3 PARTITION OF prt2_m FOR VALUES FROM (500, 500) TO (600, 600);
+INSERT INTO prt2_m SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+ANALYZE prt2_m;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------
+ Sort
+ Sort Key: prt1_m_p1.a, prt2_m_p1.b
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p1.a = ((prt2_m_p1.b + prt2_m_p1.a) / 2)) AND (((prt1_m_p1.a + prt1_m_p1.b) / 2) = prt2_m_p1.b))
+ -> Seq Scan on prt1_m_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p1
+ Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p2.a = ((prt2_m_p2.b + prt2_m_p2.a) / 2)) AND (((prt1_m_p2.a + prt1_m_p2.b) / 2) = prt2_m_p2.b))
+ -> Seq Scan on prt1_m_p2
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p2
+ Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p3.a = ((prt2_m_p3.b + prt2_m_p3.a) / 2)) AND (((prt1_m_p3.a + prt1_m_p3.b) / 2) = prt2_m_p3.b))
+ -> Seq Scan on prt1_m_p3
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p3
+ Filter: (c = 0)
+(24 rows)
+
+SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
+ a | c | b | c
+-----+---+-----+---
+ 0 | 0 | 0 | 0
+ 50 | 0 | |
+ 100 | 0 | |
+ 150 | 0 | 150 | 0
+ 200 | 0 | |
+ 250 | 0 | |
+ 300 | 0 | 300 | 0
+ 350 | 0 | |
+ 400 | 0 | |
+ 450 | 0 | 450 | 0
+ 500 | 0 | |
+ 550 | 0 | |
+ | | 75 | 0
+ | | 225 | 0
+ | | 375 | 0
+ | | 525 | 0
+(16 rows)
+
+--
+-- tests for list partitioned tables.
+--
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 470 | 0 | 0011
+(1 row)
+
+--
+-- list partitioned by expression
+--
+CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
+ANALYZE plt1_e;
+-- test partition matching with N-way join
+EXPLAIN (COSTS OFF)
+SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Group Key: t1.c, t2.c, t3.c
+ -> Sort
+ Sort Key: t1.c, t3.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = ltrim(t3.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t2.b = t1.b) AND ((t2.c)::text = (t1.c)::text))
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt1_e_p4 t3
+ -> Hash Join
+ Hash Cond: ((t1_1.c)::text = ltrim(t3_1.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t1_1.b = t2_1.b) AND ((t1_1.c)::text = (t2_1.c)::text))
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_e_p1 t3_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = ltrim(t3_2.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t1_2.b = t2_2.b) AND ((t1_2.c)::text = (t2_2.c)::text))
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_e_p2 t3_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = ltrim(t3_3.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t2_3.b = t1_3.b) AND ((t2_3.c)::text = (t1_3.c)::text))
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt1_e_p3 t3_3
+(41 rows)
+
+SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+ avg | avg | avg | c | c | c
+----------------------+---------------------+----------------------+------+------+------
+ 246.5000000000000000 | 22.4666666666666667 | 268.9666666666666667 | 0000 | 0000 | 0000
+ 248.5000000000000000 | 21.3333333333333333 | 269.8333333333333333 | 0002 | 0002 | 0002
+ 249.5000000000000000 | 22.3333333333333333 | 271.8333333333333333 | 0003 | 0003 | 0003
+ 250.5000000000000000 | 23.3333333333333333 | 273.8333333333333333 | 0004 | 0004 | 0004
+ 251.5000000000000000 | 22.7666666666666667 | 274.2666666666666667 | 0005 | 0005 | 0005
+ 252.5000000000000000 | 22.2000000000000000 | 274.7000000000000000 | 0006 | 0006 | 0006
+ 246.0000000000000000 | 23.9655172413793103 | 269.9655172413793103 | 0008 | 0008 | 0008
+ 247.0000000000000000 | 23.3448275862068966 | 270.3448275862068966 | 0009 | 0009 | 0009
+(8 rows)
+
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 470 | 0011
+ | | 235 | 0014
+(8 rows)
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 235 | 0014
+ | | 470 | 0011
+(10 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 47 | 0 | 0013
+ 235 | 0 | 0014
+ 470 | 0 | 0011
+(3 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+----------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Materialize
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(20 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Materialize
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+---
+ 470 | 0 |
+(1 row)
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
Sort
- Sort Key: prt1_m_p1.a, prt2_m_p1.b
- -> Append
- -> Hash Full Join
- Hash Cond: ((prt1_m_p1.a = ((prt2_m_p1.b + prt2_m_p1.a) / 2)) AND (((prt1_m_p1.a + prt1_m_p1.b) / 2) = prt2_m_p1.b))
- -> Seq Scan on prt1_m_p1
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p1
- Filter: (c = 0)
- -> Hash Full Join
- Hash Cond: ((prt1_m_p2.a = ((prt2_m_p2.b + prt2_m_p2.a) / 2)) AND (((prt1_m_p2.a + prt1_m_p2.b) / 2) = prt2_m_p2.b))
- -> Seq Scan on prt1_m_p2
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p2
- Filter: (c = 0)
- -> Hash Full Join
- Hash Cond: ((prt1_m_p3.a = ((prt2_m_p3.b + prt2_m_p3.a) / 2)) AND (((prt1_m_p3.a + prt1_m_p3.b) / 2) = prt2_m_p3.b))
- -> Seq Scan on prt1_m_p3
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p3
- Filter: (c = 0)
-(24 rows)
+ Sort Key: t2.a
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
-SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 50 | 0 | |
- 100 | 0 | |
- 150 | 0 | 150 | 0
- 200 | 0 | |
- 250 | 0 | |
- 300 | 0 | 300 | 0
- 350 | 0 | |
- 400 | 0 | |
- 450 | 0 | 450 | 0
- 500 | 0 | |
- 550 | 0 | |
- | | 75 | 0
- | | 225 | 0
- | | 375 | 0
- | | 525 | 0
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
(16 rows)
---
--- tests for list partitioned tables.
---
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
---
--- list partitioned by expression
---
-CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1_e;
--- test partition matching with N-way join
+-- semi join
EXPLAIN (COSTS OFF)
-SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- QUERY PLAN
---------------------------------------------------------------------------------
- GroupAggregate
- Group Key: t1.c, t2.c, t3.c
- -> Sort
- Sort Key: t1.c, t3.c
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
-> Append
- -> Hash Join
- Hash Cond: (t1.c = ltrim(t3.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1.b = t2.b) AND (t1.c = t2.c))
- -> Seq Scan on plt1_p1 t1
- -> Hash
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_e_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.c = ltrim(t3_1.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1_1.b = t2_1.b) AND (t1_1.c = t2_1.c))
- -> Seq Scan on plt1_p2 t1_1
- -> Hash
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_e_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.c = ltrim(t3_2.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1_2.b = t2_2.b) AND (t1_2.c = t2_2.c))
- -> Seq Scan on plt1_p3 t1_2
- -> Hash
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_e_p3 t3_2
-(32 rows)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(22 rows)
-SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- avg | avg | avg | c | c | c
-----------------------+----------------------+-----------------------+------+------+-------
- 24.0000000000000000 | 24.0000000000000000 | 48.0000000000000000 | 0000 | 0000 | A0000
- 75.0000000000000000 | 75.0000000000000000 | 148.0000000000000000 | 0001 | 0001 | A0001
- 123.0000000000000000 | 123.0000000000000000 | 248.0000000000000000 | 0002 | 0002 | A0002
- 174.0000000000000000 | 174.0000000000000000 | 348.0000000000000000 | 0003 | 0003 | A0003
- 225.0000000000000000 | 225.0000000000000000 | 448.0000000000000000 | 0004 | 0004 | A0004
- 273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
- 324.0000000000000000 | 324.0000000000000000 | 648.0000000000000000 | 0006 | 0006 | A0006
- 375.0000000000000000 | 375.0000000000000000 | 748.0000000000000000 | 0007 | 0007 | A0007
- 423.0000000000000000 | 423.0000000000000000 | 848.0000000000000000 | 0008 | 0008 | A0008
- 474.0000000000000000 | 474.0000000000000000 | 948.0000000000000000 | 0009 | 0009 | A0009
- 525.0000000000000000 | 525.0000000000000000 | 1048.0000000000000000 | 0010 | 0010 | A0010
- 573.0000000000000000 | 573.0000000000000000 | 1148.0000000000000000 | 0011 | 0011 | A0011
-(12 rows)
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(22 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(19 rows)
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
@@ -1242,22 +4041,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
--------------------------------------------------
Hash Left Join
Hash Cond: (t2.b = a)
- -> Append
- -> Hash Join
- Hash Cond: (t3.a = t2.b)
- -> Seq Scan on prt1_p1 t3
- -> Hash
- -> Seq Scan on prt2_p1 t2
- -> Hash Join
- Hash Cond: (t3_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t3_1
- -> Hash
- -> Seq Scan on prt2_p2 t2_1
- -> Hash Join
- Hash Cond: (t3_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t3_2
- -> Hash
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash Join
+ Hash Cond: (t3.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t3
+ -> Seq Scan on prt1_p1 t3_1
+ -> Seq Scan on prt1_p2 t3_2
+ -> Seq Scan on prt1_p3 t3_3
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Result
One-Time Filter: false
@@ -1272,16 +4071,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
-> Hash Left Join
Hash Cond: (t2.b = a)
-> Append
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
Filter: (a = 0)
-> Hash
-> Result
One-Time Filter: false
-(14 rows)
+(20 rows)
--
-- tests for hash partitioned tables.
@@ -1357,41 +4162,9 @@ SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, ph
273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
(6 rows)
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
- Sort
- Sort Key: t1.a
- -> Append
- -> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
- -> Hash
- -> Seq Scan on prt1_p1 t1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
- -> Hash
- -> Seq Scan on prt1_p2 t1_1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
- -> Hash
- -> Seq Scan on prt1_p3 t1_2
- Filter: (b = 0)
-(21 rows)
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
@@ -1406,26 +4179,24 @@ SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c
Sort Key: t1.c
-> HashAggregate
Group Key: t1.c, t2.c
- -> Append
- -> Hash Join
- Hash Cond: (t2.c = t1.c)
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_p1 t1
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_1.c = t1_1.c)
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p1 t1_1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_2.c = t1_2.c)
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p2 t1_2
Filter: ((a % 25) = 0)
-(23 rows)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: ((a % 25) = 0)
+(21 rows)
--
-- multiple levels of partitioning
@@ -1827,64 +4598,70 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2 WHERE t1.a = t2.a;
Hash Join
Hash Cond: (t1.a = t2.a)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Seq Scan on prt4_n_p1 t2
-> Seq Scan on prt4_n_p2 t2_1
-> Seq Scan on prt4_n_p3 t2_2
-(11 rows)
+(13 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2, prt2 t3 WHERE t1.a = t2.a and t1.a = t3.b;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------
Hash Join
- Hash Cond: (t2.a = t1.a)
+ Hash Cond: (t3.b = t1.a)
-> Append
- -> Seq Scan on prt4_n_p1 t2
- -> Seq Scan on prt4_n_p2 t2_1
- -> Seq Scan on prt4_n_p3 t2_2
+ -> Seq Scan on prt2_p0 t3
+ -> Seq Scan on prt2_p1 t3_1
+ -> Seq Scan on prt2_p2 t3_2
+ -> Seq Scan on prt2_p3 t3_3
+ -> Seq Scan on prt2_p4 t3_4
+ -> Seq Scan on prt2_p5 t3_5
-> Hash
- -> Append
- -> Hash Join
- Hash Cond: (t1.a = t3.b)
- -> Seq Scan on prt1_p1 t1
- -> Hash
- -> Seq Scan on prt2_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t1_1
- -> Hash
- -> Seq Scan on prt2_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t1_2
- -> Hash
- -> Seq Scan on prt2_p3 t3_2
+ -> Hash Join
+ Hash Cond: (t1.a = t2.a)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt4_n_p1 t2
+ -> Seq Scan on prt4_n_p2 t2_1
+ -> Seq Scan on prt4_n_p3 t2_2
(23 rows)
-- partitionwise join can not be applied if there are no equi-join conditions
-- between partition keys
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON (t1.a < t2.b);
- QUERY PLAN
----------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------
Nested Loop Left Join
+ Join Filter: (t1.a < t2.b)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
- -> Append
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
- Index Cond: (t1.a < b)
-(12 rows)
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Materialize
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(16 rows)
-- equi-join with join condition on partial keys does not qualify for
-- partitionwise join
@@ -1970,16 +4747,17 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 JOIN prt2_n t2 ON (t1.c = t2.c) JOI
-> Seq Scan on prt2_n_p2 t2_1
-> Hash
-> Hash Join
- Hash Cond: (t3.c = (t1.c)::text)
+ Hash Cond: ((t3.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on plt1_p1 t3
- -> Seq Scan on plt1_p2 t3_1
- -> Seq Scan on plt1_p3 t3_2
+ -> Seq Scan on plt1_p4 t3
+ -> Seq Scan on plt1_p1 t3_1
+ -> Seq Scan on plt1_p2 t3_2
+ -> Seq Scan on plt1_p3 t3_3
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(16 rows)
+(17 rows)
-- partitionwise join can not be applied for a join between list and range
-- partitioned table
@@ -1990,14 +4768,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 FULL JOIN prt1 t2 ON (t1.c = t2.c);
Hash Full Join
Hash Cond: ((t2.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on prt1_p1 t2
- -> Seq Scan on prt1_p2 t2_1
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(10 rows)
+(12 rows)
-- partitionwise join can not be applied if only one of joining table has
-- default partition
@@ -2013,16 +4793,23 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b =
-> Hash Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
diff --git a/src/test/regress/sql/partition_join.sql b/src/test/regress/sql/partition_join.sql
index c1c9859651..0e884835fb 100644
--- a/src/test/regress/sql/partition_join.sql
+++ b/src/test/regress/sql/partition_join.sql
@@ -10,25 +10,39 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
@@ -67,11 +81,19 @@ EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -93,20 +115,30 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
@@ -169,6 +201,128 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
RESET enable_hashjoin;
RESET enable_nestloop;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
--
-- partitioned by multiple columns
--
@@ -193,28 +347,79 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1
--
-- tests for list partitioned tables.
--
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
--
-- list partitioned by expression
--
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
ANALYZE plt1_e;
-- test partition matching with N-way join
@@ -222,6 +427,175 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.a = 1 AND t1.a = 2;
@@ -267,27 +641,18 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
ALTER TABLE plt2 DETACH PARTITION plt2_p3;
ALTER TABLE plt2 ATTACH PARTITION plt2_p3 DEFAULT;
ANALYZE plt2;
-
EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.a % 25 = 0 GROUP BY t1.c, t2.c ORDER BY t1.c, t2.c;
+
--
-- multiple levels of partitioning
--
--
2.16.4
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
@ 2018-11-25 20:04 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: Dmitry Dolgov @ 2018-11-25 20:04 UTC (permalink / raw)
To: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers; +Cc: ashutosh.bapat.oss@gmail.com
> On Thu, Oct 25, 2018 at 11:19 PM Dmitry Dolgov <9erthalion6@gmail.com> wrote:
>
> Since most of my complaints about the patch were related to code readability,
> I modified it a bit to show more clearly what I have in mind. I haven't changed
> anything about the functionality, just adjusted some parts of it:
>
> * removed some unused arguments (looks like they were added for consistency in
> all higher level branches, but not all of them were actually in use)
>
> * replaced representation for partition mapping (instead of int arrays there is
> a structure, that allows to replace 0/1 with more meaningful from/to)
>
> * tried to make naming a bit more consistent - so, if a function doesn't
> explicitely say anything about outer/inner, we have partmap1/partmap2,
> otherwise outermap/innermap. I don't really like this style with
> partmap1/partmap2 or index1/index2, but it seems consistent with the rest of
> the code in partbounds.c
>
> * removed some state representation flags, e.g. merged - instead, if there is a
> situation when we can't merge, functions will return NULL right away
>
> * removed questionable debugging statement
I've noticed, that this patch set is outdated, so here is the rebased version.
Attachments:
[application/octet-stream] 0001-Hash-partition-bound-equality-refactoring-v13.patch (5.1K, ../../CA+q6zcW_tdoZQUjuV34SkDSQhb8sfbzk6u3L9Qouf7Hdm3pgpg@mail.gmail.com/2-0001-Hash-partition-bound-equality-refactoring-v13.patch)
download | inline diff:
From c47036b5aa5e46307c2e0a3db94bec86431f0f38 Mon Sep 17 00:00:00 2001
From: erthalion <9erthalion6@gmail.com>
Date: Tue, 11 Sep 2018 21:08:07 +0200
Subject: [PATCH 1/5] Hash partition bound equality refactoring
Separate the code to check whether two given hash bounds are equal into a
separate function, so that it can be called from multiple places. Right now
it's only caller is partition_bounds_equal() but later we will use it for
merging partition bounds.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/partitioning/partbounds.c | 95 ++++++++++++++++++++++-------------
1 file changed, 61 insertions(+), 34 deletions(-)
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index eeaab2f4c9..0af3372cdf 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -104,6 +104,9 @@ static void get_range_key_properties(PartitionKey key, int keynum,
Expr **keyCol,
Const **lower_val, Const **upper_val);
static List *get_range_nulltest(PartitionKey key);
+static bool partition_hbounds_equal(PartitionBoundInfo b1,
+ PartitionBoundInfo b2);
+
/*
* get_qual_from_partbound
@@ -652,6 +655,63 @@ create_range_bounds(PartitionBoundSpec **boundspecs, int nparts,
return boundinfo;
}
+/*
+ * Are two hash partition bound collections logically equal?
+ *
+ * Hash partition bounds store modulus and remainder in datums array which are
+ * always integers irrespective of the number of partition keys and their data
+ * types. Hence we can compare the hash bound collection without any partition
+ * key specific information. Separating this logic in a function which does not
+ * require partition key specific information allows it be called from places
+ * where the partition key specific information is not completely available.
+ */
+static bool
+partition_hbounds_equal(PartitionBoundInfo b1, PartitionBoundInfo b2)
+{
+ int greatest_modulus = get_hash_partition_greatest_modulus(b1);
+ int i;
+
+ Assert(b1->strategy == PARTITION_STRATEGY_HASH &&
+ b2->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * If two hash partitioned tables have different greatest moduli,
+ * their partition schemes don't match. For hash partitioned table,
+ * the greatest modulus is given by the last datum and number of
+ * partitions is given by ndatums.
+ */
+ if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ return false;
+
+ /*
+ * We arrange the partitions in the ascending order of their modulus and
+ * remainders. Also every modulus is factor of next larger modulus.
+ * Therefore we can safely store index of a given partition in indexes
+ * array at remainder of that partition. Also entries at (remainder + N *
+ * modulus) positions in indexes array are all same for (modulus,
+ * remainder) specification for any partition. Thus datums array from both
+ * the given bounds are same, if and only if their indexes array will be
+ * same. So, it suffices to compare indexes array.
+ */
+ for (i = 0; i < greatest_modulus; i++)
+ if (b1->indexes[i] != b2->indexes[i])
+ return false;
+
+#ifdef USE_ASSERT_CHECKING
+
+ /*
+ * Nonetheless make sure that the bounds are indeed same when the indexes
+ * match. Hash partition bound stores modulus and remainder at
+ * b1->datums[i][0] and b1->datums[i][1] position respectively.
+ */
+ for (i = 0; i < b1->ndatums; i++)
+ Assert((b1->datums[i][0] == b2->datums[i][0] &&
+ b1->datums[i][1] == b2->datums[i][1]));
+#endif
+
+ return true;
+}
+
/*
* Are two partition bound collections logically equal?
*
@@ -680,41 +740,8 @@ partition_bounds_equal(int partnatts, int16 *parttyplen, bool *parttypbyval,
if (b1->strategy == PARTITION_STRATEGY_HASH)
{
- int greatest_modulus = get_hash_partition_greatest_modulus(b1);
-
- /*
- * If two hash partitioned tables have different greatest moduli,
- * their partition schemes don't match.
- */
- if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ if (!partition_hbounds_equal(b1, b2))
return false;
-
- /*
- * We arrange the partitions in the ascending order of their moduli
- * and remainders. Also every modulus is factor of next larger
- * modulus. Therefore we can safely store index of a given partition
- * in indexes array at remainder of that partition. Also entries at
- * (remainder + N * modulus) positions in indexes array are all same
- * for (modulus, remainder) specification for any partition. Thus
- * datums array from both the given bounds are same, if and only if
- * their indexes array will be same. So, it suffices to compare
- * indexes array.
- */
- for (i = 0; i < greatest_modulus; i++)
- if (b1->indexes[i] != b2->indexes[i])
- return false;
-
-#ifdef USE_ASSERT_CHECKING
-
- /*
- * Nonetheless make sure that the bounds are indeed same when the
- * indexes match. Hash partition bound stores modulus and remainder
- * at b1->datums[i][0] and b1->datums[i][1] position respectively.
- */
- for (i = 0; i < b1->ndatums; i++)
- Assert((b1->datums[i][0] == b2->datums[i][0] &&
- b1->datums[i][1] == b2->datums[i][1]));
-#endif
}
else
{
--
2.16.4
[application/octet-stream] 0002-Targetlist-of-a-child-join-is-produced-by-translating-v13.patch (3.5K, ../../CA+q6zcW_tdoZQUjuV34SkDSQhb8sfbzk6u3L9Qouf7Hdm3pgpg@mail.gmail.com/3-0002-Targetlist-of-a-child-join-is-produced-by-translating-v13.patch)
download | inline diff:
From 77fa061f1d3d89efc8abb0ec91bfd7611a39641b Mon Sep 17 00:00:00 2001
From: erthalion <9erthalion6@gmail.com>
Date: Tue, 11 Sep 2018 21:09:44 +0200
Subject: [PATCH 2/5] Targetlist of a child-join is produced by translating
that of parent join
The next patch adds more general partition matching algorithm for
partition-wise join. With that change, the first pair of joining
relations for the parent joinrel may not produce a partition-wise join
because of the restrictions in partition_bounds_merge(), to be added
in the next patch. Hence the first pair of joining relations, which
is used to build the child join and presented to
build_child_join_rel(), for the child joinrel does not correspond to
the first pair of joining relations for the parent joinrel. The
targetlist built using different pairs have the targetlist entries
arranged in different order. An appendrel expects that all its
children have their targetlists ordered in the same fashion. Hence
translate the parent's targetlist so that parent and child joinrels
have their targetlists in sync.
Basic partition-wise join commit
f49842d1ee31b976c681322f76025d7732e860f3 modified
build_joinrel_tlist() to build targetlist for child-join. With the
above changes we don't need it anymore. Similarly, the same commit
added code to set_append_rel_size() to compute attr_needed for a
child-join relation. That change too is not needed with the above
change. This commit reverts those two changes.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/optimizer/util/relnode.c | 20 ++++++++++++++++++++
1 file changed, 20 insertions(+)
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 39f5729b91..2f1137c13d 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -802,6 +802,19 @@ build_child_join_rel(PlannerInfo *root, RelOptInfo *outer_rel,
appinfos = find_appinfos_by_relids(root, joinrel->relids, &nappinfos);
+ /*
+ * The first pair of joining relations for the parent joinrel may not
+ * produce a partition-wise join because of the restrictions in
+ * partition_bounds_merge(). Hence the first pair of joining relations,
+ * which is used to build the child join and presented here, for the child
+ * joinrel does not correspond to the first pair of joining relations for
+ * the parent joinrel. The targetlist built using different pairs have the
+ * targetlist nodes arranged in different order. An appendrel expects that
+ * all its children have their targetlists ordered in the same fashion.
+ * Hence translate the parent's targetlist so that parent and child
+ * joinrels have their targetlists in sync.
+ */
+ joinrel->reltarget = copy_pathtarget(parent_joinrel->reltarget);
/* Set up reltarget struct */
build_child_join_reltarget(root, parent_joinrel, joinrel,
nappinfos, appinfos);
@@ -907,6 +920,12 @@ build_joinrel_tlist(PlannerInfo *root, RelOptInfo *joinrel,
Relids relids = joinrel->relids;
ListCell *vars;
+ /*
+ * We only see parent joins. Targetlist of a child-join is computed by
+ * translating corresponding parent join's targetlist.
+ */
+ Assert(joinrel->reloptkind == RELOPT_JOINREL);
+
foreach(vars, input_rel->reltarget->exprs)
{
Var *var = (Var *) lfirst(vars);
@@ -934,6 +953,7 @@ build_joinrel_tlist(PlannerInfo *root, RelOptInfo *joinrel,
/* Is it still needed above this joinrel? */
ndx = var->varattno - baserel->min_attr;
+
if (bms_nonempty_difference(baserel->attr_needed[ndx], relids))
{
/* Yup, add it to the output */
--
2.16.4
[application/octet-stream] 0003-Partition-wise-join-for-1-1-1-0-0-1-partition-matching-v13.patch (72.3K, ../../CA+q6zcW_tdoZQUjuV34SkDSQhb8sfbzk6u3L9Qouf7Hdm3pgpg@mail.gmail.com/4-0003-Partition-wise-join-for-1-1-1-0-0-1-partition-matching-v13.patch)
download | inline diff:
From 7428090314f1e25072d2f6841b83f513e4e611f2 Mon Sep 17 00:00:00 2001
From: erthalion <9erthalion6@gmail.com>
Date: Tue, 11 Sep 2018 21:10:46 +0200
Subject: [PATCH 3/5] Partition-wise join for 1:1, 1:0, 0:1 partition matching
Earlier version of partition-wise join implementation allowed
partition-wise join between two relations with exactly same partition
bounds. This commit allows partition-wise join to be applied under
following conditions
1. the partition bounds of joining relations are such that rows from
given partition on one side join can join with rows from maximum one
partition on the other side i.e. bounds of a given partition on one
side match/overlap with those of maximum one partition on the other
side. If the mapping happens to be m:n where m > 1 or n > 1, we have
to gang multiple partition relations together into a single relation.
This means that we have to add simple relations during join
processing, something which is not supported right now. ALso, in such
a case, different pairs of joining relations can produce different
partition bounds for the same join relation, which again is not
supported right now.
2. For every partition on outer side that can contribute to the result
of an OUTER join, there exists at least one (taken along with item 1,
it means exactly one) matching partition on the inner side. To
support partition-wise join when the inner matching partition doesn't
exist, we have to add a dummy base relation corresponding to the
non-existent inner partition. We don't have support to add base
relations during join processing.
3. For hash partitioned tables however, we support partition-wise join
only when the bounds exactly match. For hash partitioning it's unusual
to have missing partitions and hence generic partition matching is not
required.
With advanced partition matching, we won't be able to apply
partition-wise join when there are missing matching partitions. So for
a given N-way join, some sub-joins may not be partitioned, while the
overall N-way join is partitioned. We can not try partition-wise join
when one or both of the joining relations are not partitioned in one
of the pairs of joining relation. Skip partition-wise join for that
pair.
An example is A IJ B LJ C where B has an extra partition compared to A
and C. Join B LJ C requires dummy relation to join the extra partition
from B to a missing partition from C, and hence can not use
partition-wise join right now and hence BC is not partitioned. The
extra partition in B gets eliminated in A IJ B and thus it can use
partition-wise join and is partitioned. Hence (AB)C can use
partition-wise join but not A(BC).
Not every pair of joining relation (including the one presented to
build_joinrel_partition_info()) for the same joinrel can use
partition-wise join or has both the relations partitioned. Hence we
calculate the partition bounds for the join relation in
try_partition_wise_join() instead of doing it here.
The partition bounds produced for the first pair that can use
partition-wise are saved in the RelOptInfo of the joinrel. Partition
bounds produced for subsequent pairs should match that produced by the
first pair.
Support for default partition in list partitioned tables
========================================================
When a list value is present in one of the joining relations and not
the other, and the other relation has default partition, match (join)
the partition containing that list value with the default partition.
If there are multiple matches, we can not proceed with the
partition-wise join similar to the case of matching non-default
partition. If the default partition happens to be on the outer side of
the join, the resulting join partition acts as a default partition as
it will contain all the values from the default partition. If
the partition containing the list value happens to be on the outer
side of the join, the resulting join partition is associated with the
list value, since no other partition key value from the default
partition makes it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a partition from the inner side,
if inner side has a list value that is not present in the outer side.
But if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Support for matching default partition in range partitioned tables
==================================================================
When a range is present in one of the joining relations and not the
other, and the other relation has default partition, match (join) the
partition corresponding range with the default partition. If two
ranges overlap but their ranges don't match exactly, the
non-overlapping portion from one range may join the previous
(non-overlapping portion near the lower bound, if exists), next
(non-overlapping portion near the upper bound, if exists) ranges from
the other relation or default partition from the other relation. This
causes multiple partitions on the other side to be joined with a
single partition on the first side; a case we don't support. Any range
from one side which doesn't overlap with any range on the other side,
may find its join partner in the default partition and the
corresponding range partition will need to be joined with the default
partition. If the default partition happens to be on the outer side
of the join, the resulting join partition acts as a default partition
as it will contain all the values from the default partition. If the
non-partition corresponding to the range happens to be on the outer
side of the join, the resulting join partition is associated with that
range, since partition key values from the default partition outside
that range won't make it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a non-default partition from the
inner side, if inner side has a range missing in the outer side. But
if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/optimizer/path/joinrels.c | 99 +-
src/backend/optimizer/util/relnode.c | 33 +-
src/backend/partitioning/partbounds.c | 1724 +++++++++++++++++++++++++++++++++
src/include/partitioning/partbounds.h | 6 +
4 files changed, 1817 insertions(+), 45 deletions(-)
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index d3d21fed5d..875b39e334 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1312,25 +1312,31 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
RelOptInfo *joinrel, SpecialJoinInfo *parent_sjinfo,
List *parent_restrictlist)
{
- int nparts;
int cnt_parts;
+ PartitionScheme part_scheme;
+ PartitionBoundInfo join_boundinfo;
+ List *parts1;
+ List *parts2;
+ ListCell *lc1;
+ ListCell *lc2;
/* Guard against stack overflow due to overly deep partition hierarchy. */
check_stack_depth();
/* Nothing to do, if the join relation is not partitioned. */
- if (!IS_PARTITIONED_REL(joinrel))
+ if (joinrel->part_scheme == NULL)
return;
/* The join relation should have consider_partitionwise_join set. */
Assert(joinrel->consider_partitionwise_join);
/*
- * Since this join relation is partitioned, all the base relations
- * participating in this join must be partitioned and so are all the
- * intermediate join relations.
+ * We can not perform partition-wise join if either of the joining
+ * relations is not partitioned.
*/
- Assert(IS_PARTITIONED_REL(rel1) && IS_PARTITIONED_REL(rel2));
+ if (!IS_PARTITIONED_REL(rel1) || !IS_PARTITIONED_REL(rel2))
+ return;
+
Assert(REL_HAS_ALL_PART_PROPS(rel1) && REL_HAS_ALL_PART_PROPS(rel2));
/* The joining relations should have consider_partitionwise_join set. */
@@ -1343,32 +1349,67 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
*/
Assert(joinrel->part_scheme == rel1->part_scheme &&
joinrel->part_scheme == rel2->part_scheme);
+ part_scheme = joinrel->part_scheme;
/*
- * 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.
+ * Get the list of matching partitions to be joined along with the
+ * partition bounds of the join relation. Because of the restrictions
+ * imposed by partition matching algorithm, not every pair of joining
+ * relations for this join will be able to use partition-wise join. But all
+ * those pairs which can use partition-wise join will produce the same
+ * partition bounds for the join relation.
*/
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel1->boundinfo));
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel2->boundinfo));
+ join_boundinfo = partition_bounds_merge(part_scheme->partnatts,
+ part_scheme->partsupfunc,
+ part_scheme->partcollation,
+ rel1->boundinfo, rel1->nparts,
+ rel2->boundinfo, rel2->nparts,
+ parent_sjinfo->jointype,
+ &parts1, &parts2);
+
+ if (join_boundinfo == NULL)
+ return;
+
+ if (joinrel->boundinfo == NULL)
+ {
+ Assert(joinrel->nparts == 0 && joinrel->part_rels == NULL);
+ joinrel->boundinfo = join_boundinfo;
+ joinrel->nparts = list_length(parts1);
+ Assert(joinrel->nparts == list_length(parts2));
+ joinrel->part_rels =
+ (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+ joinrel->nparts);
+ }
+ else
+ {
+ Assert(partition_bounds_equal(part_scheme->partnatts,
+ part_scheme->parttyplen,
+ part_scheme->parttypbyval,
+ join_boundinfo, joinrel->boundinfo));
+ /*
+ * Every pair of joining relations should result in the same number
+ * of child-joins.
+ */
+ Assert(joinrel->nparts == list_length(parts1));
+ Assert(joinrel->nparts == list_length(parts2));
+ Assert(joinrel->part_rels);
+ }
- nparts = joinrel->nparts;
+ elog(DEBUG3, "join between relations %s and %s is considered for partition-wise join.",
+ bmsToString(rel1->relids), bmsToString(rel2->relids));
/*
* Create child-join relations for this partitioned join, if those don't
* exist. Add paths to child-joins for a pair of child relations
* corresponding to the given pair of parent relations.
*/
- for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+ cnt_parts = 0;
+ forboth(lc1, parts1, lc2, parts2)
{
- RelOptInfo *child_rel1 = rel1->part_rels[cnt_parts];
- RelOptInfo *child_rel2 = rel2->part_rels[cnt_parts];
+ int part1 = lfirst_int(lc1);
+ int part2 = lfirst_int(lc2);
+ RelOptInfo *child_rel1;
+ RelOptInfo *child_rel2;
SpecialJoinInfo *child_sjinfo;
List *child_restrictlist;
RelOptInfo *child_joinrel;
@@ -1376,6 +1417,10 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
AppendRelInfo **appinfos;
int nappinfos;
+ Assert(part1 >= 0 && part2 >= 0);
+ child_rel1 = rel1->part_rels[part1];
+ child_rel2 = rel2->part_rels[part2];
+
/* We should never try to join two overlapping sets of rels. */
Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1409,12 +1454,24 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
joinrel->part_rels[cnt_parts] = child_joinrel;
}
+ /*
+ * For every pair of joining relations, the set of matching partitions
+ * would change. However, the base relation partitions constituting
+ * the given child should remain same for all the joining pairs. Since
+ * the order in which children are stored in the array of child-joins,
+ * depends upon partition bounds of the join, which are same for all
+ * the joining pairs, every joining pair yields the child-joins in the
+ * same order.
+ */
Assert(bms_equal(child_joinrel->relids, child_joinrelids));
populate_joinrel_with_paths(root, child_rel1, child_rel2,
child_joinrel, child_sjinfo,
child_restrictlist);
+ cnt_parts++;
}
+
+ Assert(cnt_parts == joinrel->nparts);
}
/*
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 2f1137c13d..4f15cd8e8b 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1627,7 +1627,7 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
* of the way the query planner deduces implied equalities and reorders
* the joins. Please see optimizer/README for details.
*/
- if (!IS_PARTITIONED_REL(outer_rel) || !IS_PARTITIONED_REL(inner_rel) ||
+ if (outer_rel->part_scheme == NULL || inner_rel->part_scheme == NULL ||
!outer_rel->consider_partitionwise_join ||
!inner_rel->consider_partitionwise_join ||
outer_rel->part_scheme != inner_rel->part_scheme ||
@@ -1640,24 +1640,6 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
part_scheme = outer_rel->part_scheme;
- Assert(REL_HAS_ALL_PART_PROPS(outer_rel) &&
- REL_HAS_ALL_PART_PROPS(inner_rel));
-
- /*
- * For now, our partition matching algorithm can match partitions only
- * when the partition bounds of the joining relations are exactly same.
- * So, bail out otherwise.
- */
- if (outer_rel->nparts != inner_rel->nparts ||
- !partition_bounds_equal(part_scheme->partnatts,
- part_scheme->parttyplen,
- part_scheme->parttypbyval,
- outer_rel->boundinfo, inner_rel->boundinfo))
- {
- Assert(!IS_PARTITIONED_REL(joinrel));
- return;
- }
-
/*
* This function will be called only once for each joinrel, hence it
* should not have partition scheme, partition bounds, partition key
@@ -1669,17 +1651,20 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
/*
* Join relation is partitioned using the same partitioning scheme as the
- * joining relations and has same bounds.
+ * joining relations.
+ *
+ * Because of restrictions in partition_bounds_merge(), not every pair of
+ * joining relations (including the one presented to this function) for the
+ * same joinrel can use partition-wise join or has both the relations
+ * partitioned. Hence we calculate the partition bounds, number of
+ * partitions and child-join relations of the join relation when and if we
+ * find a suitable pair in try_partition_wise_join().
*/
joinrel->part_scheme = part_scheme;
- joinrel->boundinfo = outer_rel->boundinfo;
partnatts = joinrel->part_scheme->partnatts;
joinrel->partexprs = (List **) palloc0(sizeof(List *) * partnatts);
joinrel->nullable_partexprs =
(List **) palloc0(sizeof(List *) * partnatts);
- joinrel->nparts = outer_rel->nparts;
- joinrel->part_rels =
- (RelOptInfo **) palloc0(sizeof(RelOptInfo *) * joinrel->nparts);
/*
* Set the consider_partitionwise_join flag.
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index 0af3372cdf..491ebedc4c 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -106,6 +106,63 @@ static void get_range_key_properties(PartitionKey key, int keynum,
static List *get_range_nulltest(PartitionKey key);
static bool partition_hbounds_equal(PartitionBoundInfo b1,
PartitionBoundInfo b2);
+static PartitionBoundInfo partition_range_bounds_merge(int partnatts,
+ FmgrInfo *supfuncs, Oid *collations,
+ PartitionBoundInfo boundinfo1, int nparts1,
+ PartitionBoundInfo boundinfo2, int nparts2,
+ JoinType jointype, List **parts1, List **parts2);
+static PartitionBoundInfo partition_list_bounds_merge(int partnatts,
+ FmgrInfo *partsupfunc, Oid *collations,
+ PartitionBoundInfo boundinfo1, int nparts1,
+ PartitionBoundInfo boundinfo2, int nparts2,
+ JoinType jointype, List **parts1, List **parts2);
+static PartitionBoundInfo partition_hash_bounds_merge(int partnatts,
+ FmgrInfo *partsupfunc,
+ Oid *partcollation, PartitionBoundInfo left_bi,
+ int left_nparts, PartitionBoundInfo right_bi,
+ int right_nparts, JoinType jointype, List **left_parts,
+ List **right_parts);
+static void generate_matching_part_pairs(int *mergemap1, int npart1,
+ int *mergemap2, int nparts2, JoinType jointype,
+ int nparts, List **parts1, List **parts2);
+static PartitionBoundInfo build_merged_partition_bounds(char strategy,
+ List *merged_datums, List *merged_indexes,
+ List *merged_contents, int null_index,
+ int default_index);
+static int map_and_merge_partitions(int *partmap1, int *mergemap1, int index1,
+ int *partmap2, int *mergemap2, int index2,
+ int *next_index);
+static int32 partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *collations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2);
+static bool partition_range_cmp(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval);
+static bool partition_range_merge_next_lb(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes);
+static bool merge_default_partitions(PartitionBoundInfo outer_bi,
+ int *outer_pmap,
+ int *outer_mmap, PartitionBoundInfo inner_bi,
+ int *inner_pmap, int *inner_mmap, JoinType jointype,
+ int *next_index, int *default_index);
+static bool merge_null_partitions(PartitionBoundInfo outer_bi, int *outer_pmap,
+ int *outer_mmap, PartitionBoundInfo inner_bi,
+ int *inner_pmap, int *inner_mmap, JoinType jointype,
+ int *next_index, int *null_index, int *default_index);
+static bool handle_missing_partition(int *missing_side_pmap,
+ int *missing_side_mmap,
+ int missing_side_default, int *other_pmap,
+ int *other_mmap, int other_part,
+ bool missing_side_outer,
+ bool missing_side_inner,
+ int *next_index, int *default_index,
+ int *merged_index);
/*
@@ -2941,3 +2998,1670 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
PG_RETURN_BOOL(rowHash % modulus == remainder);
}
+
+/*
+ * partition_bounds_merge
+ *
+ * The function produces the partition bounds for a join between two relations
+ * whose partition bounds are given. The function also returns two lists of
+ * partition indexes one for each of the joining relations. Both the lists
+ * contain the same number of elements. The partition indexes at the same
+ * positions in the lists indicate the pair partitions, one from each side, to
+ * be joined and the position itself corresponds to the index of partition
+ * produced by that child-join in the partitioned join.
+ *
+ * The function returns NULL if we can not find the matching pair of
+ * partitions. This happens if 1. multiple partitions on one side match with
+ * one partition on the other side. 2. a given partition on the outer side
+ * doesn't have a matching partition on the inner side. We can not support the
+ * first case since we don't have a way to represent multiple partitions as a
+ * single relation (RelOptInfo) and then perform join using the ganged
+ * relation. We can not support the second case since the missing inner
+ * partition needs to be represented as an empty relation and we don't have a
+ * way to introduce empty relation during join planning after creating paths
+ * for all the base relations.
+ */
+extern PartitionBoundInfo
+partition_bounds_merge(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation,
+ PartitionBoundInfo outer_bi, int outer_nparts,
+ PartitionBoundInfo inner_bi, int inner_nparts,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts)
+{
+ PartitionBoundInfo merged_bounds;
+ char strategy;
+
+ /* Bail out if partitioning strategies are different. */
+ if (outer_bi->strategy != inner_bi->strategy)
+ return NULL;
+
+ if (jointype != JOIN_LEFT && jointype != JOIN_INNER &&
+ jointype != JOIN_SEMI && jointype != JOIN_ANTI &&
+ jointype != JOIN_FULL)
+ elog(ERROR, "unexpected join type %d", jointype);
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+ strategy = outer_bi->strategy;
+ switch (strategy)
+ {
+ case PARTITION_STRATEGY_LIST:
+ merged_bounds = partition_list_bounds_merge(partnatts, partsupfunc,
+ partcollation,
+ outer_bi, outer_nparts,
+ inner_bi, inner_nparts,
+ jointype, outer_parts,
+ inner_parts);
+ break;
+
+ case PARTITION_STRATEGY_RANGE:
+ merged_bounds = partition_range_bounds_merge(partnatts,
+ partsupfunc,
+ partcollation,
+ outer_bi,
+ outer_nparts,
+ inner_bi,
+ inner_nparts,
+ jointype,
+ outer_parts,
+ inner_parts);
+ break;
+
+ case PARTITION_STRATEGY_HASH:
+ merged_bounds = partition_hash_bounds_merge(partnatts,
+ partsupfunc,
+ partcollation,
+ outer_bi, outer_nparts,
+ inner_bi, inner_nparts,
+ jointype, outer_parts,
+ inner_parts);
+ break;
+
+ default:
+ elog(ERROR, "unexpected partition strategy: %d", strategy);
+ }
+
+ Assert(merged_bounds || (*outer_parts == NIL && *inner_parts == NIL));
+
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+
+ Assert((*outer_parts == NIL || *inner_parts != NIL) &&
+ (*inner_parts == NIL || *outer_parts != NIL));
+
+ return merged_bounds;
+}
+
+/*
+ * partition_get_range_bounds
+ *
+ * Given the index of lower bound in datums array, return lower and upper
+ * bounds and the index of the partition with that lower bound.
+ */
+static int
+partition_get_range_bounds(PartitionBoundInfo bi, int lb_index,
+ PartitionRangeBound *lower,
+ PartitionRangeBound *upper)
+{
+ int part_index;
+
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The lower bound should correspond to a valid partition. */
+ part_index = bi->indexes[lb_index + 1];
+ Assert(part_index >= 0);
+
+ lower->kind = bi->kind[lb_index];
+ lower->datums = bi->datums[lb_index];
+ lower->lower = true;
+ upper->kind = bi->kind[lb_index + 1];
+ upper->datums = bi->datums[lb_index + 1];
+ upper->lower = false;
+
+ return part_index;
+}
+
+/*
+ * partition_range_get_next_lb_index
+ *
+ * Given the index of lower bound in datums array return the
+ * index of lower bound of the next partition. When the given index corresponds
+ * to the last partition, return number of datums (ndatums).
+ */
+static int
+partition_range_get_next_lb_index(PartitionBoundInfo bi, int lb_index)
+{
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The partition index corresponding to the upper bound should be valid. */
+ Assert(bi->indexes[lb_index + 1] >= 0);
+
+ /*
+ * If there are no bounds left beyond the upper bound, we have reached the
+ * last partition.
+ */
+ if (lb_index + 2 < bi->ndatums)
+ {
+ /*
+ * If the bound next to the upper bound corresponds to no partition,
+ * that's the next lower bound of the next partition. Otherwise, the
+ * current upper bound is the lower bound of the next partition.
+ */
+ if (bi->indexes[lb_index + 2] < 0)
+ return lb_index + 2;
+ else
+ return lb_index + 1;
+ }
+ else
+ return bi->ndatums;
+}
+
+static int32
+partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2)
+{
+ return partition_rbound_cmp(partnatts, partsupfunc, partcollations,
+ bound1->datums, bound1->kind, bound1->lower,
+ bound2);
+}
+
+/*
+ * partition_range_cmp
+ *
+ * Compare the bounds of two range partitions. Set ub_cmpval <, = or > 0, if the
+ * first partition's upper bound is lower than, equal to or higher than the
+ * second partition's upper bound resp. Similarly set lb_cmpval <, = or > 0,
+ * if the first partition's lower bound is lower than, equal to or higher than
+ * the second partition's lower bound resp.
+ *
+ * Return true, if the ranges overlap, otherwise return false.
+ */
+static bool
+partition_range_cmp(int partnatts, FmgrInfo *partsupfuncs, Oid *partcollations,
+ PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval)
+{
+ bool overlap;
+
+ /*
+ * Compare upper bound of the first partition with the lower bound of the
+ * second and vice-versa. If lower bound is higher than the upper bound,
+ * the partitions are not overlapping. All other cases indicate overlapping
+ * partitions.
+ */
+ if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound1, upper_bound2) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = 1;
+ *lb_cmpval = 1;
+ }
+ else if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound2, upper_bound1) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = -1;
+ *lb_cmpval = -1;
+ }
+ else
+ {
+ overlap = true;
+ *ub_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, upper_bound1,
+ upper_bound2);
+ *lb_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, lower_bound1,
+ lower_bound2);
+ }
+
+ return overlap;
+}
+
+/*
+ * partition_range_merge
+ *
+ * Merge the partition bounds of given two partitions such that the join
+ * between the given two partitions fits merged bounds.
+ *
+ * "merged_upper" will be set to one of the given upper bounds and
+ * "merged_lower" will be set to one of the given lower bounds.
+ */
+static void
+partition_range_merge(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, JoinType jointype,
+ PartitionRangeBound *left_lb,
+ PartitionRangeBound *left_ub,
+ PartitionRangeBound *right_lb,
+ PartitionRangeBound *right_ub,
+ PartitionRangeBound **merged_lb,
+ PartitionRangeBound **merged_ub)
+{
+ /*
+ * An outer join will have all the rows from the outer side, so merged
+ * bounds will be same as the outer bounds. An inner join will have rows
+ * that fit both the bounds, thus lower merged bound will be higher of two
+ * lower bounds and upper merged bound will be lower of the two upper
+ * bounds.
+ */
+ switch (jointype)
+ {
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ *merged_ub = left_ub;
+ *merged_lb = left_lb;
+ break;
+
+ case JOIN_INNER:
+ case JOIN_SEMI:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) < 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) > 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ case JOIN_FULL:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) > 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) < 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ default:
+ elog(ERROR, "unexpected join type %d", jointype);
+ }
+
+ return;
+}
+
+/*
+ * Add the lower bound of the next range to the list of bounds, if the lower
+ * bound is higher or equal to the previous upper bound. If successful return
+ * true, otherwise false.
+ */
+static bool
+partition_range_merge_next_lb(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes)
+{
+ int cmpval;
+
+ if (!*merged_datums)
+ {
+ Assert(!*merged_kinds && !*merged_indexes);
+ cmpval = 1;
+ }
+ else
+ {
+ PartitionRangeBound prev_ub;
+
+ prev_ub.datums = llast(*merged_datums);
+ prev_ub.kind = llast(*merged_kinds);
+ prev_ub.lower = false;
+
+ cmpval = partition_rbound_cmp(partnatts, partsupfuncs, partcollations,
+ next_lb_datums, next_lb_kind, false,
+ &prev_ub);
+ }
+
+ /*
+ * The lower bound is lower than the last upper bound, thus does not fit
+ * the bounds created so far and hence can not be merged with the existing
+ * bounds.
+ */
+ if (cmpval < 0)
+ return false;
+
+ /*
+ * Add bounds of the new merged partition. If the next lower bound is
+ * higher than the last upper bound, add new range with index
+ * corresponding to the lower bound as -1. If the merged lower bound
+ * is same as the last merged upper bound, the last upper bound will be
+ * reused as the lower bound of the next range.
+ */
+ if (cmpval > 0)
+ {
+ *merged_datums = lappend(*merged_datums, next_lb_datums);
+ *merged_kinds = lappend(*merged_kinds, next_lb_kind);
+ *merged_indexes = lappend_int(*merged_indexes, -1);
+ }
+
+ return true;
+}
+
+/*
+ * handle_missing_partition
+ *
+ * If a range appears in one of the joining relations but not the other, a row
+ * in the corresponding partition will not have any join partner in the other
+ * relation, unless the other relation has a default partition. If a given list
+ * value is present in one joining relation but not the other, the default
+ * partition on the other side may contain that value.
+ *
+ * In both these cases, such an extra partition forms a joining pair with the
+ * default partition, if any, on the other side.
+ *
+ * If the default partition happens to be on the outer side of the join, the
+ * resultant partition will act as the default partition of the join relation.
+ * Otherwise the resultant partition will be associated with the range.
+ *
+ * When the default partition is not present in the other relation, the rows in
+ * the extra partition will be included in the bounds of the join result, if it
+ * appears on the outer side of the join, since all rows from the outer side
+ * are included in the join result.
+ *
+ * This function handles all these cases.
+ *
+ * missing_side_pmap, missing_side_mmap and missing_side_default are the
+ * partition map, merge map (See partition_range/list_bounds_merge() for
+ * details) and the index of default partition respectively corresponding the
+ * side with missing partition.
+ *
+ * other_pmap, other_mmap and other_part are the partition map, merge map (See
+ * partition_range/list_bounds_merge() for details) and the index of extra
+ * partition respectively corresponding to the side with the extra partition.
+ *
+ * It returns true if the matching succeeds, otherwise returns false.
+ */
+static bool
+handle_missing_partition(int *missing_side_pmap, int *missing_side_mmap,
+ int missing_side_default, int *other_pmap,
+ int *other_mmap, int other_part,
+ bool missing_side_outer,
+ bool missing_side_inner,
+ int *next_index, int *default_index,
+ int *merged_index)
+{
+ bool missing_has_default = (missing_side_default != -1);
+
+ if (missing_has_default)
+ {
+ *merged_index = map_and_merge_partitions(missing_side_pmap,
+ missing_side_mmap,
+ missing_side_default,
+ other_pmap, other_mmap,
+ other_part,
+ next_index);
+ if (*merged_index < 0)
+ return false;
+
+ if (missing_side_outer)
+ {
+ /*
+ * Default partition on the outer side forms the default
+ * partition of the join result.
+ */
+ if (*default_index < 0)
+ *default_index = *merged_index;
+ else if(*default_index != *merged_index)
+ {
+ /*
+ * Ended up with default partition on the outer side
+ * being joined with multiple partitions on the inner
+ * side. We don't support this case.
+ */
+ return false;
+ }
+
+ /*
+ * Since the merged partition acts as a default partition, it
+ * doesn't need a separate index.
+ */
+ *merged_index = -1;
+ }
+ }
+ else if (missing_side_inner)
+ {
+ /*
+ * If this partition has already been mapped (say because we
+ * found an overlapping range earlier), we know where does it
+ * fit in the join result. Nothing to do in that case. Else
+ * create a new merged partition.
+ */
+ if (other_mmap[other_part] < 0)
+ {
+ other_mmap[other_part] = *next_index;
+ *next_index = *next_index + 1;
+ *merged_index = other_mmap[other_part];
+ }
+ }
+
+ return true;
+}
+
+/*
+ * partition_range_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for range partitioned tables.
+ */
+static PartitionBoundInfo
+partition_range_bounds_merge(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, PartitionBoundInfo outer_bi,
+ int outer_nparts, PartitionBoundInfo inner_bi,
+ int inner_nparts, JoinType jointype,
+ List **outer_parts, List **inner_parts)
+{
+ int *outer_pmap;
+ int *outer_mmap;
+ int *inner_pmap;
+ int *inner_mmap;
+ int cnt1;
+ int cnt2;
+ int outer_part;
+ int inner_part;
+ PartitionBoundInfo merged_bounds = NULL;
+ bool merged = true;
+ int outer_lb_index;
+ int inner_lb_index;
+ int next_index;
+ int default_index = -1;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ List *merged_kinds = NIL;
+ int inner_default = inner_bi->default_index;
+ int outer_default = outer_bi->default_index;
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_RANGE);
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+
+ /*
+ * Allocate and initialize partition maps. We maintain four maps, two maps
+ * for each joining relation. pmap[i] gives the partition from the other
+ * relation which would join with ith partition of the given relation.
+ * Partition i from the given relation will join with partition pmap[i]
+ * from the other relation to produce partition mmap[i] of the join (merged
+ * partition).
+ *
+ * pmap[i] = -1 indicates that ith partition of a given relation does not
+ * have a matching partition from the other relation.
+ *
+ * mmap[i] = -1 indicates that ith partition of a given relation does not
+ * contribute to the join result. That can happen only when the given
+ * relation is the inner relation and it doesn't have a matching partition
+ * from the outer relation, hence pmap[i] should be -1.
+ *
+ * In case of an outer join, every partition of the outer join will appear
+ * in the join result, and thus has mmap[i] set for all i. But it's not
+ * necessary that every partition on the outer side will have a matching
+ * partition on the inner side. In such a case, we end up with pmap[i] = -1
+ * and mmap[i] != -1.
+ */
+ outer_pmap = (int *) palloc(sizeof(int) * outer_nparts);
+ outer_mmap = (int *) palloc(sizeof(int) * outer_nparts);
+ inner_pmap = (int *) palloc(sizeof(int) * inner_nparts);
+ inner_mmap = (int *) palloc(sizeof(int) * inner_nparts);
+
+ for (cnt1 = 0; cnt1 < outer_nparts; cnt1++)
+ {
+ outer_pmap[cnt1] = -1;
+ outer_mmap[cnt1] = -1;
+ }
+ for (cnt2 = 0; cnt2 < inner_nparts; cnt2++)
+ {
+ inner_pmap[cnt2] = -1;
+ inner_mmap[cnt2] = -1;
+ }
+
+ /*
+ * Merge the ranges (partitions) from both sides. Every iteration compares
+ * a pair of ranges, one from each side, advancing to the next range from
+ * the side with smaller upper range bound. If upper bounds of ranges from
+ * both sides match exactly, both the sides are advanced. For a given pair
+ * of ranges, we decide whether the corresponding partition match or not.
+ * lb_index, for inner or outer side, keeps track of the index of lower bound
+ * datum in PartitionBoundInfo::datums of that side.
+ */
+ outer_lb_index = 0;
+ inner_lb_index = 0;
+ next_index = 0;
+ while (outer_lb_index < outer_bi->ndatums ||
+ inner_lb_index < inner_bi->ndatums)
+ {
+ PartitionRangeBound outer_lb;
+ PartitionRangeBound outer_ub;
+ PartitionRangeBound inner_lb;
+ PartitionRangeBound inner_ub;
+ PartitionRangeBound *merged_lb = NULL;
+ PartitionRangeBound *merged_ub = NULL;
+ int merged_index = -1;
+ bool overlap;
+ bool finished_outer = false;
+ bool finished_inner = false;
+
+ /* Result of bounds comparison per partition_rbound_cmp(). */
+ int ub_cmpval; /* Upper bounds comparison result. */
+ int lb_cmpval; /* Lower bounds comparison result. */
+
+ /* Get the range bounds of the next pair of partitions. */
+ if (outer_lb_index < outer_bi->ndatums)
+ outer_part = partition_get_range_bounds(outer_bi, outer_lb_index,
+ &outer_lb, &outer_ub);
+ else
+ finished_outer = true;
+
+ if (inner_lb_index < inner_bi->ndatums)
+ inner_part = partition_get_range_bounds(inner_bi, inner_lb_index,
+ &inner_lb, &inner_ub);
+ else
+ finished_inner = true;
+
+ Assert(!finished_outer || !finished_inner);
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining partitions on the side
+ * which finishes later. For that we set the comparison parameters
+ * overlap, ub_cmpval and lb_cmpval in such a way that it appears as if
+ * the side which finishes earlier has an extra partition with lower
+ * and upper bounds higher than any other partition of the unfinished
+ * side. That way we advance the partitions on that side till all of
+ * them are exhausted.
+ */
+ if (finished_outer)
+ {
+ overlap = false;
+ ub_cmpval = 1;
+ lb_cmpval = 1;
+ }
+ else if (finished_inner)
+ {
+ overlap = false;
+ ub_cmpval = -1;
+ lb_cmpval = -1;
+ }
+ else
+ overlap = partition_range_cmp(partnatts, partsupfuncs, partcollations,
+ &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &ub_cmpval, &lb_cmpval);
+
+ if (overlap)
+ {
+ /*
+ * The rows from overlapping portion of ranges on both sides may
+ * join, hence the corresponding pair of partitions form a joining
+ * pair. Match them and produce the bounds of the joint partition
+ * and its index by merging the bounds according to the type of
+ * join.
+ */
+ partition_range_merge(partnatts, partsupfuncs, partcollations,
+ jointype, &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &merged_lb, &merged_ub);
+ merged_index = map_and_merge_partitions(outer_pmap, outer_mmap,
+ outer_part, inner_pmap,
+ inner_mmap, inner_part,
+ &next_index);
+
+ if (merged_index < 0)
+ {
+ /* Failed to match the partitions. */
+ merged = false;
+ break;
+ }
+
+ /*
+ * If the ranges overlap but don't exactly match, a row from
+ * non-overlapping portion of the range from one side of join may
+ * find its join partner in the previous or next overlapping
+ * partition or default partition on the other side , if such a
+ * partition exists. All those cases, if true, will cause one
+ * partition from that side to match at least two partitions on the
+ * other side; a case that we do not support now. Previous
+ * partition has been delt with in the previous iteration of this
+ * loop, next partition will be delt in the next iteration. We will
+ * deal with the default partition here.
+ */
+ if ((lb_cmpval < 0 && inner_has_default) ||
+ /* Non-overlapping range on the lower side of outer range. */
+ (lb_cmpval > 0 && outer_has_default) ||
+ /* Non-overlapping range on the lower side of inner range. */
+ (ub_cmpval < 0 && outer_has_default) ||
+ /* Non-overlapping range on the upper side of inner range. */
+ (ub_cmpval > 0 && inner_has_default))
+ /* Non-overlapping range on the upper side of outer range. */
+ {
+ merged = false;
+ break;
+ }
+ }
+
+ if (ub_cmpval == 0)
+ {
+ /* Upper bounds of both the ranges match. */
+ Assert(overlap);
+
+ /* Move to the next pair of partitions. */
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+ else if (ub_cmpval < 0)
+ {
+ /* Upper bound of inner range higher than that of the outer. */
+
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the inner side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &outer_lb;
+ merged_ub = &outer_ub;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+ merged = handle_missing_partition(inner_pmap, inner_mmap,
+ inner_default, outer_pmap,
+ outer_mmap, outer_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index);
+
+ if (!merged)
+ break;
+ }
+
+ /* Move to the next partition on the outer side. */
+ Assert(!finished_outer);
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ }
+ else
+ {
+ Assert(ub_cmpval > 0);
+
+ /* Upper bound of outer range higher than that of the inner. */
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the outer side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &inner_lb;
+ merged_ub = &inner_ub;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+ merged = handle_missing_partition(outer_pmap, outer_mmap,
+ outer_default, inner_pmap,
+ inner_mmap, inner_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index);
+
+ if (!merged)
+ break;
+ }
+
+ /* Move to the next partition on the inner side. */
+ Assert (!finished_inner);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+
+ Assert(merged);
+
+ if (merged_index < 0)
+ {
+ /* We didn't find a new merged partition. */
+ continue;
+ }
+
+ /*
+ * We have a valid partition index for the next partition of join. The
+ * partition should have valid range.
+ */
+ Assert(merged_lb && merged_ub);
+
+ /* Try merging new lower bound with the last upper bound. */
+ merged = partition_range_merge_next_lb(partnatts, partsupfuncs,
+ partcollations,
+ merged_lb->datums,
+ merged_lb->kind, &merged_datums,
+ &merged_kinds, &merged_indexes);
+ if (merged)
+ {
+ /* Add upper bound with the merged partition index. */
+ merged_datums = lappend(merged_datums, merged_ub->datums);
+ merged_kinds = lappend(merged_kinds, merged_ub->kind);
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ }
+ else
+ break;
+ }
+
+ if (merged)
+ merged = merge_default_partitions(outer_bi, outer_pmap, outer_mmap,
+ inner_bi, inner_pmap, inner_mmap,
+ jointype, &next_index,
+ &default_index);
+
+ /* Create PartitionBoundInfo for the join result. */
+ if (merged)
+ {
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_mmap, outer_nparts, inner_mmap,
+ inner_nparts, jointype, next_index,
+ outer_parts, inner_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes,
+ merged_kinds,
+ -1, default_index);
+ }
+ }
+
+ /* Free any memory we used in this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ list_free(merged_kinds);
+ pfree(outer_pmap);
+ pfree(inner_pmap);
+ pfree(outer_mmap);
+ pfree(inner_mmap);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_list_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for list partitioned tables.
+ *
+ */
+static PartitionBoundInfo
+partition_list_bounds_merge(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, PartitionBoundInfo outer_bi,
+ int outer_nparts, PartitionBoundInfo inner_bi,
+ int inner_nparts, JoinType jointype,
+ List **outer_parts, List **inner_parts)
+{
+ int *outer_pmap; /* outer to inner partition map */
+ int *outer_mmap; /* outer to merged partition map */
+ int *inner_pmap; /* inner to outer partition map */
+ int *inner_mmap; /* inner to merged partition map */
+ int cnto;
+ int cnti;
+ bool merged = true;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ int next_index = 0;
+ int null_index;
+ int default_index = -1;
+ PartitionBoundInfo merged_bounds = NULL;
+ int *outer_indexes = outer_bi->indexes;
+ int *inner_indexes = inner_bi->indexes;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_LIST);
+
+ /* List partitions do not require unbounded ranges. */
+ Assert(!outer_bi->kind && !inner_bi->kind);
+
+ /*
+ * Allocate and initialize partition maps. We maintain four maps, two maps
+ * for each joining relation. pmap[i] gives the partition from the other
+ * relation which would join with ith partition of the given relation.
+ * Partition i from the given relation will join with partition pmap[i]
+ * from the other relation to produce partition mmap[i] of the join (merged
+ * partition).
+ *
+ * pmap[i] = -1 indicates that ith partition of a given relation does not
+ * have a matching partition from the other relation.
+ *
+ * mmap[i] = -1 indicates that ith partition of a given relation does not
+ * contribute to the join result. That can happen only when the given
+ * relation is the inner relation and it doesn't have a matching partition
+ * from the outer relation, hence pmap[i] should be -1.
+ *
+ * In case of an outer join, every partition of the outer join will appear
+ * in the join result, and thus has mmap[i] set for all i. But it's not
+ * necessary that every partition on the outer side will have a matching
+ * partition on the inner side. In such a case, we end up with pmap[i] = -1
+ * and mmap[i] != -1.
+ */
+ outer_pmap = (int *) palloc(sizeof(int) * outer_nparts);
+ outer_mmap = (int *) palloc(sizeof(int) * outer_nparts);
+ inner_pmap = (int *) palloc(sizeof(int) * inner_nparts);
+ inner_mmap = (int *) palloc(sizeof(int) * inner_nparts);
+
+ for (cnto = 0; cnto < outer_nparts; cnto++)
+ {
+ outer_pmap[cnto] = -1;
+ outer_mmap[cnto] = -1;
+ }
+ for (cnti = 0; cnti < inner_nparts; cnti++)
+ {
+ inner_pmap[cnti] = -1;
+ inner_mmap[cnti] = -1;
+ }
+
+ /*
+ * Merge the list value datums from both sides. Every iteration compares a
+ * pair of datums, one from each side, advancing to the next datum from the
+ * side with smaller datum. If datums from both sides match exactly, both
+ * the sides are advanced. For a given pair of datums, we decide whether
+ * the corresponding partition match or not.
+ */
+ cnto = cnti = 0;
+ while (cnto < outer_bi->ndatums || cnti < inner_bi->ndatums)
+ {
+ Datum *odatums;
+ Datum *idatums;
+ int o_index;
+ int i_index;
+ int cmpval;
+ int merged_index = -1;
+ Datum *merged_datum;
+ bool finished_inner;
+ bool finished_outer;
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining datums on the side which
+ * finishes later. For that we set the comparison parameter cmpval in
+ * such a way that it appears as if the side which finishes earlier has
+ * an extra datum higher than any other datum on the unfinished side.
+ * That way we advance the datums on the unfinished side till all of
+ * its datums are exhausted.
+ */
+ if (cnto >= outer_bi->ndatums)
+ {
+ finished_outer = true;
+ odatums = NULL;
+ o_index = -1;
+ }
+ else
+ {
+ finished_outer = false;
+ odatums = outer_bi->datums[cnto];
+ o_index = outer_indexes[cnto];
+ }
+
+ if (cnti >= inner_bi->ndatums)
+ {
+ finished_inner = true;
+ idatums = NULL;
+ i_index = -1;
+ }
+ else
+ {
+ finished_inner = false;
+ idatums = inner_bi->datums[cnti];
+ i_index = inner_indexes[cnti];
+ }
+
+ /* If we exhausted both the sides, we won't enter the loop. */
+ Assert(!finished_inner || !finished_outer);
+
+ if (finished_outer)
+ cmpval = 1;
+ else if (finished_inner)
+ cmpval = -1;
+ else
+ {
+ /* Every list datum should map to a valid partition index. */
+ Assert(o_index >= 0 && i_index >= 0 &&
+ odatums != NULL && idatums != NULL);
+
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
+ partcollation[0],
+ odatums[0], idatums[0]));
+ }
+
+ if (cmpval == 0)
+ {
+ /*
+ * Datums match. Rows on either side with these datums as partition
+ * key value will join and will be part of the partition of the
+ * join result produced by joining the corresponding partitions.
+ * Match the corresponding partitions and if successful, add the
+ * datum to the list of merged datums with index of merged
+ * partition containing it.
+ */
+ merged_datum = odatums;
+ merged_index = map_and_merge_partitions(outer_pmap, outer_mmap,
+ o_index, inner_pmap,
+ inner_mmap, i_index,
+ &next_index);
+
+ if (merged_index < 0)
+ {
+ merged = false;
+ break;
+ }
+
+ /* Move to the next pair of bounds. */
+ cnto++;
+ cnti++;
+ }
+ else if (cmpval < 0)
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /* A datum missing from the inner side. */
+ merged_index = -1;
+ merged_datum = odatums;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+ merged = handle_missing_partition(inner_pmap, inner_mmap,
+ inner_default, outer_pmap,
+ outer_mmap, o_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index);
+
+ if (!merged)
+ break;
+
+ /* Move to the next datum on the outer side. */
+ Assert(!finished_outer);
+ cnto++;
+ }
+ else
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ Assert(cmpval > 0);
+
+ /* A datum missing from the outer side. */
+ merged_index = -1;
+ merged_datum = idatums;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+ merged = handle_missing_partition(outer_pmap, outer_mmap,
+ outer_default, inner_pmap,
+ inner_mmap, i_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index);
+
+ if (!merged)
+ break;
+
+ /* Move to the next datum on the right side. */
+ Assert(!finished_inner);
+ cnti++;
+ }
+
+ /*
+ * Add the list value with appropriate index in the list of datums, if
+ * we have associated a partition with this list value.
+ */
+ if (merged_index >= 0)
+ {
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ merged_datums = lappend(merged_datums, merged_datum);
+ }
+ }
+
+ if (merged)
+ merged = merge_null_partitions(outer_bi, outer_pmap, outer_mmap,
+ inner_bi, inner_pmap, inner_mmap,
+ jointype, &next_index, &null_index,
+ &default_index);
+
+ if (merged)
+ merged = merge_default_partitions(outer_bi, outer_pmap, outer_mmap,
+ inner_bi, inner_pmap, inner_mmap,
+ jointype, &next_index,
+ &default_index);
+
+ /* If successful build the output structures. */
+ if (merged)
+ {
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_mmap, outer_nparts, inner_mmap,
+ inner_nparts, jointype, next_index,
+ outer_parts, inner_parts);
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes, NIL,
+ null_index, default_index);
+ }
+ }
+
+ /* Free up all extra memory before returning from this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ pfree(outer_pmap);
+ pfree(inner_pmap);
+ pfree(outer_mmap);
+ pfree(inner_mmap);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_bounds_merge()'s arm for hash partitioned tables.
+ *
+ * If the given two hash bounds are same, the function returns the first one
+ * without any change, alongwith the lists of matching partitions. Otherwise it
+ * returns NULL.
+ *
+ * We could try merging the bounds when both the bounds have same greatest
+ * modulii. But there seems to be hardly any requirement for the same.
+ */
+static PartitionBoundInfo
+partition_hash_bounds_merge(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation, PartitionBoundInfo outer_bi,
+ int outer_nparts, PartitionBoundInfo inner_bi,
+ int inner_nparts, JoinType jointype,
+ List **outer_parts, List **inner_parts)
+{
+ int nparts;
+ int cnt;
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * Hash partitioned table does not have explicit NULL accepting partition
+ * and also does not have a default partition.
+ */
+ Assert(!partition_bound_has_default(outer_bi) &&
+ !partition_bound_has_default(inner_bi));
+ Assert(!partition_bound_accepts_nulls(outer_bi) &&
+ !partition_bound_accepts_nulls(inner_bi));
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+
+ if (outer_nparts != inner_nparts)
+ return NULL;
+ nparts = outer_nparts;
+
+ if (outer_bi->ndatums != inner_bi->ndatums ||
+ !partition_hbounds_equal(outer_bi, inner_bi))
+ return NULL;
+
+ /*
+ * Cook up list of matching partitions. Since bounds are exactly same the
+ * partitions at the same position from both the relations match.
+ */
+ for (cnt = 0; cnt < nparts; cnt++)
+ {
+ *outer_parts = lappend_int(*outer_parts, cnt);
+ *inner_parts = lappend_int(*inner_parts, cnt);
+ }
+
+ return outer_bi;
+}
+
+/*
+ * map_and_merge_partitions
+ *
+ * If the two given partitions (given by index1 and index2 resp.) are already
+ * mapped to each other return the index of corresponding partition in the
+ * merged set of partitions. If they do not have a merged partition associated
+ * with them, assign a new merged partition index. If the partitions are
+ * already mapped and their mapped partitions are different from each other,
+ * they can not be merged, so return -1.
+ *
+ * partmap1[i] gives the partition of relation 2 which matches ith partition of
+ * relation 1. Similarly for partmap2.
+ *
+ * mergemap1[i] gives the partition in the merged set to which ith partition of
+ * relation 1 maps to. Similarly for mergemap2.
+ *
+ * index1 and index2 are the indexes of matching partition from respective
+ * relations.
+ *
+ * *next_index is used and incremented when the given partitions require a new
+ * merged partition.
+ */
+static int
+map_and_merge_partitions(int *partmap1, int *mergemap1, int index1,
+ int *partmap2, int *mergemap2, int index2,
+ int *next_index)
+{
+ int merged_index;
+
+ /*
+ * If both the partitions are not mapped to each other, update the
+ * maps.
+ */
+ if (partmap1[index1] < 0 && partmap2[index2] < 0)
+ {
+ partmap1[index1] = index2;
+ partmap2[index2] = index1;
+ }
+
+ /*
+ * If the given to partitions map to each other, find the corresponding
+ * merged partition index .
+ */
+ if (partmap1[index1] == index2 && partmap2[index2] == index1)
+ {
+ /*
+ * If both the partitions are mapped to the same merged partition, get
+ * the index of merged partition.
+ */
+ if (mergemap1[index1] == mergemap2[index2])
+ {
+ merged_index = mergemap1[index1];
+
+ /*
+ * If the given two partitions do not have a merged partition
+ * associated with them, allocate a new merged partition.
+ */
+ if (merged_index < 0)
+ {
+ merged_index = *next_index;
+ *next_index = *next_index + 1;
+ mergemap1[index1] = merged_index;
+ mergemap2[index2] = merged_index;
+ }
+ }
+
+ /*
+ * If partition from one relation was mapped to a merged partition but
+ * not the partition from the other relation, map the same merged
+ * partition to the partition from other relation, since matching
+ * partitions map to the same merged partition.
+ */
+ else if (mergemap1[index1] >= 0 && mergemap2[index2] < 0)
+ {
+ mergemap2[index2] = mergemap1[index1];
+ merged_index = mergemap1[index1];
+ }
+ else if (mergemap1[index1] < 0 && mergemap2[index2] >= 0)
+ {
+ mergemap1[index1] = mergemap2[index2];
+ merged_index = mergemap2[index2];
+ }
+ else
+ {
+ Assert(mergemap1[index1] != mergemap2[index2] &&
+ mergemap1[index1] >= 0 && mergemap2[index2] >= 0);
+
+ /*
+ * Both the partitions map to different merged partitions. This
+ * means that multiple partitions from one relation matches to one
+ * partition from the other relation. Partition-wise join does not
+ * handle this case right now, since it requires ganging multiple
+ * partitions together (into one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+ }
+ else
+ {
+ /*
+ * Multiple partitions from one relation map to one partition from the
+ * other relation. Partition-wise join does not handle this case right
+ * now, since it requires ganging multiple partitions together (into
+ * one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+
+ return merged_index;
+}
+
+/*
+ * generate_matching_part_pairs
+ *
+ * mergemap1 and mergemap2 map each partition from either side of the join to a
+ * merged partition resp. E.g. mergemap1[i] gives the merged partition to which
+ * ith partition of first relation maps and mergemap2[j] gives the merged
+ * partition to which jth partition of second relation maps. If mergemap1[i] =
+ * mergemap2[j], i and j form the matching pair of partitions.
+ *
+ * Given these maps this function produces the list pairs of partitions which
+ * when joined produce the merged partitions in the order of merged partition
+ * indexes.
+ *
+ * nparts1 and nparts2 are the number of partitions of the joining relations
+ * resp.
+ *
+ * nparts is the number of merged partitions.
+ *
+ * If successful, the pairs of partitions are returned as two separate lists,
+ * parts1 and parts2 resp., one for each side. Otherwise, those lists will be
+ * set to NIL.
+ */
+static void
+generate_matching_part_pairs(int *mergemap1, int nparts1, int *mergemap2,
+ int nparts2, JoinType jointype, int nparts,
+ List **parts1, List **parts2)
+{
+ bool merged = true;
+ int **matching_parts;
+ int cnt1;
+ int cnt2;
+
+ matching_parts = (int **) palloc(sizeof(int *) * 2);
+ matching_parts[0] = (int *) palloc(sizeof(int) * nparts);
+ matching_parts[1] = (int *) palloc(sizeof(int) * nparts);
+
+ *parts1 = NIL;
+ *parts2 = NIL;
+
+ for (cnt1 = 0; cnt1 < nparts; cnt1++)
+ {
+ matching_parts[0][cnt1] = -1;
+ matching_parts[1][cnt1] = -1;
+ }
+
+ /* Set pairs of matching partitions. */
+ for (cnt1 = 0; cnt1 < nparts1; cnt1++)
+ {
+ if (mergemap1[cnt1] >= 0)
+ {
+ Assert(mergemap1[cnt1] < nparts);
+ matching_parts[0][mergemap1[cnt1]] = cnt1;
+ }
+ }
+ for (cnt2 = 0; cnt2 < nparts2; cnt2++)
+ {
+ if (mergemap2[cnt2] >= 0)
+ {
+ Assert(mergemap2[cnt2] < nparts);
+ matching_parts[1][mergemap2[cnt2]] = cnt2;
+ }
+ }
+
+ /*
+ * If we have a partition missing on an inner side, we need to add a dummy
+ * relation which joins with the outer partition. If the inner relation
+ * happens to be a base relation, it will require adding a dummy child
+ * base relation during join processing. Right now, we freeze the base
+ * relation arrays like PlannerInfo::simple_rte_array after planning for
+ * base relations. Adding a new (dummy) base relation would require some
+ * changes to that. So, right now, we do not implement partition-wise join
+ * in such cases.
+ */
+ for (cnt1 = 0; cnt1 < nparts; cnt1++)
+ {
+ int part1 = matching_parts[0][cnt1];
+ int part2 = matching_parts[1][cnt1];
+
+ /* At least one of the partitions should exist. */
+ Assert(part1 >= 0 || part2 >= 0);
+
+ switch (jointype)
+ {
+ case JOIN_INNER:
+ case JOIN_SEMI:
+
+ /*
+ * An inner or semi join can not return any row when the
+ * matching partition on either side is missing. We should
+ * have eliminated all such cases while merging the bounds.
+ */
+ Assert(part1 >= 0 && part2 >= 0);
+ break;
+
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ Assert(part1 >= 0);
+ if (part2 < 0)
+ merged = false;
+ break;
+
+ case JOIN_FULL:
+ if (part1 < 0 || part2 < 0)
+ merged = false;
+ break;
+
+ default:
+ elog(ERROR, "unrecognized join type: %d", (int) jointype);
+ }
+
+ if (!merged)
+ break;
+
+ *parts1 = lappend_int(*parts1, part1);
+ *parts2 = lappend_int(*parts2, part2);
+ }
+
+ pfree(matching_parts[0]);
+ pfree(matching_parts[1]);
+ pfree(matching_parts);
+
+ if (!merged)
+ {
+ list_free(*parts1);
+ list_free(*parts2);
+ *parts1 = NIL;
+ *parts2 = NIL;
+ }
+}
+
+static PartitionBoundInfo
+build_merged_partition_bounds(char strategy, List *merged_datums,
+ List *merged_indexes, List *merged_kinds,
+ int null_index, int default_index)
+{
+ int cnt;
+ PartitionBoundInfo merged_bounds;
+ ListCell *lc;
+
+ /* We expect the same number of elements in datums and indexes lists. */
+ Assert(list_length(merged_datums) == list_length(merged_indexes));
+
+ merged_bounds = (PartitionBoundInfo) palloc(sizeof(PartitionBoundInfoData));
+ merged_bounds->strategy = strategy;
+ merged_bounds->ndatums = list_length(merged_datums);
+
+ if (strategy == PARTITION_STRATEGY_RANGE)
+ {
+ Assert(list_length(merged_datums) == list_length(merged_kinds));
+ merged_bounds->kind =
+ (PartitionRangeDatumKind **) palloc(sizeof(PartitionRangeDatumKind *) *
+ list_length(merged_kinds));
+ cnt = 0;
+ foreach(lc, merged_kinds)
+ merged_bounds->kind[cnt++] = lfirst(lc);
+
+ /* There are ndatums+1 indexes in case of range partitions */
+ merged_indexes = lappend_int(merged_indexes, -1);
+ }
+ else
+ merged_bounds->kind = NULL;
+
+ cnt = 0;
+ merged_bounds->datums = (Datum **) palloc(sizeof(Datum *) *
+ list_length(merged_datums));
+ foreach(lc, merged_datums)
+ merged_bounds->datums[cnt++] = lfirst(lc);
+
+ merged_bounds->indexes = (int *) palloc(sizeof(int) *
+ list_length(merged_indexes));
+ cnt = 0;
+ foreach(lc, merged_indexes)
+ merged_bounds->indexes[cnt++] = lfirst_int(lc);
+
+ merged_bounds->null_index = null_index;
+ merged_bounds->default_index = default_index;
+
+ return merged_bounds;
+}
+
+/*
+ * Merge default partitions from both sides, if any, and assign the default
+ * partition for the join result, if necessary.
+ *
+ * If both the relations have default partitions, try mapping those to each
+ * other. If the mapping succeeds corresponding merged partition will act as
+ * the default partition of the join result.
+ *
+ * If inner side of the join has default but not the outer side, rows in it
+ * won't appear in the join result. So don't create a default partition. If
+ * outer side of the join has default but not the inner side, rows in it will
+ * appear in the join result, so create a default merged partition.
+ */
+static bool
+merge_default_partitions(PartitionBoundInfo outer_bi, int *outer_pmap,
+ int *outer_mmap, PartitionBoundInfo inner_bi,
+ int *inner_pmap, int *inner_mmap, JoinType jointype,
+ int *next_index, int *default_index)
+{
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool merged = true;
+
+ if (!outer_has_default && !inner_has_default)
+ Assert(*default_index < 0);
+ else if (outer_has_default && !inner_has_default)
+ {
+ if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (outer_mmap[outer_default] < 0)
+ {
+ outer_mmap[outer_default] = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = outer_mmap[outer_default];
+ }
+ else
+ Assert(*default_index == outer_mmap[outer_default]);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else if (!outer_has_default && inner_has_default)
+ {
+ if (jointype == JOIN_FULL)
+ {
+ if (inner_mmap[inner_default] < 0)
+ {
+ inner_mmap[inner_default] = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = inner_mmap[inner_default];
+ }
+ else
+ Assert(*default_index == inner_mmap[inner_default]);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else
+ {
+ Assert(outer_has_default && inner_has_default);
+
+ *default_index = map_and_merge_partitions(outer_pmap, outer_mmap,
+ outer_default, inner_pmap,
+ inner_mmap, inner_default,
+ next_index);
+
+ if (*default_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
+
+/*
+ * merge_null_partitions
+ *
+ * Merge NULL partitions, i.e. a partition that can hold NULL values for a list
+ * partitioned table, if any. Find the index of merged partition to which the
+ * NULL values would belong in the join result. If one joining relation has a
+ * NULL partition but not the other, try matching it with the default partition
+ * from the other relation since the default partition may have rows with NULL
+ * partition key. We can eliminate a NULL partition when it appears only on the
+ * inner side of the join and the outer side doesn't have a default partition.
+ *
+ * When the equality operator used for join is strict, two NULL values will not
+ * be considered as equal, and thus a NULL partition can be eliminated for an
+ * inner join. But we don't check the strictness operator here.
+ */
+static bool
+merge_null_partitions(PartitionBoundInfo outer_bi, int *outer_pmap,
+ int *outer_mmap, PartitionBoundInfo inner_bi,
+ int *inner_pmap, int *inner_mmap, JoinType jointype,
+ int *next_index, int *null_index, int *default_index)
+{
+ bool outer_has_null = partition_bound_accepts_nulls(outer_bi);
+ bool inner_has_null = partition_bound_accepts_nulls(inner_bi);
+ int outer_ni = outer_bi->null_index;
+ int inner_ni = inner_bi->null_index;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool merged = true;
+
+ if (!outer_has_null && !inner_has_null)
+ *null_index = -1;
+ else if (outer_has_null && !inner_has_null)
+ {
+ int merged_index;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+
+ merged = handle_missing_partition(inner_pmap, inner_mmap,
+ inner_default, outer_pmap,
+ outer_mmap, outer_ni,
+ missing_side_outer,
+ missing_side_inner, next_index,
+ default_index, &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join to which the outer null partition maps
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = outer_mmap[outer_ni];
+ }
+ else if (!outer_has_null && inner_has_null)
+ {
+ int merged_index;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as OUTER
+ * relation. For INNER and SEMI join OUTER and INNER differentiation is
+ * immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+ merged = handle_missing_partition(outer_pmap, outer_mmap,
+ outer_default, inner_pmap,
+ inner_mmap, inner_ni,
+ missing_side_outer,
+ missing_side_inner,
+ next_index, default_index,
+ &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join, to which the outer side null partition maps,
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = inner_mmap[inner_ni];
+ }
+ else
+ {
+ /* Both the relations have NULL partitions, try merging them. */
+ *null_index = map_and_merge_partitions(outer_pmap, outer_mmap,
+ outer_ni, inner_pmap,
+ inner_mmap, inner_ni,
+ next_index);
+ if (*null_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
diff --git a/src/include/partitioning/partbounds.h b/src/include/partitioning/partbounds.h
index 36fb584e23..5cc5697da7 100644
--- a/src/include/partitioning/partbounds.h
+++ b/src/include/partitioning/partbounds.h
@@ -107,5 +107,11 @@ extern int partition_range_datum_bsearch(FmgrInfo *partsupfunc,
int nvalues, Datum *values, bool *is_equal);
extern int partition_hash_bsearch(PartitionBoundInfo boundinfo,
int modulus, int remainder);
+extern PartitionBoundInfo partition_bounds_merge(int partnatts,
+ FmgrInfo *partsupfunc, Oid *partcollation,
+ PartitionBoundInfo outer_bi, int outer_nparts,
+ PartitionBoundInfo inner_bi, int inner_nparts,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts);
#endif /* PARTBOUNDS_H */
--
2.16.4
[application/octet-stream] 0004-Tests-for-0-1-1-1-and-1-0-partition-matching-v13.patch (220.4K, ../../CA+q6zcW_tdoZQUjuV34SkDSQhb8sfbzk6u3L9Qouf7Hdm3pgpg@mail.gmail.com/5-0004-Tests-for-0-1-1-1-and-1-0-partition-matching-v13.patch)
download | inline diff:
From c40ff3fd808166a6121be9980868d3b957d29ec5 Mon Sep 17 00:00:00 2001
From: erthalion <9erthalion6@gmail.com>
Date: Tue, 11 Sep 2018 21:11:55 +0200
Subject: [PATCH 4/5] Tests for 0:1, 1:1 and 1:0 partition matching
Rajkumar Raghuvanshi and Ashutosh Bapat.
---
src/test/regress/expected/partition_join.out | 4131 +++++++++++++++++++++-----
src/test/regress/sql/partition_join.sql | 427 ++-
2 files changed, 3855 insertions(+), 703 deletions(-)
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index c55de5d476..f19611c853 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -8,59 +8,86 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(21 rows)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
-(4 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+(7 rows)
-- left outer join, with whole-row reference; partitionwise join does not apply
EXPLAIN (COSTS OFF)
@@ -72,35 +99,50 @@ SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(22 rows)
SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- t1 | t2
---------------+--------------
- (0,0,0000) | (0,0,0000)
- (50,0,0050) |
- (100,0,0100) |
- (150,0,0150) | (0,150,0150)
- (200,0,0200) |
- (250,0,0250) |
- (300,0,0300) | (0,300,0300)
- (350,0,0350) |
- (400,0,0400) |
- (450,0,0450) | (0,450,0450)
- (500,0,0500) |
- (550,0,0550) |
-(12 rows)
+ t1 | t2
+----------------+----------------
+ (-250,0,-0250) |
+ (-200,0,-0200) |
+ (-150,0,-0150) | (0,-150,-0150)
+ (-100,0,-0100) |
+ (-50,0,-0050) |
+ (0,0,0000) | (0,0,0000)
+ (50,0,0050) |
+ (100,0,0100) |
+ (150,0,0150) | (0,150,0150)
+ (200,0,0200) |
+ (250,0,0250) |
+ (300,0,0300) | (0,300,0300)
+ (350,0,0350) |
+ (400,0,0400) |
+ (450,0,0450) | (0,450,0450)
+ (500,0,0500) |
+ (550,0,0550) |
+ (600,0,0600) | (0,600,0600)
+ (650,0,0650) |
+ (700,0,0700) |
+ (750,0,0750) | (0,750,0750)
+(21 rows)
-- right outer join
EXPLAIN (COSTS OFF)
@@ -112,35 +154,53 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHE
-> Append
-> Hash Right Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Right Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Hash Right Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-> Nested Loop Left Join
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p3 t2_3
Filter: (a = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t2_2.b)
-(20 rows)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
- | | 75 | 0075
- | | 225 | 0225
- | | 375 | 0375
- | | 525 | 0525
-(8 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+ | | -225 | -0225
+ | | -75 | -0075
+ | | 75 | 0075
+ | | 225 | 0225
+ | | 375 | 0375
+ | | 525 | 0525
+ | | 675 | 0675
+(14 rows)
-- full outer join, with placeholder vars
EXPLAIN (COSTS OFF)
@@ -148,8 +208,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
QUERY PLAN
------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b
+ Sort Key: prt1_p0.a, prt2_p0.b
-> Append
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ Filter: (((50) = prt1_p0.a) OR ((75) = prt2_p0.b))
+ -> Seq Scan on prt1_p0
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p1.a = prt2_p1.b)
Filter: (((50) = prt1_p1.a) OR ((75) = prt2_p1.b))
@@ -174,7 +242,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
-> Hash
-> Seq Scan on prt2_p3
Filter: (a = 0)
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ Filter: (((50) = prt1_p4.a) OR ((75) = prt2_p4.b))
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) WHERE t1.phv = t1.a OR t2.phv = t2.b ORDER BY t1.a, t2.b;
a | c | b | c
@@ -211,8 +287,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Hash Left Join
+ Hash Cond: (prt1_p0.a = b)
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Hash
+ -> Result
+ One-Time Filter: false
-> Hash Left Join
Hash Cond: (prt1_p1.a = b)
-> Seq Scan on prt1_p1
@@ -227,29 +310,42 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
-> Hash
-> Seq Scan on prt1_p2
Filter: ((a < 450) AND (b = 0))
-(17 rows)
+(24 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
-(9 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+(14 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
QUERY PLAN
------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = b)
+ Filter: ((prt1_p0.b = 0) OR (a = 0))
+ -> Seq Scan on prt1_p0
+ Filter: (a < 450)
+ -> Hash
+ -> Result
+ One-Time Filter: false
-> Hash Full Join
Hash Cond: (prt1_p1.a = b)
Filter: ((prt1_p1.b = 0) OR (a = 0))
@@ -274,64 +370,153 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JO
-> Hash
-> Result
One-Time Filter: false
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt2_p4.b = a)
+ Filter: ((b = 0) OR (prt2_p4.a = 0))
+ -> Seq Scan on prt2_p4
+ Filter: (b > 250)
+ -> Hash
+ -> Result
+ One-Time Filter: false
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
- | | 375 | 0375
- | | 450 | 0450
- | | 525 | 0525
-(12 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ | | 375 | 0375
+ | | 450 | 0450
+ | | 525 | 0525
+ | | 600 | 0600
+ | | 675 | 0675
+ | | 750 | 0750
+(20 rows)
-- Semi-join
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Semi Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Semi Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Nested Loop Semi Join
- Join Filter: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Materialize
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-(24 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(39 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p0 t2
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_2.b = t2_2.a)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p2 t2_2
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: (t1_3.b = t2_3.a)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt1_p3 t2_3
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.b = t2_4.a)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p4 t2_4
+ Filter: (b = 0)
+(37 rows)
+
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
@@ -342,27 +527,82 @@ SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS
-> Append
-> Hash Anti Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash Anti Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash Anti Join
Hash Cond: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p3 t2_2
-(17 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash Anti Join
+ Hash Cond: (t1_3.a = t2_3.b)
+ -> Seq Scan on prt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_3
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(27 rows)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
- sum | avg | sum | avg
--------+----------------------+------+---------------------
- 60000 | 300.0000000000000000 | 2400 | 12.0000000000000000
+ sum | avg | sum | avg
+-------+----------------------+------+--------------------
+ 95550 | 273.0000000000000000 | 2200 | 6.2857142857142857
(1 row)
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ QUERY PLAN
+--------------------------------------------------------------
+ Append
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Hash Anti Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(27 rows)
+
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ b | c
+------+-------
+ -225 | -0225
+ -75 | -0075
+ 75 | 0075
+ 225 | 0225
+ 375 | 0375
+ 525 | 0525
+ 675 | 0675
+(7 rows)
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -374,49 +614,74 @@ SELECT * FROM prt1 t1 LEFT JOIN LATERAL
Sort Key: t1.a
-> Append
-> Nested Loop Left Join
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p1_a on prt1_p1 t2
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
Index Cond: (a = t1.a)
- -> Index Scan using iprt2_p1_b on prt2_p1 t3
+ -> Index Scan using iprt2_p0_b on prt2_p0 t3
Index Cond: (b = t2.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_1
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
Index Cond: (a = t1_1.a)
- -> Index Scan using iprt2_p2_b on prt2_p2 t3_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t3_1
Index Cond: (b = t2_1.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_2
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
Index Cond: (a = t1_2.a)
- -> Index Scan using iprt2_p3_b on prt2_p3 t3_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t3_2
Index Cond: (b = t2_2.a)
-(27 rows)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.a)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t3_3
+ Index Cond: (b = t2_3.a)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.a)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t3_4
+ Index Cond: (b = t2_4.a)
+(43 rows)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, least(t1.a,t2.a,t3.b) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.a = ss.t2a WHERE t1.b = 0 ORDER BY t1.a;
- a | b | c | t2a | t3a | least
------+---+------+-----+-----+-------
- 0 | 0 | 0000 | 0 | 0 | 0
- 50 | 0 | 0050 | | |
- 100 | 0 | 0100 | | |
- 150 | 0 | 0150 | 150 | 0 | 150
- 200 | 0 | 0200 | | |
- 250 | 0 | 0250 | | |
- 300 | 0 | 0300 | 300 | 0 | 300
- 350 | 0 | 0350 | | |
- 400 | 0 | 0400 | | |
- 450 | 0 | 0450 | 450 | 0 | 450
- 500 | 0 | 0500 | | |
- 550 | 0 | 0550 | | |
-(12 rows)
+ a | b | c | t2a | t3a | least
+------+---+-------+------+-----+-------
+ -250 | 0 | -0250 | | |
+ -200 | 0 | -0200 | | |
+ -150 | 0 | -0150 | -150 | 0 | -150
+ -100 | 0 | -0100 | | |
+ -50 | 0 | -0050 | | |
+ 0 | 0 | 0000 | 0 | 0 | 0
+ 50 | 0 | 0050 | | |
+ 100 | 0 | 0100 | | |
+ 150 | 0 | 0150 | 150 | 0 | 150
+ 200 | 0 | 0200 | | |
+ 250 | 0 | 0250 | | |
+ 300 | 0 | 0300 | 300 | 0 | 300
+ 350 | 0 | 0350 | | |
+ 400 | 0 | 0400 | | |
+ 450 | 0 | 0450 | 450 | 0 | 450
+ 500 | 0 | 0500 | | |
+ 550 | 0 | 0550 | | |
+ 600 | 0 | 0600 | 600 | 0 | 600
+ 650 | 0 | 0650 | | |
+ 700 | 0 | 0700 | | |
+ 750 | 0 | 0750 | 750 | 0 | 750
+(21 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
@@ -430,64 +695,95 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
Hash Cond: ((t1.c)::text = (t2.c)::text)
Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Hash Join
Hash Cond: (t2.a = t3.b)
- -> Seq Scan on prt1_p1 t2
+ -> Seq Scan on prt1_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t3
+ -> Seq Scan on prt2_p0 t3
-> Hash Join
Hash Cond: (t2_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t2_1
+ -> Seq Scan on prt1_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p1 t3_1
-> Hash Join
Hash Cond: (t2_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p2 t2_2
-> Hash
- -> Seq Scan on prt2_p3 t3_2
-(26 rows)
+ -> Seq Scan on prt2_p2 t3_2
+ -> Hash Join
+ Hash Cond: (t2_3.a = t3_3.b)
+ -> Seq Scan on prt1_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t3_3
+ -> Hash Join
+ Hash Cond: (t2_4.a = t3_4.b)
+ -> Seq Scan on prt1_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t3_4
+(38 rows)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, t2.b t2b, t2.c t2c, least(t1.a,t2.a,t3.a) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.c = ss.t2c WHERE (t1.b + coalesce(ss.t2b, 0)) = 0 ORDER BY t1.a;
- a | t2a | t2c
------+-----+------
- 0 | 0 | 0000
- 50 | |
- 100 | |
- 150 | 150 | 0150
- 200 | |
- 250 | |
- 300 | 300 | 0300
- 350 | |
- 400 | |
- 450 | 450 | 0450
- 500 | |
- 550 | |
-(12 rows)
+ a | t2a | t2c
+------+------+-------
+ -250 | |
+ -200 | |
+ -150 | -150 | -0150
+ -100 | |
+ -50 | |
+ 0 | 0 | 0000
+ 50 | |
+ 100 | |
+ 150 | 150 | 0150
+ 200 | |
+ 250 | |
+ 300 | 300 | 0300
+ 350 | |
+ 400 | |
+ 450 | 450 | 0450
+ 500 | |
+ 550 | |
+ 600 | 600 | 0600
+ 650 | |
+ 700 | |
+ 750 | 750 | 0750
+(21 rows)
--
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
@@ -498,32 +794,49 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 =
-> Append
-> Hash Join
Hash Cond: (((t2.b + t2.a) / 2) = ((t1.a + t1.b) / 2))
- -> Seq Scan on prt2_e_p1 t2
+ -> Seq Scan on prt2_e_p0 t2
-> Hash
- -> Seq Scan on prt1_e_p1 t1
+ -> Seq Scan on prt1_e_p0 t1
Filter: (c = 0)
-> Hash Join
- Hash Cond: (((t2_1.b + t2_1.a) / 2) = ((t1_1.a + t1_1.b) / 2))
- -> Seq Scan on prt2_e_p2 t2_1
+ Hash Cond: (((t1_1.a + t1_1.b) / 2) = ((t2_1.b + t2_1.a) / 2))
+ -> Seq Scan on prt1_e_p1 t1_1
+ Filter: (c = 0)
-> Hash
- -> Seq Scan on prt1_e_p2 t1_1
- Filter: (c = 0)
+ -> Seq Scan on prt2_e_p1 t2_1
-> Hash Join
Hash Cond: (((t2_2.b + t2_2.a) / 2) = ((t1_2.a + t1_2.b) / 2))
- -> Seq Scan on prt2_e_p3 t2_2
+ -> Seq Scan on prt2_e_p2 t2_2
-> Hash
- -> Seq Scan on prt1_e_p3 t1_2
+ -> Seq Scan on prt1_e_p2 t1_2
Filter: (c = 0)
-(21 rows)
+ -> Hash Join
+ Hash Cond: (((t2_3.b + t2_3.a) / 2) = ((t1_3.a + t1_3.b) / 2))
+ -> Seq Scan on prt2_e_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t1_3
+ Filter: (c = 0)
+ -> Hash Join
+ Hash Cond: (((t2_4.b + t2_4.a) / 2) = ((t1_4.a + t1_4.b) / 2))
+ -> Seq Scan on prt2_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_4
+ Filter: (c = 0)
+(33 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 150 | 0 | 150 | 0
- 300 | 0 | 300 | 0
- 450 | 0 | 450 | 0
-(4 rows)
+ a | c | b | c
+------+---+------+---
+ -250 | 0 | -250 | 0
+ -100 | 0 | -100 | 0
+ 0 | 0 | 0 | 0
+ 0 | 0 | 0 | 0
+ 150 | 0 | 150 | 0
+ 300 | 0 | 300 | 0
+ 450 | 0 | 450 | 0
+ 600 | 0 | 600 | 0
+ 750 | 0 | 750 | 0
+(9 rows)
--
-- N-way join
@@ -536,154 +849,232 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = ((t3.a + t3.b) / 2))
+ Join Filter: (t1.a = t2.b)
-> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p1_ab2 on prt1_e_p1 t3
- Index Cond: (((a + b) / 2) = t2.b)
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
+ Index Cond: (b = ((t3.a + t3.b) / 2))
-> Nested Loop
Join Filter: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_1
+ -> Index Scan using iprt1_e_p4_ab2 on prt1_e_p1 t3_1
Index Cond: (((a + b) / 2) = t2_1.b)
-> Nested Loop
Join Filter: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_2
Index Cond: (((a + b) / 2) = t2_2.b)
-(33 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = ((t3_3.a + t3_3.b) / 2))
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (((a + b) / 2) = t2_3.b)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t2_4.b)
+ -> Hash Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (b = ((t3_4.a + t3_4.b) / 2))
+(52 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t3 WHERE t1.a = t2.b AND t1.a = (t3.a + t3.b)/2 AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
-(4 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(8 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
---------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Hash Right Join
Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_1.a + t3_1.b) / 2) = t1_1.a)
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
-> Hash
-> Hash Right Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_2.a + t3_2.b) / 2) = t1_2.a)
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
-> Hash
-> Hash Right Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(33 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (t1_3.a = ((a + b) / 2))
+ -> Hash Right Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(51 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
--------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1.a = ((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
Index Cond: (t1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t2_1
Index Cond: (t1_1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t2_2
Index Cond: (t1_2.a = b)
-(30 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t3_3.a + t3_3.b) / 2))
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Nested Loop Left Join
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = ((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (t1_4.a = b)
+(47 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- Cases with non-nullable expressions in subquery results;
-- make sure these go to null as expected
@@ -692,21 +1083,34 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
QUERY PLAN
----------------------------------------------------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b, ((prt1_e_p1.a + prt1_e_p1.b))
+ Sort Key: prt1_p0.a, prt2_p0.b, ((prt1_e_p0.a + prt1_e_p0.b))
-> Append
-> Hash Full Join
- Hash Cond: (prt1_p1.a = ((prt1_e_p1.a + prt1_e_p1.b) / 2))
- Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ Hash Cond: (prt1_p0.a = ((prt1_e_p0.a + prt1_e_p0.b) / 2))
+ Filter: ((prt1_p0.a = (50)) OR (prt2_p0.b = (75)) OR (((prt1_e_p0.a + prt1_e_p0.b) / 2) = (50)))
-> Hash Full Join
- Hash Cond: (prt1_p1.a = prt2_p1.b)
- -> Seq Scan on prt1_p1
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ -> Seq Scan on prt1_p0
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1
+ -> Seq Scan on prt2_p0
Filter: (a = 0)
-> Hash
- -> Seq Scan on prt1_e_p1
+ -> Seq Scan on prt1_e_p0
Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: (((prt1_e_p1.a + prt1_e_p1.b) / 2) = prt1_p1.a)
+ Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ -> Seq Scan on prt1_e_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Hash Full Join
+ Hash Cond: (prt1_p1.a = prt2_p1.b)
+ -> Seq Scan on prt1_p1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p2.a = ((prt1_e_p2.a + prt1_e_p2.b) / 2))
Filter: ((prt1_p2.a = (50)) OR (prt2_p2.b = (75)) OR (((prt1_e_p2.a + prt1_e_p2.b) / 2) = (50)))
@@ -733,7 +1137,20 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
-> Hash
-> Seq Scan on prt1_e_p3
Filter: (c = 0)
-(42 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = ((prt1_e_p4.a + prt1_e_p4.b) / 2))
+ Filter: ((prt1_p4.a = (50)) OR (prt2_p4.b = (75)) OR (((prt1_e_p4.a + prt1_e_p4.b) / 2) = (50)))
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_e_p4
+ Filter: (c = 0)
+(68 rows)
SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b)) FULL JOIN (SELECT 50 phv, * FROM prt1_e WHERE prt1_e.c = 0) t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.a = t1.phv OR t2.b = t2.phv OR (t3.a + t3.b)/2 = t3.phv ORDER BY t1.a, t2.b, t3.a + t3.b;
a | phv | b | phv | ?column? | phv
@@ -751,172 +1168,260 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHER
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = t1_3.b)
+ Join Filter: (t1.a = t1_5.b)
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Join
- Hash Cond: (((t2.a + t2.b) / 2) = t1_3.b)
- -> Seq Scan on prt1_e_p1 t2
+ Hash Cond: (((t2.a + t2.b) / 2) = t1_5.b)
+ -> Seq Scan on prt1_e_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t1_3
+ -> Seq Scan on prt2_p0 t1_5
Filter: (a = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
Index Cond: (a = ((t2.a + t2.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_1.a = t1_4.b)
+ Join Filter: (t1_1.a = t1_6.b)
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Join
- Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_4.b)
- -> Seq Scan on prt1_e_p2 t2_1
+ Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_6.b)
+ -> Seq Scan on prt1_e_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t1_4
+ -> Seq Scan on prt2_p1 t1_6
Filter: (a = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
Index Cond: (a = ((t2_1.a + t2_1.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_2.a = t1_5.b)
+ Join Filter: (t1_2.a = t1_7.b)
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Nested Loop
- -> Seq Scan on prt2_p3 t1_5
+ -> Seq Scan on prt2_p2 t1_7
Filter: (a = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_2
- Index Cond: (((a + b) / 2) = t1_5.b)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t2_2
+ Index Cond: (((a + b) / 2) = t1_7.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
Index Cond: (a = ((t2_2.a + t2_2.b) / 2))
Filter: (b = 0)
-(41 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = t1_8.b)
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t1_8
+ Filter: (a = 0)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_3
+ Index Cond: (((a + b) / 2) = t1_8.b)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t2_3.a + t2_3.b) / 2))
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t1_9.b)
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Join
+ Hash Cond: (((t2_4.a + t2_4.b) / 2) = t1_9.b)
+ -> Seq Scan on prt1_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t1_9
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = ((t2_4.a + t2_4.b) / 2))
+ Filter: (b = 0)
+(66 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHERE t1.a = 0 AND t1.b = (t2.a + t2.b)/2) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
--------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Nested Loop
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Semi Join
- Hash Cond: (t1_3.b = ((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt2_p1 t1_3
+ Hash Cond: (t1_5.b = ((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt2_p0 t1_5
-> Hash
- -> Seq Scan on prt1_e_p1 t1_6
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
- Index Cond: (a = t1_3.b)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t1_5.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Semi Join
- Hash Cond: (t1_4.b = ((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt2_p2 t1_4
+ Hash Cond: (t1_6.b = ((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt2_p1 t1_6
-> Hash
- -> Seq Scan on prt1_e_p2 t1_7
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
- Index Cond: (a = t1_4.b)
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
+ Index Cond: (a = t1_6.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Hash Semi Join
- Hash Cond: (t1_5.b = ((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt2_p3 t1_5
+ Hash Cond: (t1_7.b = ((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt2_p2 t1_7
-> Hash
- -> Seq Scan on prt1_e_p3 t1_8
+ -> Seq Scan on prt1_e_p2 t1_12
Filter: (c = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t1_5.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t1_7.b)
Filter: (b = 0)
-(39 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Hash Semi Join
+ Hash Cond: (t1_8.b = ((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt2_p3 t1_8
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t1_13
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t1_8.b)
+ Filter: (b = 0)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Semi Join
+ Hash Cond: (t1_9.b = ((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt2_p4 t1_9
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = t1_9.b)
+ Filter: (b = 0)
+(63 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
-- test merge joins
SET enable_hashjoin TO off;
SET enable_nestloop TO off;
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
-----------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------
Merge Append
Sort Key: t1.a
-> Merge Semi Join
- Merge Cond: (t1.a = t1_3.b)
+ Merge Cond: (t1.a = t1_5.b)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_3.b = (((t1_6.a + t1_6.b) / 2)))
+ Merge Cond: (t1_5.b = (((t1_10.a + t1_10.b) / 2)))
-> Sort
- Sort Key: t1_3.b
- -> Seq Scan on prt2_p1 t1_3
+ Sort Key: t1_5.b
+ -> Seq Scan on prt2_p0 t1_5
-> Sort
- Sort Key: (((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt1_e_p1 t1_6
+ Sort Key: (((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_1.a = t1_4.b)
+ Merge Cond: (t1_1.a = t1_6.b)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_4.b = (((t1_7.a + t1_7.b) / 2)))
+ Merge Cond: (t1_6.b = (((t1_11.a + t1_11.b) / 2)))
-> Sort
- Sort Key: t1_4.b
- -> Seq Scan on prt2_p2 t1_4
+ Sort Key: t1_6.b
+ -> Seq Scan on prt2_p1 t1_6
-> Sort
- Sort Key: (((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt1_e_p2 t1_7
+ Sort Key: (((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_2.a = t1_5.b)
+ Merge Cond: (t1_2.a = t1_7.b)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_5.b = (((t1_8.a + t1_8.b) / 2)))
+ Merge Cond: (t1_7.b = (((t1_12.a + t1_12.b) / 2)))
-> Sort
- Sort Key: t1_5.b
- -> Seq Scan on prt2_p3 t1_5
+ Sort Key: t1_7.b
+ -> Seq Scan on prt2_p2 t1_7
-> Sort
- Sort Key: (((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt1_e_p3 t1_8
+ Sort Key: (((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt1_e_p2 t1_12
Filter: (c = 0)
-(47 rows)
+ -> Merge Semi Join
+ Merge Cond: (t1_3.a = t1_8.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_8.b = (((t1_13.a + t1_13.b) / 2)))
+ -> Sort
+ Sort Key: t1_8.b
+ -> Seq Scan on prt2_p3 t1_8
+ -> Sort
+ Sort Key: (((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt1_e_p3 t1_13
+ Filter: (c = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_4.a = t1_9.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_9.b = (((t1_14.a + t1_14.b) / 2)))
+ -> Sort
+ Sort Key: t1_9.b
+ -> Seq Scan on prt2_p4 t1_9
+ -> Sort
+ Sort Key: (((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+(77 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
@@ -933,14 +1438,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3.a + t3.b) / 2)) = t1.a)
-> Sort
Sort Key: (((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Sort
Sort Key: t2.b
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Merge Left Join
Merge Cond: (t1_1.a = t2_1.b)
-> Sort
@@ -949,14 +1454,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_1.a + t3_1.b) / 2)) = t1_1.a)
-> Sort
Sort Key: (((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Sort
Sort Key: t2_1.b
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Merge Left Join
Merge Cond: (t1_2.a = t2_2.b)
-> Sort
@@ -965,32 +1470,74 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_2.a + t3_2.b) / 2)) = t1_2.a)
-> Sort
Sort Key: (((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Sort
Sort Key: t2_2.b
- -> Seq Scan on prt2_p3 t2_2
-(51 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Merge Left Join
+ Merge Cond: (t1_3.a = t2_3.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_3.a + t3_3.b) / 2)) = t1_3.a)
+ -> Sort
+ Sort Key: (((t3_3.a + t3_3.b) / 2))
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ -> Sort
+ Sort Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ -> Merge Left Join
+ Merge Cond: (t1_4.a = t2_4.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_4.a + t3_4.b) / 2)) = t1_4.a)
+ -> Sort
+ Sort Key: (((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ -> Sort
+ Sort Key: t2_4.b
+ -> Seq Scan on prt2_p4 t2_4
+(83 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- MergeAppend on nullable column
EXPLAIN (COSTS OFF)
@@ -998,8 +1545,18 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Merge Left Join
+ Merge Cond: (prt1_p0.a = b)
+ -> Sort
+ Sort Key: prt1_p0.a
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Sort
+ Sort Key: b
+ -> Result
+ One-Time Filter: false
-> Merge Left Join
Merge Cond: (prt1_p1.a = b)
-> Sort
@@ -1020,21 +1577,26 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
Sort Key: prt2_p2.b
-> Seq Scan on prt2_p2
Filter: (b > 250)
-(23 rows)
+(33 rows)
SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | b
------+-----
- 0 |
- 50 |
- 100 |
- 150 |
- 200 |
- 250 |
- 300 | 300
- 350 |
- 400 |
-(9 rows)
+ a | b
+------+-----
+ -250 |
+ -200 |
+ -150 |
+ -100 |
+ -50 |
+ 0 |
+ 50 |
+ 100 |
+ 150 |
+ 200 |
+ 250 |
+ 300 | 300
+ 350 |
+ 400 |
+(14 rows)
-- merge join when expression with whole-row reference needs to be sorted;
-- partitionwise join does not apply
@@ -1048,175 +1610,2412 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
Sort Key: t1.a, ((((t1.*)::prt1))::text)
-> Result
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Sort
Sort Key: t2.b, ((((t2.*)::prt2))::text)
-> Result
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
-(16 rows)
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+(20 rows)
SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.b ORDER BY t1.a;
- a | b
-----+----
- 0 | 0
- 6 | 6
- 12 | 12
- 18 | 18
- 24 | 24
-(5 rows)
+ a | b
+-----+-----
+ -24 | -24
+ -18 | -18
+ -12 | -12
+ -6 | -6
+ 0 | 0
+ 6 | 6
+ 12 | 12
+ 18 | 18
+ 24 | 24
+(9 rows)
RESET enable_hashjoin;
RESET enable_nestloop;
---
--- partitioned by multiple columns
---
-CREATE TABLE prt1_m (a int, b int, c int) PARTITION BY RANGE(a, ((a + b)/2));
-CREATE TABLE prt1_m_p1 PARTITION OF prt1_m FOR VALUES FROM (0, 0) TO (250, 250);
-CREATE TABLE prt1_m_p2 PARTITION OF prt1_m FOR VALUES FROM (250, 250) TO (500, 500);
-CREATE TABLE prt1_m_p3 PARTITION OF prt1_m FOR VALUES FROM (500, 500) TO (600, 600);
-INSERT INTO prt1_m SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
-ANALYZE prt1_m;
-CREATE TABLE prt2_m (a int, b int, c int) PARTITION BY RANGE(((b + a)/2), b);
-CREATE TABLE prt2_m_p1 PARTITION OF prt2_m FOR VALUES FROM (0, 0) TO (250, 250);
-CREATE TABLE prt2_m_p2 PARTITION OF prt2_m FOR VALUES FROM (250, 250) TO (500, 500);
-CREATE TABLE prt2_m_p3 PARTITION OF prt2_m FOR VALUES FROM (500, 500) TO (600, 600);
-INSERT INTO prt2_m SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
-ANALYZE prt2_m;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
- QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+ -> Seq Scan on prt2_p3 t2_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_4
+ Filter: (b = 0)
+(22 rows)
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p1 t2
+ -> Hash
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p2 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p3 t1_2
+ Filter: (b = 0)
+(21 rows)
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -150 | -0150 | 0 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 0 | 0150
+ 300 | 0300 | 0 | 0300
+ 450 | 0450 | 0 | 0450
+ 600 | 0600 | 0 | 0600
+ 750 | 0750 | 0 | 0750
+(7 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | 0 | -0150
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | 0 | 0000
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | 0 | 0150
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 0 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ 450 | 0450 | 0 | 0450
+ 500 | 0500 | |
+ 550 | 0550 | |
+ 600 | 0600 | 0 | 0600
+ 650 | 0650 | |
+ 700 | 0700 | |
+ 750 | 0750 | 0 | 0750
+(21 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Semi Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Append
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
+ Index Cond: (a = t1_1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(28 rows)
+
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Anti Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Anti Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -250 | 0 | -0250
+ -200 | 0 | -0200
+ -100 | 0 | -0100
+ -50 | 0 | -0050
+ 50 | 0 | 0050
+ 100 | 0 | 0100
+ 200 | 0 | 0200
+ 250 | 0 | 0250
+ 350 | 0 | 0350
+ 400 | 0 | 0400
+ 500 | 0 | 0500
+ 550 | 0 | 0550
+ 650 | 0 | 0650
+ 700 | 0 | 0700
+(14 rows)
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ QUERY PLAN
+---------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t3.c
+ -> Append
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t3
+ Index Cond: (a = t2.b)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t2.b)
+ -> Hash Right Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t3_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t3_2
+ Index Cond: (a = t2_2.b)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t2_2.b)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t3_3
+ Index Cond: (a = t2_3.b)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(47 rows)
+
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ a | a | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.b
+ -> Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(24 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: (t1.a = t2.b)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.a, 0)) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------
+ Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(22 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Join
+ Hash Cond: (t1.a = t2.b)
+ Join Filter: ((t1.b + t2.a) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+--
+-- partitioned by multiple columns
+--
+CREATE TABLE prt1_m (a int, b int, c int) PARTITION BY RANGE(a, ((a + b)/2));
+CREATE TABLE prt1_m_p1 PARTITION OF prt1_m FOR VALUES FROM (0, 0) TO (250, 250);
+CREATE TABLE prt1_m_p2 PARTITION OF prt1_m FOR VALUES FROM (250, 250) TO (500, 500);
+CREATE TABLE prt1_m_p3 PARTITION OF prt1_m FOR VALUES FROM (500, 500) TO (600, 600);
+INSERT INTO prt1_m SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+ANALYZE prt1_m;
+CREATE TABLE prt2_m (a int, b int, c int) PARTITION BY RANGE(((b + a)/2), b);
+CREATE TABLE prt2_m_p1 PARTITION OF prt2_m FOR VALUES FROM (0, 0) TO (250, 250);
+CREATE TABLE prt2_m_p2 PARTITION OF prt2_m FOR VALUES FROM (250, 250) TO (500, 500);
+CREATE TABLE prt2_m_p3 PARTITION OF prt2_m FOR VALUES FROM (500, 500) TO (600, 600);
+INSERT INTO prt2_m SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+ANALYZE prt2_m;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------
+ Sort
+ Sort Key: prt1_m_p1.a, prt2_m_p1.b
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p1.a = ((prt2_m_p1.b + prt2_m_p1.a) / 2)) AND (((prt1_m_p1.a + prt1_m_p1.b) / 2) = prt2_m_p1.b))
+ -> Seq Scan on prt1_m_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p1
+ Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p2.a = ((prt2_m_p2.b + prt2_m_p2.a) / 2)) AND (((prt1_m_p2.a + prt1_m_p2.b) / 2) = prt2_m_p2.b))
+ -> Seq Scan on prt1_m_p2
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p2
+ Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p3.a = ((prt2_m_p3.b + prt2_m_p3.a) / 2)) AND (((prt1_m_p3.a + prt1_m_p3.b) / 2) = prt2_m_p3.b))
+ -> Seq Scan on prt1_m_p3
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p3
+ Filter: (c = 0)
+(24 rows)
+
+SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
+ a | c | b | c
+-----+---+-----+---
+ 0 | 0 | 0 | 0
+ 50 | 0 | |
+ 100 | 0 | |
+ 150 | 0 | 150 | 0
+ 200 | 0 | |
+ 250 | 0 | |
+ 300 | 0 | 300 | 0
+ 350 | 0 | |
+ 400 | 0 | |
+ 450 | 0 | 450 | 0
+ 500 | 0 | |
+ 550 | 0 | |
+ | | 75 | 0
+ | | 225 | 0
+ | | 375 | 0
+ | | 525 | 0
+(16 rows)
+
+--
+-- tests for list partitioned tables.
+--
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 470 | 0 | 0011
+(1 row)
+
+--
+-- list partitioned by expression
+--
+CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
+ANALYZE plt1_e;
+-- test partition matching with N-way join
+EXPLAIN (COSTS OFF)
+SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Group Key: t1.c, t2.c, t3.c
+ -> Sort
+ Sort Key: t1.c, t3.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = ltrim(t3.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t2.b = t1.b) AND ((t2.c)::text = (t1.c)::text))
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt1_e_p4 t3
+ -> Hash Join
+ Hash Cond: ((t1_1.c)::text = ltrim(t3_1.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t1_1.b = t2_1.b) AND ((t1_1.c)::text = (t2_1.c)::text))
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_e_p1 t3_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = ltrim(t3_2.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t1_2.b = t2_2.b) AND ((t1_2.c)::text = (t2_2.c)::text))
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_e_p2 t3_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = ltrim(t3_3.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t2_3.b = t1_3.b) AND ((t2_3.c)::text = (t1_3.c)::text))
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt1_e_p3 t3_3
+(41 rows)
+
+SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+ avg | avg | avg | c | c | c
+----------------------+---------------------+----------------------+------+------+------
+ 246.5000000000000000 | 22.4666666666666667 | 268.9666666666666667 | 0000 | 0000 | 0000
+ 248.5000000000000000 | 21.3333333333333333 | 269.8333333333333333 | 0002 | 0002 | 0002
+ 249.5000000000000000 | 22.3333333333333333 | 271.8333333333333333 | 0003 | 0003 | 0003
+ 250.5000000000000000 | 23.3333333333333333 | 273.8333333333333333 | 0004 | 0004 | 0004
+ 251.5000000000000000 | 22.7666666666666667 | 274.2666666666666667 | 0005 | 0005 | 0005
+ 252.5000000000000000 | 22.2000000000000000 | 274.7000000000000000 | 0006 | 0006 | 0006
+ 246.0000000000000000 | 23.9655172413793103 | 269.9655172413793103 | 0008 | 0008 | 0008
+ 247.0000000000000000 | 23.3448275862068966 | 270.3448275862068966 | 0009 | 0009 | 0009
+(8 rows)
+
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 470 | 0011
+ | | 235 | 0014
+(8 rows)
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 235 | 0014
+ | | 470 | 0011
+(10 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 47 | 0 | 0013
+ 235 | 0 | 0014
+ 470 | 0 | 0011
+(3 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+----------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Materialize
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(20 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Materialize
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+---
+ 470 | 0 |
+(1 row)
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
Sort
- Sort Key: prt1_m_p1.a, prt2_m_p1.b
- -> Append
- -> Hash Full Join
- Hash Cond: ((prt1_m_p1.a = ((prt2_m_p1.b + prt2_m_p1.a) / 2)) AND (((prt1_m_p1.a + prt1_m_p1.b) / 2) = prt2_m_p1.b))
- -> Seq Scan on prt1_m_p1
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p1
- Filter: (c = 0)
- -> Hash Full Join
- Hash Cond: ((prt1_m_p2.a = ((prt2_m_p2.b + prt2_m_p2.a) / 2)) AND (((prt1_m_p2.a + prt1_m_p2.b) / 2) = prt2_m_p2.b))
- -> Seq Scan on prt1_m_p2
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p2
- Filter: (c = 0)
- -> Hash Full Join
- Hash Cond: ((prt1_m_p3.a = ((prt2_m_p3.b + prt2_m_p3.a) / 2)) AND (((prt1_m_p3.a + prt1_m_p3.b) / 2) = prt2_m_p3.b))
- -> Seq Scan on prt1_m_p3
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p3
- Filter: (c = 0)
-(24 rows)
+ Sort Key: t2.a
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
-SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 50 | 0 | |
- 100 | 0 | |
- 150 | 0 | 150 | 0
- 200 | 0 | |
- 250 | 0 | |
- 300 | 0 | 300 | 0
- 350 | 0 | |
- 400 | 0 | |
- 450 | 0 | 450 | 0
- 500 | 0 | |
- 550 | 0 | |
- | | 75 | 0
- | | 225 | 0
- | | 375 | 0
- | | 525 | 0
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
(16 rows)
---
--- tests for list partitioned tables.
---
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
---
--- list partitioned by expression
---
-CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1_e;
--- test partition matching with N-way join
+-- semi join
EXPLAIN (COSTS OFF)
-SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- QUERY PLAN
---------------------------------------------------------------------------------
- GroupAggregate
- Group Key: t1.c, t2.c, t3.c
- -> Sort
- Sort Key: t1.c, t3.c
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
-> Append
- -> Hash Join
- Hash Cond: (t1.c = ltrim(t3.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1.b = t2.b) AND (t1.c = t2.c))
- -> Seq Scan on plt1_p1 t1
- -> Hash
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_e_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.c = ltrim(t3_1.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1_1.b = t2_1.b) AND (t1_1.c = t2_1.c))
- -> Seq Scan on plt1_p2 t1_1
- -> Hash
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_e_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.c = ltrim(t3_2.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1_2.b = t2_2.b) AND (t1_2.c = t2_2.c))
- -> Seq Scan on plt1_p3 t1_2
- -> Hash
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_e_p3 t3_2
-(32 rows)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(22 rows)
-SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- avg | avg | avg | c | c | c
-----------------------+----------------------+-----------------------+------+------+-------
- 24.0000000000000000 | 24.0000000000000000 | 48.0000000000000000 | 0000 | 0000 | A0000
- 75.0000000000000000 | 75.0000000000000000 | 148.0000000000000000 | 0001 | 0001 | A0001
- 123.0000000000000000 | 123.0000000000000000 | 248.0000000000000000 | 0002 | 0002 | A0002
- 174.0000000000000000 | 174.0000000000000000 | 348.0000000000000000 | 0003 | 0003 | A0003
- 225.0000000000000000 | 225.0000000000000000 | 448.0000000000000000 | 0004 | 0004 | A0004
- 273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
- 324.0000000000000000 | 324.0000000000000000 | 648.0000000000000000 | 0006 | 0006 | A0006
- 375.0000000000000000 | 375.0000000000000000 | 748.0000000000000000 | 0007 | 0007 | A0007
- 423.0000000000000000 | 423.0000000000000000 | 848.0000000000000000 | 0008 | 0008 | A0008
- 474.0000000000000000 | 474.0000000000000000 | 948.0000000000000000 | 0009 | 0009 | A0009
- 525.0000000000000000 | 525.0000000000000000 | 1048.0000000000000000 | 0010 | 0010 | A0010
- 573.0000000000000000 | 573.0000000000000000 | 1148.0000000000000000 | 0011 | 0011 | A0011
-(12 rows)
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(22 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(19 rows)
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
@@ -1241,22 +4040,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
--------------------------------------------------
Hash Left Join
Hash Cond: (t2.b = a)
- -> Append
- -> Hash Join
- Hash Cond: (t3.a = t2.b)
- -> Seq Scan on prt1_p1 t3
- -> Hash
- -> Seq Scan on prt2_p1 t2
- -> Hash Join
- Hash Cond: (t3_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t3_1
- -> Hash
- -> Seq Scan on prt2_p2 t2_1
- -> Hash Join
- Hash Cond: (t3_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t3_2
- -> Hash
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash Join
+ Hash Cond: (t3.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t3
+ -> Seq Scan on prt1_p1 t3_1
+ -> Seq Scan on prt1_p2 t3_2
+ -> Seq Scan on prt1_p3 t3_3
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Result
One-Time Filter: false
@@ -1271,16 +4070,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
-> Hash Left Join
Hash Cond: (t2.b = a)
-> Append
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
Filter: (a = 0)
-> Hash
-> Result
One-Time Filter: false
-(14 rows)
+(20 rows)
--
-- tests for hash partitioned tables.
@@ -1356,41 +4161,9 @@ SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, ph
273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
(6 rows)
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
- Sort
- Sort Key: t1.a
- -> Append
- -> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
- -> Hash
- -> Seq Scan on prt1_p1 t1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
- -> Hash
- -> Seq Scan on prt1_p2 t1_1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
- -> Hash
- -> Seq Scan on prt1_p3 t1_2
- Filter: (b = 0)
-(21 rows)
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
@@ -1405,26 +4178,24 @@ SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c
Sort Key: t1.c
-> HashAggregate
Group Key: t1.c, t2.c
- -> Append
- -> Hash Join
- Hash Cond: (t2.c = t1.c)
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_p1 t1
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_1.c = t1_1.c)
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p1 t1_1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_2.c = t1_2.c)
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p2 t1_2
Filter: ((a % 25) = 0)
-(23 rows)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: ((a % 25) = 0)
+(21 rows)
--
-- multiple levels of partitioning
@@ -1826,64 +4597,70 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2 WHERE t1.a = t2.a;
Hash Join
Hash Cond: (t1.a = t2.a)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Seq Scan on prt4_n_p1 t2
-> Seq Scan on prt4_n_p2 t2_1
-> Seq Scan on prt4_n_p3 t2_2
-(11 rows)
+(13 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2, prt2 t3 WHERE t1.a = t2.a and t1.a = t3.b;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------
Hash Join
- Hash Cond: (t2.a = t1.a)
+ Hash Cond: (t3.b = t1.a)
-> Append
- -> Seq Scan on prt4_n_p1 t2
- -> Seq Scan on prt4_n_p2 t2_1
- -> Seq Scan on prt4_n_p3 t2_2
+ -> Seq Scan on prt2_p0 t3
+ -> Seq Scan on prt2_p1 t3_1
+ -> Seq Scan on prt2_p2 t3_2
+ -> Seq Scan on prt2_p3 t3_3
+ -> Seq Scan on prt2_p4 t3_4
+ -> Seq Scan on prt2_p5 t3_5
-> Hash
- -> Append
- -> Hash Join
- Hash Cond: (t1.a = t3.b)
- -> Seq Scan on prt1_p1 t1
- -> Hash
- -> Seq Scan on prt2_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t1_1
- -> Hash
- -> Seq Scan on prt2_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t1_2
- -> Hash
- -> Seq Scan on prt2_p3 t3_2
+ -> Hash Join
+ Hash Cond: (t1.a = t2.a)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt4_n_p1 t2
+ -> Seq Scan on prt4_n_p2 t2_1
+ -> Seq Scan on prt4_n_p3 t2_2
(23 rows)
-- partitionwise join can not be applied if there are no equi-join conditions
-- between partition keys
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON (t1.a < t2.b);
- QUERY PLAN
----------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------
Nested Loop Left Join
+ Join Filter: (t1.a < t2.b)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
- -> Append
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
- Index Cond: (t1.a < b)
-(12 rows)
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Materialize
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(16 rows)
-- equi-join with join condition on partial keys does not qualify for
-- partitionwise join
@@ -1969,16 +4746,17 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 JOIN prt2_n t2 ON (t1.c = t2.c) JOI
-> Seq Scan on prt2_n_p2 t2_1
-> Hash
-> Hash Join
- Hash Cond: (t3.c = (t1.c)::text)
+ Hash Cond: ((t3.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on plt1_p1 t3
- -> Seq Scan on plt1_p2 t3_1
- -> Seq Scan on plt1_p3 t3_2
+ -> Seq Scan on plt1_p4 t3
+ -> Seq Scan on plt1_p1 t3_1
+ -> Seq Scan on plt1_p2 t3_2
+ -> Seq Scan on plt1_p3 t3_3
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(16 rows)
+(17 rows)
-- partitionwise join can not be applied for a join between list and range
-- partitioned table
@@ -1989,14 +4767,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 FULL JOIN prt1 t2 ON (t1.c = t2.c);
Hash Full Join
Hash Cond: ((t2.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on prt1_p1 t2
- -> Seq Scan on prt1_p2 t2_1
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(10 rows)
+(12 rows)
-- partitionwise join can not be applied if only one of joining table has
-- default partition
@@ -2012,16 +4792,23 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b =
-> Hash Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
diff --git a/src/test/regress/sql/partition_join.sql b/src/test/regress/sql/partition_join.sql
index c1c9859651..0e884835fb 100644
--- a/src/test/regress/sql/partition_join.sql
+++ b/src/test/regress/sql/partition_join.sql
@@ -10,25 +10,39 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
@@ -67,11 +81,19 @@ EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -93,20 +115,30 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
@@ -169,6 +201,128 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
RESET enable_hashjoin;
RESET enable_nestloop;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
--
-- partitioned by multiple columns
--
@@ -193,28 +347,79 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1
--
-- tests for list partitioned tables.
--
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
--
-- list partitioned by expression
--
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
ANALYZE plt1_e;
-- test partition matching with N-way join
@@ -222,6 +427,175 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.a = 1 AND t1.a = 2;
@@ -267,27 +641,18 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
ALTER TABLE plt2 DETACH PARTITION plt2_p3;
ALTER TABLE plt2 ATTACH PARTITION plt2_p3 DEFAULT;
ANALYZE plt2;
-
EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.a % 25 = 0 GROUP BY t1.c, t2.c ORDER BY t1.c, t2.c;
+
--
-- multiple levels of partitioning
--
--
2.16.4
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
@ 2018-11-25 21:06 ` Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Thomas Munro @ 2018-11-25 21:06 UTC (permalink / raw)
To: Dmitry Dolgov <9erthalion6@gmail.com>; +Cc: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers; ashutosh.bapat.oss@gmail.com
On Mon, Nov 26, 2018 at 9:03 AM Dmitry Dolgov <9erthalion6@gmail.com> wrote:
> I've noticed, that this patch set is outdated, so here is the rebased version.
This turned red on cfbot because I turned on -Werror:
partbounds.c: In function ‘partition_bounds_merge’:
partbounds.c:3619:43: error: ‘outer_part’ may be used uninitialized in
this function [-Werror=maybe-uninitialized]
merged_index = map_and_merge_partitions(outer_pmap, outer_mmap,
^
partbounds.c:3475:6: note: ‘outer_part’ was declared here
int outer_part;
^
cc1: all warnings being treated as errors
--
Thomas Munro
http://www.enterprisedb.com
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
@ 2018-11-26 12:41 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Dmitry Dolgov @ 2018-11-26 12:41 UTC (permalink / raw)
To: Thomas Munro <thomas.munro@enterprisedb.com>; +Cc: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers; ashutosh.bapat.oss@gmail.com
> On Sun, Nov 25, 2018 at 10:07 PM Thomas Munro <thomas.munro@enterprisedb.com> wrote:
>
> This turned red on cfbot because I turned on -Werror:
>
> partbounds.c: In function ‘partition_bounds_merge’:
> partbounds.c:3619:43: error: ‘outer_part’ may be used uninitialized in
> this function [-Werror=maybe-uninitialized]
> merged_index = map_and_merge_partitions(outer_pmap, outer_mmap,
> ^
> partbounds.c:3475:6: note: ‘outer_part’ was declared here
> int outer_part;
> ^
> cc1: all warnings being treated as errors
Thanks, I've messed this up too - rebased a wrong branch, the correct one
doesn't have this code already. Sorry for that, and here is the proper version
of this patch.
Attachments:
[application/octet-stream] 0002-Targetlist-of-a-child-join-is-produced-by-translating-v14.patch (3.5K, ../../CA+q6zcUh5VoTvL5P5NRiN31V3FNFgwUaTjD=upmXLs5=gie2nQ@mail.gmail.com/2-0002-Targetlist-of-a-child-join-is-produced-by-translating-v14.patch)
download | inline diff:
From bd68b5832f5d0812767223a332eac26c1cf0513b Mon Sep 17 00:00:00 2001
From: erthalion <9erthalion6@gmail.com>
Date: Tue, 11 Sep 2018 21:09:44 +0200
Subject: [PATCH 2/5] Targetlist of a child-join is produced by translating
that of parent join
The next patch adds more general partition matching algorithm for
partition-wise join. With that change, the first pair of joining
relations for the parent joinrel may not produce a partition-wise join
because of the restrictions in partition_bounds_merge(), to be added
in the next patch. Hence the first pair of joining relations, which
is used to build the child join and presented to
build_child_join_rel(), for the child joinrel does not correspond to
the first pair of joining relations for the parent joinrel. The
targetlist built using different pairs have the targetlist entries
arranged in different order. An appendrel expects that all its
children have their targetlists ordered in the same fashion. Hence
translate the parent's targetlist so that parent and child joinrels
have their targetlists in sync.
Basic partition-wise join commit
f49842d1ee31b976c681322f76025d7732e860f3 modified
build_joinrel_tlist() to build targetlist for child-join. With the
above changes we don't need it anymore. Similarly, the same commit
added code to set_append_rel_size() to compute attr_needed for a
child-join relation. That change too is not needed with the above
change. This commit reverts those two changes.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/optimizer/util/relnode.c | 20 ++++++++++++++++++++
1 file changed, 20 insertions(+)
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 39f5729b91..2f1137c13d 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -802,6 +802,19 @@ build_child_join_rel(PlannerInfo *root, RelOptInfo *outer_rel,
appinfos = find_appinfos_by_relids(root, joinrel->relids, &nappinfos);
+ /*
+ * The first pair of joining relations for the parent joinrel may not
+ * produce a partition-wise join because of the restrictions in
+ * partition_bounds_merge(). Hence the first pair of joining relations,
+ * which is used to build the child join and presented here, for the child
+ * joinrel does not correspond to the first pair of joining relations for
+ * the parent joinrel. The targetlist built using different pairs have the
+ * targetlist nodes arranged in different order. An appendrel expects that
+ * all its children have their targetlists ordered in the same fashion.
+ * Hence translate the parent's targetlist so that parent and child
+ * joinrels have their targetlists in sync.
+ */
+ joinrel->reltarget = copy_pathtarget(parent_joinrel->reltarget);
/* Set up reltarget struct */
build_child_join_reltarget(root, parent_joinrel, joinrel,
nappinfos, appinfos);
@@ -907,6 +920,12 @@ build_joinrel_tlist(PlannerInfo *root, RelOptInfo *joinrel,
Relids relids = joinrel->relids;
ListCell *vars;
+ /*
+ * We only see parent joins. Targetlist of a child-join is computed by
+ * translating corresponding parent join's targetlist.
+ */
+ Assert(joinrel->reloptkind == RELOPT_JOINREL);
+
foreach(vars, input_rel->reltarget->exprs)
{
Var *var = (Var *) lfirst(vars);
@@ -934,6 +953,7 @@ build_joinrel_tlist(PlannerInfo *root, RelOptInfo *joinrel,
/* Is it still needed above this joinrel? */
ndx = var->varattno - baserel->min_attr;
+
if (bms_nonempty_difference(baserel->attr_needed[ndx], relids))
{
/* Yup, add it to the output */
--
2.16.4
[application/octet-stream] 0003-Partition-wise-join-for-1-1-1-0-0-1-partition-matching-v14.patch (69.5K, ../../CA+q6zcUh5VoTvL5P5NRiN31V3FNFgwUaTjD=upmXLs5=gie2nQ@mail.gmail.com/3-0003-Partition-wise-join-for-1-1-1-0-0-1-partition-matching-v14.patch)
download | inline diff:
From 7adc97a2c1849d85cdce9dac2047d27347396924 Mon Sep 17 00:00:00 2001
From: erthalion <9erthalion6@gmail.com>
Date: Tue, 11 Sep 2018 21:10:46 +0200
Subject: [PATCH 3/5] Partition-wise join for 1:1, 1:0, 0:1 partition matching.
Earlier version of partition-wise join implementation allowed
partition-wise join between two relations with exactly same partition
bounds. This commit allows partition-wise join to be applied under
following conditions
1. the partition bounds of joining relations are such that rows from
given partition on one side join can join with rows from maximum one
partition on the other side i.e. bounds of a given partition on one
side match/overlap with those of maximum one partition on the other
side. If the mapping happens to be m:n where m > 1 or n > 1, we have
to gang multiple partition relations together into a single relation.
This means that we have to add simple relations during join
processing, something which is not supported right now. ALso, in such
a case, different pairs of joining relations can produce different
partition bounds for the same join relation, which again is not
supported right now.
2. For every partition on outer side that can contribute to the result
of an OUTER join, there exists at least one (taken along with item 1,
it means exactly one) matching partition on the inner side. To
support partition-wise join when the inner matching partition doesn't
exist, we have to add a dummy base relation corresponding to the
non-existent inner partition. We don't have support to add base
relations during join processing.
3. For hash partitioned tables however, we support partition-wise join
only when the bounds exactly match. For hash partitioning it's unusual
to have missing partitions and hence generic partition matching is not
required.
With advanced partition matching, we won't be able to apply
partition-wise join when there are missing matching partitions. So for
a given N-way join, some sub-joins may not be partitioned, while the
overall N-way join is partitioned. We can not try partition-wise join
when one or both of the joining relations are not partitioned in one
of the pairs of joining relation. Skip partition-wise join for that
pair.
An example is A IJ B LJ C where B has an extra partition compared to A
and C. Join B LJ C requires dummy relation to join the extra partition
from B to a missing partition from C, and hence can not use
partition-wise join right now and hence BC is not partitioned. The
extra partition in B gets eliminated in A IJ B and thus it can use
partition-wise join and is partitioned. Hence (AB)C can use
partition-wise join but not A(BC).
Not every pair of joining relation (including the one presented to
build_joinrel_partition_info()) for the same joinrel can use
partition-wise join or has both the relations partitioned. Hence we
calculate the partition bounds for the join relation in
try_partition_wise_join() instead of doing it here.
The partition bounds produced for the first pair that can use
partition-wise are saved in the RelOptInfo of the joinrel. Partition
bounds produced for subsequent pairs should match that produced by the
first pair.
Support for default partition in list partitioned tables
========================================================
When a list value is present in one of the joining relations and not
the other, and the other relation has default partition, match (join)
the partition containing that list value with the default partition.
If there are multiple matches, we can not proceed with the
partition-wise join similar to the case of matching non-default
partition. If the default partition happens to be on the outer side of
the join, the resulting join partition acts as a default partition as
it will contain all the values from the default partition. If
the partition containing the list value happens to be on the outer
side of the join, the resulting join partition is associated with the
list value, since no other partition key value from the default
partition makes it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a partition from the inner side,
if inner side has a list value that is not present in the outer side.
But if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Support for matching default partition in range partitioned tables
==================================================================
When a range is present in one of the joining relations and not the
other, and the other relation has default partition, match (join) the
partition corresponding range with the default partition. If two
ranges overlap but their ranges don't match exactly, the
non-overlapping portion from one range may join the previous
(non-overlapping portion near the lower bound, if exists), next
(non-overlapping portion near the upper bound, if exists) ranges from
the other relation or default partition from the other relation. This
causes multiple partitions on the other side to be joined with a
single partition on the first side; a case we don't support. Any range
from one side which doesn't overlap with any range on the other side,
may find its join partner in the default partition and the
corresponding range partition will need to be joined with the default
partition. If the default partition happens to be on the outer side
of the join, the resulting join partition acts as a default partition
as it will contain all the values from the default partition. If the
non-partition corresponding to the range happens to be on the outer
side of the join, the resulting join partition is associated with that
range, since partition key values from the default partition outside
that range won't make it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a non-default partition from the
inner side, if inner side has a range missing in the outer side. But
if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/optimizer/path/joinrels.c | 95 +-
src/backend/optimizer/util/relnode.c | 33 +-
src/backend/partitioning/partbounds.c | 1676 ++++++++++++++++++++++++++++++++-
src/include/partitioning/partbounds.h | 5 +
4 files changed, 1763 insertions(+), 46 deletions(-)
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index d3d21fed5d..e476079143 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1312,25 +1312,31 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
RelOptInfo *joinrel, SpecialJoinInfo *parent_sjinfo,
List *parent_restrictlist)
{
- int nparts;
int cnt_parts;
+ PartitionScheme part_scheme;
+ PartitionBoundInfo join_boundinfo;
+ List *parts1;
+ List *parts2;
+ ListCell *lc1;
+ ListCell *lc2;
/* Guard against stack overflow due to overly deep partition hierarchy. */
check_stack_depth();
/* Nothing to do, if the join relation is not partitioned. */
- if (!IS_PARTITIONED_REL(joinrel))
+ if (joinrel->part_scheme == NULL)
return;
/* The join relation should have consider_partitionwise_join set. */
Assert(joinrel->consider_partitionwise_join);
/*
- * Since this join relation is partitioned, all the base relations
- * participating in this join must be partitioned and so are all the
- * intermediate join relations.
+ * We can not perform partition-wise join if either of the joining
+ * relations is not partitioned.
*/
- Assert(IS_PARTITIONED_REL(rel1) && IS_PARTITIONED_REL(rel2));
+ if (!IS_PARTITIONED_REL(rel1) || !IS_PARTITIONED_REL(rel2))
+ return;
+
Assert(REL_HAS_ALL_PART_PROPS(rel1) && REL_HAS_ALL_PART_PROPS(rel2));
/* The joining relations should have consider_partitionwise_join set. */
@@ -1343,32 +1349,63 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
*/
Assert(joinrel->part_scheme == rel1->part_scheme &&
joinrel->part_scheme == rel2->part_scheme);
+ part_scheme = joinrel->part_scheme;
/*
- * 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.
+ * Get the list of matching partitions to be joined along with the
+ * partition bounds of the join relation. Because of the restrictions
+ * imposed by partition matching algorithm, not every pair of joining
+ * relations for this join will be able to use partition-wise join. But all
+ * those pairs which can use partition-wise join will produce the same
+ * partition bounds for the join relation.
*/
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel1->boundinfo));
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel2->boundinfo));
+ join_boundinfo = partition_bounds_merge(part_scheme->partnatts,
+ part_scheme->partsupfunc,
+ part_scheme->partcollation,
+ rel1, rel2,
+ parent_sjinfo->jointype,
+ &parts1, &parts2);
+
+ if (join_boundinfo == NULL)
+ return;
- nparts = joinrel->nparts;
+ if (joinrel->boundinfo == NULL)
+ {
+ Assert(joinrel->nparts == 0 && joinrel->part_rels == NULL);
+ joinrel->boundinfo = join_boundinfo;
+ joinrel->nparts = list_length(parts1);
+ Assert(joinrel->nparts == list_length(parts2));
+ joinrel->part_rels =
+ (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+ joinrel->nparts);
+ }
+ else
+ {
+ Assert(partition_bounds_equal(part_scheme->partnatts,
+ part_scheme->parttyplen,
+ part_scheme->parttypbyval,
+ join_boundinfo, joinrel->boundinfo));
+ /*
+ * Every pair of joining relations should result in the same number
+ * of child-joins.
+ */
+ Assert(joinrel->nparts == list_length(parts1));
+ Assert(joinrel->nparts == list_length(parts2));
+ Assert(joinrel->part_rels);
+ }
/*
* Create child-join relations for this partitioned join, if those don't
* exist. Add paths to child-joins for a pair of child relations
* corresponding to the given pair of parent relations.
*/
- for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+ cnt_parts = 0;
+ forboth(lc1, parts1, lc2, parts2)
{
- RelOptInfo *child_rel1 = rel1->part_rels[cnt_parts];
- RelOptInfo *child_rel2 = rel2->part_rels[cnt_parts];
+ int part1 = lfirst_int(lc1);
+ int part2 = lfirst_int(lc2);
+ RelOptInfo *child_rel1;
+ RelOptInfo *child_rel2;
SpecialJoinInfo *child_sjinfo;
List *child_restrictlist;
RelOptInfo *child_joinrel;
@@ -1376,6 +1413,10 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
AppendRelInfo **appinfos;
int nappinfos;
+ Assert(part1 >= 0 && part2 >= 0);
+ child_rel1 = rel1->part_rels[part1];
+ child_rel2 = rel2->part_rels[part2];
+
/* We should never try to join two overlapping sets of rels. */
Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1409,12 +1450,24 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
joinrel->part_rels[cnt_parts] = child_joinrel;
}
+ /*
+ * For every pair of joining relations, the set of matching partitions
+ * would change. However, the base relation partitions constituting
+ * the given child should remain same for all the joining pairs. Since
+ * the order in which children are stored in the array of child-joins,
+ * depends upon partition bounds of the join, which are same for all
+ * the joining pairs, every joining pair yields the child-joins in the
+ * same order.
+ */
Assert(bms_equal(child_joinrel->relids, child_joinrelids));
populate_joinrel_with_paths(root, child_rel1, child_rel2,
child_joinrel, child_sjinfo,
child_restrictlist);
+ cnt_parts++;
}
+
+ Assert(cnt_parts == joinrel->nparts);
}
/*
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 2f1137c13d..4f15cd8e8b 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1627,7 +1627,7 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
* of the way the query planner deduces implied equalities and reorders
* the joins. Please see optimizer/README for details.
*/
- if (!IS_PARTITIONED_REL(outer_rel) || !IS_PARTITIONED_REL(inner_rel) ||
+ if (outer_rel->part_scheme == NULL || inner_rel->part_scheme == NULL ||
!outer_rel->consider_partitionwise_join ||
!inner_rel->consider_partitionwise_join ||
outer_rel->part_scheme != inner_rel->part_scheme ||
@@ -1640,24 +1640,6 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
part_scheme = outer_rel->part_scheme;
- Assert(REL_HAS_ALL_PART_PROPS(outer_rel) &&
- REL_HAS_ALL_PART_PROPS(inner_rel));
-
- /*
- * For now, our partition matching algorithm can match partitions only
- * when the partition bounds of the joining relations are exactly same.
- * So, bail out otherwise.
- */
- if (outer_rel->nparts != inner_rel->nparts ||
- !partition_bounds_equal(part_scheme->partnatts,
- part_scheme->parttyplen,
- part_scheme->parttypbyval,
- outer_rel->boundinfo, inner_rel->boundinfo))
- {
- Assert(!IS_PARTITIONED_REL(joinrel));
- return;
- }
-
/*
* This function will be called only once for each joinrel, hence it
* should not have partition scheme, partition bounds, partition key
@@ -1669,17 +1651,20 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
/*
* Join relation is partitioned using the same partitioning scheme as the
- * joining relations and has same bounds.
+ * joining relations.
+ *
+ * Because of restrictions in partition_bounds_merge(), not every pair of
+ * joining relations (including the one presented to this function) for the
+ * same joinrel can use partition-wise join or has both the relations
+ * partitioned. Hence we calculate the partition bounds, number of
+ * partitions and child-join relations of the join relation when and if we
+ * find a suitable pair in try_partition_wise_join().
*/
joinrel->part_scheme = part_scheme;
- joinrel->boundinfo = outer_rel->boundinfo;
partnatts = joinrel->part_scheme->partnatts;
joinrel->partexprs = (List **) palloc0(sizeof(List *) * partnatts);
joinrel->nullable_partexprs =
(List **) palloc0(sizeof(List *) * partnatts);
- joinrel->nparts = outer_rel->nparts;
- joinrel->part_rels =
- (RelOptInfo **) palloc0(sizeof(RelOptInfo *) * joinrel->nparts);
/*
* Set the consider_partitionwise_join flag.
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index 0af3372cdf..771520379d 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -65,6 +65,12 @@ typedef struct PartitionRangeBound
bool lower; /* this is the lower (vs upper) bound */
} PartitionRangeBound;
+typedef struct PartitionMap
+{
+ int from;
+ int to;
+} PartitionMap;
+
static int32 qsort_partition_hbound_cmp(const void *a, const void *b);
static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
void *arg);
@@ -106,7 +112,58 @@ static void get_range_key_properties(PartitionKey key, int keynum,
static List *get_range_nulltest(PartitionKey key);
static bool partition_hbounds_equal(PartitionBoundInfo b1,
PartitionBoundInfo b2);
-
+static PartitionBoundInfo partition_range_bounds_merge(
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype, int partnatts,
+ FmgrInfo *supfuncs, Oid *collations);
+static PartitionBoundInfo partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *collations,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype);
+static PartitionBoundInfo partition_hash_bounds_merge(RelOptInfo *outer_rel,
+ RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype);
+static void generate_matching_part_pairs(PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ int nparts1, int nparts2,
+ JoinType jointype, int nparts,
+ List **parts1, List **parts2);
+static PartitionBoundInfo build_merged_partition_bounds(char strategy,
+ List *merged_datums, List *merged_indexes,
+ List *merged_contents, int null_index,
+ int default_index);
+static int map_and_merge_partitions(PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ int index1, int index2, int *next_index);
+static int32 partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *collations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2);
+static bool partition_range_cmp(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval);
+static bool partition_range_merge_next_lb(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes);
+static bool merge_default_partitions(PartitionBoundInfo outer_bi,
+ PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ JoinType jointype,
+ int *next_index, int *default_index);
+static bool merge_null_partitions(PartitionBoundInfo outer_bi,
+ PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ JoinType jointype,
+ int *next_index, int *null_index,
+ int *default_index);
/*
* get_qual_from_partbound
@@ -2941,3 +2998,1620 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
PG_RETURN_BOOL(rowHash % modulus == remainder);
}
+
+/*
+ * partition_bounds_merge
+ *
+ * The function produces the partition bounds for a join between two relations
+ * whose partition bounds are given. The function also returns two lists of
+ * partition indexes one for each of the joining relations. Both the lists
+ * contain the same number of elements. The partition indexes at the same
+ * positions in the lists indicate the pair partitions, one from each side, to
+ * be joined and the position itself corresponds to the index of partition
+ * produced by that child-join in the partitioned join.
+ *
+ * The function returns NULL if we can not find the matching pair of
+ * partitions. This happens if 1. multiple partitions on one side match with
+ * one partition on the other side. 2. a given partition on the outer side
+ * doesn't have a matching partition on the inner side. We can not support the
+ * first case since we don't have a way to represent multiple partitions as a
+ * single relation (RelOptInfo) and then perform join using the ganged
+ * relation. We can not support the second case since the missing inner
+ * partition needs to be represented as an empty relation and we don't have a
+ * way to introduce empty relation during join planning after creating paths
+ * for all the base relations.
+ */
+extern PartitionBoundInfo
+partition_bounds_merge(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts)
+{
+ PartitionBoundInfo merged_bounds;
+ PartitionBoundInfo outer_binfo = outer_rel->boundinfo,
+ inner_binfo = inner_rel->boundinfo;
+ char strategy = outer_binfo->strategy;
+
+ /* Bail out if partitioning strategies are different. */
+ if (outer_binfo->strategy != inner_binfo->strategy)
+ return NULL;
+
+ if (jointype != JOIN_LEFT && jointype != JOIN_INNER &&
+ jointype != JOIN_SEMI && jointype != JOIN_ANTI &&
+ jointype != JOIN_FULL)
+ elog(ERROR, "unexpected join type %d", jointype);
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+ switch (strategy)
+ {
+ case PARTITION_STRATEGY_LIST:
+ merged_bounds = partition_list_bounds_merge(partsupfunc,
+ partcollation,
+ outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype);
+ break;
+
+ case PARTITION_STRATEGY_RANGE:
+ merged_bounds = partition_range_bounds_merge(outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype, partnatts,
+ partsupfunc,
+ partcollation);
+ break;
+
+ case PARTITION_STRATEGY_HASH:
+ merged_bounds = partition_hash_bounds_merge(outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype);
+ break;
+
+ default:
+ elog(ERROR, "unexpected partition strategy: %d", strategy);
+ }
+
+ Assert(merged_bounds || (*outer_parts == NIL && *inner_parts == NIL));
+
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+
+ Assert((*outer_parts == NIL || *inner_parts != NIL) &&
+ (*inner_parts == NIL || *outer_parts != NIL));
+
+ return merged_bounds;
+}
+
+/*
+ * partition_get_range_bounds
+ *
+ * Given the index of lower bound in datums array, return lower and upper
+ * bounds and the index of the partition with that lower bound.
+ */
+static int
+partition_get_range_bounds(PartitionBoundInfo bi, int lb_index,
+ PartitionRangeBound *lower,
+ PartitionRangeBound *upper)
+{
+ int part_index;
+
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The lower bound should correspond to a valid partition. */
+ part_index = bi->indexes[lb_index + 1];
+ Assert(part_index >= 0);
+
+ lower->kind = bi->kind[lb_index];
+ lower->datums = bi->datums[lb_index];
+ lower->lower = true;
+ upper->kind = bi->kind[lb_index + 1];
+ upper->datums = bi->datums[lb_index + 1];
+ upper->lower = false;
+
+ return part_index;
+}
+
+/*
+ * partition_range_get_next_lb_index
+ *
+ * Given the index of lower bound in datums array return the
+ * index of lower bound of the next partition. When the given index corresponds
+ * to the last partition, return number of datums (ndatums).
+ */
+static int
+partition_range_get_next_lb_index(PartitionBoundInfo bi, int lb_index)
+{
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The partition index corresponding to the upper bound should be valid. */
+ Assert(bi->indexes[lb_index + 1] >= 0);
+
+ /*
+ * If there are no bounds left beyond the upper bound, we have reached the
+ * last partition.
+ */
+ if (lb_index + 2 < bi->ndatums)
+ {
+ /*
+ * If the bound next to the upper bound corresponds to no partition,
+ * that's the next lower bound of the next partition. Otherwise, the
+ * current upper bound is the lower bound of the next partition.
+ */
+ if (bi->indexes[lb_index + 2] < 0)
+ return lb_index + 2;
+ else
+ return lb_index + 1;
+ }
+ else
+ return bi->ndatums;
+}
+
+static int32
+partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2)
+{
+ return partition_rbound_cmp(partnatts, partsupfunc, partcollations,
+ bound1->datums, bound1->kind, bound1->lower,
+ bound2);
+}
+
+/*
+ * partition_range_cmp
+ *
+ * Compare the bounds of two range partitions. Set ub_cmpval <, = or > 0, if the
+ * first partition's upper bound is lower than, equal to or higher than the
+ * second partition's upper bound resp. Similarly set lb_cmpval <, = or > 0,
+ * if the first partition's lower bound is lower than, equal to or higher than
+ * the second partition's lower bound resp.
+ *
+ * Return true, if the ranges overlap, otherwise return false.
+ */
+static bool
+partition_range_cmp(int partnatts, FmgrInfo *partsupfuncs, Oid *partcollations,
+ PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval)
+{
+ bool overlap;
+
+ /*
+ * Compare upper bound of the first partition with the lower bound of the
+ * second and vice-versa. If lower bound is higher than the upper bound,
+ * the partitions are not overlapping. All other cases indicate overlapping
+ * partitions.
+ */
+ if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound1, upper_bound2) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = 1;
+ *lb_cmpval = 1;
+ }
+ else if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound2, upper_bound1) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = -1;
+ *lb_cmpval = -1;
+ }
+ else
+ {
+ overlap = true;
+ *ub_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, upper_bound1,
+ upper_bound2);
+ *lb_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, lower_bound1,
+ lower_bound2);
+ }
+
+ return overlap;
+}
+
+/*
+ * partition_range_merge
+ *
+ * Merge the partition bounds of given two partitions such that the join
+ * between the given two partitions fits merged bounds.
+ *
+ * "merged_upper" will be set to one of the given upper bounds and
+ * "merged_lower" will be set to one of the given lower bounds.
+ */
+static void
+partition_range_merge(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, JoinType jointype,
+ PartitionRangeBound *left_lb,
+ PartitionRangeBound *left_ub,
+ PartitionRangeBound *right_lb,
+ PartitionRangeBound *right_ub,
+ PartitionRangeBound **merged_lb,
+ PartitionRangeBound **merged_ub)
+{
+ /*
+ * An outer join will have all the rows from the outer side, so merged
+ * bounds will be same as the outer bounds. An inner join will have rows
+ * that fit both the bounds, thus lower merged bound will be higher of two
+ * lower bounds and upper merged bound will be lower of the two upper
+ * bounds.
+ */
+ switch (jointype)
+ {
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ *merged_ub = left_ub;
+ *merged_lb = left_lb;
+ break;
+
+ case JOIN_INNER:
+ case JOIN_SEMI:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) < 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) > 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ case JOIN_FULL:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) > 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) < 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ default:
+ elog(ERROR, "unexpected join type %d", jointype);
+ }
+
+ return;
+}
+
+/*
+ * Add the lower bound of the next range to the list of bounds, if the lower
+ * bound is higher or equal to the previous upper bound. If successful return
+ * true, otherwise false.
+ */
+static bool
+partition_range_merge_next_lb(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes)
+{
+ int cmpval;
+
+ if (!*merged_datums)
+ {
+ Assert(!*merged_kinds && !*merged_indexes);
+ cmpval = 1;
+ }
+ else
+ {
+ PartitionRangeBound prev_ub;
+
+ prev_ub.datums = llast(*merged_datums);
+ prev_ub.kind = llast(*merged_kinds);
+ prev_ub.lower = false;
+
+ cmpval = partition_rbound_cmp(partnatts, partsupfuncs, partcollations,
+ next_lb_datums, next_lb_kind, false,
+ &prev_ub);
+ }
+
+ /*
+ * The lower bound is lower than the last upper bound, thus does not fit
+ * the bounds created so far and hence can not be merged with the existing
+ * bounds.
+ */
+ if (cmpval < 0)
+ return false;
+
+ /*
+ * Add bounds of the new merged partition. If the next lower bound is
+ * higher than the last upper bound, add new range with index
+ * corresponding to the lower bound as -1. If the merged lower bound
+ * is same as the last merged upper bound, the last upper bound will be
+ * reused as the lower bound of the next range.
+ */
+ if (cmpval > 0)
+ {
+ *merged_datums = lappend(*merged_datums, next_lb_datums);
+ *merged_kinds = lappend(*merged_kinds, next_lb_kind);
+ *merged_indexes = lappend_int(*merged_indexes, -1);
+ }
+
+ return true;
+}
+
+/*
+ * handle_missing_partition
+ *
+ * If a range appears in one of the joining relations but not the other, a row
+ * in the corresponding partition will not have any join partner in the other
+ * relation, unless the other relation has a default partition. If a given list
+ * value is present in one joining relation but not the other, the default
+ * partition on the other side may contain that value.
+ *
+ * In both these cases, such an extra partition forms a joining pair with the
+ * default partition, if any, on the other side.
+ *
+ * If the default partition happens to be on the outer side of the join, the
+ * resultant partition will act as the default partition of the join relation.
+ * Otherwise the resultant partition will be associated with the range.
+ *
+ * When the default partition is not present in the other relation, the rows in
+ * the extra partition will be included in the bounds of the join result, if it
+ * appears on the outer side of the join, since all rows from the outer side
+ * are included in the join result.
+ *
+ * This function handles all these cases.
+ *
+ * maps_with_missing and missing_side_default are the partition maps (See
+ * partition_range/list_bounds_merge() for details) and the index of default
+ * partition respectively corresponding the side with missing partition.
+ *
+ * maps_with_extra and extra_part are the partition maps (See
+ * partition_range/list_bounds_merge() for details) and the index of extra
+ * partition respectively corresponding to the side with the extra partition.
+ *
+ * It returns true if the matching succeeds, otherwise returns false.
+ */
+static bool
+handle_missing_partition(PartitionMap *maps_with_missing,
+ PartitionMap *maps_with_extra,
+ int missing_side_default,
+ int extra_part,
+ bool missing_side_outer,
+ bool missing_side_inner,
+ int *next_index, int *default_index,
+ int *merged_index)
+{
+ bool missing_has_default = (missing_side_default != -1);
+
+ if (missing_has_default)
+ {
+ *merged_index = map_and_merge_partitions(maps_with_missing,
+ maps_with_extra,
+ missing_side_default,
+ extra_part,
+ next_index);
+ if (*merged_index < 0)
+ return false;
+
+ if (missing_side_outer)
+ {
+ /*
+ * Default partition on the outer side forms the default
+ * partition of the join result.
+ */
+ if (*default_index < 0)
+ *default_index = *merged_index;
+ else if(*default_index != *merged_index)
+ {
+ /*
+ * Ended up with default partition on the outer side
+ * being joined with multiple partitions on the inner
+ * side. We don't support this case.
+ */
+ return false;
+ }
+
+ /*
+ * Since the merged partition acts as a default partition, it
+ * doesn't need a separate index.
+ */
+ *merged_index = -1;
+ }
+ }
+ else if (missing_side_inner)
+ {
+ /*
+ * If this partition has already been mapped (say because we
+ * found an overlapping range earlier), we know where does it
+ * fit in the join result. Nothing to do in that case. Else
+ * create a new merged partition.
+ */
+ PartitionMap *extra_map = &maps_with_extra[extra_part];
+ if (extra_map->to < 0)
+ {
+ extra_map->to = *next_index;
+ *next_index = *next_index + 1;
+ *merged_index = extra_map->to;
+ }
+ }
+
+ return true;
+}
+
+static PartitionMap*
+init_partition_map(RelOptInfo *rel)
+{
+ int i, nparts = rel->nparts;
+ PartitionMap *map;
+
+ map = (PartitionMap *) palloc(sizeof(PartitionMap) * nparts);
+
+ for (i = 0; i < nparts; i++)
+ {
+ map[i].from = -1;
+ map[i].to = -1;
+ }
+
+ return map;
+}
+
+/*
+ * Allocate and initialize partition maps. We maintain four maps, two maps
+ * for each joining relation. pmap[i] gives the partition from the other
+ * relation which would join with ith partition of the given relation.
+ * Partition i from the given relation will join with partition pmap[i]
+ * from the other relation to produce partition mmap[i] of the join (merged
+ * partition).
+ *
+ * pmap[i] = -1 indicates that ith partition of a given relation does not
+ * have a matching partition from the other relation.
+ *
+ * mmap[i] = -1 indicates that ith partition of a given relation does not
+ * contribute to the join result. That can happen only when the given
+ * relation is the inner relation and it doesn't have a matching partition
+ * from the outer relation, hence pmap[i] should be -1.
+ *
+ * In case of an outer join, every partition of the outer join will appear
+ * in the join result, and thus has mmap[i] set for all i. But it's not
+ * necessary that every partition on the outer side will have a matching
+ * partition on the inner side. In such a case, we end up with pmap[i] = -1
+ * and mmap[i] != -1.
+ */
+
+/*
+ * partition_range_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for range partitioned tables.
+ */
+static PartitionBoundInfo
+partition_range_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype, int partnatts,
+ FmgrInfo *partsupfuncs, Oid *partcollations)
+
+{
+ PartitionMap *outer_maps = NULL;
+ PartitionMap *inner_maps = NULL;
+ int outer_part = 0;
+ int inner_part = 0;
+ PartitionBoundInfo merged_bounds = NULL;
+ int outer_lb_index;
+ int inner_lb_index;
+ int next_index;
+ int default_index = -1;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ List *merged_kinds = NIL;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int inner_default = inner_bi->default_index;
+ int outer_default = outer_bi->default_index;
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_RANGE);
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ outer_maps = init_partition_map(outer_rel);
+ inner_maps = init_partition_map(inner_rel);
+
+ /*
+ * Merge the ranges (partitions) from both sides. Every iteration compares
+ * a pair of ranges, one from each side, advancing to the next range from
+ * the side with smaller upper range bound. If upper bounds of ranges from
+ * both sides match exactly, both the sides are advanced. For a given pair
+ * of ranges, we decide whether the corresponding partition match or not.
+ * lb_index, for inner or outer side, keeps track of the index of lower bound
+ * datum in PartitionBoundInfo::datums of that side.
+ */
+ outer_lb_index = 0;
+ inner_lb_index = 0;
+ next_index = 0;
+ while (outer_lb_index < outer_bi->ndatums ||
+ inner_lb_index < inner_bi->ndatums)
+ {
+ PartitionRangeBound outer_lb, outer_ub,
+ inner_lb, inner_ub,
+ *merged_lb = NULL,
+ *merged_ub = NULL;
+
+ int merged_index = -1;
+ bool overlap;
+ bool finished_outer = false;
+ bool finished_inner = false;
+
+ /* Result of bounds comparison per partition_rbound_cmp(). */
+ int ub_cmpval; /* Upper bounds comparison result. */
+ int lb_cmpval; /* Lower bounds comparison result. */
+
+ /* Get the range bounds of the next pair of partitions. */
+ if (outer_lb_index < outer_bi->ndatums)
+ outer_part = partition_get_range_bounds(outer_bi, outer_lb_index,
+ &outer_lb, &outer_ub);
+ else
+ finished_outer = true;
+
+ if (inner_lb_index < inner_bi->ndatums)
+ inner_part = partition_get_range_bounds(inner_bi, inner_lb_index,
+ &inner_lb, &inner_ub);
+ else
+ finished_inner = true;
+
+ Assert(!finished_outer || !finished_inner);
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining partitions on the side
+ * which finishes later. For that we set the comparison parameters
+ * overlap, ub_cmpval and lb_cmpval in such a way that it appears as if
+ * the side which finishes earlier has an extra partition with lower
+ * and upper bounds higher than any other partition of the unfinished
+ * side. That way we advance the partitions on that side till all of
+ * them are exhausted.
+ */
+ if (finished_outer)
+ {
+ overlap = false;
+ ub_cmpval = 1;
+ lb_cmpval = 1;
+ }
+ else if (finished_inner)
+ {
+ overlap = false;
+ ub_cmpval = -1;
+ lb_cmpval = -1;
+ }
+ else
+ overlap = partition_range_cmp(partnatts, partsupfuncs, partcollations,
+ &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &ub_cmpval, &lb_cmpval);
+
+ if (overlap)
+ {
+ /*
+ * The rows from overlapping portion of ranges on both sides may
+ * join, hence the corresponding pair of partitions form a joining
+ * pair. Match them and produce the bounds of the joint partition
+ * and its index by merging the bounds according to the type of
+ * join.
+ */
+ partition_range_merge(partnatts, partsupfuncs, partcollations,
+ jointype, &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &merged_lb, &merged_ub);
+
+ merged_index = map_and_merge_partitions(outer_maps, inner_maps,
+ outer_part, inner_part,
+ &next_index);
+
+ if (merged_index < 0)
+ {
+ /* Failed to match the partitions. */
+ return NULL;
+ }
+
+ /*
+ * If the ranges overlap but don't exactly match, a row from
+ * non-overlapping portion of the range from one side of join may
+ * find its join partner in the previous or next overlapping
+ * partition or default partition on the other side , if such a
+ * partition exists. All those cases, if true, will cause one
+ * partition from that side to match at least two partitions on the
+ * other side; a case that we do not support now. Previous
+ * partition has been delt with in the previous iteration of this
+ * loop, next partition will be delt in the next iteration. We will
+ * deal with the default partition here.
+ */
+ if ((lb_cmpval < 0 && inner_has_default) ||
+ /* Non-overlapping range on the lower side of outer range. */
+ (lb_cmpval > 0 && outer_has_default) ||
+ /* Non-overlapping range on the lower side of inner range. */
+ (ub_cmpval < 0 && outer_has_default) ||
+ /* Non-overlapping range on the upper side of inner range. */
+ (ub_cmpval > 0 && inner_has_default))
+ /* Non-overlapping range on the upper side of outer range. */
+ return NULL;
+ }
+
+ if (ub_cmpval == 0)
+ {
+ /* Upper bounds of both the ranges match. */
+ Assert(overlap);
+
+ /* Move to the next pair of partitions. */
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+ else if (ub_cmpval < 0)
+ {
+ /* Upper bound of inner range higher than that of the outer. */
+
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the inner side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &outer_lb;
+ merged_ub = &outer_ub;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+ if (!handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ outer_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+ }
+
+ /* Move to the next partition on the outer side. */
+ Assert(!finished_outer);
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ }
+ else
+ {
+ Assert(ub_cmpval > 0);
+
+ /* Upper bound of outer range higher than that of the inner. */
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the outer side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &inner_lb;
+ merged_ub = &inner_ub;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ inner_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+ }
+
+ /* Move to the next partition on the inner side. */
+ Assert (!finished_inner);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+
+ if (merged_index < 0)
+ {
+ /* We didn't find a new merged partition. */
+ continue;
+ }
+
+ /*
+ * We have a valid partition index for the next partition of join. The
+ * partition should have valid range.
+ */
+ Assert(merged_lb && merged_ub);
+
+ /* Try merging new lower bound with the last upper bound. */
+ if (!partition_range_merge_next_lb(partnatts, partsupfuncs,
+ partcollations,
+ merged_lb->datums,
+ merged_lb->kind, &merged_datums,
+ &merged_kinds, &merged_indexes))
+ return NULL;
+
+ /* Add upper bound with the merged partition index. */
+ merged_datums = lappend(merged_datums, merged_ub->datums);
+ merged_kinds = lappend(merged_kinds, merged_ub->kind);
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ }
+
+ if (!merge_default_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index,
+ &default_index))
+ return NULL;
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_maps, inner_maps,
+ outer_nparts, inner_nparts,
+ jointype, next_index,
+ outer_parts, inner_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes,
+ merged_kinds,
+ -1, default_index);
+ }
+
+ /* Free any memory we used in this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ list_free(merged_kinds);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_list_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for list partitioned tables.
+ *
+ */
+static PartitionBoundInfo
+partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype)
+{
+ PartitionMap *outer_maps = NULL;
+ PartitionMap *inner_maps = NULL;
+ int cnto;
+ int cnti;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ int next_index = 0;
+ int null_index;
+ int default_index = -1;
+ PartitionBoundInfo merged_bounds = NULL;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int *outer_indexes = outer_bi->indexes;
+ int *inner_indexes = inner_bi->indexes;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_LIST);
+
+ /* List partitions do not require unbounded ranges. */
+ Assert(!outer_bi->kind && !inner_bi->kind);
+
+ outer_maps = init_partition_map(outer_rel);
+ inner_maps = init_partition_map(inner_rel);
+
+ /*
+ * Merge the list value datums from both sides. Every iteration compares a
+ * pair of datums, one from each side, advancing to the next datum from the
+ * side with smaller datum. If datums from both sides match exactly, both
+ * the sides are advanced. For a given pair of datums, we decide whether
+ * the corresponding partition match or not.
+ */
+ cnto = cnti = 0;
+ while (cnto < outer_bi->ndatums || cnti < inner_bi->ndatums)
+ {
+ Datum *odatums;
+ Datum *idatums;
+ int o_index;
+ int i_index;
+ int cmpval;
+ int merged_index = -1;
+ Datum *merged_datum;
+ bool finished_inner;
+ bool finished_outer;
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining datums on the side which
+ * finishes later. For that we set the comparison parameter cmpval in
+ * such a way that it appears as if the side which finishes earlier has
+ * an extra datum higher than any other datum on the unfinished side.
+ * That way we advance the datums on the unfinished side till all of
+ * its datums are exhausted.
+ */
+ if (cnto >= outer_bi->ndatums)
+ {
+ finished_outer = true;
+ odatums = NULL;
+ o_index = -1;
+ }
+ else
+ {
+ finished_outer = false;
+ odatums = outer_bi->datums[cnto];
+ o_index = outer_indexes[cnto];
+ }
+
+ if (cnti >= inner_bi->ndatums)
+ {
+ finished_inner = true;
+ idatums = NULL;
+ i_index = -1;
+ }
+ else
+ {
+ finished_inner = false;
+ idatums = inner_bi->datums[cnti];
+ i_index = inner_indexes[cnti];
+ }
+
+ /* If we exhausted both the sides, we won't enter the loop. */
+ Assert(!finished_inner || !finished_outer);
+
+ if (finished_outer)
+ cmpval = 1;
+ else if (finished_inner)
+ cmpval = -1;
+ else
+ {
+ /* Every list datum should map to a valid partition index. */
+ Assert(o_index >= 0 && i_index >= 0 &&
+ odatums != NULL && idatums != NULL);
+
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
+ partcollation[0],
+ odatums[0], idatums[0]));
+ }
+
+ if (cmpval == 0)
+ {
+ /*
+ * Datums match. Rows on either side with these datums as partition
+ * key value will join and will be part of the partition of the
+ * join result produced by joining the corresponding partitions.
+ * Match the corresponding partitions and if successful, add the
+ * datum to the list of merged datums with index of merged
+ * partition containing it.
+ */
+ merged_datum = odatums;
+ merged_index = map_and_merge_partitions(outer_maps, inner_maps,
+ o_index, i_index,
+ &next_index);
+
+ if (merged_index < 0)
+ return NULL;
+
+ /* Move to the next pair of bounds. */
+ cnto++;
+ cnti++;
+ }
+ else if (cmpval < 0)
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /* A datum missing from the inner side. */
+ merged_index = -1;
+ merged_datum = odatums;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ o_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+
+ /* Move to the next datum on the outer side. */
+ Assert(!finished_outer);
+ cnto++;
+ }
+ else
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ Assert(cmpval > 0);
+
+ /* A datum missing from the outer side. */
+ merged_index = -1;
+ merged_datum = idatums;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ i_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+
+ /* Move to the next datum on the right side. */
+ Assert(!finished_inner);
+ cnti++;
+ }
+
+ /*
+ * Add the list value with appropriate index in the list of datums, if
+ * we have associated a partition with this list value.
+ */
+ if (merged_index >= 0)
+ {
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ merged_datums = lappend(merged_datums, merged_datum);
+ }
+ }
+
+ if (!merge_null_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index, &null_index,
+ &default_index))
+ return NULL;
+
+ if (!merge_default_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index,
+ &default_index))
+ return NULL;
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_maps, inner_maps,
+ outer_nparts, inner_nparts,
+ jointype, next_index,
+ outer_parts, inner_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes, NIL,
+ null_index, default_index);
+ }
+
+ /* Free up all extra memory before returning from this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_bounds_merge()'s arm for hash partitioned tables.
+ *
+ * If the given two hash bounds are same, the function returns the first one
+ * without any change, alongwith the lists of matching partitions. Otherwise it
+ * returns NULL.
+ *
+ * We could try merging the bounds when both the bounds have same greatest
+ * modulii. But there seems to be hardly any requirement for the same.
+ */
+static PartitionBoundInfo
+partition_hash_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype)
+{
+ int nparts;
+ int cnt;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * Hash partitioned table does not have explicit NULL accepting partition
+ * and also does not have a default partition.
+ */
+ Assert(!partition_bound_has_default(outer_bi) &&
+ !partition_bound_has_default(inner_bi));
+ Assert(!partition_bound_accepts_nulls(outer_bi) &&
+ !partition_bound_accepts_nulls(inner_bi));
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+
+ if (outer_nparts != inner_nparts)
+ return NULL;
+ nparts = outer_nparts;
+
+ if (outer_bi->ndatums != inner_bi->ndatums ||
+ !partition_hbounds_equal(outer_bi, inner_bi))
+ return NULL;
+
+ /*
+ * Cook up list of matching partitions. Since bounds are exactly same the
+ * partitions at the same position from both the relations match.
+ */
+ for (cnt = 0; cnt < nparts; cnt++)
+ {
+ *outer_parts = lappend_int(*outer_parts, cnt);
+ *inner_parts = lappend_int(*inner_parts, cnt);
+ }
+
+ return outer_bi;
+}
+
+/*
+ * map_and_merge_partitions
+ *
+ * If the two given partitions (given by index1 and index2 resp.) are
+ * already mapped to each other return the index of corresponding partition in
+ * the merged set of partitions. If they do not have a merged partition
+ * associated with them, assign a new merged partition index. If the
+ * partitions are already mapped and their mapped partitions are different from
+ * each other, they can not be merged, so return -1.
+ *
+ * partmaps1[i] gives the mapping of partitions for both relations. It
+ * describes which partition of relation 2 matches ith partition of relation 1,
+ * and which partition in the merged set matches ith partition of relation 1
+ * maps to. Similarly for partmap2.
+ *
+ * index1 and index2 are the indexes of matching partition from respective
+ * relations.
+ *
+ * *next_index is used and incremented when the given partitions require a new
+ * merged partition.
+ */
+
+static int
+map_and_merge_partitions(PartitionMap *partmaps1, PartitionMap *partmaps2,
+ int index1, int index2, int *next_index)
+{
+ PartitionMap *partmap1 = &partmaps1[index1];
+ PartitionMap *partmap2 = &partmaps2[index2];
+ int merged_index;
+
+ /*
+ * If both the partitions are not mapped to each other, update the
+ * maps.
+ */
+ if (partmap1->from < 0 && partmap2->from < 0)
+ {
+ partmap1->from = index2;
+ partmap2->from = index1;
+ }
+
+ /*
+ * If the given to partitions map to each other, find the corresponding
+ * merged partition index .
+ */
+ if (partmap1->from == index2 && partmap2->from == index1)
+ {
+ /*
+ * If both the partitions are mapped to the same merged partition, get
+ * the index of merged partition.
+ */
+ if (partmap1->to == partmap2->to)
+ {
+ merged_index = partmap1->to;
+
+ /*
+ * If the given two partitions do not have a merged partition
+ * associated with them, allocate a new merged partition.
+ */
+ if (merged_index < 0)
+ {
+ merged_index = *next_index;
+ *next_index = *next_index + 1;
+ partmap1->to = merged_index;
+ partmap2->to = merged_index;
+ }
+ }
+
+ /*
+ * If partition from one relation was mapped to a merged partition but
+ * not the partition from the other relation, map the same merged
+ * partition to the partition from other relation, since matching
+ * partitions map to the same merged partition.
+ */
+ else if (partmap1->to >= 0 && partmap2->to < 0)
+ {
+ partmap2->to = partmap1->to;
+ merged_index = partmap1->to;
+ }
+ else if (partmap1->to < 0 && partmap2->to >= 0)
+ {
+ partmap1->to = partmap2->to;
+ merged_index = partmap2->to;
+ }
+ else
+ {
+ Assert(partmap1->to != partmap2->to &&
+ partmap1->to >= 0 && partmap2->to >= 0);
+
+ /*
+ * Both the partitions map to different merged partitions. This
+ * means that multiple partitions from one relation matches to one
+ * partition from the other relation. Partition-wise join does not
+ * handle this case right now, since it requires ganging multiple
+ * partitions together (into one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+ }
+ else
+ {
+ /*
+ * Multiple partitions from one relation map to one partition from the
+ * other relation. Partition-wise join does not handle this case right
+ * now, since it requires ganging multiple partitions together (into
+ * one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+
+ return merged_index;
+}
+
+/*
+ * generate_matching_part_pairs
+ *
+ * partmaps1 map each partition from either side of the join to a merged
+ * partition resp. E.g. partmaps1[i].to gives the merged partition to which ith
+ * partition of first relation maps. Similarly for partmap2. If
+ * partmaps1[i].to == partmaps2[j].to, i and j form the matching pair of
+ * partitions.
+ *
+ * Given these maps this function produces the list pairs of partitions which
+ * when joined produce the merged partitions in the order of merged partition
+ * indexes.
+ *
+ * nparts1 and nparts2 are the number of partitions of the joining relations
+ * resp.
+ *
+ * nparts is the number of merged partitions.
+ *
+ * If successful, the pairs of partitions are returned as two separate lists,
+ * parts1 and parts2 resp., one for each side. Otherwise, those lists will be
+ * set to NIL.
+ */
+static void
+generate_matching_part_pairs(PartitionMap *partmaps1, PartitionMap *partmaps2,
+ int nparts1, int nparts2,
+ JoinType jointype, int nparts,
+ List **matched_parts1, List **matched_parts2)
+{
+ bool merged = true;
+ int *matching1 = (int *) palloc(sizeof(int) * nparts),
+ *matching2 = (int *) palloc(sizeof(int) * nparts);
+ int i;
+
+ *matched_parts1 = NIL;
+ *matched_parts2 = NIL;
+
+ /* Set pairs of matching partitions. */
+ for (i = 0; i < nparts; i++)
+ {
+ if (i >= nparts1)
+ matching1[i] = -1;
+ else
+ {
+ PartitionMap outer_map = partmaps1[i];
+
+ if (outer_map.to >= 0)
+ {
+ Assert(outer_map.to < nparts);
+ matching1[outer_map.to] = i;
+ }
+ }
+
+ if (i >= nparts2)
+ matching2[i] = -1;
+ else
+ {
+ PartitionMap inner_map = partmaps2[i];
+
+ if (inner_map.to >= 0)
+ {
+ Assert(inner_map.to < nparts);
+ matching2[inner_map.to] = i;
+ }
+ }
+ }
+
+ /*
+ * If we have a partition missing on an inner side, we need to add a dummy
+ * relation which joins with the outer partition. If the inner relation
+ * happens to be a base relation, it will require adding a dummy child
+ * base relation during join processing. Right now, we freeze the base
+ * relation arrays like PlannerInfo::simple_rte_array after planning for
+ * base relations. Adding a new (dummy) base relation would require some
+ * changes to that. So, right now, we do not implement partition-wise join
+ * in such cases.
+ */
+ for (i = 0; i < nparts; i++)
+ {
+ int part1 = matching1[i];
+ int part2 = matching2[i];
+
+ /* At least one of the partitions should exist. */
+ Assert(part1 >= 0 || part2 >= 0);
+
+ switch (jointype)
+ {
+ case JOIN_INNER:
+ case JOIN_SEMI:
+
+ /*
+ * An inner or semi join can not return any row when the
+ * matching partition on either side is missing. We should
+ * have eliminated all such cases while merging the bounds.
+ */
+ Assert(part1 >= 0 && part2 >= 0);
+ break;
+
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ Assert(part1 >= 0);
+ if (part2 < 0)
+ merged = false;
+ break;
+
+ case JOIN_FULL:
+ if (part1 < 0 || part2 < 0)
+ merged = false;
+ break;
+
+ default:
+ elog(ERROR, "unrecognized join type: %d", (int) jointype);
+ }
+
+ if (!merged)
+ break;
+
+ *matched_parts1 = lappend_int(*matched_parts1, part1);
+ *matched_parts2 = lappend_int(*matched_parts2, part2);
+ }
+
+ pfree(matching1);
+ pfree(matching2);
+
+ if (!merged)
+ {
+ list_free(*matched_parts1);
+ list_free(*matched_parts2);
+ *matched_parts1 = NIL;
+ *matched_parts2 = NIL;
+ }
+}
+
+static PartitionBoundInfo
+build_merged_partition_bounds(char strategy, List *merged_datums,
+ List *merged_indexes, List *merged_kinds,
+ int null_index, int default_index)
+{
+ int cnt;
+ PartitionBoundInfo merged_bounds;
+ ListCell *lc;
+
+ /* We expect the same number of elements in datums and indexes lists. */
+ Assert(list_length(merged_datums) == list_length(merged_indexes));
+
+ merged_bounds = (PartitionBoundInfo) palloc(sizeof(PartitionBoundInfoData));
+ merged_bounds->strategy = strategy;
+ merged_bounds->ndatums = list_length(merged_datums);
+
+ if (strategy == PARTITION_STRATEGY_RANGE)
+ {
+ Assert(list_length(merged_datums) == list_length(merged_kinds));
+ merged_bounds->kind =
+ (PartitionRangeDatumKind **) palloc(sizeof(PartitionRangeDatumKind *) *
+ list_length(merged_kinds));
+ cnt = 0;
+ foreach(lc, merged_kinds)
+ merged_bounds->kind[cnt++] = lfirst(lc);
+
+ /* There are ndatums+1 indexes in case of range partitions */
+ merged_indexes = lappend_int(merged_indexes, -1);
+ }
+ else
+ merged_bounds->kind = NULL;
+
+ cnt = 0;
+ merged_bounds->datums = (Datum **) palloc(sizeof(Datum *) *
+ list_length(merged_datums));
+ foreach(lc, merged_datums)
+ merged_bounds->datums[cnt++] = lfirst(lc);
+
+ merged_bounds->indexes = (int *) palloc(sizeof(int) *
+ list_length(merged_indexes));
+ cnt = 0;
+ foreach(lc, merged_indexes)
+ merged_bounds->indexes[cnt++] = lfirst_int(lc);
+
+ merged_bounds->null_index = null_index;
+ merged_bounds->default_index = default_index;
+
+ return merged_bounds;
+}
+
+/*
+ * Merge default partitions from both sides, if any, and assign the default
+ * partition for the join result, if necessary.
+ *
+ * If both the relations have default partitions, try mapping those to each
+ * other. If the mapping succeeds corresponding merged partition will act as
+ * the default partition of the join result.
+ *
+ * If inner side of the join has default but not the outer side, rows in it
+ * won't appear in the join result. So don't create a default partition. If
+ * outer side of the join has default but not the inner side, rows in it will
+ * appear in the join result, so create a default merged partition.
+ */
+static bool
+merge_default_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps, PartitionMap *inner_maps,
+ JoinType jointype, int *next_index, int *default_index)
+{
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool merged = true;
+ PartitionMap *outer_default_map = NULL;
+ PartitionMap *inner_default_map = NULL;
+
+ if (outer_has_default)
+ outer_default_map = &outer_maps[outer_default];
+
+ if (inner_has_default)
+ inner_default_map = &inner_maps[inner_default];
+
+ if (!outer_has_default && !inner_has_default)
+ Assert(*default_index < 0);
+ else if (outer_default_map != NULL && inner_default_map == NULL)
+ {
+ if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (outer_default_map->to < 0)
+ {
+ outer_default_map->to = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = outer_default_map->to;
+ }
+ else
+ Assert(*default_index == outer_default_map->to);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else if (outer_default_map == NULL && inner_default_map != NULL)
+ {
+ if (jointype == JOIN_FULL)
+ {
+ if (inner_default_map->to < 0)
+ {
+ inner_default_map->to = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = inner_default_map->to;
+ }
+ else
+ Assert(*default_index == inner_default_map->to);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else
+ {
+ Assert(outer_has_default && inner_has_default);
+
+ *default_index = map_and_merge_partitions(outer_maps, inner_maps,
+ outer_default, inner_default,
+ next_index);
+
+ if (*default_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
+
+/*
+ * merge_null_partitions
+ *
+ * Merge NULL partitions, i.e. a partition that can hold NULL values for a list
+ * partitioned table, if any. Find the index of merged partition to which the
+ * NULL values would belong in the join result. If one joining relation has a
+ * NULL partition but not the other, try matching it with the default partition
+ * from the other relation since the default partition may have rows with NULL
+ * partition key. We can eliminate a NULL partition when it appears only on the
+ * inner side of the join and the outer side doesn't have a default partition.
+ *
+ * When the equality operator used for join is strict, two NULL values will not
+ * be considered as equal, and thus a NULL partition can be eliminated for an
+ * inner join. But we don't check the strictness operator here.
+ */
+static bool
+merge_null_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps, PartitionMap *inner_maps,
+ JoinType jointype, int *next_index,
+ int *null_index, int *default_index)
+{
+ bool outer_has_null = partition_bound_accepts_nulls(outer_bi);
+ bool inner_has_null = partition_bound_accepts_nulls(inner_bi);
+ int outer_ni = outer_bi->null_index;
+ int inner_ni = inner_bi->null_index;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool merged = true;
+
+ if (!outer_has_null && !inner_has_null)
+ *null_index = -1;
+ else if (outer_has_null && !inner_has_null)
+ {
+ int merged_index;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+
+ merged = handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ outer_ni,
+ missing_side_outer,
+ missing_side_inner, next_index,
+ default_index, &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join to which the outer null partition maps
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = outer_maps[outer_ni].to;
+ }
+ else if (!outer_has_null && inner_has_null)
+ {
+ int merged_index;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as OUTER
+ * relation. For INNER and SEMI join OUTER and INNER differentiation is
+ * immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+ merged = handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ inner_ni,
+ missing_side_outer,
+ missing_side_inner,
+ next_index, default_index,
+ &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join, to which the outer side null partition maps,
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = inner_maps[inner_ni].to;
+ }
+ else
+ {
+ /* Both the relations have NULL partitions, try merging them. */
+ *null_index = map_and_merge_partitions(outer_maps,
+ inner_maps,
+ outer_ni,
+ inner_ni,
+ next_index);
+ if (*null_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
diff --git a/src/include/partitioning/partbounds.h b/src/include/partitioning/partbounds.h
index 36fb584e23..789d089ddc 100644
--- a/src/include/partitioning/partbounds.h
+++ b/src/include/partitioning/partbounds.h
@@ -107,5 +107,10 @@ extern int partition_range_datum_bsearch(FmgrInfo *partsupfunc,
int nvalues, Datum *values, bool *is_equal);
extern int partition_hash_bsearch(PartitionBoundInfo boundinfo,
int modulus, int remainder);
+extern PartitionBoundInfo partition_bounds_merge(int partnatts,
+ FmgrInfo *partsupfunc, Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts);
#endif /* PARTBOUNDS_H */
--
2.16.4
[application/octet-stream] 0001-Hash-partition-bound-equality-refactoring-v14.patch (5.1K, ../../CA+q6zcUh5VoTvL5P5NRiN31V3FNFgwUaTjD=upmXLs5=gie2nQ@mail.gmail.com/4-0001-Hash-partition-bound-equality-refactoring-v14.patch)
download | inline diff:
From bab6680b6b5f8dff042672fc6e08b9a9cc580353 Mon Sep 17 00:00:00 2001
From: erthalion <9erthalion6@gmail.com>
Date: Tue, 11 Sep 2018 21:08:07 +0200
Subject: [PATCH 1/5] Hash partition bound equality refactoring.
Separate the code to check whether two given hash bounds are equal into a
separate function, so that it can be called from multiple places. Right now
it's only caller is partition_bounds_equal() but later we will use it for
merging partition bounds.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/partitioning/partbounds.c | 95 ++++++++++++++++++++++-------------
1 file changed, 61 insertions(+), 34 deletions(-)
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index eeaab2f4c9..0af3372cdf 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -104,6 +104,9 @@ static void get_range_key_properties(PartitionKey key, int keynum,
Expr **keyCol,
Const **lower_val, Const **upper_val);
static List *get_range_nulltest(PartitionKey key);
+static bool partition_hbounds_equal(PartitionBoundInfo b1,
+ PartitionBoundInfo b2);
+
/*
* get_qual_from_partbound
@@ -652,6 +655,63 @@ create_range_bounds(PartitionBoundSpec **boundspecs, int nparts,
return boundinfo;
}
+/*
+ * Are two hash partition bound collections logically equal?
+ *
+ * Hash partition bounds store modulus and remainder in datums array which are
+ * always integers irrespective of the number of partition keys and their data
+ * types. Hence we can compare the hash bound collection without any partition
+ * key specific information. Separating this logic in a function which does not
+ * require partition key specific information allows it be called from places
+ * where the partition key specific information is not completely available.
+ */
+static bool
+partition_hbounds_equal(PartitionBoundInfo b1, PartitionBoundInfo b2)
+{
+ int greatest_modulus = get_hash_partition_greatest_modulus(b1);
+ int i;
+
+ Assert(b1->strategy == PARTITION_STRATEGY_HASH &&
+ b2->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * If two hash partitioned tables have different greatest moduli,
+ * their partition schemes don't match. For hash partitioned table,
+ * the greatest modulus is given by the last datum and number of
+ * partitions is given by ndatums.
+ */
+ if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ return false;
+
+ /*
+ * We arrange the partitions in the ascending order of their modulus and
+ * remainders. Also every modulus is factor of next larger modulus.
+ * Therefore we can safely store index of a given partition in indexes
+ * array at remainder of that partition. Also entries at (remainder + N *
+ * modulus) positions in indexes array are all same for (modulus,
+ * remainder) specification for any partition. Thus datums array from both
+ * the given bounds are same, if and only if their indexes array will be
+ * same. So, it suffices to compare indexes array.
+ */
+ for (i = 0; i < greatest_modulus; i++)
+ if (b1->indexes[i] != b2->indexes[i])
+ return false;
+
+#ifdef USE_ASSERT_CHECKING
+
+ /*
+ * Nonetheless make sure that the bounds are indeed same when the indexes
+ * match. Hash partition bound stores modulus and remainder at
+ * b1->datums[i][0] and b1->datums[i][1] position respectively.
+ */
+ for (i = 0; i < b1->ndatums; i++)
+ Assert((b1->datums[i][0] == b2->datums[i][0] &&
+ b1->datums[i][1] == b2->datums[i][1]));
+#endif
+
+ return true;
+}
+
/*
* Are two partition bound collections logically equal?
*
@@ -680,41 +740,8 @@ partition_bounds_equal(int partnatts, int16 *parttyplen, bool *parttypbyval,
if (b1->strategy == PARTITION_STRATEGY_HASH)
{
- int greatest_modulus = get_hash_partition_greatest_modulus(b1);
-
- /*
- * If two hash partitioned tables have different greatest moduli,
- * their partition schemes don't match.
- */
- if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ if (!partition_hbounds_equal(b1, b2))
return false;
-
- /*
- * We arrange the partitions in the ascending order of their moduli
- * and remainders. Also every modulus is factor of next larger
- * modulus. Therefore we can safely store index of a given partition
- * in indexes array at remainder of that partition. Also entries at
- * (remainder + N * modulus) positions in indexes array are all same
- * for (modulus, remainder) specification for any partition. Thus
- * datums array from both the given bounds are same, if and only if
- * their indexes array will be same. So, it suffices to compare
- * indexes array.
- */
- for (i = 0; i < greatest_modulus; i++)
- if (b1->indexes[i] != b2->indexes[i])
- return false;
-
-#ifdef USE_ASSERT_CHECKING
-
- /*
- * Nonetheless make sure that the bounds are indeed same when the
- * indexes match. Hash partition bound stores modulus and remainder
- * at b1->datums[i][0] and b1->datums[i][1] position respectively.
- */
- for (i = 0; i < b1->ndatums; i++)
- Assert((b1->datums[i][0] == b2->datums[i][0] &&
- b1->datums[i][1] == b2->datums[i][1]));
-#endif
}
else
{
--
2.16.4
[application/octet-stream] 0004-Tests-for-0-1-1-1-and-1-0-partition-matching-v14.patch (218.8K, ../../CA+q6zcUh5VoTvL5P5NRiN31V3FNFgwUaTjD=upmXLs5=gie2nQ@mail.gmail.com/5-0004-Tests-for-0-1-1-1-and-1-0-partition-matching-v14.patch)
download | inline diff:
From 79133983393b6583dd153e1180f146b285c33901 Mon Sep 17 00:00:00 2001
From: erthalion <9erthalion6@gmail.com>
Date: Tue, 11 Sep 2018 21:11:55 +0200
Subject: [PATCH 4/5] Tests for 0:1, 1:1 and 1:0 partition matching
Rajkumar Raghuvanshi and Ashutosh Bapat.
---
src/test/regress/expected/partition_join.out | 4101 +++++++++++++++++++++-----
src/test/regress/sql/partition_join.sql | 427 ++-
2 files changed, 3834 insertions(+), 694 deletions(-)
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index c55de5d476..3be5ebe29d 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -8,59 +8,86 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(21 rows)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
-(4 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+(7 rows)
-- left outer join, with whole-row reference; partitionwise join does not apply
EXPLAIN (COSTS OFF)
@@ -72,35 +99,50 @@ SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(22 rows)
SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- t1 | t2
---------------+--------------
- (0,0,0000) | (0,0,0000)
- (50,0,0050) |
- (100,0,0100) |
- (150,0,0150) | (0,150,0150)
- (200,0,0200) |
- (250,0,0250) |
- (300,0,0300) | (0,300,0300)
- (350,0,0350) |
- (400,0,0400) |
- (450,0,0450) | (0,450,0450)
- (500,0,0500) |
- (550,0,0550) |
-(12 rows)
+ t1 | t2
+----------------+----------------
+ (-250,0,-0250) |
+ (-200,0,-0200) |
+ (-150,0,-0150) | (0,-150,-0150)
+ (-100,0,-0100) |
+ (-50,0,-0050) |
+ (0,0,0000) | (0,0,0000)
+ (50,0,0050) |
+ (100,0,0100) |
+ (150,0,0150) | (0,150,0150)
+ (200,0,0200) |
+ (250,0,0250) |
+ (300,0,0300) | (0,300,0300)
+ (350,0,0350) |
+ (400,0,0400) |
+ (450,0,0450) | (0,450,0450)
+ (500,0,0500) |
+ (550,0,0550) |
+ (600,0,0600) | (0,600,0600)
+ (650,0,0650) |
+ (700,0,0700) |
+ (750,0,0750) | (0,750,0750)
+(21 rows)
-- right outer join
EXPLAIN (COSTS OFF)
@@ -112,35 +154,53 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHE
-> Append
-> Hash Right Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Right Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Hash Right Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-> Nested Loop Left Join
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p3 t2_3
Filter: (a = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t2_2.b)
-(20 rows)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
- | | 75 | 0075
- | | 225 | 0225
- | | 375 | 0375
- | | 525 | 0525
-(8 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+ | | -225 | -0225
+ | | -75 | -0075
+ | | 75 | 0075
+ | | 225 | 0225
+ | | 375 | 0375
+ | | 525 | 0525
+ | | 675 | 0675
+(14 rows)
-- full outer join, with placeholder vars
EXPLAIN (COSTS OFF)
@@ -148,8 +208,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
QUERY PLAN
------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b
+ Sort Key: prt1_p0.a, prt2_p0.b
-> Append
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ Filter: (((50) = prt1_p0.a) OR ((75) = prt2_p0.b))
+ -> Seq Scan on prt1_p0
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p1.a = prt2_p1.b)
Filter: (((50) = prt1_p1.a) OR ((75) = prt2_p1.b))
@@ -174,7 +242,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
-> Hash
-> Seq Scan on prt2_p3
Filter: (a = 0)
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ Filter: (((50) = prt1_p4.a) OR ((75) = prt2_p4.b))
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) WHERE t1.phv = t1.a OR t2.phv = t2.b ORDER BY t1.a, t2.b;
a | c | b | c
@@ -211,8 +287,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Hash Left Join
+ Hash Cond: (prt1_p0.a = b)
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Hash
+ -> Result
+ One-Time Filter: false
-> Hash Left Join
Hash Cond: (prt1_p1.a = b)
-> Seq Scan on prt1_p1
@@ -227,29 +310,42 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
-> Hash
-> Seq Scan on prt1_p2
Filter: ((a < 450) AND (b = 0))
-(17 rows)
+(24 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
-(9 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+(14 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
QUERY PLAN
------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = b)
+ Filter: ((prt1_p0.b = 0) OR (a = 0))
+ -> Seq Scan on prt1_p0
+ Filter: (a < 450)
+ -> Hash
+ -> Result
+ One-Time Filter: false
-> Hash Full Join
Hash Cond: (prt1_p1.a = b)
Filter: ((prt1_p1.b = 0) OR (a = 0))
@@ -274,64 +370,153 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JO
-> Hash
-> Result
One-Time Filter: false
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt2_p4.b = a)
+ Filter: ((b = 0) OR (prt2_p4.a = 0))
+ -> Seq Scan on prt2_p4
+ Filter: (b > 250)
+ -> Hash
+ -> Result
+ One-Time Filter: false
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
- | | 375 | 0375
- | | 450 | 0450
- | | 525 | 0525
-(12 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ | | 375 | 0375
+ | | 450 | 0450
+ | | 525 | 0525
+ | | 600 | 0600
+ | | 675 | 0675
+ | | 750 | 0750
+(20 rows)
-- Semi-join
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Semi Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Semi Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Nested Loop Semi Join
- Join Filter: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Materialize
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-(24 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(39 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p0 t2
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_2.b = t2_2.a)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p2 t2_2
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: (t1_3.b = t2_3.a)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt1_p3 t2_3
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.b = t2_4.a)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p4 t2_4
+ Filter: (b = 0)
+(37 rows)
+
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
@@ -342,27 +527,82 @@ SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS
-> Append
-> Hash Anti Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash Anti Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash Anti Join
Hash Cond: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p3 t2_2
-(17 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash Anti Join
+ Hash Cond: (t1_3.a = t2_3.b)
+ -> Seq Scan on prt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_3
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(27 rows)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
- sum | avg | sum | avg
--------+----------------------+------+---------------------
- 60000 | 300.0000000000000000 | 2400 | 12.0000000000000000
+ sum | avg | sum | avg
+-------+----------------------+------+--------------------
+ 95550 | 273.0000000000000000 | 2200 | 6.2857142857142857
(1 row)
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ QUERY PLAN
+--------------------------------------------------------------
+ Append
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Hash Anti Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(27 rows)
+
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ b | c
+------+-------
+ -225 | -0225
+ -75 | -0075
+ 75 | 0075
+ 225 | 0225
+ 375 | 0375
+ 525 | 0525
+ 675 | 0675
+(7 rows)
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -374,49 +614,74 @@ SELECT * FROM prt1 t1 LEFT JOIN LATERAL
Sort Key: t1.a
-> Append
-> Nested Loop Left Join
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p1_a on prt1_p1 t2
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
Index Cond: (a = t1.a)
- -> Index Scan using iprt2_p1_b on prt2_p1 t3
+ -> Index Scan using iprt2_p0_b on prt2_p0 t3
Index Cond: (b = t2.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_1
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
Index Cond: (a = t1_1.a)
- -> Index Scan using iprt2_p2_b on prt2_p2 t3_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t3_1
Index Cond: (b = t2_1.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_2
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
Index Cond: (a = t1_2.a)
- -> Index Scan using iprt2_p3_b on prt2_p3 t3_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t3_2
Index Cond: (b = t2_2.a)
-(27 rows)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.a)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t3_3
+ Index Cond: (b = t2_3.a)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.a)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t3_4
+ Index Cond: (b = t2_4.a)
+(43 rows)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, least(t1.a,t2.a,t3.b) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.a = ss.t2a WHERE t1.b = 0 ORDER BY t1.a;
- a | b | c | t2a | t3a | least
------+---+------+-----+-----+-------
- 0 | 0 | 0000 | 0 | 0 | 0
- 50 | 0 | 0050 | | |
- 100 | 0 | 0100 | | |
- 150 | 0 | 0150 | 150 | 0 | 150
- 200 | 0 | 0200 | | |
- 250 | 0 | 0250 | | |
- 300 | 0 | 0300 | 300 | 0 | 300
- 350 | 0 | 0350 | | |
- 400 | 0 | 0400 | | |
- 450 | 0 | 0450 | 450 | 0 | 450
- 500 | 0 | 0500 | | |
- 550 | 0 | 0550 | | |
-(12 rows)
+ a | b | c | t2a | t3a | least
+------+---+-------+------+-----+-------
+ -250 | 0 | -0250 | | |
+ -200 | 0 | -0200 | | |
+ -150 | 0 | -0150 | -150 | 0 | -150
+ -100 | 0 | -0100 | | |
+ -50 | 0 | -0050 | | |
+ 0 | 0 | 0000 | 0 | 0 | 0
+ 50 | 0 | 0050 | | |
+ 100 | 0 | 0100 | | |
+ 150 | 0 | 0150 | 150 | 0 | 150
+ 200 | 0 | 0200 | | |
+ 250 | 0 | 0250 | | |
+ 300 | 0 | 0300 | 300 | 0 | 300
+ 350 | 0 | 0350 | | |
+ 400 | 0 | 0400 | | |
+ 450 | 0 | 0450 | 450 | 0 | 450
+ 500 | 0 | 0500 | | |
+ 550 | 0 | 0550 | | |
+ 600 | 0 | 0600 | 600 | 0 | 600
+ 650 | 0 | 0650 | | |
+ 700 | 0 | 0700 | | |
+ 750 | 0 | 0750 | 750 | 0 | 750
+(21 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
@@ -430,64 +695,95 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
Hash Cond: ((t1.c)::text = (t2.c)::text)
Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Hash Join
Hash Cond: (t2.a = t3.b)
- -> Seq Scan on prt1_p1 t2
+ -> Seq Scan on prt1_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t3
+ -> Seq Scan on prt2_p0 t3
-> Hash Join
Hash Cond: (t2_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t2_1
+ -> Seq Scan on prt1_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p1 t3_1
-> Hash Join
Hash Cond: (t2_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p2 t2_2
-> Hash
- -> Seq Scan on prt2_p3 t3_2
-(26 rows)
+ -> Seq Scan on prt2_p2 t3_2
+ -> Hash Join
+ Hash Cond: (t2_3.a = t3_3.b)
+ -> Seq Scan on prt1_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t3_3
+ -> Hash Join
+ Hash Cond: (t2_4.a = t3_4.b)
+ -> Seq Scan on prt1_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t3_4
+(38 rows)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, t2.b t2b, t2.c t2c, least(t1.a,t2.a,t3.a) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.c = ss.t2c WHERE (t1.b + coalesce(ss.t2b, 0)) = 0 ORDER BY t1.a;
- a | t2a | t2c
------+-----+------
- 0 | 0 | 0000
- 50 | |
- 100 | |
- 150 | 150 | 0150
- 200 | |
- 250 | |
- 300 | 300 | 0300
- 350 | |
- 400 | |
- 450 | 450 | 0450
- 500 | |
- 550 | |
-(12 rows)
+ a | t2a | t2c
+------+------+-------
+ -250 | |
+ -200 | |
+ -150 | -150 | -0150
+ -100 | |
+ -50 | |
+ 0 | 0 | 0000
+ 50 | |
+ 100 | |
+ 150 | 150 | 0150
+ 200 | |
+ 250 | |
+ 300 | 300 | 0300
+ 350 | |
+ 400 | |
+ 450 | 450 | 0450
+ 500 | |
+ 550 | |
+ 600 | 600 | 0600
+ 650 | |
+ 700 | |
+ 750 | 750 | 0750
+(21 rows)
--
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
@@ -498,32 +794,49 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 =
-> Append
-> Hash Join
Hash Cond: (((t2.b + t2.a) / 2) = ((t1.a + t1.b) / 2))
- -> Seq Scan on prt2_e_p1 t2
+ -> Seq Scan on prt2_e_p0 t2
-> Hash
- -> Seq Scan on prt1_e_p1 t1
+ -> Seq Scan on prt1_e_p0 t1
Filter: (c = 0)
-> Hash Join
- Hash Cond: (((t2_1.b + t2_1.a) / 2) = ((t1_1.a + t1_1.b) / 2))
- -> Seq Scan on prt2_e_p2 t2_1
+ Hash Cond: (((t1_1.a + t1_1.b) / 2) = ((t2_1.b + t2_1.a) / 2))
+ -> Seq Scan on prt1_e_p1 t1_1
+ Filter: (c = 0)
-> Hash
- -> Seq Scan on prt1_e_p2 t1_1
- Filter: (c = 0)
+ -> Seq Scan on prt2_e_p1 t2_1
-> Hash Join
Hash Cond: (((t2_2.b + t2_2.a) / 2) = ((t1_2.a + t1_2.b) / 2))
- -> Seq Scan on prt2_e_p3 t2_2
+ -> Seq Scan on prt2_e_p2 t2_2
-> Hash
- -> Seq Scan on prt1_e_p3 t1_2
+ -> Seq Scan on prt1_e_p2 t1_2
Filter: (c = 0)
-(21 rows)
+ -> Hash Join
+ Hash Cond: (((t2_3.b + t2_3.a) / 2) = ((t1_3.a + t1_3.b) / 2))
+ -> Seq Scan on prt2_e_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t1_3
+ Filter: (c = 0)
+ -> Hash Join
+ Hash Cond: (((t2_4.b + t2_4.a) / 2) = ((t1_4.a + t1_4.b) / 2))
+ -> Seq Scan on prt2_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_4
+ Filter: (c = 0)
+(33 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 150 | 0 | 150 | 0
- 300 | 0 | 300 | 0
- 450 | 0 | 450 | 0
-(4 rows)
+ a | c | b | c
+------+---+------+---
+ -250 | 0 | -250 | 0
+ -100 | 0 | -100 | 0
+ 0 | 0 | 0 | 0
+ 0 | 0 | 0 | 0
+ 150 | 0 | 150 | 0
+ 300 | 0 | 300 | 0
+ 450 | 0 | 450 | 0
+ 600 | 0 | 600 | 0
+ 750 | 0 | 750 | 0
+(9 rows)
--
-- N-way join
@@ -536,154 +849,232 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = ((t3.a + t3.b) / 2))
+ Join Filter: (t1.a = t2.b)
-> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p1_ab2 on prt1_e_p1 t3
- Index Cond: (((a + b) / 2) = t2.b)
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
+ Index Cond: (b = ((t3.a + t3.b) / 2))
-> Nested Loop
Join Filter: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_1
+ -> Index Scan using iprt1_e_p4_ab2 on prt1_e_p1 t3_1
Index Cond: (((a + b) / 2) = t2_1.b)
-> Nested Loop
Join Filter: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_2
Index Cond: (((a + b) / 2) = t2_2.b)
-(33 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = ((t3_3.a + t3_3.b) / 2))
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (((a + b) / 2) = t2_3.b)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t2_4.b)
+ -> Hash Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (b = ((t3_4.a + t3_4.b) / 2))
+(52 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t3 WHERE t1.a = t2.b AND t1.a = (t3.a + t3.b)/2 AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
-(4 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(8 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
---------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Hash Right Join
Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_1.a + t3_1.b) / 2) = t1_1.a)
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
-> Hash
-> Hash Right Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_2.a + t3_2.b) / 2) = t1_2.a)
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
-> Hash
-> Hash Right Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(33 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (t1_3.a = ((a + b) / 2))
+ -> Hash Right Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(51 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
--------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1.a = ((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
Index Cond: (t1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t2_1
Index Cond: (t1_1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t2_2
Index Cond: (t1_2.a = b)
-(30 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t3_3.a + t3_3.b) / 2))
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Nested Loop Left Join
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = ((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (t1_4.a = b)
+(47 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- Cases with non-nullable expressions in subquery results;
-- make sure these go to null as expected
@@ -692,21 +1083,34 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
QUERY PLAN
----------------------------------------------------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b, ((prt1_e_p1.a + prt1_e_p1.b))
+ Sort Key: prt1_p0.a, prt2_p0.b, ((prt1_e_p0.a + prt1_e_p0.b))
-> Append
-> Hash Full Join
- Hash Cond: (prt1_p1.a = ((prt1_e_p1.a + prt1_e_p1.b) / 2))
- Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ Hash Cond: (prt1_p0.a = ((prt1_e_p0.a + prt1_e_p0.b) / 2))
+ Filter: ((prt1_p0.a = (50)) OR (prt2_p0.b = (75)) OR (((prt1_e_p0.a + prt1_e_p0.b) / 2) = (50)))
-> Hash Full Join
- Hash Cond: (prt1_p1.a = prt2_p1.b)
- -> Seq Scan on prt1_p1
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ -> Seq Scan on prt1_p0
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1
+ -> Seq Scan on prt2_p0
Filter: (a = 0)
-> Hash
- -> Seq Scan on prt1_e_p1
+ -> Seq Scan on prt1_e_p0
Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: (((prt1_e_p1.a + prt1_e_p1.b) / 2) = prt1_p1.a)
+ Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ -> Seq Scan on prt1_e_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Hash Full Join
+ Hash Cond: (prt1_p1.a = prt2_p1.b)
+ -> Seq Scan on prt1_p1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p2.a = ((prt1_e_p2.a + prt1_e_p2.b) / 2))
Filter: ((prt1_p2.a = (50)) OR (prt2_p2.b = (75)) OR (((prt1_e_p2.a + prt1_e_p2.b) / 2) = (50)))
@@ -733,7 +1137,20 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
-> Hash
-> Seq Scan on prt1_e_p3
Filter: (c = 0)
-(42 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = ((prt1_e_p4.a + prt1_e_p4.b) / 2))
+ Filter: ((prt1_p4.a = (50)) OR (prt2_p4.b = (75)) OR (((prt1_e_p4.a + prt1_e_p4.b) / 2) = (50)))
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_e_p4
+ Filter: (c = 0)
+(68 rows)
SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b)) FULL JOIN (SELECT 50 phv, * FROM prt1_e WHERE prt1_e.c = 0) t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.a = t1.phv OR t2.b = t2.phv OR (t3.a + t3.b)/2 = t3.phv ORDER BY t1.a, t2.b, t3.a + t3.b;
a | phv | b | phv | ?column? | phv
@@ -751,53 +1168,81 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHER
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = t1_3.b)
+ Join Filter: (t1.a = t1_5.b)
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Join
- Hash Cond: (((t2.a + t2.b) / 2) = t1_3.b)
- -> Seq Scan on prt1_e_p1 t2
+ Hash Cond: (((t2.a + t2.b) / 2) = t1_5.b)
+ -> Seq Scan on prt1_e_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t1_3
+ -> Seq Scan on prt2_p0 t1_5
Filter: (a = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
Index Cond: (a = ((t2.a + t2.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_1.a = t1_4.b)
+ Join Filter: (t1_1.a = t1_6.b)
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Join
- Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_4.b)
- -> Seq Scan on prt1_e_p2 t2_1
+ Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_6.b)
+ -> Seq Scan on prt1_e_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t1_4
+ -> Seq Scan on prt2_p1 t1_6
Filter: (a = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
Index Cond: (a = ((t2_1.a + t2_1.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_2.a = t1_5.b)
+ Join Filter: (t1_2.a = t1_7.b)
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Nested Loop
- -> Seq Scan on prt2_p3 t1_5
+ -> Seq Scan on prt2_p2 t1_7
Filter: (a = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_2
- Index Cond: (((a + b) / 2) = t1_5.b)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t2_2
+ Index Cond: (((a + b) / 2) = t1_7.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
Index Cond: (a = ((t2_2.a + t2_2.b) / 2))
Filter: (b = 0)
-(41 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = t1_8.b)
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t1_8
+ Filter: (a = 0)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_3
+ Index Cond: (((a + b) / 2) = t1_8.b)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t2_3.a + t2_3.b) / 2))
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t1_9.b)
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Join
+ Hash Cond: (((t2_4.a + t2_4.b) / 2) = t1_9.b)
+ -> Seq Scan on prt1_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t1_9
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = ((t2_4.a + t2_4.b) / 2))
+ Filter: (b = 0)
+(66 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHERE t1.a = 0 AND t1.b = (t2.a + t2.b)/2) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
@@ -808,27 +1253,39 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (
-> Append
-> Nested Loop
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Semi Join
- Hash Cond: (t1_3.b = ((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt2_p1 t1_3
+ Hash Cond: (t1_5.b = ((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt2_p0 t1_5
-> Hash
- -> Seq Scan on prt1_e_p1 t1_6
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
- Index Cond: (a = t1_3.b)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t1_5.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Semi Join
- Hash Cond: (t1_4.b = ((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt2_p2 t1_4
+ Hash Cond: (t1_6.b = ((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt2_p1 t1_6
-> Hash
- -> Seq Scan on prt1_e_p2 t1_7
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
- Index Cond: (a = t1_4.b)
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
+ Index Cond: (a = t1_6.b)
+ Filter: (b = 0)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_7.b
+ -> Hash Semi Join
+ Hash Cond: (t1_7.b = ((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt2_p2 t1_7
+ -> Hash
+ -> Seq Scan on prt1_e_p2 t1_12
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t1_7.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
@@ -845,78 +1302,114 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (
(39 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
-- test merge joins
SET enable_hashjoin TO off;
SET enable_nestloop TO off;
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
-----------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------
Merge Append
Sort Key: t1.a
-> Merge Semi Join
- Merge Cond: (t1.a = t1_3.b)
+ Merge Cond: (t1.a = t1_5.b)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_3.b = (((t1_6.a + t1_6.b) / 2)))
+ Merge Cond: (t1_5.b = (((t1_10.a + t1_10.b) / 2)))
-> Sort
- Sort Key: t1_3.b
- -> Seq Scan on prt2_p1 t1_3
+ Sort Key: t1_5.b
+ -> Seq Scan on prt2_p0 t1_5
-> Sort
- Sort Key: (((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt1_e_p1 t1_6
+ Sort Key: (((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_1.a = t1_4.b)
+ Merge Cond: (t1_1.a = t1_6.b)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_4.b = (((t1_7.a + t1_7.b) / 2)))
+ Merge Cond: (t1_6.b = (((t1_11.a + t1_11.b) / 2)))
-> Sort
- Sort Key: t1_4.b
- -> Seq Scan on prt2_p2 t1_4
+ Sort Key: t1_6.b
+ -> Seq Scan on prt2_p1 t1_6
-> Sort
- Sort Key: (((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt1_e_p2 t1_7
+ Sort Key: (((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_2.a = t1_5.b)
+ Merge Cond: (t1_2.a = t1_7.b)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_5.b = (((t1_8.a + t1_8.b) / 2)))
+ Merge Cond: (t1_7.b = (((t1_12.a + t1_12.b) / 2)))
-> Sort
- Sort Key: t1_5.b
- -> Seq Scan on prt2_p3 t1_5
+ Sort Key: t1_7.b
+ -> Seq Scan on prt2_p2 t1_7
-> Sort
- Sort Key: (((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt1_e_p3 t1_8
+ Sort Key: (((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt1_e_p2 t1_12
Filter: (c = 0)
-(47 rows)
+ -> Merge Semi Join
+ Merge Cond: (t1_3.a = t1_8.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_8.b = (((t1_13.a + t1_13.b) / 2)))
+ -> Sort
+ Sort Key: t1_8.b
+ -> Seq Scan on prt2_p3 t1_8
+ -> Sort
+ Sort Key: (((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt1_e_p3 t1_13
+ Filter: (c = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_4.a = t1_9.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_9.b = (((t1_14.a + t1_14.b) / 2)))
+ -> Sort
+ Sort Key: t1_9.b
+ -> Seq Scan on prt2_p4 t1_9
+ -> Sort
+ Sort Key: (((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+(77 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
@@ -933,14 +1426,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3.a + t3.b) / 2)) = t1.a)
-> Sort
Sort Key: (((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Sort
Sort Key: t2.b
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Merge Left Join
Merge Cond: (t1_1.a = t2_1.b)
-> Sort
@@ -949,14 +1442,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_1.a + t3_1.b) / 2)) = t1_1.a)
-> Sort
Sort Key: (((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Sort
Sort Key: t2_1.b
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Merge Left Join
Merge Cond: (t1_2.a = t2_2.b)
-> Sort
@@ -965,32 +1458,74 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_2.a + t3_2.b) / 2)) = t1_2.a)
-> Sort
Sort Key: (((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Sort
Sort Key: t2_2.b
- -> Seq Scan on prt2_p3 t2_2
-(51 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Merge Left Join
+ Merge Cond: (t1_3.a = t2_3.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_3.a + t3_3.b) / 2)) = t1_3.a)
+ -> Sort
+ Sort Key: (((t3_3.a + t3_3.b) / 2))
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ -> Sort
+ Sort Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ -> Merge Left Join
+ Merge Cond: (t1_4.a = t2_4.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_4.a + t3_4.b) / 2)) = t1_4.a)
+ -> Sort
+ Sort Key: (((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ -> Sort
+ Sort Key: t2_4.b
+ -> Seq Scan on prt2_p4 t2_4
+(83 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- MergeAppend on nullable column
EXPLAIN (COSTS OFF)
@@ -998,8 +1533,18 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Merge Left Join
+ Merge Cond: (prt1_p0.a = b)
+ -> Sort
+ Sort Key: prt1_p0.a
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Sort
+ Sort Key: b
+ -> Result
+ One-Time Filter: false
-> Merge Left Join
Merge Cond: (prt1_p1.a = b)
-> Sort
@@ -1020,21 +1565,26 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
Sort Key: prt2_p2.b
-> Seq Scan on prt2_p2
Filter: (b > 250)
-(23 rows)
+(33 rows)
SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | b
------+-----
- 0 |
- 50 |
- 100 |
- 150 |
- 200 |
- 250 |
- 300 | 300
- 350 |
- 400 |
-(9 rows)
+ a | b
+------+-----
+ -250 |
+ -200 |
+ -150 |
+ -100 |
+ -50 |
+ 0 |
+ 50 |
+ 100 |
+ 150 |
+ 200 |
+ 250 |
+ 300 | 300
+ 350 |
+ 400 |
+(14 rows)
-- merge join when expression with whole-row reference needs to be sorted;
-- partitionwise join does not apply
@@ -1048,175 +1598,2412 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
Sort Key: t1.a, ((((t1.*)::prt1))::text)
-> Result
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Sort
Sort Key: t2.b, ((((t2.*)::prt2))::text)
-> Result
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
-(16 rows)
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+(20 rows)
SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.b ORDER BY t1.a;
- a | b
-----+----
- 0 | 0
- 6 | 6
- 12 | 12
- 18 | 18
- 24 | 24
-(5 rows)
+ a | b
+-----+-----
+ -24 | -24
+ -18 | -18
+ -12 | -12
+ -6 | -6
+ 0 | 0
+ 6 | 6
+ 12 | 12
+ 18 | 18
+ 24 | 24
+(9 rows)
RESET enable_hashjoin;
RESET enable_nestloop;
---
--- partitioned by multiple columns
---
-CREATE TABLE prt1_m (a int, b int, c int) PARTITION BY RANGE(a, ((a + b)/2));
-CREATE TABLE prt1_m_p1 PARTITION OF prt1_m FOR VALUES FROM (0, 0) TO (250, 250);
-CREATE TABLE prt1_m_p2 PARTITION OF prt1_m FOR VALUES FROM (250, 250) TO (500, 500);
-CREATE TABLE prt1_m_p3 PARTITION OF prt1_m FOR VALUES FROM (500, 500) TO (600, 600);
-INSERT INTO prt1_m SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
-ANALYZE prt1_m;
-CREATE TABLE prt2_m (a int, b int, c int) PARTITION BY RANGE(((b + a)/2), b);
-CREATE TABLE prt2_m_p1 PARTITION OF prt2_m FOR VALUES FROM (0, 0) TO (250, 250);
-CREATE TABLE prt2_m_p2 PARTITION OF prt2_m FOR VALUES FROM (250, 250) TO (500, 500);
-CREATE TABLE prt2_m_p3 PARTITION OF prt2_m FOR VALUES FROM (500, 500) TO (600, 600);
-INSERT INTO prt2_m SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
-ANALYZE prt2_m;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
- QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+ -> Seq Scan on prt2_p3 t2_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_4
+ Filter: (b = 0)
+(22 rows)
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p1 t2
+ -> Hash
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p2 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p3 t1_2
+ Filter: (b = 0)
+(21 rows)
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -150 | -0150 | 0 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 0 | 0150
+ 300 | 0300 | 0 | 0300
+ 450 | 0450 | 0 | 0450
+ 600 | 0600 | 0 | 0600
+ 750 | 0750 | 0 | 0750
+(7 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | 0 | -0150
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | 0 | 0000
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | 0 | 0150
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 0 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ 450 | 0450 | 0 | 0450
+ 500 | 0500 | |
+ 550 | 0550 | |
+ 600 | 0600 | 0 | 0600
+ 650 | 0650 | |
+ 700 | 0700 | |
+ 750 | 0750 | 0 | 0750
+(21 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Semi Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Append
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
+ Index Cond: (a = t1_1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(28 rows)
+
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Anti Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Anti Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -250 | 0 | -0250
+ -200 | 0 | -0200
+ -100 | 0 | -0100
+ -50 | 0 | -0050
+ 50 | 0 | 0050
+ 100 | 0 | 0100
+ 200 | 0 | 0200
+ 250 | 0 | 0250
+ 350 | 0 | 0350
+ 400 | 0 | 0400
+ 500 | 0 | 0500
+ 550 | 0 | 0550
+ 650 | 0 | 0650
+ 700 | 0 | 0700
+(14 rows)
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ QUERY PLAN
+---------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t3.c
+ -> Append
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t3
+ Index Cond: (a = t2.b)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t2.b)
+ -> Hash Right Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t3_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t3_2
+ Index Cond: (a = t2_2.b)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t2_2.b)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t3_3
+ Index Cond: (a = t2_3.b)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(47 rows)
+
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ a | a | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.b
+ -> Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(24 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: (t1.a = t2.b)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.a, 0)) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------
+ Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(22 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Join
+ Hash Cond: (t1.a = t2.b)
+ Join Filter: ((t1.b + t2.a) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+--
+-- partitioned by multiple columns
+--
+CREATE TABLE prt1_m (a int, b int, c int) PARTITION BY RANGE(a, ((a + b)/2));
+CREATE TABLE prt1_m_p1 PARTITION OF prt1_m FOR VALUES FROM (0, 0) TO (250, 250);
+CREATE TABLE prt1_m_p2 PARTITION OF prt1_m FOR VALUES FROM (250, 250) TO (500, 500);
+CREATE TABLE prt1_m_p3 PARTITION OF prt1_m FOR VALUES FROM (500, 500) TO (600, 600);
+INSERT INTO prt1_m SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+ANALYZE prt1_m;
+CREATE TABLE prt2_m (a int, b int, c int) PARTITION BY RANGE(((b + a)/2), b);
+CREATE TABLE prt2_m_p1 PARTITION OF prt2_m FOR VALUES FROM (0, 0) TO (250, 250);
+CREATE TABLE prt2_m_p2 PARTITION OF prt2_m FOR VALUES FROM (250, 250) TO (500, 500);
+CREATE TABLE prt2_m_p3 PARTITION OF prt2_m FOR VALUES FROM (500, 500) TO (600, 600);
+INSERT INTO prt2_m SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+ANALYZE prt2_m;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------
+ Sort
+ Sort Key: prt1_m_p1.a, prt2_m_p1.b
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p1.a = ((prt2_m_p1.b + prt2_m_p1.a) / 2)) AND (((prt1_m_p1.a + prt1_m_p1.b) / 2) = prt2_m_p1.b))
+ -> Seq Scan on prt1_m_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p1
+ Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p2.a = ((prt2_m_p2.b + prt2_m_p2.a) / 2)) AND (((prt1_m_p2.a + prt1_m_p2.b) / 2) = prt2_m_p2.b))
+ -> Seq Scan on prt1_m_p2
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p2
+ Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p3.a = ((prt2_m_p3.b + prt2_m_p3.a) / 2)) AND (((prt1_m_p3.a + prt1_m_p3.b) / 2) = prt2_m_p3.b))
+ -> Seq Scan on prt1_m_p3
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p3
+ Filter: (c = 0)
+(24 rows)
+
+SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
+ a | c | b | c
+-----+---+-----+---
+ 0 | 0 | 0 | 0
+ 50 | 0 | |
+ 100 | 0 | |
+ 150 | 0 | 150 | 0
+ 200 | 0 | |
+ 250 | 0 | |
+ 300 | 0 | 300 | 0
+ 350 | 0 | |
+ 400 | 0 | |
+ 450 | 0 | 450 | 0
+ 500 | 0 | |
+ 550 | 0 | |
+ | | 75 | 0
+ | | 225 | 0
+ | | 375 | 0
+ | | 525 | 0
+(16 rows)
+
+--
+-- tests for list partitioned tables.
+--
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 470 | 0 | 0011
+(1 row)
+
+--
+-- list partitioned by expression
+--
+CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
+ANALYZE plt1_e;
+-- test partition matching with N-way join
+EXPLAIN (COSTS OFF)
+SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Group Key: t1.c, t2.c, t3.c
+ -> Sort
+ Sort Key: t1.c, t3.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = ltrim(t3.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t2.b = t1.b) AND ((t2.c)::text = (t1.c)::text))
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt1_e_p4 t3
+ -> Hash Join
+ Hash Cond: ((t1_1.c)::text = ltrim(t3_1.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t1_1.b = t2_1.b) AND ((t1_1.c)::text = (t2_1.c)::text))
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_e_p1 t3_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = ltrim(t3_2.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t1_2.b = t2_2.b) AND ((t1_2.c)::text = (t2_2.c)::text))
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_e_p2 t3_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = ltrim(t3_3.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t2_3.b = t1_3.b) AND ((t2_3.c)::text = (t1_3.c)::text))
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt1_e_p3 t3_3
+(41 rows)
+
+SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+ avg | avg | avg | c | c | c
+----------------------+---------------------+----------------------+------+------+------
+ 246.5000000000000000 | 22.4666666666666667 | 268.9666666666666667 | 0000 | 0000 | 0000
+ 248.5000000000000000 | 21.3333333333333333 | 269.8333333333333333 | 0002 | 0002 | 0002
+ 249.5000000000000000 | 22.3333333333333333 | 271.8333333333333333 | 0003 | 0003 | 0003
+ 250.5000000000000000 | 23.3333333333333333 | 273.8333333333333333 | 0004 | 0004 | 0004
+ 251.5000000000000000 | 22.7666666666666667 | 274.2666666666666667 | 0005 | 0005 | 0005
+ 252.5000000000000000 | 22.2000000000000000 | 274.7000000000000000 | 0006 | 0006 | 0006
+ 246.0000000000000000 | 23.9655172413793103 | 269.9655172413793103 | 0008 | 0008 | 0008
+ 247.0000000000000000 | 23.3448275862068966 | 270.3448275862068966 | 0009 | 0009 | 0009
+(8 rows)
+
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 470 | 0011
+ | | 235 | 0014
+(8 rows)
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 235 | 0014
+ | | 470 | 0011
+(10 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 47 | 0 | 0013
+ 235 | 0 | 0014
+ 470 | 0 | 0011
+(3 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+----------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Materialize
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(20 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Materialize
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+---
+ 470 | 0 |
+(1 row)
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
Sort
- Sort Key: prt1_m_p1.a, prt2_m_p1.b
- -> Append
- -> Hash Full Join
- Hash Cond: ((prt1_m_p1.a = ((prt2_m_p1.b + prt2_m_p1.a) / 2)) AND (((prt1_m_p1.a + prt1_m_p1.b) / 2) = prt2_m_p1.b))
- -> Seq Scan on prt1_m_p1
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p1
- Filter: (c = 0)
- -> Hash Full Join
- Hash Cond: ((prt1_m_p2.a = ((prt2_m_p2.b + prt2_m_p2.a) / 2)) AND (((prt1_m_p2.a + prt1_m_p2.b) / 2) = prt2_m_p2.b))
- -> Seq Scan on prt1_m_p2
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p2
- Filter: (c = 0)
- -> Hash Full Join
- Hash Cond: ((prt1_m_p3.a = ((prt2_m_p3.b + prt2_m_p3.a) / 2)) AND (((prt1_m_p3.a + prt1_m_p3.b) / 2) = prt2_m_p3.b))
- -> Seq Scan on prt1_m_p3
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p3
- Filter: (c = 0)
-(24 rows)
+ Sort Key: t2.a
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
-SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 50 | 0 | |
- 100 | 0 | |
- 150 | 0 | 150 | 0
- 200 | 0 | |
- 250 | 0 | |
- 300 | 0 | 300 | 0
- 350 | 0 | |
- 400 | 0 | |
- 450 | 0 | 450 | 0
- 500 | 0 | |
- 550 | 0 | |
- | | 75 | 0
- | | 225 | 0
- | | 375 | 0
- | | 525 | 0
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
(16 rows)
---
--- tests for list partitioned tables.
---
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
---
--- list partitioned by expression
---
-CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1_e;
--- test partition matching with N-way join
+-- semi join
EXPLAIN (COSTS OFF)
-SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- QUERY PLAN
---------------------------------------------------------------------------------
- GroupAggregate
- Group Key: t1.c, t2.c, t3.c
- -> Sort
- Sort Key: t1.c, t3.c
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
-> Append
- -> Hash Join
- Hash Cond: (t1.c = ltrim(t3.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1.b = t2.b) AND (t1.c = t2.c))
- -> Seq Scan on plt1_p1 t1
- -> Hash
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_e_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.c = ltrim(t3_1.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1_1.b = t2_1.b) AND (t1_1.c = t2_1.c))
- -> Seq Scan on plt1_p2 t1_1
- -> Hash
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_e_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.c = ltrim(t3_2.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1_2.b = t2_2.b) AND (t1_2.c = t2_2.c))
- -> Seq Scan on plt1_p3 t1_2
- -> Hash
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_e_p3 t3_2
-(32 rows)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(22 rows)
-SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- avg | avg | avg | c | c | c
-----------------------+----------------------+-----------------------+------+------+-------
- 24.0000000000000000 | 24.0000000000000000 | 48.0000000000000000 | 0000 | 0000 | A0000
- 75.0000000000000000 | 75.0000000000000000 | 148.0000000000000000 | 0001 | 0001 | A0001
- 123.0000000000000000 | 123.0000000000000000 | 248.0000000000000000 | 0002 | 0002 | A0002
- 174.0000000000000000 | 174.0000000000000000 | 348.0000000000000000 | 0003 | 0003 | A0003
- 225.0000000000000000 | 225.0000000000000000 | 448.0000000000000000 | 0004 | 0004 | A0004
- 273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
- 324.0000000000000000 | 324.0000000000000000 | 648.0000000000000000 | 0006 | 0006 | A0006
- 375.0000000000000000 | 375.0000000000000000 | 748.0000000000000000 | 0007 | 0007 | A0007
- 423.0000000000000000 | 423.0000000000000000 | 848.0000000000000000 | 0008 | 0008 | A0008
- 474.0000000000000000 | 474.0000000000000000 | 948.0000000000000000 | 0009 | 0009 | A0009
- 525.0000000000000000 | 525.0000000000000000 | 1048.0000000000000000 | 0010 | 0010 | A0010
- 573.0000000000000000 | 573.0000000000000000 | 1148.0000000000000000 | 0011 | 0011 | A0011
-(12 rows)
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(22 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(19 rows)
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
@@ -1241,22 +4028,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
--------------------------------------------------
Hash Left Join
Hash Cond: (t2.b = a)
- -> Append
- -> Hash Join
- Hash Cond: (t3.a = t2.b)
- -> Seq Scan on prt1_p1 t3
- -> Hash
- -> Seq Scan on prt2_p1 t2
- -> Hash Join
- Hash Cond: (t3_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t3_1
- -> Hash
- -> Seq Scan on prt2_p2 t2_1
- -> Hash Join
- Hash Cond: (t3_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t3_2
- -> Hash
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash Join
+ Hash Cond: (t3.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t3
+ -> Seq Scan on prt1_p1 t3_1
+ -> Seq Scan on prt1_p2 t3_2
+ -> Seq Scan on prt1_p3 t3_3
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Result
One-Time Filter: false
@@ -1271,16 +4058,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
-> Hash Left Join
Hash Cond: (t2.b = a)
-> Append
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
Filter: (a = 0)
-> Hash
-> Result
One-Time Filter: false
-(14 rows)
+(20 rows)
--
-- tests for hash partitioned tables.
@@ -1356,41 +4149,9 @@ SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, ph
273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
(6 rows)
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
- Sort
- Sort Key: t1.a
- -> Append
- -> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
- -> Hash
- -> Seq Scan on prt1_p1 t1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
- -> Hash
- -> Seq Scan on prt1_p2 t1_1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
- -> Hash
- -> Seq Scan on prt1_p3 t1_2
- Filter: (b = 0)
-(21 rows)
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
@@ -1405,26 +4166,24 @@ SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c
Sort Key: t1.c
-> HashAggregate
Group Key: t1.c, t2.c
- -> Append
- -> Hash Join
- Hash Cond: (t2.c = t1.c)
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_p1 t1
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_1.c = t1_1.c)
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p1 t1_1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_2.c = t1_2.c)
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p2 t1_2
Filter: ((a % 25) = 0)
-(23 rows)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: ((a % 25) = 0)
+(21 rows)
--
-- multiple levels of partitioning
@@ -1826,64 +4585,70 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2 WHERE t1.a = t2.a;
Hash Join
Hash Cond: (t1.a = t2.a)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Seq Scan on prt4_n_p1 t2
-> Seq Scan on prt4_n_p2 t2_1
-> Seq Scan on prt4_n_p3 t2_2
-(11 rows)
+(13 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2, prt2 t3 WHERE t1.a = t2.a and t1.a = t3.b;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------
Hash Join
- Hash Cond: (t2.a = t1.a)
+ Hash Cond: (t3.b = t1.a)
-> Append
- -> Seq Scan on prt4_n_p1 t2
- -> Seq Scan on prt4_n_p2 t2_1
- -> Seq Scan on prt4_n_p3 t2_2
+ -> Seq Scan on prt2_p0 t3
+ -> Seq Scan on prt2_p1 t3_1
+ -> Seq Scan on prt2_p2 t3_2
+ -> Seq Scan on prt2_p3 t3_3
+ -> Seq Scan on prt2_p4 t3_4
+ -> Seq Scan on prt2_p5 t3_5
-> Hash
- -> Append
- -> Hash Join
- Hash Cond: (t1.a = t3.b)
- -> Seq Scan on prt1_p1 t1
- -> Hash
- -> Seq Scan on prt2_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t1_1
- -> Hash
- -> Seq Scan on prt2_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t1_2
- -> Hash
- -> Seq Scan on prt2_p3 t3_2
+ -> Hash Join
+ Hash Cond: (t1.a = t2.a)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt4_n_p1 t2
+ -> Seq Scan on prt4_n_p2 t2_1
+ -> Seq Scan on prt4_n_p3 t2_2
(23 rows)
-- partitionwise join can not be applied if there are no equi-join conditions
-- between partition keys
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON (t1.a < t2.b);
- QUERY PLAN
----------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------
Nested Loop Left Join
+ Join Filter: (t1.a < t2.b)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
- -> Append
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
- Index Cond: (t1.a < b)
-(12 rows)
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Materialize
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(16 rows)
-- equi-join with join condition on partial keys does not qualify for
-- partitionwise join
@@ -1969,16 +4734,17 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 JOIN prt2_n t2 ON (t1.c = t2.c) JOI
-> Seq Scan on prt2_n_p2 t2_1
-> Hash
-> Hash Join
- Hash Cond: (t3.c = (t1.c)::text)
+ Hash Cond: ((t3.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on plt1_p1 t3
- -> Seq Scan on plt1_p2 t3_1
- -> Seq Scan on plt1_p3 t3_2
+ -> Seq Scan on plt1_p4 t3
+ -> Seq Scan on plt1_p1 t3_1
+ -> Seq Scan on plt1_p2 t3_2
+ -> Seq Scan on plt1_p3 t3_3
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(16 rows)
+(17 rows)
-- partitionwise join can not be applied for a join between list and range
-- partitioned table
@@ -1989,14 +4755,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 FULL JOIN prt1 t2 ON (t1.c = t2.c);
Hash Full Join
Hash Cond: ((t2.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on prt1_p1 t2
- -> Seq Scan on prt1_p2 t2_1
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(10 rows)
+(12 rows)
-- partitionwise join can not be applied if only one of joining table has
-- default partition
@@ -2012,16 +4780,23 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b =
-> Hash Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
diff --git a/src/test/regress/sql/partition_join.sql b/src/test/regress/sql/partition_join.sql
index c1c9859651..0e884835fb 100644
--- a/src/test/regress/sql/partition_join.sql
+++ b/src/test/regress/sql/partition_join.sql
@@ -10,25 +10,39 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
@@ -67,11 +81,19 @@ EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -93,20 +115,30 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
@@ -169,6 +201,128 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
RESET enable_hashjoin;
RESET enable_nestloop;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
--
-- partitioned by multiple columns
--
@@ -193,28 +347,79 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1
--
-- tests for list partitioned tables.
--
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
--
-- list partitioned by expression
--
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
ANALYZE plt1_e;
-- test partition matching with N-way join
@@ -222,6 +427,175 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.a = 1 AND t1.a = 2;
@@ -267,27 +641,18 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
ALTER TABLE plt2 DETACH PARTITION plt2_p3;
ALTER TABLE plt2 ATTACH PARTITION plt2_p3 DEFAULT;
ANALYZE plt2;
-
EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.a % 25 = 0 GROUP BY t1.c, t2.c ORDER BY t1.c, t2.c;
+
--
-- multiple levels of partitioning
--
--
2.16.4
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
@ 2018-11-26 16:03 ` Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Dmitry Dolgov @ 2018-11-26 16:03 UTC (permalink / raw)
To: Thomas Munro <thomas.munro@enterprisedb.com>; +Cc: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers; ashutosh.bapat.oss@gmail.com
> On Mon, Nov 26, 2018 at 1:41 PM Dmitry Dolgov <9erthalion6@gmail.com> wrote:
>
> Thanks, I've messed this up too - rebased a wrong branch, the correct one
> doesn't have this code already. Sorry for that, and here is the proper version
> of this patch.
And one more version, because I haven't fixed the tests (sorry for the noise).
Attachments:
[application/octet-stream] 0002-Targetlist-of-a-child-join-is-produced-by-translating-v15.patch (3.5K, ../../CA+q6zcV8tRQh7R83xmoSZ024BCkKXk1_Bc7EXrPOYsioSMFtyw@mail.gmail.com/2-0002-Targetlist-of-a-child-join-is-produced-by-translating-v15.patch)
download | inline diff:
From bd68b5832f5d0812767223a332eac26c1cf0513b Mon Sep 17 00:00:00 2001
From: erthalion <9erthalion6@gmail.com>
Date: Tue, 11 Sep 2018 21:09:44 +0200
Subject: [PATCH 2/5] Targetlist of a child-join is produced by translating
that of parent join
The next patch adds more general partition matching algorithm for
partition-wise join. With that change, the first pair of joining
relations for the parent joinrel may not produce a partition-wise join
because of the restrictions in partition_bounds_merge(), to be added
in the next patch. Hence the first pair of joining relations, which
is used to build the child join and presented to
build_child_join_rel(), for the child joinrel does not correspond to
the first pair of joining relations for the parent joinrel. The
targetlist built using different pairs have the targetlist entries
arranged in different order. An appendrel expects that all its
children have their targetlists ordered in the same fashion. Hence
translate the parent's targetlist so that parent and child joinrels
have their targetlists in sync.
Basic partition-wise join commit
f49842d1ee31b976c681322f76025d7732e860f3 modified
build_joinrel_tlist() to build targetlist for child-join. With the
above changes we don't need it anymore. Similarly, the same commit
added code to set_append_rel_size() to compute attr_needed for a
child-join relation. That change too is not needed with the above
change. This commit reverts those two changes.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/optimizer/util/relnode.c | 20 ++++++++++++++++++++
1 file changed, 20 insertions(+)
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 39f5729b91..2f1137c13d 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -802,6 +802,19 @@ build_child_join_rel(PlannerInfo *root, RelOptInfo *outer_rel,
appinfos = find_appinfos_by_relids(root, joinrel->relids, &nappinfos);
+ /*
+ * The first pair of joining relations for the parent joinrel may not
+ * produce a partition-wise join because of the restrictions in
+ * partition_bounds_merge(). Hence the first pair of joining relations,
+ * which is used to build the child join and presented here, for the child
+ * joinrel does not correspond to the first pair of joining relations for
+ * the parent joinrel. The targetlist built using different pairs have the
+ * targetlist nodes arranged in different order. An appendrel expects that
+ * all its children have their targetlists ordered in the same fashion.
+ * Hence translate the parent's targetlist so that parent and child
+ * joinrels have their targetlists in sync.
+ */
+ joinrel->reltarget = copy_pathtarget(parent_joinrel->reltarget);
/* Set up reltarget struct */
build_child_join_reltarget(root, parent_joinrel, joinrel,
nappinfos, appinfos);
@@ -907,6 +920,12 @@ build_joinrel_tlist(PlannerInfo *root, RelOptInfo *joinrel,
Relids relids = joinrel->relids;
ListCell *vars;
+ /*
+ * We only see parent joins. Targetlist of a child-join is computed by
+ * translating corresponding parent join's targetlist.
+ */
+ Assert(joinrel->reloptkind == RELOPT_JOINREL);
+
foreach(vars, input_rel->reltarget->exprs)
{
Var *var = (Var *) lfirst(vars);
@@ -934,6 +953,7 @@ build_joinrel_tlist(PlannerInfo *root, RelOptInfo *joinrel,
/* Is it still needed above this joinrel? */
ndx = var->varattno - baserel->min_attr;
+
if (bms_nonempty_difference(baserel->attr_needed[ndx], relids))
{
/* Yup, add it to the output */
--
2.16.4
[application/octet-stream] 0001-Hash-partition-bound-equality-refactoring-v15.patch (5.1K, ../../CA+q6zcV8tRQh7R83xmoSZ024BCkKXk1_Bc7EXrPOYsioSMFtyw@mail.gmail.com/3-0001-Hash-partition-bound-equality-refactoring-v15.patch)
download | inline diff:
From bab6680b6b5f8dff042672fc6e08b9a9cc580353 Mon Sep 17 00:00:00 2001
From: erthalion <9erthalion6@gmail.com>
Date: Tue, 11 Sep 2018 21:08:07 +0200
Subject: [PATCH 1/5] Hash partition bound equality refactoring.
Separate the code to check whether two given hash bounds are equal into a
separate function, so that it can be called from multiple places. Right now
it's only caller is partition_bounds_equal() but later we will use it for
merging partition bounds.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/partitioning/partbounds.c | 95 ++++++++++++++++++++++-------------
1 file changed, 61 insertions(+), 34 deletions(-)
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index eeaab2f4c9..0af3372cdf 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -104,6 +104,9 @@ static void get_range_key_properties(PartitionKey key, int keynum,
Expr **keyCol,
Const **lower_val, Const **upper_val);
static List *get_range_nulltest(PartitionKey key);
+static bool partition_hbounds_equal(PartitionBoundInfo b1,
+ PartitionBoundInfo b2);
+
/*
* get_qual_from_partbound
@@ -652,6 +655,63 @@ create_range_bounds(PartitionBoundSpec **boundspecs, int nparts,
return boundinfo;
}
+/*
+ * Are two hash partition bound collections logically equal?
+ *
+ * Hash partition bounds store modulus and remainder in datums array which are
+ * always integers irrespective of the number of partition keys and their data
+ * types. Hence we can compare the hash bound collection without any partition
+ * key specific information. Separating this logic in a function which does not
+ * require partition key specific information allows it be called from places
+ * where the partition key specific information is not completely available.
+ */
+static bool
+partition_hbounds_equal(PartitionBoundInfo b1, PartitionBoundInfo b2)
+{
+ int greatest_modulus = get_hash_partition_greatest_modulus(b1);
+ int i;
+
+ Assert(b1->strategy == PARTITION_STRATEGY_HASH &&
+ b2->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * If two hash partitioned tables have different greatest moduli,
+ * their partition schemes don't match. For hash partitioned table,
+ * the greatest modulus is given by the last datum and number of
+ * partitions is given by ndatums.
+ */
+ if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ return false;
+
+ /*
+ * We arrange the partitions in the ascending order of their modulus and
+ * remainders. Also every modulus is factor of next larger modulus.
+ * Therefore we can safely store index of a given partition in indexes
+ * array at remainder of that partition. Also entries at (remainder + N *
+ * modulus) positions in indexes array are all same for (modulus,
+ * remainder) specification for any partition. Thus datums array from both
+ * the given bounds are same, if and only if their indexes array will be
+ * same. So, it suffices to compare indexes array.
+ */
+ for (i = 0; i < greatest_modulus; i++)
+ if (b1->indexes[i] != b2->indexes[i])
+ return false;
+
+#ifdef USE_ASSERT_CHECKING
+
+ /*
+ * Nonetheless make sure that the bounds are indeed same when the indexes
+ * match. Hash partition bound stores modulus and remainder at
+ * b1->datums[i][0] and b1->datums[i][1] position respectively.
+ */
+ for (i = 0; i < b1->ndatums; i++)
+ Assert((b1->datums[i][0] == b2->datums[i][0] &&
+ b1->datums[i][1] == b2->datums[i][1]));
+#endif
+
+ return true;
+}
+
/*
* Are two partition bound collections logically equal?
*
@@ -680,41 +740,8 @@ partition_bounds_equal(int partnatts, int16 *parttyplen, bool *parttypbyval,
if (b1->strategy == PARTITION_STRATEGY_HASH)
{
- int greatest_modulus = get_hash_partition_greatest_modulus(b1);
-
- /*
- * If two hash partitioned tables have different greatest moduli,
- * their partition schemes don't match.
- */
- if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ if (!partition_hbounds_equal(b1, b2))
return false;
-
- /*
- * We arrange the partitions in the ascending order of their moduli
- * and remainders. Also every modulus is factor of next larger
- * modulus. Therefore we can safely store index of a given partition
- * in indexes array at remainder of that partition. Also entries at
- * (remainder + N * modulus) positions in indexes array are all same
- * for (modulus, remainder) specification for any partition. Thus
- * datums array from both the given bounds are same, if and only if
- * their indexes array will be same. So, it suffices to compare
- * indexes array.
- */
- for (i = 0; i < greatest_modulus; i++)
- if (b1->indexes[i] != b2->indexes[i])
- return false;
-
-#ifdef USE_ASSERT_CHECKING
-
- /*
- * Nonetheless make sure that the bounds are indeed same when the
- * indexes match. Hash partition bound stores modulus and remainder
- * at b1->datums[i][0] and b1->datums[i][1] position respectively.
- */
- for (i = 0; i < b1->ndatums; i++)
- Assert((b1->datums[i][0] == b2->datums[i][0] &&
- b1->datums[i][1] == b2->datums[i][1]));
-#endif
}
else
{
--
2.16.4
[application/octet-stream] 0003-Partition-wise-join-for-1-1-1-0-0-1-partition-matching-v15.patch (69.5K, ../../CA+q6zcV8tRQh7R83xmoSZ024BCkKXk1_Bc7EXrPOYsioSMFtyw@mail.gmail.com/4-0003-Partition-wise-join-for-1-1-1-0-0-1-partition-matching-v15.patch)
download | inline diff:
From 7adc97a2c1849d85cdce9dac2047d27347396924 Mon Sep 17 00:00:00 2001
From: erthalion <9erthalion6@gmail.com>
Date: Tue, 11 Sep 2018 21:10:46 +0200
Subject: [PATCH 3/5] Partition-wise join for 1:1, 1:0, 0:1 partition matching.
Earlier version of partition-wise join implementation allowed
partition-wise join between two relations with exactly same partition
bounds. This commit allows partition-wise join to be applied under
following conditions
1. the partition bounds of joining relations are such that rows from
given partition on one side join can join with rows from maximum one
partition on the other side i.e. bounds of a given partition on one
side match/overlap with those of maximum one partition on the other
side. If the mapping happens to be m:n where m > 1 or n > 1, we have
to gang multiple partition relations together into a single relation.
This means that we have to add simple relations during join
processing, something which is not supported right now. ALso, in such
a case, different pairs of joining relations can produce different
partition bounds for the same join relation, which again is not
supported right now.
2. For every partition on outer side that can contribute to the result
of an OUTER join, there exists at least one (taken along with item 1,
it means exactly one) matching partition on the inner side. To
support partition-wise join when the inner matching partition doesn't
exist, we have to add a dummy base relation corresponding to the
non-existent inner partition. We don't have support to add base
relations during join processing.
3. For hash partitioned tables however, we support partition-wise join
only when the bounds exactly match. For hash partitioning it's unusual
to have missing partitions and hence generic partition matching is not
required.
With advanced partition matching, we won't be able to apply
partition-wise join when there are missing matching partitions. So for
a given N-way join, some sub-joins may not be partitioned, while the
overall N-way join is partitioned. We can not try partition-wise join
when one or both of the joining relations are not partitioned in one
of the pairs of joining relation. Skip partition-wise join for that
pair.
An example is A IJ B LJ C where B has an extra partition compared to A
and C. Join B LJ C requires dummy relation to join the extra partition
from B to a missing partition from C, and hence can not use
partition-wise join right now and hence BC is not partitioned. The
extra partition in B gets eliminated in A IJ B and thus it can use
partition-wise join and is partitioned. Hence (AB)C can use
partition-wise join but not A(BC).
Not every pair of joining relation (including the one presented to
build_joinrel_partition_info()) for the same joinrel can use
partition-wise join or has both the relations partitioned. Hence we
calculate the partition bounds for the join relation in
try_partition_wise_join() instead of doing it here.
The partition bounds produced for the first pair that can use
partition-wise are saved in the RelOptInfo of the joinrel. Partition
bounds produced for subsequent pairs should match that produced by the
first pair.
Support for default partition in list partitioned tables
========================================================
When a list value is present in one of the joining relations and not
the other, and the other relation has default partition, match (join)
the partition containing that list value with the default partition.
If there are multiple matches, we can not proceed with the
partition-wise join similar to the case of matching non-default
partition. If the default partition happens to be on the outer side of
the join, the resulting join partition acts as a default partition as
it will contain all the values from the default partition. If
the partition containing the list value happens to be on the outer
side of the join, the resulting join partition is associated with the
list value, since no other partition key value from the default
partition makes it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a partition from the inner side,
if inner side has a list value that is not present in the outer side.
But if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Support for matching default partition in range partitioned tables
==================================================================
When a range is present in one of the joining relations and not the
other, and the other relation has default partition, match (join) the
partition corresponding range with the default partition. If two
ranges overlap but their ranges don't match exactly, the
non-overlapping portion from one range may join the previous
(non-overlapping portion near the lower bound, if exists), next
(non-overlapping portion near the upper bound, if exists) ranges from
the other relation or default partition from the other relation. This
causes multiple partitions on the other side to be joined with a
single partition on the first side; a case we don't support. Any range
from one side which doesn't overlap with any range on the other side,
may find its join partner in the default partition and the
corresponding range partition will need to be joined with the default
partition. If the default partition happens to be on the outer side
of the join, the resulting join partition acts as a default partition
as it will contain all the values from the default partition. If the
non-partition corresponding to the range happens to be on the outer
side of the join, the resulting join partition is associated with that
range, since partition key values from the default partition outside
that range won't make it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a non-default partition from the
inner side, if inner side has a range missing in the outer side. But
if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/optimizer/path/joinrels.c | 95 +-
src/backend/optimizer/util/relnode.c | 33 +-
src/backend/partitioning/partbounds.c | 1676 ++++++++++++++++++++++++++++++++-
src/include/partitioning/partbounds.h | 5 +
4 files changed, 1763 insertions(+), 46 deletions(-)
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index d3d21fed5d..e476079143 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1312,25 +1312,31 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
RelOptInfo *joinrel, SpecialJoinInfo *parent_sjinfo,
List *parent_restrictlist)
{
- int nparts;
int cnt_parts;
+ PartitionScheme part_scheme;
+ PartitionBoundInfo join_boundinfo;
+ List *parts1;
+ List *parts2;
+ ListCell *lc1;
+ ListCell *lc2;
/* Guard against stack overflow due to overly deep partition hierarchy. */
check_stack_depth();
/* Nothing to do, if the join relation is not partitioned. */
- if (!IS_PARTITIONED_REL(joinrel))
+ if (joinrel->part_scheme == NULL)
return;
/* The join relation should have consider_partitionwise_join set. */
Assert(joinrel->consider_partitionwise_join);
/*
- * Since this join relation is partitioned, all the base relations
- * participating in this join must be partitioned and so are all the
- * intermediate join relations.
+ * We can not perform partition-wise join if either of the joining
+ * relations is not partitioned.
*/
- Assert(IS_PARTITIONED_REL(rel1) && IS_PARTITIONED_REL(rel2));
+ if (!IS_PARTITIONED_REL(rel1) || !IS_PARTITIONED_REL(rel2))
+ return;
+
Assert(REL_HAS_ALL_PART_PROPS(rel1) && REL_HAS_ALL_PART_PROPS(rel2));
/* The joining relations should have consider_partitionwise_join set. */
@@ -1343,32 +1349,63 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
*/
Assert(joinrel->part_scheme == rel1->part_scheme &&
joinrel->part_scheme == rel2->part_scheme);
+ part_scheme = joinrel->part_scheme;
/*
- * 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.
+ * Get the list of matching partitions to be joined along with the
+ * partition bounds of the join relation. Because of the restrictions
+ * imposed by partition matching algorithm, not every pair of joining
+ * relations for this join will be able to use partition-wise join. But all
+ * those pairs which can use partition-wise join will produce the same
+ * partition bounds for the join relation.
*/
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel1->boundinfo));
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel2->boundinfo));
+ join_boundinfo = partition_bounds_merge(part_scheme->partnatts,
+ part_scheme->partsupfunc,
+ part_scheme->partcollation,
+ rel1, rel2,
+ parent_sjinfo->jointype,
+ &parts1, &parts2);
+
+ if (join_boundinfo == NULL)
+ return;
- nparts = joinrel->nparts;
+ if (joinrel->boundinfo == NULL)
+ {
+ Assert(joinrel->nparts == 0 && joinrel->part_rels == NULL);
+ joinrel->boundinfo = join_boundinfo;
+ joinrel->nparts = list_length(parts1);
+ Assert(joinrel->nparts == list_length(parts2));
+ joinrel->part_rels =
+ (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+ joinrel->nparts);
+ }
+ else
+ {
+ Assert(partition_bounds_equal(part_scheme->partnatts,
+ part_scheme->parttyplen,
+ part_scheme->parttypbyval,
+ join_boundinfo, joinrel->boundinfo));
+ /*
+ * Every pair of joining relations should result in the same number
+ * of child-joins.
+ */
+ Assert(joinrel->nparts == list_length(parts1));
+ Assert(joinrel->nparts == list_length(parts2));
+ Assert(joinrel->part_rels);
+ }
/*
* Create child-join relations for this partitioned join, if those don't
* exist. Add paths to child-joins for a pair of child relations
* corresponding to the given pair of parent relations.
*/
- for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+ cnt_parts = 0;
+ forboth(lc1, parts1, lc2, parts2)
{
- RelOptInfo *child_rel1 = rel1->part_rels[cnt_parts];
- RelOptInfo *child_rel2 = rel2->part_rels[cnt_parts];
+ int part1 = lfirst_int(lc1);
+ int part2 = lfirst_int(lc2);
+ RelOptInfo *child_rel1;
+ RelOptInfo *child_rel2;
SpecialJoinInfo *child_sjinfo;
List *child_restrictlist;
RelOptInfo *child_joinrel;
@@ -1376,6 +1413,10 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
AppendRelInfo **appinfos;
int nappinfos;
+ Assert(part1 >= 0 && part2 >= 0);
+ child_rel1 = rel1->part_rels[part1];
+ child_rel2 = rel2->part_rels[part2];
+
/* We should never try to join two overlapping sets of rels. */
Assert(!bms_overlap(child_rel1->relids, child_rel2->relids));
child_joinrelids = bms_union(child_rel1->relids, child_rel2->relids);
@@ -1409,12 +1450,24 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
joinrel->part_rels[cnt_parts] = child_joinrel;
}
+ /*
+ * For every pair of joining relations, the set of matching partitions
+ * would change. However, the base relation partitions constituting
+ * the given child should remain same for all the joining pairs. Since
+ * the order in which children are stored in the array of child-joins,
+ * depends upon partition bounds of the join, which are same for all
+ * the joining pairs, every joining pair yields the child-joins in the
+ * same order.
+ */
Assert(bms_equal(child_joinrel->relids, child_joinrelids));
populate_joinrel_with_paths(root, child_rel1, child_rel2,
child_joinrel, child_sjinfo,
child_restrictlist);
+ cnt_parts++;
}
+
+ Assert(cnt_parts == joinrel->nparts);
}
/*
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 2f1137c13d..4f15cd8e8b 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1627,7 +1627,7 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
* of the way the query planner deduces implied equalities and reorders
* the joins. Please see optimizer/README for details.
*/
- if (!IS_PARTITIONED_REL(outer_rel) || !IS_PARTITIONED_REL(inner_rel) ||
+ if (outer_rel->part_scheme == NULL || inner_rel->part_scheme == NULL ||
!outer_rel->consider_partitionwise_join ||
!inner_rel->consider_partitionwise_join ||
outer_rel->part_scheme != inner_rel->part_scheme ||
@@ -1640,24 +1640,6 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
part_scheme = outer_rel->part_scheme;
- Assert(REL_HAS_ALL_PART_PROPS(outer_rel) &&
- REL_HAS_ALL_PART_PROPS(inner_rel));
-
- /*
- * For now, our partition matching algorithm can match partitions only
- * when the partition bounds of the joining relations are exactly same.
- * So, bail out otherwise.
- */
- if (outer_rel->nparts != inner_rel->nparts ||
- !partition_bounds_equal(part_scheme->partnatts,
- part_scheme->parttyplen,
- part_scheme->parttypbyval,
- outer_rel->boundinfo, inner_rel->boundinfo))
- {
- Assert(!IS_PARTITIONED_REL(joinrel));
- return;
- }
-
/*
* This function will be called only once for each joinrel, hence it
* should not have partition scheme, partition bounds, partition key
@@ -1669,17 +1651,20 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
/*
* Join relation is partitioned using the same partitioning scheme as the
- * joining relations and has same bounds.
+ * joining relations.
+ *
+ * Because of restrictions in partition_bounds_merge(), not every pair of
+ * joining relations (including the one presented to this function) for the
+ * same joinrel can use partition-wise join or has both the relations
+ * partitioned. Hence we calculate the partition bounds, number of
+ * partitions and child-join relations of the join relation when and if we
+ * find a suitable pair in try_partition_wise_join().
*/
joinrel->part_scheme = part_scheme;
- joinrel->boundinfo = outer_rel->boundinfo;
partnatts = joinrel->part_scheme->partnatts;
joinrel->partexprs = (List **) palloc0(sizeof(List *) * partnatts);
joinrel->nullable_partexprs =
(List **) palloc0(sizeof(List *) * partnatts);
- joinrel->nparts = outer_rel->nparts;
- joinrel->part_rels =
- (RelOptInfo **) palloc0(sizeof(RelOptInfo *) * joinrel->nparts);
/*
* Set the consider_partitionwise_join flag.
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index 0af3372cdf..771520379d 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -65,6 +65,12 @@ typedef struct PartitionRangeBound
bool lower; /* this is the lower (vs upper) bound */
} PartitionRangeBound;
+typedef struct PartitionMap
+{
+ int from;
+ int to;
+} PartitionMap;
+
static int32 qsort_partition_hbound_cmp(const void *a, const void *b);
static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
void *arg);
@@ -106,7 +112,58 @@ static void get_range_key_properties(PartitionKey key, int keynum,
static List *get_range_nulltest(PartitionKey key);
static bool partition_hbounds_equal(PartitionBoundInfo b1,
PartitionBoundInfo b2);
-
+static PartitionBoundInfo partition_range_bounds_merge(
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype, int partnatts,
+ FmgrInfo *supfuncs, Oid *collations);
+static PartitionBoundInfo partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *collations,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype);
+static PartitionBoundInfo partition_hash_bounds_merge(RelOptInfo *outer_rel,
+ RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype);
+static void generate_matching_part_pairs(PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ int nparts1, int nparts2,
+ JoinType jointype, int nparts,
+ List **parts1, List **parts2);
+static PartitionBoundInfo build_merged_partition_bounds(char strategy,
+ List *merged_datums, List *merged_indexes,
+ List *merged_contents, int null_index,
+ int default_index);
+static int map_and_merge_partitions(PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ int index1, int index2, int *next_index);
+static int32 partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *collations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2);
+static bool partition_range_cmp(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval);
+static bool partition_range_merge_next_lb(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes);
+static bool merge_default_partitions(PartitionBoundInfo outer_bi,
+ PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ JoinType jointype,
+ int *next_index, int *default_index);
+static bool merge_null_partitions(PartitionBoundInfo outer_bi,
+ PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ JoinType jointype,
+ int *next_index, int *null_index,
+ int *default_index);
/*
* get_qual_from_partbound
@@ -2941,3 +2998,1620 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
PG_RETURN_BOOL(rowHash % modulus == remainder);
}
+
+/*
+ * partition_bounds_merge
+ *
+ * The function produces the partition bounds for a join between two relations
+ * whose partition bounds are given. The function also returns two lists of
+ * partition indexes one for each of the joining relations. Both the lists
+ * contain the same number of elements. The partition indexes at the same
+ * positions in the lists indicate the pair partitions, one from each side, to
+ * be joined and the position itself corresponds to the index of partition
+ * produced by that child-join in the partitioned join.
+ *
+ * The function returns NULL if we can not find the matching pair of
+ * partitions. This happens if 1. multiple partitions on one side match with
+ * one partition on the other side. 2. a given partition on the outer side
+ * doesn't have a matching partition on the inner side. We can not support the
+ * first case since we don't have a way to represent multiple partitions as a
+ * single relation (RelOptInfo) and then perform join using the ganged
+ * relation. We can not support the second case since the missing inner
+ * partition needs to be represented as an empty relation and we don't have a
+ * way to introduce empty relation during join planning after creating paths
+ * for all the base relations.
+ */
+extern PartitionBoundInfo
+partition_bounds_merge(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts)
+{
+ PartitionBoundInfo merged_bounds;
+ PartitionBoundInfo outer_binfo = outer_rel->boundinfo,
+ inner_binfo = inner_rel->boundinfo;
+ char strategy = outer_binfo->strategy;
+
+ /* Bail out if partitioning strategies are different. */
+ if (outer_binfo->strategy != inner_binfo->strategy)
+ return NULL;
+
+ if (jointype != JOIN_LEFT && jointype != JOIN_INNER &&
+ jointype != JOIN_SEMI && jointype != JOIN_ANTI &&
+ jointype != JOIN_FULL)
+ elog(ERROR, "unexpected join type %d", jointype);
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+ switch (strategy)
+ {
+ case PARTITION_STRATEGY_LIST:
+ merged_bounds = partition_list_bounds_merge(partsupfunc,
+ partcollation,
+ outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype);
+ break;
+
+ case PARTITION_STRATEGY_RANGE:
+ merged_bounds = partition_range_bounds_merge(outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype, partnatts,
+ partsupfunc,
+ partcollation);
+ break;
+
+ case PARTITION_STRATEGY_HASH:
+ merged_bounds = partition_hash_bounds_merge(outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype);
+ break;
+
+ default:
+ elog(ERROR, "unexpected partition strategy: %d", strategy);
+ }
+
+ Assert(merged_bounds || (*outer_parts == NIL && *inner_parts == NIL));
+
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+
+ Assert((*outer_parts == NIL || *inner_parts != NIL) &&
+ (*inner_parts == NIL || *outer_parts != NIL));
+
+ return merged_bounds;
+}
+
+/*
+ * partition_get_range_bounds
+ *
+ * Given the index of lower bound in datums array, return lower and upper
+ * bounds and the index of the partition with that lower bound.
+ */
+static int
+partition_get_range_bounds(PartitionBoundInfo bi, int lb_index,
+ PartitionRangeBound *lower,
+ PartitionRangeBound *upper)
+{
+ int part_index;
+
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The lower bound should correspond to a valid partition. */
+ part_index = bi->indexes[lb_index + 1];
+ Assert(part_index >= 0);
+
+ lower->kind = bi->kind[lb_index];
+ lower->datums = bi->datums[lb_index];
+ lower->lower = true;
+ upper->kind = bi->kind[lb_index + 1];
+ upper->datums = bi->datums[lb_index + 1];
+ upper->lower = false;
+
+ return part_index;
+}
+
+/*
+ * partition_range_get_next_lb_index
+ *
+ * Given the index of lower bound in datums array return the
+ * index of lower bound of the next partition. When the given index corresponds
+ * to the last partition, return number of datums (ndatums).
+ */
+static int
+partition_range_get_next_lb_index(PartitionBoundInfo bi, int lb_index)
+{
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The partition index corresponding to the upper bound should be valid. */
+ Assert(bi->indexes[lb_index + 1] >= 0);
+
+ /*
+ * If there are no bounds left beyond the upper bound, we have reached the
+ * last partition.
+ */
+ if (lb_index + 2 < bi->ndatums)
+ {
+ /*
+ * If the bound next to the upper bound corresponds to no partition,
+ * that's the next lower bound of the next partition. Otherwise, the
+ * current upper bound is the lower bound of the next partition.
+ */
+ if (bi->indexes[lb_index + 2] < 0)
+ return lb_index + 2;
+ else
+ return lb_index + 1;
+ }
+ else
+ return bi->ndatums;
+}
+
+static int32
+partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2)
+{
+ return partition_rbound_cmp(partnatts, partsupfunc, partcollations,
+ bound1->datums, bound1->kind, bound1->lower,
+ bound2);
+}
+
+/*
+ * partition_range_cmp
+ *
+ * Compare the bounds of two range partitions. Set ub_cmpval <, = or > 0, if the
+ * first partition's upper bound is lower than, equal to or higher than the
+ * second partition's upper bound resp. Similarly set lb_cmpval <, = or > 0,
+ * if the first partition's lower bound is lower than, equal to or higher than
+ * the second partition's lower bound resp.
+ *
+ * Return true, if the ranges overlap, otherwise return false.
+ */
+static bool
+partition_range_cmp(int partnatts, FmgrInfo *partsupfuncs, Oid *partcollations,
+ PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval)
+{
+ bool overlap;
+
+ /*
+ * Compare upper bound of the first partition with the lower bound of the
+ * second and vice-versa. If lower bound is higher than the upper bound,
+ * the partitions are not overlapping. All other cases indicate overlapping
+ * partitions.
+ */
+ if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound1, upper_bound2) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = 1;
+ *lb_cmpval = 1;
+ }
+ else if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound2, upper_bound1) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = -1;
+ *lb_cmpval = -1;
+ }
+ else
+ {
+ overlap = true;
+ *ub_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, upper_bound1,
+ upper_bound2);
+ *lb_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, lower_bound1,
+ lower_bound2);
+ }
+
+ return overlap;
+}
+
+/*
+ * partition_range_merge
+ *
+ * Merge the partition bounds of given two partitions such that the join
+ * between the given two partitions fits merged bounds.
+ *
+ * "merged_upper" will be set to one of the given upper bounds and
+ * "merged_lower" will be set to one of the given lower bounds.
+ */
+static void
+partition_range_merge(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, JoinType jointype,
+ PartitionRangeBound *left_lb,
+ PartitionRangeBound *left_ub,
+ PartitionRangeBound *right_lb,
+ PartitionRangeBound *right_ub,
+ PartitionRangeBound **merged_lb,
+ PartitionRangeBound **merged_ub)
+{
+ /*
+ * An outer join will have all the rows from the outer side, so merged
+ * bounds will be same as the outer bounds. An inner join will have rows
+ * that fit both the bounds, thus lower merged bound will be higher of two
+ * lower bounds and upper merged bound will be lower of the two upper
+ * bounds.
+ */
+ switch (jointype)
+ {
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ *merged_ub = left_ub;
+ *merged_lb = left_lb;
+ break;
+
+ case JOIN_INNER:
+ case JOIN_SEMI:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) < 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) > 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ case JOIN_FULL:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) > 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) < 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ default:
+ elog(ERROR, "unexpected join type %d", jointype);
+ }
+
+ return;
+}
+
+/*
+ * Add the lower bound of the next range to the list of bounds, if the lower
+ * bound is higher or equal to the previous upper bound. If successful return
+ * true, otherwise false.
+ */
+static bool
+partition_range_merge_next_lb(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes)
+{
+ int cmpval;
+
+ if (!*merged_datums)
+ {
+ Assert(!*merged_kinds && !*merged_indexes);
+ cmpval = 1;
+ }
+ else
+ {
+ PartitionRangeBound prev_ub;
+
+ prev_ub.datums = llast(*merged_datums);
+ prev_ub.kind = llast(*merged_kinds);
+ prev_ub.lower = false;
+
+ cmpval = partition_rbound_cmp(partnatts, partsupfuncs, partcollations,
+ next_lb_datums, next_lb_kind, false,
+ &prev_ub);
+ }
+
+ /*
+ * The lower bound is lower than the last upper bound, thus does not fit
+ * the bounds created so far and hence can not be merged with the existing
+ * bounds.
+ */
+ if (cmpval < 0)
+ return false;
+
+ /*
+ * Add bounds of the new merged partition. If the next lower bound is
+ * higher than the last upper bound, add new range with index
+ * corresponding to the lower bound as -1. If the merged lower bound
+ * is same as the last merged upper bound, the last upper bound will be
+ * reused as the lower bound of the next range.
+ */
+ if (cmpval > 0)
+ {
+ *merged_datums = lappend(*merged_datums, next_lb_datums);
+ *merged_kinds = lappend(*merged_kinds, next_lb_kind);
+ *merged_indexes = lappend_int(*merged_indexes, -1);
+ }
+
+ return true;
+}
+
+/*
+ * handle_missing_partition
+ *
+ * If a range appears in one of the joining relations but not the other, a row
+ * in the corresponding partition will not have any join partner in the other
+ * relation, unless the other relation has a default partition. If a given list
+ * value is present in one joining relation but not the other, the default
+ * partition on the other side may contain that value.
+ *
+ * In both these cases, such an extra partition forms a joining pair with the
+ * default partition, if any, on the other side.
+ *
+ * If the default partition happens to be on the outer side of the join, the
+ * resultant partition will act as the default partition of the join relation.
+ * Otherwise the resultant partition will be associated with the range.
+ *
+ * When the default partition is not present in the other relation, the rows in
+ * the extra partition will be included in the bounds of the join result, if it
+ * appears on the outer side of the join, since all rows from the outer side
+ * are included in the join result.
+ *
+ * This function handles all these cases.
+ *
+ * maps_with_missing and missing_side_default are the partition maps (See
+ * partition_range/list_bounds_merge() for details) and the index of default
+ * partition respectively corresponding the side with missing partition.
+ *
+ * maps_with_extra and extra_part are the partition maps (See
+ * partition_range/list_bounds_merge() for details) and the index of extra
+ * partition respectively corresponding to the side with the extra partition.
+ *
+ * It returns true if the matching succeeds, otherwise returns false.
+ */
+static bool
+handle_missing_partition(PartitionMap *maps_with_missing,
+ PartitionMap *maps_with_extra,
+ int missing_side_default,
+ int extra_part,
+ bool missing_side_outer,
+ bool missing_side_inner,
+ int *next_index, int *default_index,
+ int *merged_index)
+{
+ bool missing_has_default = (missing_side_default != -1);
+
+ if (missing_has_default)
+ {
+ *merged_index = map_and_merge_partitions(maps_with_missing,
+ maps_with_extra,
+ missing_side_default,
+ extra_part,
+ next_index);
+ if (*merged_index < 0)
+ return false;
+
+ if (missing_side_outer)
+ {
+ /*
+ * Default partition on the outer side forms the default
+ * partition of the join result.
+ */
+ if (*default_index < 0)
+ *default_index = *merged_index;
+ else if(*default_index != *merged_index)
+ {
+ /*
+ * Ended up with default partition on the outer side
+ * being joined with multiple partitions on the inner
+ * side. We don't support this case.
+ */
+ return false;
+ }
+
+ /*
+ * Since the merged partition acts as a default partition, it
+ * doesn't need a separate index.
+ */
+ *merged_index = -1;
+ }
+ }
+ else if (missing_side_inner)
+ {
+ /*
+ * If this partition has already been mapped (say because we
+ * found an overlapping range earlier), we know where does it
+ * fit in the join result. Nothing to do in that case. Else
+ * create a new merged partition.
+ */
+ PartitionMap *extra_map = &maps_with_extra[extra_part];
+ if (extra_map->to < 0)
+ {
+ extra_map->to = *next_index;
+ *next_index = *next_index + 1;
+ *merged_index = extra_map->to;
+ }
+ }
+
+ return true;
+}
+
+static PartitionMap*
+init_partition_map(RelOptInfo *rel)
+{
+ int i, nparts = rel->nparts;
+ PartitionMap *map;
+
+ map = (PartitionMap *) palloc(sizeof(PartitionMap) * nparts);
+
+ for (i = 0; i < nparts; i++)
+ {
+ map[i].from = -1;
+ map[i].to = -1;
+ }
+
+ return map;
+}
+
+/*
+ * Allocate and initialize partition maps. We maintain four maps, two maps
+ * for each joining relation. pmap[i] gives the partition from the other
+ * relation which would join with ith partition of the given relation.
+ * Partition i from the given relation will join with partition pmap[i]
+ * from the other relation to produce partition mmap[i] of the join (merged
+ * partition).
+ *
+ * pmap[i] = -1 indicates that ith partition of a given relation does not
+ * have a matching partition from the other relation.
+ *
+ * mmap[i] = -1 indicates that ith partition of a given relation does not
+ * contribute to the join result. That can happen only when the given
+ * relation is the inner relation and it doesn't have a matching partition
+ * from the outer relation, hence pmap[i] should be -1.
+ *
+ * In case of an outer join, every partition of the outer join will appear
+ * in the join result, and thus has mmap[i] set for all i. But it's not
+ * necessary that every partition on the outer side will have a matching
+ * partition on the inner side. In such a case, we end up with pmap[i] = -1
+ * and mmap[i] != -1.
+ */
+
+/*
+ * partition_range_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for range partitioned tables.
+ */
+static PartitionBoundInfo
+partition_range_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype, int partnatts,
+ FmgrInfo *partsupfuncs, Oid *partcollations)
+
+{
+ PartitionMap *outer_maps = NULL;
+ PartitionMap *inner_maps = NULL;
+ int outer_part = 0;
+ int inner_part = 0;
+ PartitionBoundInfo merged_bounds = NULL;
+ int outer_lb_index;
+ int inner_lb_index;
+ int next_index;
+ int default_index = -1;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ List *merged_kinds = NIL;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int inner_default = inner_bi->default_index;
+ int outer_default = outer_bi->default_index;
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_RANGE);
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ outer_maps = init_partition_map(outer_rel);
+ inner_maps = init_partition_map(inner_rel);
+
+ /*
+ * Merge the ranges (partitions) from both sides. Every iteration compares
+ * a pair of ranges, one from each side, advancing to the next range from
+ * the side with smaller upper range bound. If upper bounds of ranges from
+ * both sides match exactly, both the sides are advanced. For a given pair
+ * of ranges, we decide whether the corresponding partition match or not.
+ * lb_index, for inner or outer side, keeps track of the index of lower bound
+ * datum in PartitionBoundInfo::datums of that side.
+ */
+ outer_lb_index = 0;
+ inner_lb_index = 0;
+ next_index = 0;
+ while (outer_lb_index < outer_bi->ndatums ||
+ inner_lb_index < inner_bi->ndatums)
+ {
+ PartitionRangeBound outer_lb, outer_ub,
+ inner_lb, inner_ub,
+ *merged_lb = NULL,
+ *merged_ub = NULL;
+
+ int merged_index = -1;
+ bool overlap;
+ bool finished_outer = false;
+ bool finished_inner = false;
+
+ /* Result of bounds comparison per partition_rbound_cmp(). */
+ int ub_cmpval; /* Upper bounds comparison result. */
+ int lb_cmpval; /* Lower bounds comparison result. */
+
+ /* Get the range bounds of the next pair of partitions. */
+ if (outer_lb_index < outer_bi->ndatums)
+ outer_part = partition_get_range_bounds(outer_bi, outer_lb_index,
+ &outer_lb, &outer_ub);
+ else
+ finished_outer = true;
+
+ if (inner_lb_index < inner_bi->ndatums)
+ inner_part = partition_get_range_bounds(inner_bi, inner_lb_index,
+ &inner_lb, &inner_ub);
+ else
+ finished_inner = true;
+
+ Assert(!finished_outer || !finished_inner);
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining partitions on the side
+ * which finishes later. For that we set the comparison parameters
+ * overlap, ub_cmpval and lb_cmpval in such a way that it appears as if
+ * the side which finishes earlier has an extra partition with lower
+ * and upper bounds higher than any other partition of the unfinished
+ * side. That way we advance the partitions on that side till all of
+ * them are exhausted.
+ */
+ if (finished_outer)
+ {
+ overlap = false;
+ ub_cmpval = 1;
+ lb_cmpval = 1;
+ }
+ else if (finished_inner)
+ {
+ overlap = false;
+ ub_cmpval = -1;
+ lb_cmpval = -1;
+ }
+ else
+ overlap = partition_range_cmp(partnatts, partsupfuncs, partcollations,
+ &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &ub_cmpval, &lb_cmpval);
+
+ if (overlap)
+ {
+ /*
+ * The rows from overlapping portion of ranges on both sides may
+ * join, hence the corresponding pair of partitions form a joining
+ * pair. Match them and produce the bounds of the joint partition
+ * and its index by merging the bounds according to the type of
+ * join.
+ */
+ partition_range_merge(partnatts, partsupfuncs, partcollations,
+ jointype, &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &merged_lb, &merged_ub);
+
+ merged_index = map_and_merge_partitions(outer_maps, inner_maps,
+ outer_part, inner_part,
+ &next_index);
+
+ if (merged_index < 0)
+ {
+ /* Failed to match the partitions. */
+ return NULL;
+ }
+
+ /*
+ * If the ranges overlap but don't exactly match, a row from
+ * non-overlapping portion of the range from one side of join may
+ * find its join partner in the previous or next overlapping
+ * partition or default partition on the other side , if such a
+ * partition exists. All those cases, if true, will cause one
+ * partition from that side to match at least two partitions on the
+ * other side; a case that we do not support now. Previous
+ * partition has been delt with in the previous iteration of this
+ * loop, next partition will be delt in the next iteration. We will
+ * deal with the default partition here.
+ */
+ if ((lb_cmpval < 0 && inner_has_default) ||
+ /* Non-overlapping range on the lower side of outer range. */
+ (lb_cmpval > 0 && outer_has_default) ||
+ /* Non-overlapping range on the lower side of inner range. */
+ (ub_cmpval < 0 && outer_has_default) ||
+ /* Non-overlapping range on the upper side of inner range. */
+ (ub_cmpval > 0 && inner_has_default))
+ /* Non-overlapping range on the upper side of outer range. */
+ return NULL;
+ }
+
+ if (ub_cmpval == 0)
+ {
+ /* Upper bounds of both the ranges match. */
+ Assert(overlap);
+
+ /* Move to the next pair of partitions. */
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+ else if (ub_cmpval < 0)
+ {
+ /* Upper bound of inner range higher than that of the outer. */
+
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the inner side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &outer_lb;
+ merged_ub = &outer_ub;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+ if (!handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ outer_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+ }
+
+ /* Move to the next partition on the outer side. */
+ Assert(!finished_outer);
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ }
+ else
+ {
+ Assert(ub_cmpval > 0);
+
+ /* Upper bound of outer range higher than that of the inner. */
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the outer side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &inner_lb;
+ merged_ub = &inner_ub;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ inner_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+ }
+
+ /* Move to the next partition on the inner side. */
+ Assert (!finished_inner);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+
+ if (merged_index < 0)
+ {
+ /* We didn't find a new merged partition. */
+ continue;
+ }
+
+ /*
+ * We have a valid partition index for the next partition of join. The
+ * partition should have valid range.
+ */
+ Assert(merged_lb && merged_ub);
+
+ /* Try merging new lower bound with the last upper bound. */
+ if (!partition_range_merge_next_lb(partnatts, partsupfuncs,
+ partcollations,
+ merged_lb->datums,
+ merged_lb->kind, &merged_datums,
+ &merged_kinds, &merged_indexes))
+ return NULL;
+
+ /* Add upper bound with the merged partition index. */
+ merged_datums = lappend(merged_datums, merged_ub->datums);
+ merged_kinds = lappend(merged_kinds, merged_ub->kind);
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ }
+
+ if (!merge_default_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index,
+ &default_index))
+ return NULL;
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_maps, inner_maps,
+ outer_nparts, inner_nparts,
+ jointype, next_index,
+ outer_parts, inner_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes,
+ merged_kinds,
+ -1, default_index);
+ }
+
+ /* Free any memory we used in this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ list_free(merged_kinds);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_list_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for list partitioned tables.
+ *
+ */
+static PartitionBoundInfo
+partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype)
+{
+ PartitionMap *outer_maps = NULL;
+ PartitionMap *inner_maps = NULL;
+ int cnto;
+ int cnti;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ int next_index = 0;
+ int null_index;
+ int default_index = -1;
+ PartitionBoundInfo merged_bounds = NULL;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int *outer_indexes = outer_bi->indexes;
+ int *inner_indexes = inner_bi->indexes;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_LIST);
+
+ /* List partitions do not require unbounded ranges. */
+ Assert(!outer_bi->kind && !inner_bi->kind);
+
+ outer_maps = init_partition_map(outer_rel);
+ inner_maps = init_partition_map(inner_rel);
+
+ /*
+ * Merge the list value datums from both sides. Every iteration compares a
+ * pair of datums, one from each side, advancing to the next datum from the
+ * side with smaller datum. If datums from both sides match exactly, both
+ * the sides are advanced. For a given pair of datums, we decide whether
+ * the corresponding partition match or not.
+ */
+ cnto = cnti = 0;
+ while (cnto < outer_bi->ndatums || cnti < inner_bi->ndatums)
+ {
+ Datum *odatums;
+ Datum *idatums;
+ int o_index;
+ int i_index;
+ int cmpval;
+ int merged_index = -1;
+ Datum *merged_datum;
+ bool finished_inner;
+ bool finished_outer;
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining datums on the side which
+ * finishes later. For that we set the comparison parameter cmpval in
+ * such a way that it appears as if the side which finishes earlier has
+ * an extra datum higher than any other datum on the unfinished side.
+ * That way we advance the datums on the unfinished side till all of
+ * its datums are exhausted.
+ */
+ if (cnto >= outer_bi->ndatums)
+ {
+ finished_outer = true;
+ odatums = NULL;
+ o_index = -1;
+ }
+ else
+ {
+ finished_outer = false;
+ odatums = outer_bi->datums[cnto];
+ o_index = outer_indexes[cnto];
+ }
+
+ if (cnti >= inner_bi->ndatums)
+ {
+ finished_inner = true;
+ idatums = NULL;
+ i_index = -1;
+ }
+ else
+ {
+ finished_inner = false;
+ idatums = inner_bi->datums[cnti];
+ i_index = inner_indexes[cnti];
+ }
+
+ /* If we exhausted both the sides, we won't enter the loop. */
+ Assert(!finished_inner || !finished_outer);
+
+ if (finished_outer)
+ cmpval = 1;
+ else if (finished_inner)
+ cmpval = -1;
+ else
+ {
+ /* Every list datum should map to a valid partition index. */
+ Assert(o_index >= 0 && i_index >= 0 &&
+ odatums != NULL && idatums != NULL);
+
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
+ partcollation[0],
+ odatums[0], idatums[0]));
+ }
+
+ if (cmpval == 0)
+ {
+ /*
+ * Datums match. Rows on either side with these datums as partition
+ * key value will join and will be part of the partition of the
+ * join result produced by joining the corresponding partitions.
+ * Match the corresponding partitions and if successful, add the
+ * datum to the list of merged datums with index of merged
+ * partition containing it.
+ */
+ merged_datum = odatums;
+ merged_index = map_and_merge_partitions(outer_maps, inner_maps,
+ o_index, i_index,
+ &next_index);
+
+ if (merged_index < 0)
+ return NULL;
+
+ /* Move to the next pair of bounds. */
+ cnto++;
+ cnti++;
+ }
+ else if (cmpval < 0)
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /* A datum missing from the inner side. */
+ merged_index = -1;
+ merged_datum = odatums;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ o_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+
+ /* Move to the next datum on the outer side. */
+ Assert(!finished_outer);
+ cnto++;
+ }
+ else
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ Assert(cmpval > 0);
+
+ /* A datum missing from the outer side. */
+ merged_index = -1;
+ merged_datum = idatums;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ i_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+
+ /* Move to the next datum on the right side. */
+ Assert(!finished_inner);
+ cnti++;
+ }
+
+ /*
+ * Add the list value with appropriate index in the list of datums, if
+ * we have associated a partition with this list value.
+ */
+ if (merged_index >= 0)
+ {
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ merged_datums = lappend(merged_datums, merged_datum);
+ }
+ }
+
+ if (!merge_null_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index, &null_index,
+ &default_index))
+ return NULL;
+
+ if (!merge_default_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index,
+ &default_index))
+ return NULL;
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_maps, inner_maps,
+ outer_nparts, inner_nparts,
+ jointype, next_index,
+ outer_parts, inner_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes, NIL,
+ null_index, default_index);
+ }
+
+ /* Free up all extra memory before returning from this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_bounds_merge()'s arm for hash partitioned tables.
+ *
+ * If the given two hash bounds are same, the function returns the first one
+ * without any change, alongwith the lists of matching partitions. Otherwise it
+ * returns NULL.
+ *
+ * We could try merging the bounds when both the bounds have same greatest
+ * modulii. But there seems to be hardly any requirement for the same.
+ */
+static PartitionBoundInfo
+partition_hash_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype)
+{
+ int nparts;
+ int cnt;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * Hash partitioned table does not have explicit NULL accepting partition
+ * and also does not have a default partition.
+ */
+ Assert(!partition_bound_has_default(outer_bi) &&
+ !partition_bound_has_default(inner_bi));
+ Assert(!partition_bound_accepts_nulls(outer_bi) &&
+ !partition_bound_accepts_nulls(inner_bi));
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+
+ if (outer_nparts != inner_nparts)
+ return NULL;
+ nparts = outer_nparts;
+
+ if (outer_bi->ndatums != inner_bi->ndatums ||
+ !partition_hbounds_equal(outer_bi, inner_bi))
+ return NULL;
+
+ /*
+ * Cook up list of matching partitions. Since bounds are exactly same the
+ * partitions at the same position from both the relations match.
+ */
+ for (cnt = 0; cnt < nparts; cnt++)
+ {
+ *outer_parts = lappend_int(*outer_parts, cnt);
+ *inner_parts = lappend_int(*inner_parts, cnt);
+ }
+
+ return outer_bi;
+}
+
+/*
+ * map_and_merge_partitions
+ *
+ * If the two given partitions (given by index1 and index2 resp.) are
+ * already mapped to each other return the index of corresponding partition in
+ * the merged set of partitions. If they do not have a merged partition
+ * associated with them, assign a new merged partition index. If the
+ * partitions are already mapped and their mapped partitions are different from
+ * each other, they can not be merged, so return -1.
+ *
+ * partmaps1[i] gives the mapping of partitions for both relations. It
+ * describes which partition of relation 2 matches ith partition of relation 1,
+ * and which partition in the merged set matches ith partition of relation 1
+ * maps to. Similarly for partmap2.
+ *
+ * index1 and index2 are the indexes of matching partition from respective
+ * relations.
+ *
+ * *next_index is used and incremented when the given partitions require a new
+ * merged partition.
+ */
+
+static int
+map_and_merge_partitions(PartitionMap *partmaps1, PartitionMap *partmaps2,
+ int index1, int index2, int *next_index)
+{
+ PartitionMap *partmap1 = &partmaps1[index1];
+ PartitionMap *partmap2 = &partmaps2[index2];
+ int merged_index;
+
+ /*
+ * If both the partitions are not mapped to each other, update the
+ * maps.
+ */
+ if (partmap1->from < 0 && partmap2->from < 0)
+ {
+ partmap1->from = index2;
+ partmap2->from = index1;
+ }
+
+ /*
+ * If the given to partitions map to each other, find the corresponding
+ * merged partition index .
+ */
+ if (partmap1->from == index2 && partmap2->from == index1)
+ {
+ /*
+ * If both the partitions are mapped to the same merged partition, get
+ * the index of merged partition.
+ */
+ if (partmap1->to == partmap2->to)
+ {
+ merged_index = partmap1->to;
+
+ /*
+ * If the given two partitions do not have a merged partition
+ * associated with them, allocate a new merged partition.
+ */
+ if (merged_index < 0)
+ {
+ merged_index = *next_index;
+ *next_index = *next_index + 1;
+ partmap1->to = merged_index;
+ partmap2->to = merged_index;
+ }
+ }
+
+ /*
+ * If partition from one relation was mapped to a merged partition but
+ * not the partition from the other relation, map the same merged
+ * partition to the partition from other relation, since matching
+ * partitions map to the same merged partition.
+ */
+ else if (partmap1->to >= 0 && partmap2->to < 0)
+ {
+ partmap2->to = partmap1->to;
+ merged_index = partmap1->to;
+ }
+ else if (partmap1->to < 0 && partmap2->to >= 0)
+ {
+ partmap1->to = partmap2->to;
+ merged_index = partmap2->to;
+ }
+ else
+ {
+ Assert(partmap1->to != partmap2->to &&
+ partmap1->to >= 0 && partmap2->to >= 0);
+
+ /*
+ * Both the partitions map to different merged partitions. This
+ * means that multiple partitions from one relation matches to one
+ * partition from the other relation. Partition-wise join does not
+ * handle this case right now, since it requires ganging multiple
+ * partitions together (into one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+ }
+ else
+ {
+ /*
+ * Multiple partitions from one relation map to one partition from the
+ * other relation. Partition-wise join does not handle this case right
+ * now, since it requires ganging multiple partitions together (into
+ * one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+
+ return merged_index;
+}
+
+/*
+ * generate_matching_part_pairs
+ *
+ * partmaps1 map each partition from either side of the join to a merged
+ * partition resp. E.g. partmaps1[i].to gives the merged partition to which ith
+ * partition of first relation maps. Similarly for partmap2. If
+ * partmaps1[i].to == partmaps2[j].to, i and j form the matching pair of
+ * partitions.
+ *
+ * Given these maps this function produces the list pairs of partitions which
+ * when joined produce the merged partitions in the order of merged partition
+ * indexes.
+ *
+ * nparts1 and nparts2 are the number of partitions of the joining relations
+ * resp.
+ *
+ * nparts is the number of merged partitions.
+ *
+ * If successful, the pairs of partitions are returned as two separate lists,
+ * parts1 and parts2 resp., one for each side. Otherwise, those lists will be
+ * set to NIL.
+ */
+static void
+generate_matching_part_pairs(PartitionMap *partmaps1, PartitionMap *partmaps2,
+ int nparts1, int nparts2,
+ JoinType jointype, int nparts,
+ List **matched_parts1, List **matched_parts2)
+{
+ bool merged = true;
+ int *matching1 = (int *) palloc(sizeof(int) * nparts),
+ *matching2 = (int *) palloc(sizeof(int) * nparts);
+ int i;
+
+ *matched_parts1 = NIL;
+ *matched_parts2 = NIL;
+
+ /* Set pairs of matching partitions. */
+ for (i = 0; i < nparts; i++)
+ {
+ if (i >= nparts1)
+ matching1[i] = -1;
+ else
+ {
+ PartitionMap outer_map = partmaps1[i];
+
+ if (outer_map.to >= 0)
+ {
+ Assert(outer_map.to < nparts);
+ matching1[outer_map.to] = i;
+ }
+ }
+
+ if (i >= nparts2)
+ matching2[i] = -1;
+ else
+ {
+ PartitionMap inner_map = partmaps2[i];
+
+ if (inner_map.to >= 0)
+ {
+ Assert(inner_map.to < nparts);
+ matching2[inner_map.to] = i;
+ }
+ }
+ }
+
+ /*
+ * If we have a partition missing on an inner side, we need to add a dummy
+ * relation which joins with the outer partition. If the inner relation
+ * happens to be a base relation, it will require adding a dummy child
+ * base relation during join processing. Right now, we freeze the base
+ * relation arrays like PlannerInfo::simple_rte_array after planning for
+ * base relations. Adding a new (dummy) base relation would require some
+ * changes to that. So, right now, we do not implement partition-wise join
+ * in such cases.
+ */
+ for (i = 0; i < nparts; i++)
+ {
+ int part1 = matching1[i];
+ int part2 = matching2[i];
+
+ /* At least one of the partitions should exist. */
+ Assert(part1 >= 0 || part2 >= 0);
+
+ switch (jointype)
+ {
+ case JOIN_INNER:
+ case JOIN_SEMI:
+
+ /*
+ * An inner or semi join can not return any row when the
+ * matching partition on either side is missing. We should
+ * have eliminated all such cases while merging the bounds.
+ */
+ Assert(part1 >= 0 && part2 >= 0);
+ break;
+
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ Assert(part1 >= 0);
+ if (part2 < 0)
+ merged = false;
+ break;
+
+ case JOIN_FULL:
+ if (part1 < 0 || part2 < 0)
+ merged = false;
+ break;
+
+ default:
+ elog(ERROR, "unrecognized join type: %d", (int) jointype);
+ }
+
+ if (!merged)
+ break;
+
+ *matched_parts1 = lappend_int(*matched_parts1, part1);
+ *matched_parts2 = lappend_int(*matched_parts2, part2);
+ }
+
+ pfree(matching1);
+ pfree(matching2);
+
+ if (!merged)
+ {
+ list_free(*matched_parts1);
+ list_free(*matched_parts2);
+ *matched_parts1 = NIL;
+ *matched_parts2 = NIL;
+ }
+}
+
+static PartitionBoundInfo
+build_merged_partition_bounds(char strategy, List *merged_datums,
+ List *merged_indexes, List *merged_kinds,
+ int null_index, int default_index)
+{
+ int cnt;
+ PartitionBoundInfo merged_bounds;
+ ListCell *lc;
+
+ /* We expect the same number of elements in datums and indexes lists. */
+ Assert(list_length(merged_datums) == list_length(merged_indexes));
+
+ merged_bounds = (PartitionBoundInfo) palloc(sizeof(PartitionBoundInfoData));
+ merged_bounds->strategy = strategy;
+ merged_bounds->ndatums = list_length(merged_datums);
+
+ if (strategy == PARTITION_STRATEGY_RANGE)
+ {
+ Assert(list_length(merged_datums) == list_length(merged_kinds));
+ merged_bounds->kind =
+ (PartitionRangeDatumKind **) palloc(sizeof(PartitionRangeDatumKind *) *
+ list_length(merged_kinds));
+ cnt = 0;
+ foreach(lc, merged_kinds)
+ merged_bounds->kind[cnt++] = lfirst(lc);
+
+ /* There are ndatums+1 indexes in case of range partitions */
+ merged_indexes = lappend_int(merged_indexes, -1);
+ }
+ else
+ merged_bounds->kind = NULL;
+
+ cnt = 0;
+ merged_bounds->datums = (Datum **) palloc(sizeof(Datum *) *
+ list_length(merged_datums));
+ foreach(lc, merged_datums)
+ merged_bounds->datums[cnt++] = lfirst(lc);
+
+ merged_bounds->indexes = (int *) palloc(sizeof(int) *
+ list_length(merged_indexes));
+ cnt = 0;
+ foreach(lc, merged_indexes)
+ merged_bounds->indexes[cnt++] = lfirst_int(lc);
+
+ merged_bounds->null_index = null_index;
+ merged_bounds->default_index = default_index;
+
+ return merged_bounds;
+}
+
+/*
+ * Merge default partitions from both sides, if any, and assign the default
+ * partition for the join result, if necessary.
+ *
+ * If both the relations have default partitions, try mapping those to each
+ * other. If the mapping succeeds corresponding merged partition will act as
+ * the default partition of the join result.
+ *
+ * If inner side of the join has default but not the outer side, rows in it
+ * won't appear in the join result. So don't create a default partition. If
+ * outer side of the join has default but not the inner side, rows in it will
+ * appear in the join result, so create a default merged partition.
+ */
+static bool
+merge_default_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps, PartitionMap *inner_maps,
+ JoinType jointype, int *next_index, int *default_index)
+{
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool merged = true;
+ PartitionMap *outer_default_map = NULL;
+ PartitionMap *inner_default_map = NULL;
+
+ if (outer_has_default)
+ outer_default_map = &outer_maps[outer_default];
+
+ if (inner_has_default)
+ inner_default_map = &inner_maps[inner_default];
+
+ if (!outer_has_default && !inner_has_default)
+ Assert(*default_index < 0);
+ else if (outer_default_map != NULL && inner_default_map == NULL)
+ {
+ if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (outer_default_map->to < 0)
+ {
+ outer_default_map->to = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = outer_default_map->to;
+ }
+ else
+ Assert(*default_index == outer_default_map->to);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else if (outer_default_map == NULL && inner_default_map != NULL)
+ {
+ if (jointype == JOIN_FULL)
+ {
+ if (inner_default_map->to < 0)
+ {
+ inner_default_map->to = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = inner_default_map->to;
+ }
+ else
+ Assert(*default_index == inner_default_map->to);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else
+ {
+ Assert(outer_has_default && inner_has_default);
+
+ *default_index = map_and_merge_partitions(outer_maps, inner_maps,
+ outer_default, inner_default,
+ next_index);
+
+ if (*default_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
+
+/*
+ * merge_null_partitions
+ *
+ * Merge NULL partitions, i.e. a partition that can hold NULL values for a list
+ * partitioned table, if any. Find the index of merged partition to which the
+ * NULL values would belong in the join result. If one joining relation has a
+ * NULL partition but not the other, try matching it with the default partition
+ * from the other relation since the default partition may have rows with NULL
+ * partition key. We can eliminate a NULL partition when it appears only on the
+ * inner side of the join and the outer side doesn't have a default partition.
+ *
+ * When the equality operator used for join is strict, two NULL values will not
+ * be considered as equal, and thus a NULL partition can be eliminated for an
+ * inner join. But we don't check the strictness operator here.
+ */
+static bool
+merge_null_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps, PartitionMap *inner_maps,
+ JoinType jointype, int *next_index,
+ int *null_index, int *default_index)
+{
+ bool outer_has_null = partition_bound_accepts_nulls(outer_bi);
+ bool inner_has_null = partition_bound_accepts_nulls(inner_bi);
+ int outer_ni = outer_bi->null_index;
+ int inner_ni = inner_bi->null_index;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool merged = true;
+
+ if (!outer_has_null && !inner_has_null)
+ *null_index = -1;
+ else if (outer_has_null && !inner_has_null)
+ {
+ int merged_index;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+
+ merged = handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ outer_ni,
+ missing_side_outer,
+ missing_side_inner, next_index,
+ default_index, &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join to which the outer null partition maps
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = outer_maps[outer_ni].to;
+ }
+ else if (!outer_has_null && inner_has_null)
+ {
+ int merged_index;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as OUTER
+ * relation. For INNER and SEMI join OUTER and INNER differentiation is
+ * immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+ merged = handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ inner_ni,
+ missing_side_outer,
+ missing_side_inner,
+ next_index, default_index,
+ &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join, to which the outer side null partition maps,
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = inner_maps[inner_ni].to;
+ }
+ else
+ {
+ /* Both the relations have NULL partitions, try merging them. */
+ *null_index = map_and_merge_partitions(outer_maps,
+ inner_maps,
+ outer_ni,
+ inner_ni,
+ next_index);
+ if (*null_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
diff --git a/src/include/partitioning/partbounds.h b/src/include/partitioning/partbounds.h
index 36fb584e23..789d089ddc 100644
--- a/src/include/partitioning/partbounds.h
+++ b/src/include/partitioning/partbounds.h
@@ -107,5 +107,10 @@ extern int partition_range_datum_bsearch(FmgrInfo *partsupfunc,
int nvalues, Datum *values, bool *is_equal);
extern int partition_hash_bsearch(PartitionBoundInfo boundinfo,
int modulus, int remainder);
+extern PartitionBoundInfo partition_bounds_merge(int partnatts,
+ FmgrInfo *partsupfunc, Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts);
#endif /* PARTBOUNDS_H */
--
2.16.4
[application/octet-stream] 0004-Tests-for-0-1-1-1-and-1-0-partition-matching-v15.patch (220.4K, ../../CA+q6zcV8tRQh7R83xmoSZ024BCkKXk1_Bc7EXrPOYsioSMFtyw@mail.gmail.com/5-0004-Tests-for-0-1-1-1-and-1-0-partition-matching-v15.patch)
download | inline diff:
From d9fad87d22916380db8b14cc05cdd20314ba17ac Mon Sep 17 00:00:00 2001
From: erthalion <9erthalion6@gmail.com>
Date: Tue, 11 Sep 2018 21:11:55 +0200
Subject: [PATCH 4/5] Tests for 0:1, 1:1 and 1:0 partition matching
Rajkumar Raghuvanshi and Ashutosh Bapat.
---
src/test/regress/expected/partition_join.out | 4131 +++++++++++++++++++++-----
src/test/regress/sql/partition_join.sql | 427 ++-
2 files changed, 3855 insertions(+), 703 deletions(-)
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index c55de5d476..f19611c853 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -8,59 +8,86 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(21 rows)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
-(4 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+(7 rows)
-- left outer join, with whole-row reference; partitionwise join does not apply
EXPLAIN (COSTS OFF)
@@ -72,35 +99,50 @@ SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(22 rows)
SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- t1 | t2
---------------+--------------
- (0,0,0000) | (0,0,0000)
- (50,0,0050) |
- (100,0,0100) |
- (150,0,0150) | (0,150,0150)
- (200,0,0200) |
- (250,0,0250) |
- (300,0,0300) | (0,300,0300)
- (350,0,0350) |
- (400,0,0400) |
- (450,0,0450) | (0,450,0450)
- (500,0,0500) |
- (550,0,0550) |
-(12 rows)
+ t1 | t2
+----------------+----------------
+ (-250,0,-0250) |
+ (-200,0,-0200) |
+ (-150,0,-0150) | (0,-150,-0150)
+ (-100,0,-0100) |
+ (-50,0,-0050) |
+ (0,0,0000) | (0,0,0000)
+ (50,0,0050) |
+ (100,0,0100) |
+ (150,0,0150) | (0,150,0150)
+ (200,0,0200) |
+ (250,0,0250) |
+ (300,0,0300) | (0,300,0300)
+ (350,0,0350) |
+ (400,0,0400) |
+ (450,0,0450) | (0,450,0450)
+ (500,0,0500) |
+ (550,0,0550) |
+ (600,0,0600) | (0,600,0600)
+ (650,0,0650) |
+ (700,0,0700) |
+ (750,0,0750) | (0,750,0750)
+(21 rows)
-- right outer join
EXPLAIN (COSTS OFF)
@@ -112,35 +154,53 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHE
-> Append
-> Hash Right Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Right Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Hash Right Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-> Nested Loop Left Join
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p3 t2_3
Filter: (a = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t2_2.b)
-(20 rows)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
- | | 75 | 0075
- | | 225 | 0225
- | | 375 | 0375
- | | 525 | 0525
-(8 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+ | | -225 | -0225
+ | | -75 | -0075
+ | | 75 | 0075
+ | | 225 | 0225
+ | | 375 | 0375
+ | | 525 | 0525
+ | | 675 | 0675
+(14 rows)
-- full outer join, with placeholder vars
EXPLAIN (COSTS OFF)
@@ -148,8 +208,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
QUERY PLAN
------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b
+ Sort Key: prt1_p0.a, prt2_p0.b
-> Append
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ Filter: (((50) = prt1_p0.a) OR ((75) = prt2_p0.b))
+ -> Seq Scan on prt1_p0
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p1.a = prt2_p1.b)
Filter: (((50) = prt1_p1.a) OR ((75) = prt2_p1.b))
@@ -174,7 +242,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
-> Hash
-> Seq Scan on prt2_p3
Filter: (a = 0)
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ Filter: (((50) = prt1_p4.a) OR ((75) = prt2_p4.b))
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) WHERE t1.phv = t1.a OR t2.phv = t2.b ORDER BY t1.a, t2.b;
a | c | b | c
@@ -211,8 +287,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Hash Left Join
+ Hash Cond: (prt1_p0.a = b)
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Hash
+ -> Result
+ One-Time Filter: false
-> Hash Left Join
Hash Cond: (prt1_p1.a = b)
-> Seq Scan on prt1_p1
@@ -227,29 +310,42 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
-> Hash
-> Seq Scan on prt1_p2
Filter: ((a < 450) AND (b = 0))
-(17 rows)
+(24 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
-(9 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+(14 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
QUERY PLAN
------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = b)
+ Filter: ((prt1_p0.b = 0) OR (a = 0))
+ -> Seq Scan on prt1_p0
+ Filter: (a < 450)
+ -> Hash
+ -> Result
+ One-Time Filter: false
-> Hash Full Join
Hash Cond: (prt1_p1.a = b)
Filter: ((prt1_p1.b = 0) OR (a = 0))
@@ -274,64 +370,153 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JO
-> Hash
-> Result
One-Time Filter: false
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt2_p4.b = a)
+ Filter: ((b = 0) OR (prt2_p4.a = 0))
+ -> Seq Scan on prt2_p4
+ Filter: (b > 250)
+ -> Hash
+ -> Result
+ One-Time Filter: false
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
- | | 375 | 0375
- | | 450 | 0450
- | | 525 | 0525
-(12 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ | | 375 | 0375
+ | | 450 | 0450
+ | | 525 | 0525
+ | | 600 | 0600
+ | | 675 | 0675
+ | | 750 | 0750
+(20 rows)
-- Semi-join
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Semi Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Semi Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Nested Loop Semi Join
- Join Filter: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Materialize
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-(24 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(39 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p0 t2
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_2.b = t2_2.a)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p2 t2_2
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: (t1_3.b = t2_3.a)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt1_p3 t2_3
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.b = t2_4.a)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p4 t2_4
+ Filter: (b = 0)
+(37 rows)
+
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
@@ -342,27 +527,82 @@ SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS
-> Append
-> Hash Anti Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash Anti Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash Anti Join
Hash Cond: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p3 t2_2
-(17 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash Anti Join
+ Hash Cond: (t1_3.a = t2_3.b)
+ -> Seq Scan on prt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_3
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(27 rows)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
- sum | avg | sum | avg
--------+----------------------+------+---------------------
- 60000 | 300.0000000000000000 | 2400 | 12.0000000000000000
+ sum | avg | sum | avg
+-------+----------------------+------+--------------------
+ 95550 | 273.0000000000000000 | 2200 | 6.2857142857142857
(1 row)
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ QUERY PLAN
+--------------------------------------------------------------
+ Append
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Hash Anti Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(27 rows)
+
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ b | c
+------+-------
+ -225 | -0225
+ -75 | -0075
+ 75 | 0075
+ 225 | 0225
+ 375 | 0375
+ 525 | 0525
+ 675 | 0675
+(7 rows)
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -374,49 +614,74 @@ SELECT * FROM prt1 t1 LEFT JOIN LATERAL
Sort Key: t1.a
-> Append
-> Nested Loop Left Join
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p1_a on prt1_p1 t2
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
Index Cond: (a = t1.a)
- -> Index Scan using iprt2_p1_b on prt2_p1 t3
+ -> Index Scan using iprt2_p0_b on prt2_p0 t3
Index Cond: (b = t2.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_1
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
Index Cond: (a = t1_1.a)
- -> Index Scan using iprt2_p2_b on prt2_p2 t3_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t3_1
Index Cond: (b = t2_1.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_2
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
Index Cond: (a = t1_2.a)
- -> Index Scan using iprt2_p3_b on prt2_p3 t3_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t3_2
Index Cond: (b = t2_2.a)
-(27 rows)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.a)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t3_3
+ Index Cond: (b = t2_3.a)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.a)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t3_4
+ Index Cond: (b = t2_4.a)
+(43 rows)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, least(t1.a,t2.a,t3.b) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.a = ss.t2a WHERE t1.b = 0 ORDER BY t1.a;
- a | b | c | t2a | t3a | least
------+---+------+-----+-----+-------
- 0 | 0 | 0000 | 0 | 0 | 0
- 50 | 0 | 0050 | | |
- 100 | 0 | 0100 | | |
- 150 | 0 | 0150 | 150 | 0 | 150
- 200 | 0 | 0200 | | |
- 250 | 0 | 0250 | | |
- 300 | 0 | 0300 | 300 | 0 | 300
- 350 | 0 | 0350 | | |
- 400 | 0 | 0400 | | |
- 450 | 0 | 0450 | 450 | 0 | 450
- 500 | 0 | 0500 | | |
- 550 | 0 | 0550 | | |
-(12 rows)
+ a | b | c | t2a | t3a | least
+------+---+-------+------+-----+-------
+ -250 | 0 | -0250 | | |
+ -200 | 0 | -0200 | | |
+ -150 | 0 | -0150 | -150 | 0 | -150
+ -100 | 0 | -0100 | | |
+ -50 | 0 | -0050 | | |
+ 0 | 0 | 0000 | 0 | 0 | 0
+ 50 | 0 | 0050 | | |
+ 100 | 0 | 0100 | | |
+ 150 | 0 | 0150 | 150 | 0 | 150
+ 200 | 0 | 0200 | | |
+ 250 | 0 | 0250 | | |
+ 300 | 0 | 0300 | 300 | 0 | 300
+ 350 | 0 | 0350 | | |
+ 400 | 0 | 0400 | | |
+ 450 | 0 | 0450 | 450 | 0 | 450
+ 500 | 0 | 0500 | | |
+ 550 | 0 | 0550 | | |
+ 600 | 0 | 0600 | 600 | 0 | 600
+ 650 | 0 | 0650 | | |
+ 700 | 0 | 0700 | | |
+ 750 | 0 | 0750 | 750 | 0 | 750
+(21 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
@@ -430,64 +695,95 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
Hash Cond: ((t1.c)::text = (t2.c)::text)
Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Hash Join
Hash Cond: (t2.a = t3.b)
- -> Seq Scan on prt1_p1 t2
+ -> Seq Scan on prt1_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t3
+ -> Seq Scan on prt2_p0 t3
-> Hash Join
Hash Cond: (t2_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t2_1
+ -> Seq Scan on prt1_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p1 t3_1
-> Hash Join
Hash Cond: (t2_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p2 t2_2
-> Hash
- -> Seq Scan on prt2_p3 t3_2
-(26 rows)
+ -> Seq Scan on prt2_p2 t3_2
+ -> Hash Join
+ Hash Cond: (t2_3.a = t3_3.b)
+ -> Seq Scan on prt1_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t3_3
+ -> Hash Join
+ Hash Cond: (t2_4.a = t3_4.b)
+ -> Seq Scan on prt1_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t3_4
+(38 rows)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, t2.b t2b, t2.c t2c, least(t1.a,t2.a,t3.a) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.c = ss.t2c WHERE (t1.b + coalesce(ss.t2b, 0)) = 0 ORDER BY t1.a;
- a | t2a | t2c
------+-----+------
- 0 | 0 | 0000
- 50 | |
- 100 | |
- 150 | 150 | 0150
- 200 | |
- 250 | |
- 300 | 300 | 0300
- 350 | |
- 400 | |
- 450 | 450 | 0450
- 500 | |
- 550 | |
-(12 rows)
+ a | t2a | t2c
+------+------+-------
+ -250 | |
+ -200 | |
+ -150 | -150 | -0150
+ -100 | |
+ -50 | |
+ 0 | 0 | 0000
+ 50 | |
+ 100 | |
+ 150 | 150 | 0150
+ 200 | |
+ 250 | |
+ 300 | 300 | 0300
+ 350 | |
+ 400 | |
+ 450 | 450 | 0450
+ 500 | |
+ 550 | |
+ 600 | 600 | 0600
+ 650 | |
+ 700 | |
+ 750 | 750 | 0750
+(21 rows)
--
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
@@ -498,32 +794,49 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 =
-> Append
-> Hash Join
Hash Cond: (((t2.b + t2.a) / 2) = ((t1.a + t1.b) / 2))
- -> Seq Scan on prt2_e_p1 t2
+ -> Seq Scan on prt2_e_p0 t2
-> Hash
- -> Seq Scan on prt1_e_p1 t1
+ -> Seq Scan on prt1_e_p0 t1
Filter: (c = 0)
-> Hash Join
- Hash Cond: (((t2_1.b + t2_1.a) / 2) = ((t1_1.a + t1_1.b) / 2))
- -> Seq Scan on prt2_e_p2 t2_1
+ Hash Cond: (((t1_1.a + t1_1.b) / 2) = ((t2_1.b + t2_1.a) / 2))
+ -> Seq Scan on prt1_e_p1 t1_1
+ Filter: (c = 0)
-> Hash
- -> Seq Scan on prt1_e_p2 t1_1
- Filter: (c = 0)
+ -> Seq Scan on prt2_e_p1 t2_1
-> Hash Join
Hash Cond: (((t2_2.b + t2_2.a) / 2) = ((t1_2.a + t1_2.b) / 2))
- -> Seq Scan on prt2_e_p3 t2_2
+ -> Seq Scan on prt2_e_p2 t2_2
-> Hash
- -> Seq Scan on prt1_e_p3 t1_2
+ -> Seq Scan on prt1_e_p2 t1_2
Filter: (c = 0)
-(21 rows)
+ -> Hash Join
+ Hash Cond: (((t2_3.b + t2_3.a) / 2) = ((t1_3.a + t1_3.b) / 2))
+ -> Seq Scan on prt2_e_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t1_3
+ Filter: (c = 0)
+ -> Hash Join
+ Hash Cond: (((t2_4.b + t2_4.a) / 2) = ((t1_4.a + t1_4.b) / 2))
+ -> Seq Scan on prt2_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_4
+ Filter: (c = 0)
+(33 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 150 | 0 | 150 | 0
- 300 | 0 | 300 | 0
- 450 | 0 | 450 | 0
-(4 rows)
+ a | c | b | c
+------+---+------+---
+ -250 | 0 | -250 | 0
+ -100 | 0 | -100 | 0
+ 0 | 0 | 0 | 0
+ 0 | 0 | 0 | 0
+ 150 | 0 | 150 | 0
+ 300 | 0 | 300 | 0
+ 450 | 0 | 450 | 0
+ 600 | 0 | 600 | 0
+ 750 | 0 | 750 | 0
+(9 rows)
--
-- N-way join
@@ -536,154 +849,232 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = ((t3.a + t3.b) / 2))
+ Join Filter: (t1.a = t2.b)
-> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p1_ab2 on prt1_e_p1 t3
- Index Cond: (((a + b) / 2) = t2.b)
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
+ Index Cond: (b = ((t3.a + t3.b) / 2))
-> Nested Loop
Join Filter: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_1
+ -> Index Scan using iprt1_e_p4_ab2 on prt1_e_p1 t3_1
Index Cond: (((a + b) / 2) = t2_1.b)
-> Nested Loop
Join Filter: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_2
Index Cond: (((a + b) / 2) = t2_2.b)
-(33 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = ((t3_3.a + t3_3.b) / 2))
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (((a + b) / 2) = t2_3.b)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t2_4.b)
+ -> Hash Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (b = ((t3_4.a + t3_4.b) / 2))
+(52 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t3 WHERE t1.a = t2.b AND t1.a = (t3.a + t3.b)/2 AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
-(4 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(8 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
---------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Hash Right Join
Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_1.a + t3_1.b) / 2) = t1_1.a)
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
-> Hash
-> Hash Right Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_2.a + t3_2.b) / 2) = t1_2.a)
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
-> Hash
-> Hash Right Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(33 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (t1_3.a = ((a + b) / 2))
+ -> Hash Right Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(51 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
--------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1.a = ((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
Index Cond: (t1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t2_1
Index Cond: (t1_1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t2_2
Index Cond: (t1_2.a = b)
-(30 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t3_3.a + t3_3.b) / 2))
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Nested Loop Left Join
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = ((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (t1_4.a = b)
+(47 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- Cases with non-nullable expressions in subquery results;
-- make sure these go to null as expected
@@ -692,21 +1083,34 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
QUERY PLAN
----------------------------------------------------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b, ((prt1_e_p1.a + prt1_e_p1.b))
+ Sort Key: prt1_p0.a, prt2_p0.b, ((prt1_e_p0.a + prt1_e_p0.b))
-> Append
-> Hash Full Join
- Hash Cond: (prt1_p1.a = ((prt1_e_p1.a + prt1_e_p1.b) / 2))
- Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ Hash Cond: (prt1_p0.a = ((prt1_e_p0.a + prt1_e_p0.b) / 2))
+ Filter: ((prt1_p0.a = (50)) OR (prt2_p0.b = (75)) OR (((prt1_e_p0.a + prt1_e_p0.b) / 2) = (50)))
-> Hash Full Join
- Hash Cond: (prt1_p1.a = prt2_p1.b)
- -> Seq Scan on prt1_p1
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ -> Seq Scan on prt1_p0
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1
+ -> Seq Scan on prt2_p0
Filter: (a = 0)
-> Hash
- -> Seq Scan on prt1_e_p1
+ -> Seq Scan on prt1_e_p0
Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: (((prt1_e_p1.a + prt1_e_p1.b) / 2) = prt1_p1.a)
+ Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ -> Seq Scan on prt1_e_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Hash Full Join
+ Hash Cond: (prt1_p1.a = prt2_p1.b)
+ -> Seq Scan on prt1_p1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p2.a = ((prt1_e_p2.a + prt1_e_p2.b) / 2))
Filter: ((prt1_p2.a = (50)) OR (prt2_p2.b = (75)) OR (((prt1_e_p2.a + prt1_e_p2.b) / 2) = (50)))
@@ -733,7 +1137,20 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
-> Hash
-> Seq Scan on prt1_e_p3
Filter: (c = 0)
-(42 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = ((prt1_e_p4.a + prt1_e_p4.b) / 2))
+ Filter: ((prt1_p4.a = (50)) OR (prt2_p4.b = (75)) OR (((prt1_e_p4.a + prt1_e_p4.b) / 2) = (50)))
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_e_p4
+ Filter: (c = 0)
+(68 rows)
SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b)) FULL JOIN (SELECT 50 phv, * FROM prt1_e WHERE prt1_e.c = 0) t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.a = t1.phv OR t2.b = t2.phv OR (t3.a + t3.b)/2 = t3.phv ORDER BY t1.a, t2.b, t3.a + t3.b;
a | phv | b | phv | ?column? | phv
@@ -751,172 +1168,260 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHER
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = t1_3.b)
+ Join Filter: (t1.a = t1_5.b)
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Join
- Hash Cond: (((t2.a + t2.b) / 2) = t1_3.b)
- -> Seq Scan on prt1_e_p1 t2
+ Hash Cond: (((t2.a + t2.b) / 2) = t1_5.b)
+ -> Seq Scan on prt1_e_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t1_3
+ -> Seq Scan on prt2_p0 t1_5
Filter: (a = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
Index Cond: (a = ((t2.a + t2.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_1.a = t1_4.b)
+ Join Filter: (t1_1.a = t1_6.b)
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Join
- Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_4.b)
- -> Seq Scan on prt1_e_p2 t2_1
+ Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_6.b)
+ -> Seq Scan on prt1_e_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t1_4
+ -> Seq Scan on prt2_p1 t1_6
Filter: (a = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
Index Cond: (a = ((t2_1.a + t2_1.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_2.a = t1_5.b)
+ Join Filter: (t1_2.a = t1_7.b)
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Nested Loop
- -> Seq Scan on prt2_p3 t1_5
+ -> Seq Scan on prt2_p2 t1_7
Filter: (a = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_2
- Index Cond: (((a + b) / 2) = t1_5.b)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t2_2
+ Index Cond: (((a + b) / 2) = t1_7.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
Index Cond: (a = ((t2_2.a + t2_2.b) / 2))
Filter: (b = 0)
-(41 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = t1_8.b)
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t1_8
+ Filter: (a = 0)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_3
+ Index Cond: (((a + b) / 2) = t1_8.b)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t2_3.a + t2_3.b) / 2))
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t1_9.b)
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Join
+ Hash Cond: (((t2_4.a + t2_4.b) / 2) = t1_9.b)
+ -> Seq Scan on prt1_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t1_9
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = ((t2_4.a + t2_4.b) / 2))
+ Filter: (b = 0)
+(66 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHERE t1.a = 0 AND t1.b = (t2.a + t2.b)/2) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
--------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Nested Loop
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Semi Join
- Hash Cond: (t1_3.b = ((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt2_p1 t1_3
+ Hash Cond: (t1_5.b = ((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt2_p0 t1_5
-> Hash
- -> Seq Scan on prt1_e_p1 t1_6
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
- Index Cond: (a = t1_3.b)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t1_5.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Semi Join
- Hash Cond: (t1_4.b = ((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt2_p2 t1_4
+ Hash Cond: (t1_6.b = ((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt2_p1 t1_6
-> Hash
- -> Seq Scan on prt1_e_p2 t1_7
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
- Index Cond: (a = t1_4.b)
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
+ Index Cond: (a = t1_6.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Hash Semi Join
- Hash Cond: (t1_5.b = ((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt2_p3 t1_5
+ Hash Cond: (t1_7.b = ((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt2_p2 t1_7
-> Hash
- -> Seq Scan on prt1_e_p3 t1_8
+ -> Seq Scan on prt1_e_p2 t1_12
Filter: (c = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t1_5.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t1_7.b)
Filter: (b = 0)
-(39 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Hash Semi Join
+ Hash Cond: (t1_8.b = ((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt2_p3 t1_8
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t1_13
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t1_8.b)
+ Filter: (b = 0)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Semi Join
+ Hash Cond: (t1_9.b = ((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt2_p4 t1_9
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = t1_9.b)
+ Filter: (b = 0)
+(63 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
-- test merge joins
SET enable_hashjoin TO off;
SET enable_nestloop TO off;
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
-----------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------
Merge Append
Sort Key: t1.a
-> Merge Semi Join
- Merge Cond: (t1.a = t1_3.b)
+ Merge Cond: (t1.a = t1_5.b)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_3.b = (((t1_6.a + t1_6.b) / 2)))
+ Merge Cond: (t1_5.b = (((t1_10.a + t1_10.b) / 2)))
-> Sort
- Sort Key: t1_3.b
- -> Seq Scan on prt2_p1 t1_3
+ Sort Key: t1_5.b
+ -> Seq Scan on prt2_p0 t1_5
-> Sort
- Sort Key: (((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt1_e_p1 t1_6
+ Sort Key: (((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_1.a = t1_4.b)
+ Merge Cond: (t1_1.a = t1_6.b)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_4.b = (((t1_7.a + t1_7.b) / 2)))
+ Merge Cond: (t1_6.b = (((t1_11.a + t1_11.b) / 2)))
-> Sort
- Sort Key: t1_4.b
- -> Seq Scan on prt2_p2 t1_4
+ Sort Key: t1_6.b
+ -> Seq Scan on prt2_p1 t1_6
-> Sort
- Sort Key: (((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt1_e_p2 t1_7
+ Sort Key: (((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_2.a = t1_5.b)
+ Merge Cond: (t1_2.a = t1_7.b)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_5.b = (((t1_8.a + t1_8.b) / 2)))
+ Merge Cond: (t1_7.b = (((t1_12.a + t1_12.b) / 2)))
-> Sort
- Sort Key: t1_5.b
- -> Seq Scan on prt2_p3 t1_5
+ Sort Key: t1_7.b
+ -> Seq Scan on prt2_p2 t1_7
-> Sort
- Sort Key: (((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt1_e_p3 t1_8
+ Sort Key: (((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt1_e_p2 t1_12
Filter: (c = 0)
-(47 rows)
+ -> Merge Semi Join
+ Merge Cond: (t1_3.a = t1_8.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_8.b = (((t1_13.a + t1_13.b) / 2)))
+ -> Sort
+ Sort Key: t1_8.b
+ -> Seq Scan on prt2_p3 t1_8
+ -> Sort
+ Sort Key: (((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt1_e_p3 t1_13
+ Filter: (c = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_4.a = t1_9.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_9.b = (((t1_14.a + t1_14.b) / 2)))
+ -> Sort
+ Sort Key: t1_9.b
+ -> Seq Scan on prt2_p4 t1_9
+ -> Sort
+ Sort Key: (((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+(77 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
@@ -933,14 +1438,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3.a + t3.b) / 2)) = t1.a)
-> Sort
Sort Key: (((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Sort
Sort Key: t2.b
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Merge Left Join
Merge Cond: (t1_1.a = t2_1.b)
-> Sort
@@ -949,14 +1454,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_1.a + t3_1.b) / 2)) = t1_1.a)
-> Sort
Sort Key: (((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Sort
Sort Key: t2_1.b
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Merge Left Join
Merge Cond: (t1_2.a = t2_2.b)
-> Sort
@@ -965,32 +1470,74 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_2.a + t3_2.b) / 2)) = t1_2.a)
-> Sort
Sort Key: (((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Sort
Sort Key: t2_2.b
- -> Seq Scan on prt2_p3 t2_2
-(51 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Merge Left Join
+ Merge Cond: (t1_3.a = t2_3.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_3.a + t3_3.b) / 2)) = t1_3.a)
+ -> Sort
+ Sort Key: (((t3_3.a + t3_3.b) / 2))
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ -> Sort
+ Sort Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ -> Merge Left Join
+ Merge Cond: (t1_4.a = t2_4.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_4.a + t3_4.b) / 2)) = t1_4.a)
+ -> Sort
+ Sort Key: (((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ -> Sort
+ Sort Key: t2_4.b
+ -> Seq Scan on prt2_p4 t2_4
+(83 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- MergeAppend on nullable column
EXPLAIN (COSTS OFF)
@@ -998,8 +1545,18 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Merge Left Join
+ Merge Cond: (prt1_p0.a = b)
+ -> Sort
+ Sort Key: prt1_p0.a
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Sort
+ Sort Key: b
+ -> Result
+ One-Time Filter: false
-> Merge Left Join
Merge Cond: (prt1_p1.a = b)
-> Sort
@@ -1020,21 +1577,26 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
Sort Key: prt2_p2.b
-> Seq Scan on prt2_p2
Filter: (b > 250)
-(23 rows)
+(33 rows)
SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | b
------+-----
- 0 |
- 50 |
- 100 |
- 150 |
- 200 |
- 250 |
- 300 | 300
- 350 |
- 400 |
-(9 rows)
+ a | b
+------+-----
+ -250 |
+ -200 |
+ -150 |
+ -100 |
+ -50 |
+ 0 |
+ 50 |
+ 100 |
+ 150 |
+ 200 |
+ 250 |
+ 300 | 300
+ 350 |
+ 400 |
+(14 rows)
-- merge join when expression with whole-row reference needs to be sorted;
-- partitionwise join does not apply
@@ -1048,175 +1610,2412 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
Sort Key: t1.a, ((((t1.*)::prt1))::text)
-> Result
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Sort
Sort Key: t2.b, ((((t2.*)::prt2))::text)
-> Result
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
-(16 rows)
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+(20 rows)
SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.b ORDER BY t1.a;
- a | b
-----+----
- 0 | 0
- 6 | 6
- 12 | 12
- 18 | 18
- 24 | 24
-(5 rows)
+ a | b
+-----+-----
+ -24 | -24
+ -18 | -18
+ -12 | -12
+ -6 | -6
+ 0 | 0
+ 6 | 6
+ 12 | 12
+ 18 | 18
+ 24 | 24
+(9 rows)
RESET enable_hashjoin;
RESET enable_nestloop;
---
--- partitioned by multiple columns
---
-CREATE TABLE prt1_m (a int, b int, c int) PARTITION BY RANGE(a, ((a + b)/2));
-CREATE TABLE prt1_m_p1 PARTITION OF prt1_m FOR VALUES FROM (0, 0) TO (250, 250);
-CREATE TABLE prt1_m_p2 PARTITION OF prt1_m FOR VALUES FROM (250, 250) TO (500, 500);
-CREATE TABLE prt1_m_p3 PARTITION OF prt1_m FOR VALUES FROM (500, 500) TO (600, 600);
-INSERT INTO prt1_m SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
-ANALYZE prt1_m;
-CREATE TABLE prt2_m (a int, b int, c int) PARTITION BY RANGE(((b + a)/2), b);
-CREATE TABLE prt2_m_p1 PARTITION OF prt2_m FOR VALUES FROM (0, 0) TO (250, 250);
-CREATE TABLE prt2_m_p2 PARTITION OF prt2_m FOR VALUES FROM (250, 250) TO (500, 500);
-CREATE TABLE prt2_m_p3 PARTITION OF prt2_m FOR VALUES FROM (500, 500) TO (600, 600);
-INSERT INTO prt2_m SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
-ANALYZE prt2_m;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
- QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+ -> Seq Scan on prt2_p3 t2_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_4
+ Filter: (b = 0)
+(22 rows)
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p1 t2
+ -> Hash
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p2 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p3 t1_2
+ Filter: (b = 0)
+(21 rows)
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -150 | -0150 | 0 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 0 | 0150
+ 300 | 0300 | 0 | 0300
+ 450 | 0450 | 0 | 0450
+ 600 | 0600 | 0 | 0600
+ 750 | 0750 | 0 | 0750
+(7 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | 0 | -0150
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | 0 | 0000
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | 0 | 0150
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 0 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ 450 | 0450 | 0 | 0450
+ 500 | 0500 | |
+ 550 | 0550 | |
+ 600 | 0600 | 0 | 0600
+ 650 | 0650 | |
+ 700 | 0700 | |
+ 750 | 0750 | 0 | 0750
+(21 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Semi Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Append
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
+ Index Cond: (a = t1_1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(28 rows)
+
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Anti Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Anti Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -250 | 0 | -0250
+ -200 | 0 | -0200
+ -100 | 0 | -0100
+ -50 | 0 | -0050
+ 50 | 0 | 0050
+ 100 | 0 | 0100
+ 200 | 0 | 0200
+ 250 | 0 | 0250
+ 350 | 0 | 0350
+ 400 | 0 | 0400
+ 500 | 0 | 0500
+ 550 | 0 | 0550
+ 650 | 0 | 0650
+ 700 | 0 | 0700
+(14 rows)
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ QUERY PLAN
+---------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t3.c
+ -> Append
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t3
+ Index Cond: (a = t2.b)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t2.b)
+ -> Hash Right Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t3_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t3_2
+ Index Cond: (a = t2_2.b)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t2_2.b)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t3_3
+ Index Cond: (a = t2_3.b)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(47 rows)
+
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ a | a | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.b
+ -> Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(24 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: (t1.a = t2.b)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.a, 0)) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------
+ Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(22 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Join
+ Hash Cond: (t1.a = t2.b)
+ Join Filter: ((t1.b + t2.a) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+--
+-- partitioned by multiple columns
+--
+CREATE TABLE prt1_m (a int, b int, c int) PARTITION BY RANGE(a, ((a + b)/2));
+CREATE TABLE prt1_m_p1 PARTITION OF prt1_m FOR VALUES FROM (0, 0) TO (250, 250);
+CREATE TABLE prt1_m_p2 PARTITION OF prt1_m FOR VALUES FROM (250, 250) TO (500, 500);
+CREATE TABLE prt1_m_p3 PARTITION OF prt1_m FOR VALUES FROM (500, 500) TO (600, 600);
+INSERT INTO prt1_m SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+ANALYZE prt1_m;
+CREATE TABLE prt2_m (a int, b int, c int) PARTITION BY RANGE(((b + a)/2), b);
+CREATE TABLE prt2_m_p1 PARTITION OF prt2_m FOR VALUES FROM (0, 0) TO (250, 250);
+CREATE TABLE prt2_m_p2 PARTITION OF prt2_m FOR VALUES FROM (250, 250) TO (500, 500);
+CREATE TABLE prt2_m_p3 PARTITION OF prt2_m FOR VALUES FROM (500, 500) TO (600, 600);
+INSERT INTO prt2_m SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+ANALYZE prt2_m;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------
+ Sort
+ Sort Key: prt1_m_p1.a, prt2_m_p1.b
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p1.a = ((prt2_m_p1.b + prt2_m_p1.a) / 2)) AND (((prt1_m_p1.a + prt1_m_p1.b) / 2) = prt2_m_p1.b))
+ -> Seq Scan on prt1_m_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p1
+ Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p2.a = ((prt2_m_p2.b + prt2_m_p2.a) / 2)) AND (((prt1_m_p2.a + prt1_m_p2.b) / 2) = prt2_m_p2.b))
+ -> Seq Scan on prt1_m_p2
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p2
+ Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p3.a = ((prt2_m_p3.b + prt2_m_p3.a) / 2)) AND (((prt1_m_p3.a + prt1_m_p3.b) / 2) = prt2_m_p3.b))
+ -> Seq Scan on prt1_m_p3
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p3
+ Filter: (c = 0)
+(24 rows)
+
+SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
+ a | c | b | c
+-----+---+-----+---
+ 0 | 0 | 0 | 0
+ 50 | 0 | |
+ 100 | 0 | |
+ 150 | 0 | 150 | 0
+ 200 | 0 | |
+ 250 | 0 | |
+ 300 | 0 | 300 | 0
+ 350 | 0 | |
+ 400 | 0 | |
+ 450 | 0 | 450 | 0
+ 500 | 0 | |
+ 550 | 0 | |
+ | | 75 | 0
+ | | 225 | 0
+ | | 375 | 0
+ | | 525 | 0
+(16 rows)
+
+--
+-- tests for list partitioned tables.
+--
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 470 | 0 | 0011
+(1 row)
+
+--
+-- list partitioned by expression
+--
+CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
+ANALYZE plt1_e;
+-- test partition matching with N-way join
+EXPLAIN (COSTS OFF)
+SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Group Key: t1.c, t2.c, t3.c
+ -> Sort
+ Sort Key: t1.c, t3.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = ltrim(t3.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t2.b = t1.b) AND ((t2.c)::text = (t1.c)::text))
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt1_e_p4 t3
+ -> Hash Join
+ Hash Cond: ((t1_1.c)::text = ltrim(t3_1.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t1_1.b = t2_1.b) AND ((t1_1.c)::text = (t2_1.c)::text))
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_e_p1 t3_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = ltrim(t3_2.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t1_2.b = t2_2.b) AND ((t1_2.c)::text = (t2_2.c)::text))
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_e_p2 t3_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = ltrim(t3_3.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t2_3.b = t1_3.b) AND ((t2_3.c)::text = (t1_3.c)::text))
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt1_e_p3 t3_3
+(41 rows)
+
+SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+ avg | avg | avg | c | c | c
+----------------------+---------------------+----------------------+------+------+------
+ 246.5000000000000000 | 22.4666666666666667 | 268.9666666666666667 | 0000 | 0000 | 0000
+ 248.5000000000000000 | 21.3333333333333333 | 269.8333333333333333 | 0002 | 0002 | 0002
+ 249.5000000000000000 | 22.3333333333333333 | 271.8333333333333333 | 0003 | 0003 | 0003
+ 250.5000000000000000 | 23.3333333333333333 | 273.8333333333333333 | 0004 | 0004 | 0004
+ 251.5000000000000000 | 22.7666666666666667 | 274.2666666666666667 | 0005 | 0005 | 0005
+ 252.5000000000000000 | 22.2000000000000000 | 274.7000000000000000 | 0006 | 0006 | 0006
+ 246.0000000000000000 | 23.9655172413793103 | 269.9655172413793103 | 0008 | 0008 | 0008
+ 247.0000000000000000 | 23.3448275862068966 | 270.3448275862068966 | 0009 | 0009 | 0009
+(8 rows)
+
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 470 | 0011
+ | | 235 | 0014
+(8 rows)
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 235 | 0014
+ | | 470 | 0011
+(10 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 47 | 0 | 0013
+ 235 | 0 | 0014
+ 470 | 0 | 0011
+(3 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+----------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Materialize
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(20 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Materialize
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+---
+ 470 | 0 |
+(1 row)
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
Sort
- Sort Key: prt1_m_p1.a, prt2_m_p1.b
- -> Append
- -> Hash Full Join
- Hash Cond: ((prt1_m_p1.a = ((prt2_m_p1.b + prt2_m_p1.a) / 2)) AND (((prt1_m_p1.a + prt1_m_p1.b) / 2) = prt2_m_p1.b))
- -> Seq Scan on prt1_m_p1
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p1
- Filter: (c = 0)
- -> Hash Full Join
- Hash Cond: ((prt1_m_p2.a = ((prt2_m_p2.b + prt2_m_p2.a) / 2)) AND (((prt1_m_p2.a + prt1_m_p2.b) / 2) = prt2_m_p2.b))
- -> Seq Scan on prt1_m_p2
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p2
- Filter: (c = 0)
- -> Hash Full Join
- Hash Cond: ((prt1_m_p3.a = ((prt2_m_p3.b + prt2_m_p3.a) / 2)) AND (((prt1_m_p3.a + prt1_m_p3.b) / 2) = prt2_m_p3.b))
- -> Seq Scan on prt1_m_p3
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p3
- Filter: (c = 0)
-(24 rows)
+ Sort Key: t2.a
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
-SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 50 | 0 | |
- 100 | 0 | |
- 150 | 0 | 150 | 0
- 200 | 0 | |
- 250 | 0 | |
- 300 | 0 | 300 | 0
- 350 | 0 | |
- 400 | 0 | |
- 450 | 0 | 450 | 0
- 500 | 0 | |
- 550 | 0 | |
- | | 75 | 0
- | | 225 | 0
- | | 375 | 0
- | | 525 | 0
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
(16 rows)
---
--- tests for list partitioned tables.
---
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
---
--- list partitioned by expression
---
-CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1_e;
--- test partition matching with N-way join
+-- semi join
EXPLAIN (COSTS OFF)
-SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- QUERY PLAN
---------------------------------------------------------------------------------
- GroupAggregate
- Group Key: t1.c, t2.c, t3.c
- -> Sort
- Sort Key: t1.c, t3.c
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
-> Append
- -> Hash Join
- Hash Cond: (t1.c = ltrim(t3.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1.b = t2.b) AND (t1.c = t2.c))
- -> Seq Scan on plt1_p1 t1
- -> Hash
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_e_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.c = ltrim(t3_1.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1_1.b = t2_1.b) AND (t1_1.c = t2_1.c))
- -> Seq Scan on plt1_p2 t1_1
- -> Hash
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_e_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.c = ltrim(t3_2.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1_2.b = t2_2.b) AND (t1_2.c = t2_2.c))
- -> Seq Scan on plt1_p3 t1_2
- -> Hash
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_e_p3 t3_2
-(32 rows)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(22 rows)
-SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- avg | avg | avg | c | c | c
-----------------------+----------------------+-----------------------+------+------+-------
- 24.0000000000000000 | 24.0000000000000000 | 48.0000000000000000 | 0000 | 0000 | A0000
- 75.0000000000000000 | 75.0000000000000000 | 148.0000000000000000 | 0001 | 0001 | A0001
- 123.0000000000000000 | 123.0000000000000000 | 248.0000000000000000 | 0002 | 0002 | A0002
- 174.0000000000000000 | 174.0000000000000000 | 348.0000000000000000 | 0003 | 0003 | A0003
- 225.0000000000000000 | 225.0000000000000000 | 448.0000000000000000 | 0004 | 0004 | A0004
- 273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
- 324.0000000000000000 | 324.0000000000000000 | 648.0000000000000000 | 0006 | 0006 | A0006
- 375.0000000000000000 | 375.0000000000000000 | 748.0000000000000000 | 0007 | 0007 | A0007
- 423.0000000000000000 | 423.0000000000000000 | 848.0000000000000000 | 0008 | 0008 | A0008
- 474.0000000000000000 | 474.0000000000000000 | 948.0000000000000000 | 0009 | 0009 | A0009
- 525.0000000000000000 | 525.0000000000000000 | 1048.0000000000000000 | 0010 | 0010 | A0010
- 573.0000000000000000 | 573.0000000000000000 | 1148.0000000000000000 | 0011 | 0011 | A0011
-(12 rows)
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(22 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(19 rows)
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
@@ -1241,22 +4040,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
--------------------------------------------------
Hash Left Join
Hash Cond: (t2.b = a)
- -> Append
- -> Hash Join
- Hash Cond: (t3.a = t2.b)
- -> Seq Scan on prt1_p1 t3
- -> Hash
- -> Seq Scan on prt2_p1 t2
- -> Hash Join
- Hash Cond: (t3_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t3_1
- -> Hash
- -> Seq Scan on prt2_p2 t2_1
- -> Hash Join
- Hash Cond: (t3_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t3_2
- -> Hash
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash Join
+ Hash Cond: (t3.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t3
+ -> Seq Scan on prt1_p1 t3_1
+ -> Seq Scan on prt1_p2 t3_2
+ -> Seq Scan on prt1_p3 t3_3
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Result
One-Time Filter: false
@@ -1271,16 +4070,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
-> Hash Left Join
Hash Cond: (t2.b = a)
-> Append
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
Filter: (a = 0)
-> Hash
-> Result
One-Time Filter: false
-(14 rows)
+(20 rows)
--
-- tests for hash partitioned tables.
@@ -1356,41 +4161,9 @@ SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, ph
273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
(6 rows)
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
- Sort
- Sort Key: t1.a
- -> Append
- -> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
- -> Hash
- -> Seq Scan on prt1_p1 t1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
- -> Hash
- -> Seq Scan on prt1_p2 t1_1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
- -> Hash
- -> Seq Scan on prt1_p3 t1_2
- Filter: (b = 0)
-(21 rows)
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
@@ -1405,26 +4178,24 @@ SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c
Sort Key: t1.c
-> HashAggregate
Group Key: t1.c, t2.c
- -> Append
- -> Hash Join
- Hash Cond: (t2.c = t1.c)
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_p1 t1
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_1.c = t1_1.c)
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p1 t1_1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_2.c = t1_2.c)
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p2 t1_2
Filter: ((a % 25) = 0)
-(23 rows)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: ((a % 25) = 0)
+(21 rows)
--
-- multiple levels of partitioning
@@ -1826,64 +4597,70 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2 WHERE t1.a = t2.a;
Hash Join
Hash Cond: (t1.a = t2.a)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Seq Scan on prt4_n_p1 t2
-> Seq Scan on prt4_n_p2 t2_1
-> Seq Scan on prt4_n_p3 t2_2
-(11 rows)
+(13 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2, prt2 t3 WHERE t1.a = t2.a and t1.a = t3.b;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------
Hash Join
- Hash Cond: (t2.a = t1.a)
+ Hash Cond: (t3.b = t1.a)
-> Append
- -> Seq Scan on prt4_n_p1 t2
- -> Seq Scan on prt4_n_p2 t2_1
- -> Seq Scan on prt4_n_p3 t2_2
+ -> Seq Scan on prt2_p0 t3
+ -> Seq Scan on prt2_p1 t3_1
+ -> Seq Scan on prt2_p2 t3_2
+ -> Seq Scan on prt2_p3 t3_3
+ -> Seq Scan on prt2_p4 t3_4
+ -> Seq Scan on prt2_p5 t3_5
-> Hash
- -> Append
- -> Hash Join
- Hash Cond: (t1.a = t3.b)
- -> Seq Scan on prt1_p1 t1
- -> Hash
- -> Seq Scan on prt2_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t1_1
- -> Hash
- -> Seq Scan on prt2_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t1_2
- -> Hash
- -> Seq Scan on prt2_p3 t3_2
+ -> Hash Join
+ Hash Cond: (t1.a = t2.a)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt4_n_p1 t2
+ -> Seq Scan on prt4_n_p2 t2_1
+ -> Seq Scan on prt4_n_p3 t2_2
(23 rows)
-- partitionwise join can not be applied if there are no equi-join conditions
-- between partition keys
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON (t1.a < t2.b);
- QUERY PLAN
----------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------
Nested Loop Left Join
+ Join Filter: (t1.a < t2.b)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
- -> Append
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
- Index Cond: (t1.a < b)
-(12 rows)
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Materialize
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(16 rows)
-- equi-join with join condition on partial keys does not qualify for
-- partitionwise join
@@ -1969,16 +4746,17 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 JOIN prt2_n t2 ON (t1.c = t2.c) JOI
-> Seq Scan on prt2_n_p2 t2_1
-> Hash
-> Hash Join
- Hash Cond: (t3.c = (t1.c)::text)
+ Hash Cond: ((t3.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on plt1_p1 t3
- -> Seq Scan on plt1_p2 t3_1
- -> Seq Scan on plt1_p3 t3_2
+ -> Seq Scan on plt1_p4 t3
+ -> Seq Scan on plt1_p1 t3_1
+ -> Seq Scan on plt1_p2 t3_2
+ -> Seq Scan on plt1_p3 t3_3
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(16 rows)
+(17 rows)
-- partitionwise join can not be applied for a join between list and range
-- partitioned table
@@ -1989,14 +4767,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 FULL JOIN prt1 t2 ON (t1.c = t2.c);
Hash Full Join
Hash Cond: ((t2.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on prt1_p1 t2
- -> Seq Scan on prt1_p2 t2_1
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(10 rows)
+(12 rows)
-- partitionwise join can not be applied if only one of joining table has
-- default partition
@@ -2012,16 +4792,23 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b =
-> Hash Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
diff --git a/src/test/regress/sql/partition_join.sql b/src/test/regress/sql/partition_join.sql
index c1c9859651..0e884835fb 100644
--- a/src/test/regress/sql/partition_join.sql
+++ b/src/test/regress/sql/partition_join.sql
@@ -10,25 +10,39 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
@@ -67,11 +81,19 @@ EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -93,20 +115,30 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
@@ -169,6 +201,128 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
RESET enable_hashjoin;
RESET enable_nestloop;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
--
-- partitioned by multiple columns
--
@@ -193,28 +347,79 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1
--
-- tests for list partitioned tables.
--
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
--
-- list partitioned by expression
--
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
ANALYZE plt1_e;
-- test partition matching with N-way join
@@ -222,6 +427,175 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.a = 1 AND t1.a = 2;
@@ -267,27 +641,18 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
ALTER TABLE plt2 DETACH PARTITION plt2_p3;
ALTER TABLE plt2 ATTACH PARTITION plt2_p3 DEFAULT;
ANALYZE plt2;
-
EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.a % 25 = 0 GROUP BY t1.c, t2.c ORDER BY t1.c, t2.c;
+
--
-- multiple levels of partitioning
--
--
2.16.4
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
@ 2019-01-21 11:56 ` amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
0 siblings, 1 reply; 154+ messages in thread
From: amul sul @ 2019-01-21 11:56 UTC (permalink / raw)
To: Dmitry Dolgov <9erthalion6@gmail.com>; +Cc: Thomas Munro <thomas.munro@enterprisedb.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers; ashutosh.bapat.oss@gmail.com
On Mon, Nov 26, 2018 at 9:33 PM Dmitry Dolgov <9erthalion6@gmail.com> wrote:
> > On Mon, Nov 26, 2018 at 1:41 PM Dmitry Dolgov <9erthalion6@gmail.com>
> wrote:
> >
> > Thanks, I've messed this up too - rebased a wrong branch, the correct one
> > doesn't have this code already. Sorry for that, and here is the proper
> version
> > of this patch.
>
> And one more version, because I haven't fixed the tests (sorry for the
> noise).
>
0003 patch need a rebase.
Regards,
Amul
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
@ 2019-01-21 12:09 ` Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
0 siblings, 1 reply; 154+ messages in thread
From: Etsuro Fujita @ 2019-01-21 12:09 UTC (permalink / raw)
To: amul sul <sulamul@gmail.com>; +Cc: Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers; ashutosh.bapat.oss@gmail.com
(2019/01/21 20:56), amul sul wrote:
> On Mon, Nov 26, 2018 at 9:33 PM Dmitry Dolgov <9erthalion6@gmail.com
> <mailto:9erthalion6@gmail.com>> wrote:
>
> > On Mon, Nov 26, 2018 at 1:41 PM Dmitry Dolgov
> <9erthalion6@gmail.com <mailto:9erthalion6@gmail.com>> wrote:
> >
> > Thanks, I've messed this up too - rebased a wrong branch, the
> correct one
> > doesn't have this code already. Sorry for that, and here is the
> proper version
> > of this patch.
>
> And one more version, because I haven't fixed the tests (sorry for
> the noise).
> 0003 patch need a rebase.
Will do.
Thank you for letting us know!
Best regards,
Etsuro Fujita
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
@ 2019-01-22 12:38 ` Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
0 siblings, 1 reply; 154+ messages in thread
From: Etsuro Fujita @ 2019-01-22 12:38 UTC (permalink / raw)
To: amul sul <sulamul@gmail.com>; +Cc: Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers; ashutosh.bapat.oss@gmail.com
(2019/01/21 21:09), Etsuro Fujita wrote:
> (2019/01/21 20:56), amul sul wrote:
>> 0003 patch need a rebase.
>
> Will do.
While doing the rebase, I noticed that 0002 would not be necessary
anymore; what was originally proposed by it on how to generate the
tlists for child-joins in [1] is entirely included in commit
7cfdc77023ad50731723e85c215a4127436ed09c, which I pushed. I didn't pay
attention to this thread, but that was pretty much the same as what I
did in that commit (except the handling of PHVs to avoid extra work in
that commit), so I think I should have mentioned about that in the
commit message. Sorry for that, Ashutosh.
Here is an updated version of the patchset. As above, I don't think
0002 is necessary; it added copy_pathtarget to build_child_join_rel, but
I think it would be redundant because we do create_empty_pathtarget at
the top of that function and then build_child_join_reltarget. Also, it
added an assertion to build_joinrel_tlist, but I don't think it's really
necessary IMO. So I removed it entirely from the patchset. No changes
other that.
Will continue to review.
Best regards,
Etsuro Fujita
[1]
https://www.postgresql.org/message-id/CAFjFpResoxfp1rnV4Op9JOnG19VNEnjvjRN5DVd8QRHD%2BagTDw%40mail.g...
Attachments:
[text/x-patch] 0001-Hash-partition-bound-equality-refactoring-v16.patch (5.1K, ../../5C470EB8.30503@lab.ntt.co.jp/2-0001-Hash-partition-bound-equality-refactoring-v16.patch)
download | inline diff:
From 70074d78ebcb734fdf1dfd48c6df9105ec6de30b Mon Sep 17 00:00:00 2001
From: Etsuro Fujita <efujita@postgresql.org>
Date: Tue, 22 Jan 2019 21:10:54 +0900
Subject: [PATCH 1/3] Hash partition bound equality refactoring.
Separate the code to check whether two given hash bounds are equal into a
separate function, so that it can be called from multiple places. Right now
it's only caller is partition_bounds_equal() but later we will use it for
merging partition bounds.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/partitioning/partbounds.c | 95 +++++++++++++++++----------
1 file changed, 61 insertions(+), 34 deletions(-)
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index f21c9b32a6..cd49b5d01f 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -105,6 +105,9 @@ static void get_range_key_properties(PartitionKey key, int keynum,
Expr **keyCol,
Const **lower_val, Const **upper_val);
static List *get_range_nulltest(PartitionKey key);
+static bool partition_hbounds_equal(PartitionBoundInfo b1,
+ PartitionBoundInfo b2);
+
/*
* get_qual_from_partbound
@@ -653,6 +656,63 @@ create_range_bounds(PartitionBoundSpec **boundspecs, int nparts,
return boundinfo;
}
+/*
+ * Are two hash partition bound collections logically equal?
+ *
+ * Hash partition bounds store modulus and remainder in datums array which are
+ * always integers irrespective of the number of partition keys and their data
+ * types. Hence we can compare the hash bound collection without any partition
+ * key specific information. Separating this logic in a function which does not
+ * require partition key specific information allows it be called from places
+ * where the partition key specific information is not completely available.
+ */
+static bool
+partition_hbounds_equal(PartitionBoundInfo b1, PartitionBoundInfo b2)
+{
+ int greatest_modulus = get_hash_partition_greatest_modulus(b1);
+ int i;
+
+ Assert(b1->strategy == PARTITION_STRATEGY_HASH &&
+ b2->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * If two hash partitioned tables have different greatest moduli,
+ * their partition schemes don't match. For hash partitioned table,
+ * the greatest modulus is given by the last datum and number of
+ * partitions is given by ndatums.
+ */
+ if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ return false;
+
+ /*
+ * We arrange the partitions in the ascending order of their modulus and
+ * remainders. Also every modulus is factor of next larger modulus.
+ * Therefore we can safely store index of a given partition in indexes
+ * array at remainder of that partition. Also entries at (remainder + N *
+ * modulus) positions in indexes array are all same for (modulus,
+ * remainder) specification for any partition. Thus datums array from both
+ * the given bounds are same, if and only if their indexes array will be
+ * same. So, it suffices to compare indexes array.
+ */
+ for (i = 0; i < greatest_modulus; i++)
+ if (b1->indexes[i] != b2->indexes[i])
+ return false;
+
+#ifdef USE_ASSERT_CHECKING
+
+ /*
+ * Nonetheless make sure that the bounds are indeed same when the indexes
+ * match. Hash partition bound stores modulus and remainder at
+ * b1->datums[i][0] and b1->datums[i][1] position respectively.
+ */
+ for (i = 0; i < b1->ndatums; i++)
+ Assert((b1->datums[i][0] == b2->datums[i][0] &&
+ b1->datums[i][1] == b2->datums[i][1]));
+#endif
+
+ return true;
+}
+
/*
* Are two partition bound collections logically equal?
*
@@ -681,41 +741,8 @@ partition_bounds_equal(int partnatts, int16 *parttyplen, bool *parttypbyval,
if (b1->strategy == PARTITION_STRATEGY_HASH)
{
- int greatest_modulus = get_hash_partition_greatest_modulus(b1);
-
- /*
- * If two hash partitioned tables have different greatest moduli,
- * their partition schemes don't match.
- */
- if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ if (!partition_hbounds_equal(b1, b2))
return false;
-
- /*
- * We arrange the partitions in the ascending order of their moduli
- * and remainders. Also every modulus is factor of next larger
- * modulus. Therefore we can safely store index of a given partition
- * in indexes array at remainder of that partition. Also entries at
- * (remainder + N * modulus) positions in indexes array are all same
- * for (modulus, remainder) specification for any partition. Thus
- * datums array from both the given bounds are same, if and only if
- * their indexes array will be same. So, it suffices to compare
- * indexes array.
- */
- for (i = 0; i < greatest_modulus; i++)
- if (b1->indexes[i] != b2->indexes[i])
- return false;
-
-#ifdef USE_ASSERT_CHECKING
-
- /*
- * Nonetheless make sure that the bounds are indeed same when the
- * indexes match. Hash partition bound stores modulus and remainder
- * at b1->datums[i][0] and b1->datums[i][1] position respectively.
- */
- for (i = 0; i < b1->ndatums; i++)
- Assert((b1->datums[i][0] == b2->datums[i][0] &&
- b1->datums[i][1] == b2->datums[i][1]));
-#endif
}
else
{
--
2.19.2
[text/x-patch] 0002-Partition-wise-join-for-1-1-1-0-0-1-partition-matchi-v16.patch (69.4K, ../../5C470EB8.30503@lab.ntt.co.jp/3-0002-Partition-wise-join-for-1-1-1-0-0-1-partition-matchi-v16.patch)
download | inline diff:
From 7c46da16346c5d7e54c905df60d39bef7b88cc0b Mon Sep 17 00:00:00 2001
From: Etsuro Fujita <efujita@postgresql.org>
Date: Tue, 22 Jan 2019 21:25:58 +0900
Subject: [PATCH 2/3] Partition-wise join for 1:1, 1:0, 0:1 partition matching.
Earlier version of partition-wise join implementation allowed
partition-wise join between two relations with exactly same partition
bounds. This commit allows partition-wise join to be applied under
following conditions
1. the partition bounds of joining relations are such that rows from
given partition on one side join can join with rows from maximum one
partition on the other side i.e. bounds of a given partition on one
side match/overlap with those of maximum one partition on the other
side. If the mapping happens to be m:n where m > 1 or n > 1, we have
to gang multiple partition relations together into a single relation.
This means that we have to add simple relations during join
processing, something which is not supported right now. ALso, in such
a case, different pairs of joining relations can produce different
partition bounds for the same join relation, which again is not
supported right now.
2. For every partition on outer side that can contribute to the result
of an OUTER join, there exists at least one (taken along with item 1,
it means exactly one) matching partition on the inner side. To
support partition-wise join when the inner matching partition doesn't
exist, we have to add a dummy base relation corresponding to the
non-existent inner partition. We don't have support to add base
relations during join processing.
3. For hash partitioned tables however, we support partition-wise join
only when the bounds exactly match. For hash partitioning it's unusual
to have missing partitions and hence generic partition matching is not
required.
With advanced partition matching, we won't be able to apply
partition-wise join when there are missing matching partitions. So for
a given N-way join, some sub-joins may not be partitioned, while the
overall N-way join is partitioned. We can not try partition-wise join
when one or both of the joining relations are not partitioned in one
of the pairs of joining relation. Skip partition-wise join for that
pair.
An example is A IJ B LJ C where B has an extra partition compared to A
and C. Join B LJ C requires dummy relation to join the extra partition
from B to a missing partition from C, and hence can not use
partition-wise join right now and hence BC is not partitioned. The
extra partition in B gets eliminated in A IJ B and thus it can use
partition-wise join and is partitioned. Hence (AB)C can use
partition-wise join but not A(BC).
Not every pair of joining relation (including the one presented to
build_joinrel_partition_info()) for the same joinrel can use
partition-wise join or has both the relations partitioned. Hence we
calculate the partition bounds for the join relation in
try_partition_wise_join() instead of doing it here.
The partition bounds produced for the first pair that can use
partition-wise are saved in the RelOptInfo of the joinrel. Partition
bounds produced for subsequent pairs should match that produced by the
first pair.
Support for default partition in list partitioned tables
========================================================
When a list value is present in one of the joining relations and not
the other, and the other relation has default partition, match (join)
the partition containing that list value with the default partition.
If there are multiple matches, we can not proceed with the
partition-wise join similar to the case of matching non-default
partition. If the default partition happens to be on the outer side of
the join, the resulting join partition acts as a default partition as
it will contain all the values from the default partition. If
the partition containing the list value happens to be on the outer
side of the join, the resulting join partition is associated with the
list value, since no other partition key value from the default
partition makes it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a partition from the inner side,
if inner side has a list value that is not present in the outer side.
But if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Support for matching default partition in range partitioned tables
==================================================================
When a range is present in one of the joining relations and not the
other, and the other relation has default partition, match (join) the
partition corresponding range with the default partition. If two
ranges overlap but their ranges don't match exactly, the
non-overlapping portion from one range may join the previous
(non-overlapping portion near the lower bound, if exists), next
(non-overlapping portion near the upper bound, if exists) ranges from
the other relation or default partition from the other relation. This
causes multiple partitions on the other side to be joined with a
single partition on the first side; a case we don't support. Any range
from one side which doesn't overlap with any range on the other side,
may find its join partner in the default partition and the
corresponding range partition will need to be joined with the default
partition. If the default partition happens to be on the outer side
of the join, the resulting join partition acts as a default partition
as it will contain all the values from the default partition. If the
non-partition corresponding to the range happens to be on the outer
side of the join, the resulting join partition is associated with that
range, since partition key values from the default partition outside
that range won't make it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a non-default partition from the
inner side, if inner side has a range missing in the outer side. But
if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/optimizer/path/joinrels.c | 95 +-
src/backend/optimizer/util/relnode.c | 33 +-
src/backend/partitioning/partbounds.c | 1676 ++++++++++++++++++++++++-
src/include/partitioning/partbounds.h | 5 +
4 files changed, 1763 insertions(+), 46 deletions(-)
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 8bfe9c3ff7..578016c65d 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1319,25 +1319,31 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
{
bool rel1_is_simple = IS_SIMPLE_REL(rel1);
bool rel2_is_simple = IS_SIMPLE_REL(rel2);
- int nparts;
+ PartitionScheme part_scheme;
+ PartitionBoundInfo join_boundinfo;
+ List *parts1;
+ List *parts2;
+ ListCell *lc1;
+ ListCell *lc2;
int cnt_parts;
/* Guard against stack overflow due to overly deep partition hierarchy. */
check_stack_depth();
/* Nothing to do, if the join relation is not partitioned. */
- if (!IS_PARTITIONED_REL(joinrel))
+ if (joinrel->part_scheme == NULL)
return;
/* The join relation should have consider_partitionwise_join set. */
Assert(joinrel->consider_partitionwise_join);
/*
- * Since this join relation is partitioned, all the base relations
- * participating in this join must be partitioned and so are all the
- * intermediate join relations.
+ * We can not perform partition-wise join if either of the joining
+ * relations is not partitioned.
*/
- Assert(IS_PARTITIONED_REL(rel1) && IS_PARTITIONED_REL(rel2));
+ if (!IS_PARTITIONED_REL(rel1) || !IS_PARTITIONED_REL(rel2))
+ return;
+
Assert(REL_HAS_ALL_PART_PROPS(rel1) && REL_HAS_ALL_PART_PROPS(rel2));
/* The joining relations should have consider_partitionwise_join set. */
@@ -1350,32 +1356,63 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
*/
Assert(joinrel->part_scheme == rel1->part_scheme &&
joinrel->part_scheme == rel2->part_scheme);
+ part_scheme = joinrel->part_scheme;
/*
- * 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.
+ * Get the list of matching partitions to be joined along with the
+ * partition bounds of the join relation. Because of the restrictions
+ * imposed by partition matching algorithm, not every pair of joining
+ * relations for this join will be able to use partition-wise join. But all
+ * those pairs which can use partition-wise join will produce the same
+ * partition bounds for the join relation.
*/
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel1->boundinfo));
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel2->boundinfo));
+ join_boundinfo = partition_bounds_merge(part_scheme->partnatts,
+ part_scheme->partsupfunc,
+ part_scheme->partcollation,
+ rel1, rel2,
+ parent_sjinfo->jointype,
+ &parts1, &parts2);
+
+ if (join_boundinfo == NULL)
+ return;
- nparts = joinrel->nparts;
+ if (joinrel->boundinfo == NULL)
+ {
+ Assert(joinrel->nparts == 0 && joinrel->part_rels == NULL);
+ joinrel->boundinfo = join_boundinfo;
+ joinrel->nparts = list_length(parts1);
+ Assert(joinrel->nparts == list_length(parts2));
+ joinrel->part_rels =
+ (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+ joinrel->nparts);
+ }
+ else
+ {
+ Assert(partition_bounds_equal(part_scheme->partnatts,
+ part_scheme->parttyplen,
+ part_scheme->parttypbyval,
+ join_boundinfo, joinrel->boundinfo));
+ /*
+ * Every pair of joining relations should result in the same number
+ * of child-joins.
+ */
+ Assert(joinrel->nparts == list_length(parts1));
+ Assert(joinrel->nparts == list_length(parts2));
+ Assert(joinrel->part_rels);
+ }
/*
* Create child-join relations for this partitioned join, if those don't
* exist. Add paths to child-joins for a pair of child relations
* corresponding to the given pair of parent relations.
*/
- for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+ cnt_parts = 0;
+ forboth(lc1, parts1, lc2, parts2)
{
- RelOptInfo *child_rel1 = rel1->part_rels[cnt_parts];
- RelOptInfo *child_rel2 = rel2->part_rels[cnt_parts];
+ int part1 = lfirst_int(lc1);
+ int part2 = lfirst_int(lc2);
+ RelOptInfo *child_rel1;
+ RelOptInfo *child_rel2;
SpecialJoinInfo *child_sjinfo;
List *child_restrictlist;
RelOptInfo *child_joinrel;
@@ -1383,6 +1420,10 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
AppendRelInfo **appinfos;
int nappinfos;
+ Assert(part1 >= 0 && part2 >= 0);
+ child_rel1 = rel1->part_rels[part1];
+ child_rel2 = rel2->part_rels[part2];
+
/*
* If a child table has consider_partitionwise_join=false, it means
* that it's a dummy relation for which we skipped setting up tlist
@@ -1437,12 +1478,24 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
joinrel->part_rels[cnt_parts] = child_joinrel;
}
+ /*
+ * For every pair of joining relations, the set of matching partitions
+ * would change. However, the base relation partitions constituting
+ * the given child should remain same for all the joining pairs. Since
+ * the order in which children are stored in the array of child-joins,
+ * depends upon partition bounds of the join, which are same for all
+ * the joining pairs, every joining pair yields the child-joins in the
+ * same order.
+ */
Assert(bms_equal(child_joinrel->relids, child_joinrelids));
populate_joinrel_with_paths(root, child_rel1, child_rel2,
child_joinrel, child_sjinfo,
child_restrictlist);
+ cnt_parts++;
}
+
+ Assert(cnt_parts == joinrel->nparts);
}
/*
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index fe83ec4519..ad3552d761 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1608,7 +1608,7 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
* of the way the query planner deduces implied equalities and reorders
* the joins. Please see optimizer/README for details.
*/
- if (!IS_PARTITIONED_REL(outer_rel) || !IS_PARTITIONED_REL(inner_rel) ||
+ if (outer_rel->part_scheme == NULL || inner_rel->part_scheme == NULL ||
!outer_rel->consider_partitionwise_join ||
!inner_rel->consider_partitionwise_join ||
outer_rel->part_scheme != inner_rel->part_scheme ||
@@ -1621,24 +1621,6 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
part_scheme = outer_rel->part_scheme;
- Assert(REL_HAS_ALL_PART_PROPS(outer_rel) &&
- REL_HAS_ALL_PART_PROPS(inner_rel));
-
- /*
- * For now, our partition matching algorithm can match partitions only
- * when the partition bounds of the joining relations are exactly same.
- * So, bail out otherwise.
- */
- if (outer_rel->nparts != inner_rel->nparts ||
- !partition_bounds_equal(part_scheme->partnatts,
- part_scheme->parttyplen,
- part_scheme->parttypbyval,
- outer_rel->boundinfo, inner_rel->boundinfo))
- {
- Assert(!IS_PARTITIONED_REL(joinrel));
- return;
- }
-
/*
* This function will be called only once for each joinrel, hence it
* should not have partition scheme, partition bounds, partition key
@@ -1650,17 +1632,20 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
/*
* Join relation is partitioned using the same partitioning scheme as the
- * joining relations and has same bounds.
+ * joining relations.
+ *
+ * Because of restrictions in partition_bounds_merge(), not every pair of
+ * joining relations (including the one presented to this function) for the
+ * same joinrel can use partition-wise join or has both the relations
+ * partitioned. Hence we calculate the partition bounds, number of
+ * partitions and child-join relations of the join relation when and if we
+ * find a suitable pair in try_partition_wise_join().
*/
joinrel->part_scheme = part_scheme;
- joinrel->boundinfo = outer_rel->boundinfo;
partnatts = joinrel->part_scheme->partnatts;
joinrel->partexprs = (List **) palloc0(sizeof(List *) * partnatts);
joinrel->nullable_partexprs =
(List **) palloc0(sizeof(List *) * partnatts);
- joinrel->nparts = outer_rel->nparts;
- joinrel->part_rels =
- (RelOptInfo **) palloc0(sizeof(RelOptInfo *) * joinrel->nparts);
/*
* Set the consider_partitionwise_join flag.
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index cd49b5d01f..89c448040d 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -66,6 +66,12 @@ typedef struct PartitionRangeBound
bool lower; /* this is the lower (vs upper) bound */
} PartitionRangeBound;
+typedef struct PartitionMap
+{
+ int from;
+ int to;
+} PartitionMap;
+
static int32 qsort_partition_hbound_cmp(const void *a, const void *b);
static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
void *arg);
@@ -107,7 +113,58 @@ static void get_range_key_properties(PartitionKey key, int keynum,
static List *get_range_nulltest(PartitionKey key);
static bool partition_hbounds_equal(PartitionBoundInfo b1,
PartitionBoundInfo b2);
-
+static PartitionBoundInfo partition_range_bounds_merge(
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype, int partnatts,
+ FmgrInfo *supfuncs, Oid *collations);
+static PartitionBoundInfo partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *collations,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype);
+static PartitionBoundInfo partition_hash_bounds_merge(RelOptInfo *outer_rel,
+ RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype);
+static void generate_matching_part_pairs(PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ int nparts1, int nparts2,
+ JoinType jointype, int nparts,
+ List **parts1, List **parts2);
+static PartitionBoundInfo build_merged_partition_bounds(char strategy,
+ List *merged_datums, List *merged_indexes,
+ List *merged_contents, int null_index,
+ int default_index);
+static int map_and_merge_partitions(PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ int index1, int index2, int *next_index);
+static int32 partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *collations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2);
+static bool partition_range_cmp(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval);
+static bool partition_range_merge_next_lb(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes);
+static bool merge_default_partitions(PartitionBoundInfo outer_bi,
+ PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ JoinType jointype,
+ int *next_index, int *default_index);
+static bool merge_null_partitions(PartitionBoundInfo outer_bi,
+ PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ JoinType jointype,
+ int *next_index, int *null_index,
+ int *default_index);
/*
* get_qual_from_partbound
@@ -2942,3 +2999,1620 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
PG_RETURN_BOOL(rowHash % modulus == remainder);
}
+
+/*
+ * partition_bounds_merge
+ *
+ * The function produces the partition bounds for a join between two relations
+ * whose partition bounds are given. The function also returns two lists of
+ * partition indexes one for each of the joining relations. Both the lists
+ * contain the same number of elements. The partition indexes at the same
+ * positions in the lists indicate the pair partitions, one from each side, to
+ * be joined and the position itself corresponds to the index of partition
+ * produced by that child-join in the partitioned join.
+ *
+ * The function returns NULL if we can not find the matching pair of
+ * partitions. This happens if 1. multiple partitions on one side match with
+ * one partition on the other side. 2. a given partition on the outer side
+ * doesn't have a matching partition on the inner side. We can not support the
+ * first case since we don't have a way to represent multiple partitions as a
+ * single relation (RelOptInfo) and then perform join using the ganged
+ * relation. We can not support the second case since the missing inner
+ * partition needs to be represented as an empty relation and we don't have a
+ * way to introduce empty relation during join planning after creating paths
+ * for all the base relations.
+ */
+extern PartitionBoundInfo
+partition_bounds_merge(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts)
+{
+ PartitionBoundInfo merged_bounds;
+ PartitionBoundInfo outer_binfo = outer_rel->boundinfo,
+ inner_binfo = inner_rel->boundinfo;
+ char strategy = outer_binfo->strategy;
+
+ /* Bail out if partitioning strategies are different. */
+ if (outer_binfo->strategy != inner_binfo->strategy)
+ return NULL;
+
+ if (jointype != JOIN_LEFT && jointype != JOIN_INNER &&
+ jointype != JOIN_SEMI && jointype != JOIN_ANTI &&
+ jointype != JOIN_FULL)
+ elog(ERROR, "unexpected join type %d", jointype);
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+ switch (strategy)
+ {
+ case PARTITION_STRATEGY_LIST:
+ merged_bounds = partition_list_bounds_merge(partsupfunc,
+ partcollation,
+ outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype);
+ break;
+
+ case PARTITION_STRATEGY_RANGE:
+ merged_bounds = partition_range_bounds_merge(outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype, partnatts,
+ partsupfunc,
+ partcollation);
+ break;
+
+ case PARTITION_STRATEGY_HASH:
+ merged_bounds = partition_hash_bounds_merge(outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype);
+ break;
+
+ default:
+ elog(ERROR, "unexpected partition strategy: %d", strategy);
+ }
+
+ Assert(merged_bounds || (*outer_parts == NIL && *inner_parts == NIL));
+
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+
+ Assert((*outer_parts == NIL || *inner_parts != NIL) &&
+ (*inner_parts == NIL || *outer_parts != NIL));
+
+ return merged_bounds;
+}
+
+/*
+ * partition_get_range_bounds
+ *
+ * Given the index of lower bound in datums array, return lower and upper
+ * bounds and the index of the partition with that lower bound.
+ */
+static int
+partition_get_range_bounds(PartitionBoundInfo bi, int lb_index,
+ PartitionRangeBound *lower,
+ PartitionRangeBound *upper)
+{
+ int part_index;
+
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The lower bound should correspond to a valid partition. */
+ part_index = bi->indexes[lb_index + 1];
+ Assert(part_index >= 0);
+
+ lower->kind = bi->kind[lb_index];
+ lower->datums = bi->datums[lb_index];
+ lower->lower = true;
+ upper->kind = bi->kind[lb_index + 1];
+ upper->datums = bi->datums[lb_index + 1];
+ upper->lower = false;
+
+ return part_index;
+}
+
+/*
+ * partition_range_get_next_lb_index
+ *
+ * Given the index of lower bound in datums array return the
+ * index of lower bound of the next partition. When the given index corresponds
+ * to the last partition, return number of datums (ndatums).
+ */
+static int
+partition_range_get_next_lb_index(PartitionBoundInfo bi, int lb_index)
+{
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The partition index corresponding to the upper bound should be valid. */
+ Assert(bi->indexes[lb_index + 1] >= 0);
+
+ /*
+ * If there are no bounds left beyond the upper bound, we have reached the
+ * last partition.
+ */
+ if (lb_index + 2 < bi->ndatums)
+ {
+ /*
+ * If the bound next to the upper bound corresponds to no partition,
+ * that's the next lower bound of the next partition. Otherwise, the
+ * current upper bound is the lower bound of the next partition.
+ */
+ if (bi->indexes[lb_index + 2] < 0)
+ return lb_index + 2;
+ else
+ return lb_index + 1;
+ }
+ else
+ return bi->ndatums;
+}
+
+static int32
+partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2)
+{
+ return partition_rbound_cmp(partnatts, partsupfunc, partcollations,
+ bound1->datums, bound1->kind, bound1->lower,
+ bound2);
+}
+
+/*
+ * partition_range_cmp
+ *
+ * Compare the bounds of two range partitions. Set ub_cmpval <, = or > 0, if the
+ * first partition's upper bound is lower than, equal to or higher than the
+ * second partition's upper bound resp. Similarly set lb_cmpval <, = or > 0,
+ * if the first partition's lower bound is lower than, equal to or higher than
+ * the second partition's lower bound resp.
+ *
+ * Return true, if the ranges overlap, otherwise return false.
+ */
+static bool
+partition_range_cmp(int partnatts, FmgrInfo *partsupfuncs, Oid *partcollations,
+ PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval)
+{
+ bool overlap;
+
+ /*
+ * Compare upper bound of the first partition with the lower bound of the
+ * second and vice-versa. If lower bound is higher than the upper bound,
+ * the partitions are not overlapping. All other cases indicate overlapping
+ * partitions.
+ */
+ if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound1, upper_bound2) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = 1;
+ *lb_cmpval = 1;
+ }
+ else if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound2, upper_bound1) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = -1;
+ *lb_cmpval = -1;
+ }
+ else
+ {
+ overlap = true;
+ *ub_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, upper_bound1,
+ upper_bound2);
+ *lb_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, lower_bound1,
+ lower_bound2);
+ }
+
+ return overlap;
+}
+
+/*
+ * partition_range_merge
+ *
+ * Merge the partition bounds of given two partitions such that the join
+ * between the given two partitions fits merged bounds.
+ *
+ * "merged_upper" will be set to one of the given upper bounds and
+ * "merged_lower" will be set to one of the given lower bounds.
+ */
+static void
+partition_range_merge(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, JoinType jointype,
+ PartitionRangeBound *left_lb,
+ PartitionRangeBound *left_ub,
+ PartitionRangeBound *right_lb,
+ PartitionRangeBound *right_ub,
+ PartitionRangeBound **merged_lb,
+ PartitionRangeBound **merged_ub)
+{
+ /*
+ * An outer join will have all the rows from the outer side, so merged
+ * bounds will be same as the outer bounds. An inner join will have rows
+ * that fit both the bounds, thus lower merged bound will be higher of two
+ * lower bounds and upper merged bound will be lower of the two upper
+ * bounds.
+ */
+ switch (jointype)
+ {
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ *merged_ub = left_ub;
+ *merged_lb = left_lb;
+ break;
+
+ case JOIN_INNER:
+ case JOIN_SEMI:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) < 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) > 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ case JOIN_FULL:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) > 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) < 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ default:
+ elog(ERROR, "unexpected join type %d", jointype);
+ }
+
+ return;
+}
+
+/*
+ * Add the lower bound of the next range to the list of bounds, if the lower
+ * bound is higher or equal to the previous upper bound. If successful return
+ * true, otherwise false.
+ */
+static bool
+partition_range_merge_next_lb(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes)
+{
+ int cmpval;
+
+ if (!*merged_datums)
+ {
+ Assert(!*merged_kinds && !*merged_indexes);
+ cmpval = 1;
+ }
+ else
+ {
+ PartitionRangeBound prev_ub;
+
+ prev_ub.datums = llast(*merged_datums);
+ prev_ub.kind = llast(*merged_kinds);
+ prev_ub.lower = false;
+
+ cmpval = partition_rbound_cmp(partnatts, partsupfuncs, partcollations,
+ next_lb_datums, next_lb_kind, false,
+ &prev_ub);
+ }
+
+ /*
+ * The lower bound is lower than the last upper bound, thus does not fit
+ * the bounds created so far and hence can not be merged with the existing
+ * bounds.
+ */
+ if (cmpval < 0)
+ return false;
+
+ /*
+ * Add bounds of the new merged partition. If the next lower bound is
+ * higher than the last upper bound, add new range with index
+ * corresponding to the lower bound as -1. If the merged lower bound
+ * is same as the last merged upper bound, the last upper bound will be
+ * reused as the lower bound of the next range.
+ */
+ if (cmpval > 0)
+ {
+ *merged_datums = lappend(*merged_datums, next_lb_datums);
+ *merged_kinds = lappend(*merged_kinds, next_lb_kind);
+ *merged_indexes = lappend_int(*merged_indexes, -1);
+ }
+
+ return true;
+}
+
+/*
+ * handle_missing_partition
+ *
+ * If a range appears in one of the joining relations but not the other, a row
+ * in the corresponding partition will not have any join partner in the other
+ * relation, unless the other relation has a default partition. If a given list
+ * value is present in one joining relation but not the other, the default
+ * partition on the other side may contain that value.
+ *
+ * In both these cases, such an extra partition forms a joining pair with the
+ * default partition, if any, on the other side.
+ *
+ * If the default partition happens to be on the outer side of the join, the
+ * resultant partition will act as the default partition of the join relation.
+ * Otherwise the resultant partition will be associated with the range.
+ *
+ * When the default partition is not present in the other relation, the rows in
+ * the extra partition will be included in the bounds of the join result, if it
+ * appears on the outer side of the join, since all rows from the outer side
+ * are included in the join result.
+ *
+ * This function handles all these cases.
+ *
+ * maps_with_missing and missing_side_default are the partition maps (See
+ * partition_range/list_bounds_merge() for details) and the index of default
+ * partition respectively corresponding the side with missing partition.
+ *
+ * maps_with_extra and extra_part are the partition maps (See
+ * partition_range/list_bounds_merge() for details) and the index of extra
+ * partition respectively corresponding to the side with the extra partition.
+ *
+ * It returns true if the matching succeeds, otherwise returns false.
+ */
+static bool
+handle_missing_partition(PartitionMap *maps_with_missing,
+ PartitionMap *maps_with_extra,
+ int missing_side_default,
+ int extra_part,
+ bool missing_side_outer,
+ bool missing_side_inner,
+ int *next_index, int *default_index,
+ int *merged_index)
+{
+ bool missing_has_default = (missing_side_default != -1);
+
+ if (missing_has_default)
+ {
+ *merged_index = map_and_merge_partitions(maps_with_missing,
+ maps_with_extra,
+ missing_side_default,
+ extra_part,
+ next_index);
+ if (*merged_index < 0)
+ return false;
+
+ if (missing_side_outer)
+ {
+ /*
+ * Default partition on the outer side forms the default
+ * partition of the join result.
+ */
+ if (*default_index < 0)
+ *default_index = *merged_index;
+ else if(*default_index != *merged_index)
+ {
+ /*
+ * Ended up with default partition on the outer side
+ * being joined with multiple partitions on the inner
+ * side. We don't support this case.
+ */
+ return false;
+ }
+
+ /*
+ * Since the merged partition acts as a default partition, it
+ * doesn't need a separate index.
+ */
+ *merged_index = -1;
+ }
+ }
+ else if (missing_side_inner)
+ {
+ /*
+ * If this partition has already been mapped (say because we
+ * found an overlapping range earlier), we know where does it
+ * fit in the join result. Nothing to do in that case. Else
+ * create a new merged partition.
+ */
+ PartitionMap *extra_map = &maps_with_extra[extra_part];
+ if (extra_map->to < 0)
+ {
+ extra_map->to = *next_index;
+ *next_index = *next_index + 1;
+ *merged_index = extra_map->to;
+ }
+ }
+
+ return true;
+}
+
+static PartitionMap*
+init_partition_map(RelOptInfo *rel)
+{
+ int i, nparts = rel->nparts;
+ PartitionMap *map;
+
+ map = (PartitionMap *) palloc(sizeof(PartitionMap) * nparts);
+
+ for (i = 0; i < nparts; i++)
+ {
+ map[i].from = -1;
+ map[i].to = -1;
+ }
+
+ return map;
+}
+
+/*
+ * Allocate and initialize partition maps. We maintain four maps, two maps
+ * for each joining relation. pmap[i] gives the partition from the other
+ * relation which would join with ith partition of the given relation.
+ * Partition i from the given relation will join with partition pmap[i]
+ * from the other relation to produce partition mmap[i] of the join (merged
+ * partition).
+ *
+ * pmap[i] = -1 indicates that ith partition of a given relation does not
+ * have a matching partition from the other relation.
+ *
+ * mmap[i] = -1 indicates that ith partition of a given relation does not
+ * contribute to the join result. That can happen only when the given
+ * relation is the inner relation and it doesn't have a matching partition
+ * from the outer relation, hence pmap[i] should be -1.
+ *
+ * In case of an outer join, every partition of the outer join will appear
+ * in the join result, and thus has mmap[i] set for all i. But it's not
+ * necessary that every partition on the outer side will have a matching
+ * partition on the inner side. In such a case, we end up with pmap[i] = -1
+ * and mmap[i] != -1.
+ */
+
+/*
+ * partition_range_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for range partitioned tables.
+ */
+static PartitionBoundInfo
+partition_range_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype, int partnatts,
+ FmgrInfo *partsupfuncs, Oid *partcollations)
+
+{
+ PartitionMap *outer_maps = NULL;
+ PartitionMap *inner_maps = NULL;
+ int outer_part = 0;
+ int inner_part = 0;
+ PartitionBoundInfo merged_bounds = NULL;
+ int outer_lb_index;
+ int inner_lb_index;
+ int next_index;
+ int default_index = -1;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ List *merged_kinds = NIL;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int inner_default = inner_bi->default_index;
+ int outer_default = outer_bi->default_index;
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_RANGE);
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ outer_maps = init_partition_map(outer_rel);
+ inner_maps = init_partition_map(inner_rel);
+
+ /*
+ * Merge the ranges (partitions) from both sides. Every iteration compares
+ * a pair of ranges, one from each side, advancing to the next range from
+ * the side with smaller upper range bound. If upper bounds of ranges from
+ * both sides match exactly, both the sides are advanced. For a given pair
+ * of ranges, we decide whether the corresponding partition match or not.
+ * lb_index, for inner or outer side, keeps track of the index of lower bound
+ * datum in PartitionBoundInfo::datums of that side.
+ */
+ outer_lb_index = 0;
+ inner_lb_index = 0;
+ next_index = 0;
+ while (outer_lb_index < outer_bi->ndatums ||
+ inner_lb_index < inner_bi->ndatums)
+ {
+ PartitionRangeBound outer_lb, outer_ub,
+ inner_lb, inner_ub,
+ *merged_lb = NULL,
+ *merged_ub = NULL;
+
+ int merged_index = -1;
+ bool overlap;
+ bool finished_outer = false;
+ bool finished_inner = false;
+
+ /* Result of bounds comparison per partition_rbound_cmp(). */
+ int ub_cmpval; /* Upper bounds comparison result. */
+ int lb_cmpval; /* Lower bounds comparison result. */
+
+ /* Get the range bounds of the next pair of partitions. */
+ if (outer_lb_index < outer_bi->ndatums)
+ outer_part = partition_get_range_bounds(outer_bi, outer_lb_index,
+ &outer_lb, &outer_ub);
+ else
+ finished_outer = true;
+
+ if (inner_lb_index < inner_bi->ndatums)
+ inner_part = partition_get_range_bounds(inner_bi, inner_lb_index,
+ &inner_lb, &inner_ub);
+ else
+ finished_inner = true;
+
+ Assert(!finished_outer || !finished_inner);
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining partitions on the side
+ * which finishes later. For that we set the comparison parameters
+ * overlap, ub_cmpval and lb_cmpval in such a way that it appears as if
+ * the side which finishes earlier has an extra partition with lower
+ * and upper bounds higher than any other partition of the unfinished
+ * side. That way we advance the partitions on that side till all of
+ * them are exhausted.
+ */
+ if (finished_outer)
+ {
+ overlap = false;
+ ub_cmpval = 1;
+ lb_cmpval = 1;
+ }
+ else if (finished_inner)
+ {
+ overlap = false;
+ ub_cmpval = -1;
+ lb_cmpval = -1;
+ }
+ else
+ overlap = partition_range_cmp(partnatts, partsupfuncs, partcollations,
+ &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &ub_cmpval, &lb_cmpval);
+
+ if (overlap)
+ {
+ /*
+ * The rows from overlapping portion of ranges on both sides may
+ * join, hence the corresponding pair of partitions form a joining
+ * pair. Match them and produce the bounds of the joint partition
+ * and its index by merging the bounds according to the type of
+ * join.
+ */
+ partition_range_merge(partnatts, partsupfuncs, partcollations,
+ jointype, &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &merged_lb, &merged_ub);
+
+ merged_index = map_and_merge_partitions(outer_maps, inner_maps,
+ outer_part, inner_part,
+ &next_index);
+
+ if (merged_index < 0)
+ {
+ /* Failed to match the partitions. */
+ return NULL;
+ }
+
+ /*
+ * If the ranges overlap but don't exactly match, a row from
+ * non-overlapping portion of the range from one side of join may
+ * find its join partner in the previous or next overlapping
+ * partition or default partition on the other side , if such a
+ * partition exists. All those cases, if true, will cause one
+ * partition from that side to match at least two partitions on the
+ * other side; a case that we do not support now. Previous
+ * partition has been delt with in the previous iteration of this
+ * loop, next partition will be delt in the next iteration. We will
+ * deal with the default partition here.
+ */
+ if ((lb_cmpval < 0 && inner_has_default) ||
+ /* Non-overlapping range on the lower side of outer range. */
+ (lb_cmpval > 0 && outer_has_default) ||
+ /* Non-overlapping range on the lower side of inner range. */
+ (ub_cmpval < 0 && outer_has_default) ||
+ /* Non-overlapping range on the upper side of inner range. */
+ (ub_cmpval > 0 && inner_has_default))
+ /* Non-overlapping range on the upper side of outer range. */
+ return NULL;
+ }
+
+ if (ub_cmpval == 0)
+ {
+ /* Upper bounds of both the ranges match. */
+ Assert(overlap);
+
+ /* Move to the next pair of partitions. */
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+ else if (ub_cmpval < 0)
+ {
+ /* Upper bound of inner range higher than that of the outer. */
+
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the inner side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &outer_lb;
+ merged_ub = &outer_ub;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+ if (!handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ outer_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+ }
+
+ /* Move to the next partition on the outer side. */
+ Assert(!finished_outer);
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ }
+ else
+ {
+ Assert(ub_cmpval > 0);
+
+ /* Upper bound of outer range higher than that of the inner. */
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the outer side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &inner_lb;
+ merged_ub = &inner_ub;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ inner_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+ }
+
+ /* Move to the next partition on the inner side. */
+ Assert (!finished_inner);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+
+ if (merged_index < 0)
+ {
+ /* We didn't find a new merged partition. */
+ continue;
+ }
+
+ /*
+ * We have a valid partition index for the next partition of join. The
+ * partition should have valid range.
+ */
+ Assert(merged_lb && merged_ub);
+
+ /* Try merging new lower bound with the last upper bound. */
+ if (!partition_range_merge_next_lb(partnatts, partsupfuncs,
+ partcollations,
+ merged_lb->datums,
+ merged_lb->kind, &merged_datums,
+ &merged_kinds, &merged_indexes))
+ return NULL;
+
+ /* Add upper bound with the merged partition index. */
+ merged_datums = lappend(merged_datums, merged_ub->datums);
+ merged_kinds = lappend(merged_kinds, merged_ub->kind);
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ }
+
+ if (!merge_default_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index,
+ &default_index))
+ return NULL;
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_maps, inner_maps,
+ outer_nparts, inner_nparts,
+ jointype, next_index,
+ outer_parts, inner_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes,
+ merged_kinds,
+ -1, default_index);
+ }
+
+ /* Free any memory we used in this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ list_free(merged_kinds);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_list_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for list partitioned tables.
+ *
+ */
+static PartitionBoundInfo
+partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype)
+{
+ PartitionMap *outer_maps = NULL;
+ PartitionMap *inner_maps = NULL;
+ int cnto;
+ int cnti;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ int next_index = 0;
+ int null_index;
+ int default_index = -1;
+ PartitionBoundInfo merged_bounds = NULL;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int *outer_indexes = outer_bi->indexes;
+ int *inner_indexes = inner_bi->indexes;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_LIST);
+
+ /* List partitions do not require unbounded ranges. */
+ Assert(!outer_bi->kind && !inner_bi->kind);
+
+ outer_maps = init_partition_map(outer_rel);
+ inner_maps = init_partition_map(inner_rel);
+
+ /*
+ * Merge the list value datums from both sides. Every iteration compares a
+ * pair of datums, one from each side, advancing to the next datum from the
+ * side with smaller datum. If datums from both sides match exactly, both
+ * the sides are advanced. For a given pair of datums, we decide whether
+ * the corresponding partition match or not.
+ */
+ cnto = cnti = 0;
+ while (cnto < outer_bi->ndatums || cnti < inner_bi->ndatums)
+ {
+ Datum *odatums;
+ Datum *idatums;
+ int o_index;
+ int i_index;
+ int cmpval;
+ int merged_index = -1;
+ Datum *merged_datum;
+ bool finished_inner;
+ bool finished_outer;
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining datums on the side which
+ * finishes later. For that we set the comparison parameter cmpval in
+ * such a way that it appears as if the side which finishes earlier has
+ * an extra datum higher than any other datum on the unfinished side.
+ * That way we advance the datums on the unfinished side till all of
+ * its datums are exhausted.
+ */
+ if (cnto >= outer_bi->ndatums)
+ {
+ finished_outer = true;
+ odatums = NULL;
+ o_index = -1;
+ }
+ else
+ {
+ finished_outer = false;
+ odatums = outer_bi->datums[cnto];
+ o_index = outer_indexes[cnto];
+ }
+
+ if (cnti >= inner_bi->ndatums)
+ {
+ finished_inner = true;
+ idatums = NULL;
+ i_index = -1;
+ }
+ else
+ {
+ finished_inner = false;
+ idatums = inner_bi->datums[cnti];
+ i_index = inner_indexes[cnti];
+ }
+
+ /* If we exhausted both the sides, we won't enter the loop. */
+ Assert(!finished_inner || !finished_outer);
+
+ if (finished_outer)
+ cmpval = 1;
+ else if (finished_inner)
+ cmpval = -1;
+ else
+ {
+ /* Every list datum should map to a valid partition index. */
+ Assert(o_index >= 0 && i_index >= 0 &&
+ odatums != NULL && idatums != NULL);
+
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
+ partcollation[0],
+ odatums[0], idatums[0]));
+ }
+
+ if (cmpval == 0)
+ {
+ /*
+ * Datums match. Rows on either side with these datums as partition
+ * key value will join and will be part of the partition of the
+ * join result produced by joining the corresponding partitions.
+ * Match the corresponding partitions and if successful, add the
+ * datum to the list of merged datums with index of merged
+ * partition containing it.
+ */
+ merged_datum = odatums;
+ merged_index = map_and_merge_partitions(outer_maps, inner_maps,
+ o_index, i_index,
+ &next_index);
+
+ if (merged_index < 0)
+ return NULL;
+
+ /* Move to the next pair of bounds. */
+ cnto++;
+ cnti++;
+ }
+ else if (cmpval < 0)
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /* A datum missing from the inner side. */
+ merged_index = -1;
+ merged_datum = odatums;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ o_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+
+ /* Move to the next datum on the outer side. */
+ Assert(!finished_outer);
+ cnto++;
+ }
+ else
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ Assert(cmpval > 0);
+
+ /* A datum missing from the outer side. */
+ merged_index = -1;
+ merged_datum = idatums;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ i_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+
+ /* Move to the next datum on the right side. */
+ Assert(!finished_inner);
+ cnti++;
+ }
+
+ /*
+ * Add the list value with appropriate index in the list of datums, if
+ * we have associated a partition with this list value.
+ */
+ if (merged_index >= 0)
+ {
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ merged_datums = lappend(merged_datums, merged_datum);
+ }
+ }
+
+ if (!merge_null_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index, &null_index,
+ &default_index))
+ return NULL;
+
+ if (!merge_default_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index,
+ &default_index))
+ return NULL;
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_maps, inner_maps,
+ outer_nparts, inner_nparts,
+ jointype, next_index,
+ outer_parts, inner_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes, NIL,
+ null_index, default_index);
+ }
+
+ /* Free up all extra memory before returning from this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_bounds_merge()'s arm for hash partitioned tables.
+ *
+ * If the given two hash bounds are same, the function returns the first one
+ * without any change, alongwith the lists of matching partitions. Otherwise it
+ * returns NULL.
+ *
+ * We could try merging the bounds when both the bounds have same greatest
+ * modulii. But there seems to be hardly any requirement for the same.
+ */
+static PartitionBoundInfo
+partition_hash_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype)
+{
+ int nparts;
+ int cnt;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * Hash partitioned table does not have explicit NULL accepting partition
+ * and also does not have a default partition.
+ */
+ Assert(!partition_bound_has_default(outer_bi) &&
+ !partition_bound_has_default(inner_bi));
+ Assert(!partition_bound_accepts_nulls(outer_bi) &&
+ !partition_bound_accepts_nulls(inner_bi));
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+
+ if (outer_nparts != inner_nparts)
+ return NULL;
+ nparts = outer_nparts;
+
+ if (outer_bi->ndatums != inner_bi->ndatums ||
+ !partition_hbounds_equal(outer_bi, inner_bi))
+ return NULL;
+
+ /*
+ * Cook up list of matching partitions. Since bounds are exactly same the
+ * partitions at the same position from both the relations match.
+ */
+ for (cnt = 0; cnt < nparts; cnt++)
+ {
+ *outer_parts = lappend_int(*outer_parts, cnt);
+ *inner_parts = lappend_int(*inner_parts, cnt);
+ }
+
+ return outer_bi;
+}
+
+/*
+ * map_and_merge_partitions
+ *
+ * If the two given partitions (given by index1 and index2 resp.) are
+ * already mapped to each other return the index of corresponding partition in
+ * the merged set of partitions. If they do not have a merged partition
+ * associated with them, assign a new merged partition index. If the
+ * partitions are already mapped and their mapped partitions are different from
+ * each other, they can not be merged, so return -1.
+ *
+ * partmaps1[i] gives the mapping of partitions for both relations. It
+ * describes which partition of relation 2 matches ith partition of relation 1,
+ * and which partition in the merged set matches ith partition of relation 1
+ * maps to. Similarly for partmap2.
+ *
+ * index1 and index2 are the indexes of matching partition from respective
+ * relations.
+ *
+ * *next_index is used and incremented when the given partitions require a new
+ * merged partition.
+ */
+
+static int
+map_and_merge_partitions(PartitionMap *partmaps1, PartitionMap *partmaps2,
+ int index1, int index2, int *next_index)
+{
+ PartitionMap *partmap1 = &partmaps1[index1];
+ PartitionMap *partmap2 = &partmaps2[index2];
+ int merged_index;
+
+ /*
+ * If both the partitions are not mapped to each other, update the
+ * maps.
+ */
+ if (partmap1->from < 0 && partmap2->from < 0)
+ {
+ partmap1->from = index2;
+ partmap2->from = index1;
+ }
+
+ /*
+ * If the given to partitions map to each other, find the corresponding
+ * merged partition index .
+ */
+ if (partmap1->from == index2 && partmap2->from == index1)
+ {
+ /*
+ * If both the partitions are mapped to the same merged partition, get
+ * the index of merged partition.
+ */
+ if (partmap1->to == partmap2->to)
+ {
+ merged_index = partmap1->to;
+
+ /*
+ * If the given two partitions do not have a merged partition
+ * associated with them, allocate a new merged partition.
+ */
+ if (merged_index < 0)
+ {
+ merged_index = *next_index;
+ *next_index = *next_index + 1;
+ partmap1->to = merged_index;
+ partmap2->to = merged_index;
+ }
+ }
+
+ /*
+ * If partition from one relation was mapped to a merged partition but
+ * not the partition from the other relation, map the same merged
+ * partition to the partition from other relation, since matching
+ * partitions map to the same merged partition.
+ */
+ else if (partmap1->to >= 0 && partmap2->to < 0)
+ {
+ partmap2->to = partmap1->to;
+ merged_index = partmap1->to;
+ }
+ else if (partmap1->to < 0 && partmap2->to >= 0)
+ {
+ partmap1->to = partmap2->to;
+ merged_index = partmap2->to;
+ }
+ else
+ {
+ Assert(partmap1->to != partmap2->to &&
+ partmap1->to >= 0 && partmap2->to >= 0);
+
+ /*
+ * Both the partitions map to different merged partitions. This
+ * means that multiple partitions from one relation matches to one
+ * partition from the other relation. Partition-wise join does not
+ * handle this case right now, since it requires ganging multiple
+ * partitions together (into one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+ }
+ else
+ {
+ /*
+ * Multiple partitions from one relation map to one partition from the
+ * other relation. Partition-wise join does not handle this case right
+ * now, since it requires ganging multiple partitions together (into
+ * one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+
+ return merged_index;
+}
+
+/*
+ * generate_matching_part_pairs
+ *
+ * partmaps1 map each partition from either side of the join to a merged
+ * partition resp. E.g. partmaps1[i].to gives the merged partition to which ith
+ * partition of first relation maps. Similarly for partmap2. If
+ * partmaps1[i].to == partmaps2[j].to, i and j form the matching pair of
+ * partitions.
+ *
+ * Given these maps this function produces the list pairs of partitions which
+ * when joined produce the merged partitions in the order of merged partition
+ * indexes.
+ *
+ * nparts1 and nparts2 are the number of partitions of the joining relations
+ * resp.
+ *
+ * nparts is the number of merged partitions.
+ *
+ * If successful, the pairs of partitions are returned as two separate lists,
+ * parts1 and parts2 resp., one for each side. Otherwise, those lists will be
+ * set to NIL.
+ */
+static void
+generate_matching_part_pairs(PartitionMap *partmaps1, PartitionMap *partmaps2,
+ int nparts1, int nparts2,
+ JoinType jointype, int nparts,
+ List **matched_parts1, List **matched_parts2)
+{
+ bool merged = true;
+ int *matching1 = (int *) palloc(sizeof(int) * nparts),
+ *matching2 = (int *) palloc(sizeof(int) * nparts);
+ int i;
+
+ *matched_parts1 = NIL;
+ *matched_parts2 = NIL;
+
+ /* Set pairs of matching partitions. */
+ for (i = 0; i < nparts; i++)
+ {
+ if (i >= nparts1)
+ matching1[i] = -1;
+ else
+ {
+ PartitionMap outer_map = partmaps1[i];
+
+ if (outer_map.to >= 0)
+ {
+ Assert(outer_map.to < nparts);
+ matching1[outer_map.to] = i;
+ }
+ }
+
+ if (i >= nparts2)
+ matching2[i] = -1;
+ else
+ {
+ PartitionMap inner_map = partmaps2[i];
+
+ if (inner_map.to >= 0)
+ {
+ Assert(inner_map.to < nparts);
+ matching2[inner_map.to] = i;
+ }
+ }
+ }
+
+ /*
+ * If we have a partition missing on an inner side, we need to add a dummy
+ * relation which joins with the outer partition. If the inner relation
+ * happens to be a base relation, it will require adding a dummy child
+ * base relation during join processing. Right now, we freeze the base
+ * relation arrays like PlannerInfo::simple_rte_array after planning for
+ * base relations. Adding a new (dummy) base relation would require some
+ * changes to that. So, right now, we do not implement partition-wise join
+ * in such cases.
+ */
+ for (i = 0; i < nparts; i++)
+ {
+ int part1 = matching1[i];
+ int part2 = matching2[i];
+
+ /* At least one of the partitions should exist. */
+ Assert(part1 >= 0 || part2 >= 0);
+
+ switch (jointype)
+ {
+ case JOIN_INNER:
+ case JOIN_SEMI:
+
+ /*
+ * An inner or semi join can not return any row when the
+ * matching partition on either side is missing. We should
+ * have eliminated all such cases while merging the bounds.
+ */
+ Assert(part1 >= 0 && part2 >= 0);
+ break;
+
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ Assert(part1 >= 0);
+ if (part2 < 0)
+ merged = false;
+ break;
+
+ case JOIN_FULL:
+ if (part1 < 0 || part2 < 0)
+ merged = false;
+ break;
+
+ default:
+ elog(ERROR, "unrecognized join type: %d", (int) jointype);
+ }
+
+ if (!merged)
+ break;
+
+ *matched_parts1 = lappend_int(*matched_parts1, part1);
+ *matched_parts2 = lappend_int(*matched_parts2, part2);
+ }
+
+ pfree(matching1);
+ pfree(matching2);
+
+ if (!merged)
+ {
+ list_free(*matched_parts1);
+ list_free(*matched_parts2);
+ *matched_parts1 = NIL;
+ *matched_parts2 = NIL;
+ }
+}
+
+static PartitionBoundInfo
+build_merged_partition_bounds(char strategy, List *merged_datums,
+ List *merged_indexes, List *merged_kinds,
+ int null_index, int default_index)
+{
+ int cnt;
+ PartitionBoundInfo merged_bounds;
+ ListCell *lc;
+
+ /* We expect the same number of elements in datums and indexes lists. */
+ Assert(list_length(merged_datums) == list_length(merged_indexes));
+
+ merged_bounds = (PartitionBoundInfo) palloc(sizeof(PartitionBoundInfoData));
+ merged_bounds->strategy = strategy;
+ merged_bounds->ndatums = list_length(merged_datums);
+
+ if (strategy == PARTITION_STRATEGY_RANGE)
+ {
+ Assert(list_length(merged_datums) == list_length(merged_kinds));
+ merged_bounds->kind =
+ (PartitionRangeDatumKind **) palloc(sizeof(PartitionRangeDatumKind *) *
+ list_length(merged_kinds));
+ cnt = 0;
+ foreach(lc, merged_kinds)
+ merged_bounds->kind[cnt++] = lfirst(lc);
+
+ /* There are ndatums+1 indexes in case of range partitions */
+ merged_indexes = lappend_int(merged_indexes, -1);
+ }
+ else
+ merged_bounds->kind = NULL;
+
+ cnt = 0;
+ merged_bounds->datums = (Datum **) palloc(sizeof(Datum *) *
+ list_length(merged_datums));
+ foreach(lc, merged_datums)
+ merged_bounds->datums[cnt++] = lfirst(lc);
+
+ merged_bounds->indexes = (int *) palloc(sizeof(int) *
+ list_length(merged_indexes));
+ cnt = 0;
+ foreach(lc, merged_indexes)
+ merged_bounds->indexes[cnt++] = lfirst_int(lc);
+
+ merged_bounds->null_index = null_index;
+ merged_bounds->default_index = default_index;
+
+ return merged_bounds;
+}
+
+/*
+ * Merge default partitions from both sides, if any, and assign the default
+ * partition for the join result, if necessary.
+ *
+ * If both the relations have default partitions, try mapping those to each
+ * other. If the mapping succeeds corresponding merged partition will act as
+ * the default partition of the join result.
+ *
+ * If inner side of the join has default but not the outer side, rows in it
+ * won't appear in the join result. So don't create a default partition. If
+ * outer side of the join has default but not the inner side, rows in it will
+ * appear in the join result, so create a default merged partition.
+ */
+static bool
+merge_default_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps, PartitionMap *inner_maps,
+ JoinType jointype, int *next_index, int *default_index)
+{
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool merged = true;
+ PartitionMap *outer_default_map = NULL;
+ PartitionMap *inner_default_map = NULL;
+
+ if (outer_has_default)
+ outer_default_map = &outer_maps[outer_default];
+
+ if (inner_has_default)
+ inner_default_map = &inner_maps[inner_default];
+
+ if (!outer_has_default && !inner_has_default)
+ Assert(*default_index < 0);
+ else if (outer_default_map != NULL && inner_default_map == NULL)
+ {
+ if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (outer_default_map->to < 0)
+ {
+ outer_default_map->to = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = outer_default_map->to;
+ }
+ else
+ Assert(*default_index == outer_default_map->to);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else if (outer_default_map == NULL && inner_default_map != NULL)
+ {
+ if (jointype == JOIN_FULL)
+ {
+ if (inner_default_map->to < 0)
+ {
+ inner_default_map->to = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = inner_default_map->to;
+ }
+ else
+ Assert(*default_index == inner_default_map->to);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else
+ {
+ Assert(outer_has_default && inner_has_default);
+
+ *default_index = map_and_merge_partitions(outer_maps, inner_maps,
+ outer_default, inner_default,
+ next_index);
+
+ if (*default_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
+
+/*
+ * merge_null_partitions
+ *
+ * Merge NULL partitions, i.e. a partition that can hold NULL values for a list
+ * partitioned table, if any. Find the index of merged partition to which the
+ * NULL values would belong in the join result. If one joining relation has a
+ * NULL partition but not the other, try matching it with the default partition
+ * from the other relation since the default partition may have rows with NULL
+ * partition key. We can eliminate a NULL partition when it appears only on the
+ * inner side of the join and the outer side doesn't have a default partition.
+ *
+ * When the equality operator used for join is strict, two NULL values will not
+ * be considered as equal, and thus a NULL partition can be eliminated for an
+ * inner join. But we don't check the strictness operator here.
+ */
+static bool
+merge_null_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps, PartitionMap *inner_maps,
+ JoinType jointype, int *next_index,
+ int *null_index, int *default_index)
+{
+ bool outer_has_null = partition_bound_accepts_nulls(outer_bi);
+ bool inner_has_null = partition_bound_accepts_nulls(inner_bi);
+ int outer_ni = outer_bi->null_index;
+ int inner_ni = inner_bi->null_index;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool merged = true;
+
+ if (!outer_has_null && !inner_has_null)
+ *null_index = -1;
+ else if (outer_has_null && !inner_has_null)
+ {
+ int merged_index;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+
+ merged = handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ outer_ni,
+ missing_side_outer,
+ missing_side_inner, next_index,
+ default_index, &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join to which the outer null partition maps
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = outer_maps[outer_ni].to;
+ }
+ else if (!outer_has_null && inner_has_null)
+ {
+ int merged_index;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as OUTER
+ * relation. For INNER and SEMI join OUTER and INNER differentiation is
+ * immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+ merged = handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ inner_ni,
+ missing_side_outer,
+ missing_side_inner,
+ next_index, default_index,
+ &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join, to which the outer side null partition maps,
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = inner_maps[inner_ni].to;
+ }
+ else
+ {
+ /* Both the relations have NULL partitions, try merging them. */
+ *null_index = map_and_merge_partitions(outer_maps,
+ inner_maps,
+ outer_ni,
+ inner_ni,
+ next_index);
+ if (*null_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
diff --git a/src/include/partitioning/partbounds.h b/src/include/partitioning/partbounds.h
index b1ae39ad63..a71f6d99e6 100644
--- a/src/include/partitioning/partbounds.h
+++ b/src/include/partitioning/partbounds.h
@@ -107,5 +107,10 @@ extern int partition_range_datum_bsearch(FmgrInfo *partsupfunc,
int nvalues, Datum *values, bool *is_equal);
extern int partition_hash_bsearch(PartitionBoundInfo boundinfo,
int modulus, int remainder);
+extern PartitionBoundInfo partition_bounds_merge(int partnatts,
+ FmgrInfo *partsupfunc, Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts);
#endif /* PARTBOUNDS_H */
--
2.19.2
[text/x-patch] 0003-Tests-for-0-1-1-1-and-1-0-partition-matching-v16.patch (220.4K, ../../5C470EB8.30503@lab.ntt.co.jp/4-0003-Tests-for-0-1-1-1-and-1-0-partition-matching-v16.patch)
download | inline diff:
From b648d8490b7a9af970530eff3cfdf44e38baf2e9 Mon Sep 17 00:00:00 2001
From: Etsuro Fujita <efujita@postgresql.org>
Date: Tue, 22 Jan 2019 21:28:58 +0900
Subject: [PATCH 3/3] Tests for 0:1, 1:1 and 1:0 partition matching
Rajkumar Raghuvanshi and Ashutosh Bapat.
---
src/test/regress/expected/partition_join.out | 4131 +++++++++++++++---
src/test/regress/sql/partition_join.sql | 427 +-
2 files changed, 3855 insertions(+), 703 deletions(-)
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index c55de5d476..f19611c853 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -8,59 +8,86 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(21 rows)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
-(4 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+(7 rows)
-- left outer join, with whole-row reference; partitionwise join does not apply
EXPLAIN (COSTS OFF)
@@ -72,35 +99,50 @@ SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(22 rows)
SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- t1 | t2
---------------+--------------
- (0,0,0000) | (0,0,0000)
- (50,0,0050) |
- (100,0,0100) |
- (150,0,0150) | (0,150,0150)
- (200,0,0200) |
- (250,0,0250) |
- (300,0,0300) | (0,300,0300)
- (350,0,0350) |
- (400,0,0400) |
- (450,0,0450) | (0,450,0450)
- (500,0,0500) |
- (550,0,0550) |
-(12 rows)
+ t1 | t2
+----------------+----------------
+ (-250,0,-0250) |
+ (-200,0,-0200) |
+ (-150,0,-0150) | (0,-150,-0150)
+ (-100,0,-0100) |
+ (-50,0,-0050) |
+ (0,0,0000) | (0,0,0000)
+ (50,0,0050) |
+ (100,0,0100) |
+ (150,0,0150) | (0,150,0150)
+ (200,0,0200) |
+ (250,0,0250) |
+ (300,0,0300) | (0,300,0300)
+ (350,0,0350) |
+ (400,0,0400) |
+ (450,0,0450) | (0,450,0450)
+ (500,0,0500) |
+ (550,0,0550) |
+ (600,0,0600) | (0,600,0600)
+ (650,0,0650) |
+ (700,0,0700) |
+ (750,0,0750) | (0,750,0750)
+(21 rows)
-- right outer join
EXPLAIN (COSTS OFF)
@@ -112,35 +154,53 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHE
-> Append
-> Hash Right Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Right Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Hash Right Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-> Nested Loop Left Join
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p3 t2_3
Filter: (a = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t2_2.b)
-(20 rows)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
- | | 75 | 0075
- | | 225 | 0225
- | | 375 | 0375
- | | 525 | 0525
-(8 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+ | | -225 | -0225
+ | | -75 | -0075
+ | | 75 | 0075
+ | | 225 | 0225
+ | | 375 | 0375
+ | | 525 | 0525
+ | | 675 | 0675
+(14 rows)
-- full outer join, with placeholder vars
EXPLAIN (COSTS OFF)
@@ -148,8 +208,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
QUERY PLAN
------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b
+ Sort Key: prt1_p0.a, prt2_p0.b
-> Append
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ Filter: (((50) = prt1_p0.a) OR ((75) = prt2_p0.b))
+ -> Seq Scan on prt1_p0
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p1.a = prt2_p1.b)
Filter: (((50) = prt1_p1.a) OR ((75) = prt2_p1.b))
@@ -174,7 +242,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
-> Hash
-> Seq Scan on prt2_p3
Filter: (a = 0)
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ Filter: (((50) = prt1_p4.a) OR ((75) = prt2_p4.b))
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) WHERE t1.phv = t1.a OR t2.phv = t2.b ORDER BY t1.a, t2.b;
a | c | b | c
@@ -211,8 +287,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Hash Left Join
+ Hash Cond: (prt1_p0.a = b)
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Hash
+ -> Result
+ One-Time Filter: false
-> Hash Left Join
Hash Cond: (prt1_p1.a = b)
-> Seq Scan on prt1_p1
@@ -227,29 +310,42 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
-> Hash
-> Seq Scan on prt1_p2
Filter: ((a < 450) AND (b = 0))
-(17 rows)
+(24 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
-(9 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+(14 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
QUERY PLAN
------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = b)
+ Filter: ((prt1_p0.b = 0) OR (a = 0))
+ -> Seq Scan on prt1_p0
+ Filter: (a < 450)
+ -> Hash
+ -> Result
+ One-Time Filter: false
-> Hash Full Join
Hash Cond: (prt1_p1.a = b)
Filter: ((prt1_p1.b = 0) OR (a = 0))
@@ -274,64 +370,153 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JO
-> Hash
-> Result
One-Time Filter: false
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt2_p4.b = a)
+ Filter: ((b = 0) OR (prt2_p4.a = 0))
+ -> Seq Scan on prt2_p4
+ Filter: (b > 250)
+ -> Hash
+ -> Result
+ One-Time Filter: false
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
- | | 375 | 0375
- | | 450 | 0450
- | | 525 | 0525
-(12 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ | | 375 | 0375
+ | | 450 | 0450
+ | | 525 | 0525
+ | | 600 | 0600
+ | | 675 | 0675
+ | | 750 | 0750
+(20 rows)
-- Semi-join
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Semi Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Semi Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Nested Loop Semi Join
- Join Filter: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Materialize
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-(24 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(39 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p0 t2
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_2.b = t2_2.a)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p2 t2_2
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: (t1_3.b = t2_3.a)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt1_p3 t2_3
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.b = t2_4.a)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p4 t2_4
+ Filter: (b = 0)
+(37 rows)
+
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
@@ -342,27 +527,82 @@ SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS
-> Append
-> Hash Anti Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash Anti Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash Anti Join
Hash Cond: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p3 t2_2
-(17 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash Anti Join
+ Hash Cond: (t1_3.a = t2_3.b)
+ -> Seq Scan on prt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_3
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(27 rows)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
- sum | avg | sum | avg
--------+----------------------+------+---------------------
- 60000 | 300.0000000000000000 | 2400 | 12.0000000000000000
+ sum | avg | sum | avg
+-------+----------------------+------+--------------------
+ 95550 | 273.0000000000000000 | 2200 | 6.2857142857142857
(1 row)
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ QUERY PLAN
+--------------------------------------------------------------
+ Append
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Hash Anti Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(27 rows)
+
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ b | c
+------+-------
+ -225 | -0225
+ -75 | -0075
+ 75 | 0075
+ 225 | 0225
+ 375 | 0375
+ 525 | 0525
+ 675 | 0675
+(7 rows)
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -374,49 +614,74 @@ SELECT * FROM prt1 t1 LEFT JOIN LATERAL
Sort Key: t1.a
-> Append
-> Nested Loop Left Join
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p1_a on prt1_p1 t2
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
Index Cond: (a = t1.a)
- -> Index Scan using iprt2_p1_b on prt2_p1 t3
+ -> Index Scan using iprt2_p0_b on prt2_p0 t3
Index Cond: (b = t2.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_1
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
Index Cond: (a = t1_1.a)
- -> Index Scan using iprt2_p2_b on prt2_p2 t3_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t3_1
Index Cond: (b = t2_1.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_2
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
Index Cond: (a = t1_2.a)
- -> Index Scan using iprt2_p3_b on prt2_p3 t3_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t3_2
Index Cond: (b = t2_2.a)
-(27 rows)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.a)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t3_3
+ Index Cond: (b = t2_3.a)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.a)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t3_4
+ Index Cond: (b = t2_4.a)
+(43 rows)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, least(t1.a,t2.a,t3.b) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.a = ss.t2a WHERE t1.b = 0 ORDER BY t1.a;
- a | b | c | t2a | t3a | least
------+---+------+-----+-----+-------
- 0 | 0 | 0000 | 0 | 0 | 0
- 50 | 0 | 0050 | | |
- 100 | 0 | 0100 | | |
- 150 | 0 | 0150 | 150 | 0 | 150
- 200 | 0 | 0200 | | |
- 250 | 0 | 0250 | | |
- 300 | 0 | 0300 | 300 | 0 | 300
- 350 | 0 | 0350 | | |
- 400 | 0 | 0400 | | |
- 450 | 0 | 0450 | 450 | 0 | 450
- 500 | 0 | 0500 | | |
- 550 | 0 | 0550 | | |
-(12 rows)
+ a | b | c | t2a | t3a | least
+------+---+-------+------+-----+-------
+ -250 | 0 | -0250 | | |
+ -200 | 0 | -0200 | | |
+ -150 | 0 | -0150 | -150 | 0 | -150
+ -100 | 0 | -0100 | | |
+ -50 | 0 | -0050 | | |
+ 0 | 0 | 0000 | 0 | 0 | 0
+ 50 | 0 | 0050 | | |
+ 100 | 0 | 0100 | | |
+ 150 | 0 | 0150 | 150 | 0 | 150
+ 200 | 0 | 0200 | | |
+ 250 | 0 | 0250 | | |
+ 300 | 0 | 0300 | 300 | 0 | 300
+ 350 | 0 | 0350 | | |
+ 400 | 0 | 0400 | | |
+ 450 | 0 | 0450 | 450 | 0 | 450
+ 500 | 0 | 0500 | | |
+ 550 | 0 | 0550 | | |
+ 600 | 0 | 0600 | 600 | 0 | 600
+ 650 | 0 | 0650 | | |
+ 700 | 0 | 0700 | | |
+ 750 | 0 | 0750 | 750 | 0 | 750
+(21 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
@@ -430,64 +695,95 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
Hash Cond: ((t1.c)::text = (t2.c)::text)
Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Hash Join
Hash Cond: (t2.a = t3.b)
- -> Seq Scan on prt1_p1 t2
+ -> Seq Scan on prt1_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t3
+ -> Seq Scan on prt2_p0 t3
-> Hash Join
Hash Cond: (t2_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t2_1
+ -> Seq Scan on prt1_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p1 t3_1
-> Hash Join
Hash Cond: (t2_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p2 t2_2
-> Hash
- -> Seq Scan on prt2_p3 t3_2
-(26 rows)
+ -> Seq Scan on prt2_p2 t3_2
+ -> Hash Join
+ Hash Cond: (t2_3.a = t3_3.b)
+ -> Seq Scan on prt1_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t3_3
+ -> Hash Join
+ Hash Cond: (t2_4.a = t3_4.b)
+ -> Seq Scan on prt1_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t3_4
+(38 rows)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, t2.b t2b, t2.c t2c, least(t1.a,t2.a,t3.a) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.c = ss.t2c WHERE (t1.b + coalesce(ss.t2b, 0)) = 0 ORDER BY t1.a;
- a | t2a | t2c
------+-----+------
- 0 | 0 | 0000
- 50 | |
- 100 | |
- 150 | 150 | 0150
- 200 | |
- 250 | |
- 300 | 300 | 0300
- 350 | |
- 400 | |
- 450 | 450 | 0450
- 500 | |
- 550 | |
-(12 rows)
+ a | t2a | t2c
+------+------+-------
+ -250 | |
+ -200 | |
+ -150 | -150 | -0150
+ -100 | |
+ -50 | |
+ 0 | 0 | 0000
+ 50 | |
+ 100 | |
+ 150 | 150 | 0150
+ 200 | |
+ 250 | |
+ 300 | 300 | 0300
+ 350 | |
+ 400 | |
+ 450 | 450 | 0450
+ 500 | |
+ 550 | |
+ 600 | 600 | 0600
+ 650 | |
+ 700 | |
+ 750 | 750 | 0750
+(21 rows)
--
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
@@ -498,32 +794,49 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 =
-> Append
-> Hash Join
Hash Cond: (((t2.b + t2.a) / 2) = ((t1.a + t1.b) / 2))
- -> Seq Scan on prt2_e_p1 t2
+ -> Seq Scan on prt2_e_p0 t2
-> Hash
- -> Seq Scan on prt1_e_p1 t1
+ -> Seq Scan on prt1_e_p0 t1
Filter: (c = 0)
-> Hash Join
- Hash Cond: (((t2_1.b + t2_1.a) / 2) = ((t1_1.a + t1_1.b) / 2))
- -> Seq Scan on prt2_e_p2 t2_1
+ Hash Cond: (((t1_1.a + t1_1.b) / 2) = ((t2_1.b + t2_1.a) / 2))
+ -> Seq Scan on prt1_e_p1 t1_1
+ Filter: (c = 0)
-> Hash
- -> Seq Scan on prt1_e_p2 t1_1
- Filter: (c = 0)
+ -> Seq Scan on prt2_e_p1 t2_1
-> Hash Join
Hash Cond: (((t2_2.b + t2_2.a) / 2) = ((t1_2.a + t1_2.b) / 2))
- -> Seq Scan on prt2_e_p3 t2_2
+ -> Seq Scan on prt2_e_p2 t2_2
-> Hash
- -> Seq Scan on prt1_e_p3 t1_2
+ -> Seq Scan on prt1_e_p2 t1_2
Filter: (c = 0)
-(21 rows)
+ -> Hash Join
+ Hash Cond: (((t2_3.b + t2_3.a) / 2) = ((t1_3.a + t1_3.b) / 2))
+ -> Seq Scan on prt2_e_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t1_3
+ Filter: (c = 0)
+ -> Hash Join
+ Hash Cond: (((t2_4.b + t2_4.a) / 2) = ((t1_4.a + t1_4.b) / 2))
+ -> Seq Scan on prt2_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_4
+ Filter: (c = 0)
+(33 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 150 | 0 | 150 | 0
- 300 | 0 | 300 | 0
- 450 | 0 | 450 | 0
-(4 rows)
+ a | c | b | c
+------+---+------+---
+ -250 | 0 | -250 | 0
+ -100 | 0 | -100 | 0
+ 0 | 0 | 0 | 0
+ 0 | 0 | 0 | 0
+ 150 | 0 | 150 | 0
+ 300 | 0 | 300 | 0
+ 450 | 0 | 450 | 0
+ 600 | 0 | 600 | 0
+ 750 | 0 | 750 | 0
+(9 rows)
--
-- N-way join
@@ -536,154 +849,232 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = ((t3.a + t3.b) / 2))
+ Join Filter: (t1.a = t2.b)
-> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p1_ab2 on prt1_e_p1 t3
- Index Cond: (((a + b) / 2) = t2.b)
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
+ Index Cond: (b = ((t3.a + t3.b) / 2))
-> Nested Loop
Join Filter: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_1
+ -> Index Scan using iprt1_e_p4_ab2 on prt1_e_p1 t3_1
Index Cond: (((a + b) / 2) = t2_1.b)
-> Nested Loop
Join Filter: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_2
Index Cond: (((a + b) / 2) = t2_2.b)
-(33 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = ((t3_3.a + t3_3.b) / 2))
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (((a + b) / 2) = t2_3.b)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t2_4.b)
+ -> Hash Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (b = ((t3_4.a + t3_4.b) / 2))
+(52 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t3 WHERE t1.a = t2.b AND t1.a = (t3.a + t3.b)/2 AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
-(4 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(8 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
---------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Hash Right Join
Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_1.a + t3_1.b) / 2) = t1_1.a)
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
-> Hash
-> Hash Right Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_2.a + t3_2.b) / 2) = t1_2.a)
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
-> Hash
-> Hash Right Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(33 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (t1_3.a = ((a + b) / 2))
+ -> Hash Right Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(51 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
--------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1.a = ((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
Index Cond: (t1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t2_1
Index Cond: (t1_1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t2_2
Index Cond: (t1_2.a = b)
-(30 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t3_3.a + t3_3.b) / 2))
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Nested Loop Left Join
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = ((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (t1_4.a = b)
+(47 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- Cases with non-nullable expressions in subquery results;
-- make sure these go to null as expected
@@ -692,21 +1083,34 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
QUERY PLAN
----------------------------------------------------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b, ((prt1_e_p1.a + prt1_e_p1.b))
+ Sort Key: prt1_p0.a, prt2_p0.b, ((prt1_e_p0.a + prt1_e_p0.b))
-> Append
-> Hash Full Join
- Hash Cond: (prt1_p1.a = ((prt1_e_p1.a + prt1_e_p1.b) / 2))
- Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ Hash Cond: (prt1_p0.a = ((prt1_e_p0.a + prt1_e_p0.b) / 2))
+ Filter: ((prt1_p0.a = (50)) OR (prt2_p0.b = (75)) OR (((prt1_e_p0.a + prt1_e_p0.b) / 2) = (50)))
-> Hash Full Join
- Hash Cond: (prt1_p1.a = prt2_p1.b)
- -> Seq Scan on prt1_p1
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ -> Seq Scan on prt1_p0
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1
+ -> Seq Scan on prt2_p0
Filter: (a = 0)
-> Hash
- -> Seq Scan on prt1_e_p1
+ -> Seq Scan on prt1_e_p0
Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: (((prt1_e_p1.a + prt1_e_p1.b) / 2) = prt1_p1.a)
+ Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ -> Seq Scan on prt1_e_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Hash Full Join
+ Hash Cond: (prt1_p1.a = prt2_p1.b)
+ -> Seq Scan on prt1_p1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p2.a = ((prt1_e_p2.a + prt1_e_p2.b) / 2))
Filter: ((prt1_p2.a = (50)) OR (prt2_p2.b = (75)) OR (((prt1_e_p2.a + prt1_e_p2.b) / 2) = (50)))
@@ -733,7 +1137,20 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
-> Hash
-> Seq Scan on prt1_e_p3
Filter: (c = 0)
-(42 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = ((prt1_e_p4.a + prt1_e_p4.b) / 2))
+ Filter: ((prt1_p4.a = (50)) OR (prt2_p4.b = (75)) OR (((prt1_e_p4.a + prt1_e_p4.b) / 2) = (50)))
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_e_p4
+ Filter: (c = 0)
+(68 rows)
SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b)) FULL JOIN (SELECT 50 phv, * FROM prt1_e WHERE prt1_e.c = 0) t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.a = t1.phv OR t2.b = t2.phv OR (t3.a + t3.b)/2 = t3.phv ORDER BY t1.a, t2.b, t3.a + t3.b;
a | phv | b | phv | ?column? | phv
@@ -751,172 +1168,260 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHER
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = t1_3.b)
+ Join Filter: (t1.a = t1_5.b)
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Join
- Hash Cond: (((t2.a + t2.b) / 2) = t1_3.b)
- -> Seq Scan on prt1_e_p1 t2
+ Hash Cond: (((t2.a + t2.b) / 2) = t1_5.b)
+ -> Seq Scan on prt1_e_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t1_3
+ -> Seq Scan on prt2_p0 t1_5
Filter: (a = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
Index Cond: (a = ((t2.a + t2.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_1.a = t1_4.b)
+ Join Filter: (t1_1.a = t1_6.b)
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Join
- Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_4.b)
- -> Seq Scan on prt1_e_p2 t2_1
+ Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_6.b)
+ -> Seq Scan on prt1_e_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t1_4
+ -> Seq Scan on prt2_p1 t1_6
Filter: (a = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
Index Cond: (a = ((t2_1.a + t2_1.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_2.a = t1_5.b)
+ Join Filter: (t1_2.a = t1_7.b)
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Nested Loop
- -> Seq Scan on prt2_p3 t1_5
+ -> Seq Scan on prt2_p2 t1_7
Filter: (a = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_2
- Index Cond: (((a + b) / 2) = t1_5.b)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t2_2
+ Index Cond: (((a + b) / 2) = t1_7.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
Index Cond: (a = ((t2_2.a + t2_2.b) / 2))
Filter: (b = 0)
-(41 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = t1_8.b)
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t1_8
+ Filter: (a = 0)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_3
+ Index Cond: (((a + b) / 2) = t1_8.b)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t2_3.a + t2_3.b) / 2))
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t1_9.b)
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Join
+ Hash Cond: (((t2_4.a + t2_4.b) / 2) = t1_9.b)
+ -> Seq Scan on prt1_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t1_9
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = ((t2_4.a + t2_4.b) / 2))
+ Filter: (b = 0)
+(66 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHERE t1.a = 0 AND t1.b = (t2.a + t2.b)/2) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
--------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Nested Loop
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Semi Join
- Hash Cond: (t1_3.b = ((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt2_p1 t1_3
+ Hash Cond: (t1_5.b = ((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt2_p0 t1_5
-> Hash
- -> Seq Scan on prt1_e_p1 t1_6
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
- Index Cond: (a = t1_3.b)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t1_5.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Semi Join
- Hash Cond: (t1_4.b = ((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt2_p2 t1_4
+ Hash Cond: (t1_6.b = ((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt2_p1 t1_6
-> Hash
- -> Seq Scan on prt1_e_p2 t1_7
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
- Index Cond: (a = t1_4.b)
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
+ Index Cond: (a = t1_6.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Hash Semi Join
- Hash Cond: (t1_5.b = ((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt2_p3 t1_5
+ Hash Cond: (t1_7.b = ((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt2_p2 t1_7
-> Hash
- -> Seq Scan on prt1_e_p3 t1_8
+ -> Seq Scan on prt1_e_p2 t1_12
Filter: (c = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t1_5.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t1_7.b)
Filter: (b = 0)
-(39 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Hash Semi Join
+ Hash Cond: (t1_8.b = ((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt2_p3 t1_8
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t1_13
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t1_8.b)
+ Filter: (b = 0)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Semi Join
+ Hash Cond: (t1_9.b = ((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt2_p4 t1_9
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = t1_9.b)
+ Filter: (b = 0)
+(63 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
-- test merge joins
SET enable_hashjoin TO off;
SET enable_nestloop TO off;
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
-----------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------
Merge Append
Sort Key: t1.a
-> Merge Semi Join
- Merge Cond: (t1.a = t1_3.b)
+ Merge Cond: (t1.a = t1_5.b)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_3.b = (((t1_6.a + t1_6.b) / 2)))
+ Merge Cond: (t1_5.b = (((t1_10.a + t1_10.b) / 2)))
-> Sort
- Sort Key: t1_3.b
- -> Seq Scan on prt2_p1 t1_3
+ Sort Key: t1_5.b
+ -> Seq Scan on prt2_p0 t1_5
-> Sort
- Sort Key: (((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt1_e_p1 t1_6
+ Sort Key: (((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_1.a = t1_4.b)
+ Merge Cond: (t1_1.a = t1_6.b)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_4.b = (((t1_7.a + t1_7.b) / 2)))
+ Merge Cond: (t1_6.b = (((t1_11.a + t1_11.b) / 2)))
-> Sort
- Sort Key: t1_4.b
- -> Seq Scan on prt2_p2 t1_4
+ Sort Key: t1_6.b
+ -> Seq Scan on prt2_p1 t1_6
-> Sort
- Sort Key: (((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt1_e_p2 t1_7
+ Sort Key: (((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_2.a = t1_5.b)
+ Merge Cond: (t1_2.a = t1_7.b)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_5.b = (((t1_8.a + t1_8.b) / 2)))
+ Merge Cond: (t1_7.b = (((t1_12.a + t1_12.b) / 2)))
-> Sort
- Sort Key: t1_5.b
- -> Seq Scan on prt2_p3 t1_5
+ Sort Key: t1_7.b
+ -> Seq Scan on prt2_p2 t1_7
-> Sort
- Sort Key: (((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt1_e_p3 t1_8
+ Sort Key: (((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt1_e_p2 t1_12
Filter: (c = 0)
-(47 rows)
+ -> Merge Semi Join
+ Merge Cond: (t1_3.a = t1_8.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_8.b = (((t1_13.a + t1_13.b) / 2)))
+ -> Sort
+ Sort Key: t1_8.b
+ -> Seq Scan on prt2_p3 t1_8
+ -> Sort
+ Sort Key: (((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt1_e_p3 t1_13
+ Filter: (c = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_4.a = t1_9.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_9.b = (((t1_14.a + t1_14.b) / 2)))
+ -> Sort
+ Sort Key: t1_9.b
+ -> Seq Scan on prt2_p4 t1_9
+ -> Sort
+ Sort Key: (((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+(77 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
@@ -933,14 +1438,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3.a + t3.b) / 2)) = t1.a)
-> Sort
Sort Key: (((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Sort
Sort Key: t2.b
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Merge Left Join
Merge Cond: (t1_1.a = t2_1.b)
-> Sort
@@ -949,14 +1454,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_1.a + t3_1.b) / 2)) = t1_1.a)
-> Sort
Sort Key: (((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Sort
Sort Key: t2_1.b
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Merge Left Join
Merge Cond: (t1_2.a = t2_2.b)
-> Sort
@@ -965,32 +1470,74 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_2.a + t3_2.b) / 2)) = t1_2.a)
-> Sort
Sort Key: (((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Sort
Sort Key: t2_2.b
- -> Seq Scan on prt2_p3 t2_2
-(51 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Merge Left Join
+ Merge Cond: (t1_3.a = t2_3.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_3.a + t3_3.b) / 2)) = t1_3.a)
+ -> Sort
+ Sort Key: (((t3_3.a + t3_3.b) / 2))
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ -> Sort
+ Sort Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ -> Merge Left Join
+ Merge Cond: (t1_4.a = t2_4.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_4.a + t3_4.b) / 2)) = t1_4.a)
+ -> Sort
+ Sort Key: (((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ -> Sort
+ Sort Key: t2_4.b
+ -> Seq Scan on prt2_p4 t2_4
+(83 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- MergeAppend on nullable column
EXPLAIN (COSTS OFF)
@@ -998,8 +1545,18 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Merge Left Join
+ Merge Cond: (prt1_p0.a = b)
+ -> Sort
+ Sort Key: prt1_p0.a
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Sort
+ Sort Key: b
+ -> Result
+ One-Time Filter: false
-> Merge Left Join
Merge Cond: (prt1_p1.a = b)
-> Sort
@@ -1020,21 +1577,26 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
Sort Key: prt2_p2.b
-> Seq Scan on prt2_p2
Filter: (b > 250)
-(23 rows)
+(33 rows)
SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | b
------+-----
- 0 |
- 50 |
- 100 |
- 150 |
- 200 |
- 250 |
- 300 | 300
- 350 |
- 400 |
-(9 rows)
+ a | b
+------+-----
+ -250 |
+ -200 |
+ -150 |
+ -100 |
+ -50 |
+ 0 |
+ 50 |
+ 100 |
+ 150 |
+ 200 |
+ 250 |
+ 300 | 300
+ 350 |
+ 400 |
+(14 rows)
-- merge join when expression with whole-row reference needs to be sorted;
-- partitionwise join does not apply
@@ -1048,175 +1610,2412 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
Sort Key: t1.a, ((((t1.*)::prt1))::text)
-> Result
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Sort
Sort Key: t2.b, ((((t2.*)::prt2))::text)
-> Result
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
-(16 rows)
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+(20 rows)
SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.b ORDER BY t1.a;
- a | b
-----+----
- 0 | 0
- 6 | 6
- 12 | 12
- 18 | 18
- 24 | 24
-(5 rows)
+ a | b
+-----+-----
+ -24 | -24
+ -18 | -18
+ -12 | -12
+ -6 | -6
+ 0 | 0
+ 6 | 6
+ 12 | 12
+ 18 | 18
+ 24 | 24
+(9 rows)
RESET enable_hashjoin;
RESET enable_nestloop;
---
--- partitioned by multiple columns
---
-CREATE TABLE prt1_m (a int, b int, c int) PARTITION BY RANGE(a, ((a + b)/2));
-CREATE TABLE prt1_m_p1 PARTITION OF prt1_m FOR VALUES FROM (0, 0) TO (250, 250);
-CREATE TABLE prt1_m_p2 PARTITION OF prt1_m FOR VALUES FROM (250, 250) TO (500, 500);
-CREATE TABLE prt1_m_p3 PARTITION OF prt1_m FOR VALUES FROM (500, 500) TO (600, 600);
-INSERT INTO prt1_m SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
-ANALYZE prt1_m;
-CREATE TABLE prt2_m (a int, b int, c int) PARTITION BY RANGE(((b + a)/2), b);
-CREATE TABLE prt2_m_p1 PARTITION OF prt2_m FOR VALUES FROM (0, 0) TO (250, 250);
-CREATE TABLE prt2_m_p2 PARTITION OF prt2_m FOR VALUES FROM (250, 250) TO (500, 500);
-CREATE TABLE prt2_m_p3 PARTITION OF prt2_m FOR VALUES FROM (500, 500) TO (600, 600);
-INSERT INTO prt2_m SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
-ANALYZE prt2_m;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
- QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+ -> Seq Scan on prt2_p3 t2_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_4
+ Filter: (b = 0)
+(22 rows)
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p1 t2
+ -> Hash
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p2 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p3 t1_2
+ Filter: (b = 0)
+(21 rows)
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -150 | -0150 | 0 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 0 | 0150
+ 300 | 0300 | 0 | 0300
+ 450 | 0450 | 0 | 0450
+ 600 | 0600 | 0 | 0600
+ 750 | 0750 | 0 | 0750
+(7 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | 0 | -0150
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | 0 | 0000
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | 0 | 0150
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 0 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ 450 | 0450 | 0 | 0450
+ 500 | 0500 | |
+ 550 | 0550 | |
+ 600 | 0600 | 0 | 0600
+ 650 | 0650 | |
+ 700 | 0700 | |
+ 750 | 0750 | 0 | 0750
+(21 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Semi Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Append
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
+ Index Cond: (a = t1_1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(28 rows)
+
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Anti Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Anti Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -250 | 0 | -0250
+ -200 | 0 | -0200
+ -100 | 0 | -0100
+ -50 | 0 | -0050
+ 50 | 0 | 0050
+ 100 | 0 | 0100
+ 200 | 0 | 0200
+ 250 | 0 | 0250
+ 350 | 0 | 0350
+ 400 | 0 | 0400
+ 500 | 0 | 0500
+ 550 | 0 | 0550
+ 650 | 0 | 0650
+ 700 | 0 | 0700
+(14 rows)
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ QUERY PLAN
+---------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t3.c
+ -> Append
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t3
+ Index Cond: (a = t2.b)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t2.b)
+ -> Hash Right Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t3_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t3_2
+ Index Cond: (a = t2_2.b)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t2_2.b)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t3_3
+ Index Cond: (a = t2_3.b)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(47 rows)
+
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ a | a | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.b
+ -> Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(24 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: (t1.a = t2.b)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.a, 0)) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------
+ Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(22 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Join
+ Hash Cond: (t1.a = t2.b)
+ Join Filter: ((t1.b + t2.a) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+--
+-- partitioned by multiple columns
+--
+CREATE TABLE prt1_m (a int, b int, c int) PARTITION BY RANGE(a, ((a + b)/2));
+CREATE TABLE prt1_m_p1 PARTITION OF prt1_m FOR VALUES FROM (0, 0) TO (250, 250);
+CREATE TABLE prt1_m_p2 PARTITION OF prt1_m FOR VALUES FROM (250, 250) TO (500, 500);
+CREATE TABLE prt1_m_p3 PARTITION OF prt1_m FOR VALUES FROM (500, 500) TO (600, 600);
+INSERT INTO prt1_m SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+ANALYZE prt1_m;
+CREATE TABLE prt2_m (a int, b int, c int) PARTITION BY RANGE(((b + a)/2), b);
+CREATE TABLE prt2_m_p1 PARTITION OF prt2_m FOR VALUES FROM (0, 0) TO (250, 250);
+CREATE TABLE prt2_m_p2 PARTITION OF prt2_m FOR VALUES FROM (250, 250) TO (500, 500);
+CREATE TABLE prt2_m_p3 PARTITION OF prt2_m FOR VALUES FROM (500, 500) TO (600, 600);
+INSERT INTO prt2_m SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+ANALYZE prt2_m;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------
+ Sort
+ Sort Key: prt1_m_p1.a, prt2_m_p1.b
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p1.a = ((prt2_m_p1.b + prt2_m_p1.a) / 2)) AND (((prt1_m_p1.a + prt1_m_p1.b) / 2) = prt2_m_p1.b))
+ -> Seq Scan on prt1_m_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p1
+ Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p2.a = ((prt2_m_p2.b + prt2_m_p2.a) / 2)) AND (((prt1_m_p2.a + prt1_m_p2.b) / 2) = prt2_m_p2.b))
+ -> Seq Scan on prt1_m_p2
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p2
+ Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p3.a = ((prt2_m_p3.b + prt2_m_p3.a) / 2)) AND (((prt1_m_p3.a + prt1_m_p3.b) / 2) = prt2_m_p3.b))
+ -> Seq Scan on prt1_m_p3
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p3
+ Filter: (c = 0)
+(24 rows)
+
+SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
+ a | c | b | c
+-----+---+-----+---
+ 0 | 0 | 0 | 0
+ 50 | 0 | |
+ 100 | 0 | |
+ 150 | 0 | 150 | 0
+ 200 | 0 | |
+ 250 | 0 | |
+ 300 | 0 | 300 | 0
+ 350 | 0 | |
+ 400 | 0 | |
+ 450 | 0 | 450 | 0
+ 500 | 0 | |
+ 550 | 0 | |
+ | | 75 | 0
+ | | 225 | 0
+ | | 375 | 0
+ | | 525 | 0
+(16 rows)
+
+--
+-- tests for list partitioned tables.
+--
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 470 | 0 | 0011
+(1 row)
+
+--
+-- list partitioned by expression
+--
+CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
+ANALYZE plt1_e;
+-- test partition matching with N-way join
+EXPLAIN (COSTS OFF)
+SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Group Key: t1.c, t2.c, t3.c
+ -> Sort
+ Sort Key: t1.c, t3.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = ltrim(t3.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t2.b = t1.b) AND ((t2.c)::text = (t1.c)::text))
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt1_e_p4 t3
+ -> Hash Join
+ Hash Cond: ((t1_1.c)::text = ltrim(t3_1.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t1_1.b = t2_1.b) AND ((t1_1.c)::text = (t2_1.c)::text))
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_e_p1 t3_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = ltrim(t3_2.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t1_2.b = t2_2.b) AND ((t1_2.c)::text = (t2_2.c)::text))
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_e_p2 t3_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = ltrim(t3_3.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t2_3.b = t1_3.b) AND ((t2_3.c)::text = (t1_3.c)::text))
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt1_e_p3 t3_3
+(41 rows)
+
+SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+ avg | avg | avg | c | c | c
+----------------------+---------------------+----------------------+------+------+------
+ 246.5000000000000000 | 22.4666666666666667 | 268.9666666666666667 | 0000 | 0000 | 0000
+ 248.5000000000000000 | 21.3333333333333333 | 269.8333333333333333 | 0002 | 0002 | 0002
+ 249.5000000000000000 | 22.3333333333333333 | 271.8333333333333333 | 0003 | 0003 | 0003
+ 250.5000000000000000 | 23.3333333333333333 | 273.8333333333333333 | 0004 | 0004 | 0004
+ 251.5000000000000000 | 22.7666666666666667 | 274.2666666666666667 | 0005 | 0005 | 0005
+ 252.5000000000000000 | 22.2000000000000000 | 274.7000000000000000 | 0006 | 0006 | 0006
+ 246.0000000000000000 | 23.9655172413793103 | 269.9655172413793103 | 0008 | 0008 | 0008
+ 247.0000000000000000 | 23.3448275862068966 | 270.3448275862068966 | 0009 | 0009 | 0009
+(8 rows)
+
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 470 | 0011
+ | | 235 | 0014
+(8 rows)
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 235 | 0014
+ | | 470 | 0011
+(10 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 47 | 0 | 0013
+ 235 | 0 | 0014
+ 470 | 0 | 0011
+(3 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+----------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Materialize
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(20 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Materialize
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+---
+ 470 | 0 |
+(1 row)
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
Sort
- Sort Key: prt1_m_p1.a, prt2_m_p1.b
- -> Append
- -> Hash Full Join
- Hash Cond: ((prt1_m_p1.a = ((prt2_m_p1.b + prt2_m_p1.a) / 2)) AND (((prt1_m_p1.a + prt1_m_p1.b) / 2) = prt2_m_p1.b))
- -> Seq Scan on prt1_m_p1
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p1
- Filter: (c = 0)
- -> Hash Full Join
- Hash Cond: ((prt1_m_p2.a = ((prt2_m_p2.b + prt2_m_p2.a) / 2)) AND (((prt1_m_p2.a + prt1_m_p2.b) / 2) = prt2_m_p2.b))
- -> Seq Scan on prt1_m_p2
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p2
- Filter: (c = 0)
- -> Hash Full Join
- Hash Cond: ((prt1_m_p3.a = ((prt2_m_p3.b + prt2_m_p3.a) / 2)) AND (((prt1_m_p3.a + prt1_m_p3.b) / 2) = prt2_m_p3.b))
- -> Seq Scan on prt1_m_p3
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p3
- Filter: (c = 0)
-(24 rows)
+ Sort Key: t2.a
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
-SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 50 | 0 | |
- 100 | 0 | |
- 150 | 0 | 150 | 0
- 200 | 0 | |
- 250 | 0 | |
- 300 | 0 | 300 | 0
- 350 | 0 | |
- 400 | 0 | |
- 450 | 0 | 450 | 0
- 500 | 0 | |
- 550 | 0 | |
- | | 75 | 0
- | | 225 | 0
- | | 375 | 0
- | | 525 | 0
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
(16 rows)
---
--- tests for list partitioned tables.
---
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
---
--- list partitioned by expression
---
-CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1_e;
--- test partition matching with N-way join
+-- semi join
EXPLAIN (COSTS OFF)
-SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- QUERY PLAN
---------------------------------------------------------------------------------
- GroupAggregate
- Group Key: t1.c, t2.c, t3.c
- -> Sort
- Sort Key: t1.c, t3.c
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
-> Append
- -> Hash Join
- Hash Cond: (t1.c = ltrim(t3.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1.b = t2.b) AND (t1.c = t2.c))
- -> Seq Scan on plt1_p1 t1
- -> Hash
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_e_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.c = ltrim(t3_1.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1_1.b = t2_1.b) AND (t1_1.c = t2_1.c))
- -> Seq Scan on plt1_p2 t1_1
- -> Hash
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_e_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.c = ltrim(t3_2.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1_2.b = t2_2.b) AND (t1_2.c = t2_2.c))
- -> Seq Scan on plt1_p3 t1_2
- -> Hash
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_e_p3 t3_2
-(32 rows)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(22 rows)
-SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- avg | avg | avg | c | c | c
-----------------------+----------------------+-----------------------+------+------+-------
- 24.0000000000000000 | 24.0000000000000000 | 48.0000000000000000 | 0000 | 0000 | A0000
- 75.0000000000000000 | 75.0000000000000000 | 148.0000000000000000 | 0001 | 0001 | A0001
- 123.0000000000000000 | 123.0000000000000000 | 248.0000000000000000 | 0002 | 0002 | A0002
- 174.0000000000000000 | 174.0000000000000000 | 348.0000000000000000 | 0003 | 0003 | A0003
- 225.0000000000000000 | 225.0000000000000000 | 448.0000000000000000 | 0004 | 0004 | A0004
- 273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
- 324.0000000000000000 | 324.0000000000000000 | 648.0000000000000000 | 0006 | 0006 | A0006
- 375.0000000000000000 | 375.0000000000000000 | 748.0000000000000000 | 0007 | 0007 | A0007
- 423.0000000000000000 | 423.0000000000000000 | 848.0000000000000000 | 0008 | 0008 | A0008
- 474.0000000000000000 | 474.0000000000000000 | 948.0000000000000000 | 0009 | 0009 | A0009
- 525.0000000000000000 | 525.0000000000000000 | 1048.0000000000000000 | 0010 | 0010 | A0010
- 573.0000000000000000 | 573.0000000000000000 | 1148.0000000000000000 | 0011 | 0011 | A0011
-(12 rows)
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(22 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(19 rows)
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
@@ -1241,22 +4040,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
--------------------------------------------------
Hash Left Join
Hash Cond: (t2.b = a)
- -> Append
- -> Hash Join
- Hash Cond: (t3.a = t2.b)
- -> Seq Scan on prt1_p1 t3
- -> Hash
- -> Seq Scan on prt2_p1 t2
- -> Hash Join
- Hash Cond: (t3_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t3_1
- -> Hash
- -> Seq Scan on prt2_p2 t2_1
- -> Hash Join
- Hash Cond: (t3_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t3_2
- -> Hash
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash Join
+ Hash Cond: (t3.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t3
+ -> Seq Scan on prt1_p1 t3_1
+ -> Seq Scan on prt1_p2 t3_2
+ -> Seq Scan on prt1_p3 t3_3
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Result
One-Time Filter: false
@@ -1271,16 +4070,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
-> Hash Left Join
Hash Cond: (t2.b = a)
-> Append
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
Filter: (a = 0)
-> Hash
-> Result
One-Time Filter: false
-(14 rows)
+(20 rows)
--
-- tests for hash partitioned tables.
@@ -1356,41 +4161,9 @@ SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, ph
273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
(6 rows)
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
- Sort
- Sort Key: t1.a
- -> Append
- -> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
- -> Hash
- -> Seq Scan on prt1_p1 t1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
- -> Hash
- -> Seq Scan on prt1_p2 t1_1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
- -> Hash
- -> Seq Scan on prt1_p3 t1_2
- Filter: (b = 0)
-(21 rows)
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
@@ -1405,26 +4178,24 @@ SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c
Sort Key: t1.c
-> HashAggregate
Group Key: t1.c, t2.c
- -> Append
- -> Hash Join
- Hash Cond: (t2.c = t1.c)
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_p1 t1
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_1.c = t1_1.c)
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p1 t1_1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_2.c = t1_2.c)
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p2 t1_2
Filter: ((a % 25) = 0)
-(23 rows)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: ((a % 25) = 0)
+(21 rows)
--
-- multiple levels of partitioning
@@ -1826,64 +4597,70 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2 WHERE t1.a = t2.a;
Hash Join
Hash Cond: (t1.a = t2.a)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Seq Scan on prt4_n_p1 t2
-> Seq Scan on prt4_n_p2 t2_1
-> Seq Scan on prt4_n_p3 t2_2
-(11 rows)
+(13 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2, prt2 t3 WHERE t1.a = t2.a and t1.a = t3.b;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------
Hash Join
- Hash Cond: (t2.a = t1.a)
+ Hash Cond: (t3.b = t1.a)
-> Append
- -> Seq Scan on prt4_n_p1 t2
- -> Seq Scan on prt4_n_p2 t2_1
- -> Seq Scan on prt4_n_p3 t2_2
+ -> Seq Scan on prt2_p0 t3
+ -> Seq Scan on prt2_p1 t3_1
+ -> Seq Scan on prt2_p2 t3_2
+ -> Seq Scan on prt2_p3 t3_3
+ -> Seq Scan on prt2_p4 t3_4
+ -> Seq Scan on prt2_p5 t3_5
-> Hash
- -> Append
- -> Hash Join
- Hash Cond: (t1.a = t3.b)
- -> Seq Scan on prt1_p1 t1
- -> Hash
- -> Seq Scan on prt2_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t1_1
- -> Hash
- -> Seq Scan on prt2_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t1_2
- -> Hash
- -> Seq Scan on prt2_p3 t3_2
+ -> Hash Join
+ Hash Cond: (t1.a = t2.a)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt4_n_p1 t2
+ -> Seq Scan on prt4_n_p2 t2_1
+ -> Seq Scan on prt4_n_p3 t2_2
(23 rows)
-- partitionwise join can not be applied if there are no equi-join conditions
-- between partition keys
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON (t1.a < t2.b);
- QUERY PLAN
----------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------
Nested Loop Left Join
+ Join Filter: (t1.a < t2.b)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
- -> Append
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
- Index Cond: (t1.a < b)
-(12 rows)
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Materialize
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(16 rows)
-- equi-join with join condition on partial keys does not qualify for
-- partitionwise join
@@ -1969,16 +4746,17 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 JOIN prt2_n t2 ON (t1.c = t2.c) JOI
-> Seq Scan on prt2_n_p2 t2_1
-> Hash
-> Hash Join
- Hash Cond: (t3.c = (t1.c)::text)
+ Hash Cond: ((t3.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on plt1_p1 t3
- -> Seq Scan on plt1_p2 t3_1
- -> Seq Scan on plt1_p3 t3_2
+ -> Seq Scan on plt1_p4 t3
+ -> Seq Scan on plt1_p1 t3_1
+ -> Seq Scan on plt1_p2 t3_2
+ -> Seq Scan on plt1_p3 t3_3
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(16 rows)
+(17 rows)
-- partitionwise join can not be applied for a join between list and range
-- partitioned table
@@ -1989,14 +4767,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 FULL JOIN prt1 t2 ON (t1.c = t2.c);
Hash Full Join
Hash Cond: ((t2.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on prt1_p1 t2
- -> Seq Scan on prt1_p2 t2_1
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(10 rows)
+(12 rows)
-- partitionwise join can not be applied if only one of joining table has
-- default partition
@@ -2012,16 +4792,23 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b =
-> Hash Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
diff --git a/src/test/regress/sql/partition_join.sql b/src/test/regress/sql/partition_join.sql
index c1c9859651..0e884835fb 100644
--- a/src/test/regress/sql/partition_join.sql
+++ b/src/test/regress/sql/partition_join.sql
@@ -10,25 +10,39 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
@@ -67,11 +81,19 @@ EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -93,20 +115,30 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
@@ -169,6 +201,128 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
RESET enable_hashjoin;
RESET enable_nestloop;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
--
-- partitioned by multiple columns
--
@@ -193,28 +347,79 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1
--
-- tests for list partitioned tables.
--
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
--
-- list partitioned by expression
--
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
ANALYZE plt1_e;
-- test partition matching with N-way join
@@ -222,6 +427,175 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.a = 1 AND t1.a = 2;
@@ -267,27 +641,18 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
ALTER TABLE plt2 DETACH PARTITION plt2_p3;
ALTER TABLE plt2 ATTACH PARTITION plt2_p3 DEFAULT;
ANALYZE plt2;
-
EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.a % 25 = 0 GROUP BY t1.c, t2.c ORDER BY t1.c, t2.c;
+
--
-- multiple levels of partitioning
--
--
2.19.2
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
@ 2019-01-31 11:53 ` Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Etsuro Fujita @ 2019-01-31 11:53 UTC (permalink / raw)
To: amul sul <sulamul@gmail.com>; +Cc: Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers; ashutosh.bapat.oss@gmail.com
(2019/01/22 21:38), Etsuro Fujita wrote:
> Will continue to review.
I rebased the patch set against the latest HEAD. Attached is a new
version. I'll move this to the next CF, and continue to review it.
Best regards,
Etsuro Fujita
Attachments:
[text/x-patch] 0001-Hash-partition-bound-equality-refactoring-v17.patch (5.1K, ../../5C52E1AB.2080500@lab.ntt.co.jp/2-0001-Hash-partition-bound-equality-refactoring-v17.patch)
download | inline diff:
From d4333dec0a3ce91dbf007adb3d811fbb02b1ef2a Mon Sep 17 00:00:00 2001
From: Etsuro Fujita <efujita@postgresql.org>
Date: Thu, 31 Jan 2019 19:18:18 +0900
Subject: [PATCH 1/3] Hash partition bound equality refactoring.
Separate the code to check whether two given hash bounds are equal into a
separate function, so that it can be called from multiple places. Right now
it's only caller is partition_bounds_equal() but later we will use it for
merging partition bounds.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/partitioning/partbounds.c | 95 +++++++++++++++++----------
1 file changed, 61 insertions(+), 34 deletions(-)
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index d478ae7e19..c492685d11 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -104,6 +104,9 @@ static void get_range_key_properties(PartitionKey key, int keynum,
Expr **keyCol,
Const **lower_val, Const **upper_val);
static List *get_range_nulltest(PartitionKey key);
+static bool partition_hbounds_equal(PartitionBoundInfo b1,
+ PartitionBoundInfo b2);
+
/*
* get_qual_from_partbound
@@ -652,6 +655,63 @@ create_range_bounds(PartitionBoundSpec **boundspecs, int nparts,
return boundinfo;
}
+/*
+ * Are two hash partition bound collections logically equal?
+ *
+ * Hash partition bounds store modulus and remainder in datums array which are
+ * always integers irrespective of the number of partition keys and their data
+ * types. Hence we can compare the hash bound collection without any partition
+ * key specific information. Separating this logic in a function which does not
+ * require partition key specific information allows it be called from places
+ * where the partition key specific information is not completely available.
+ */
+static bool
+partition_hbounds_equal(PartitionBoundInfo b1, PartitionBoundInfo b2)
+{
+ int greatest_modulus = get_hash_partition_greatest_modulus(b1);
+ int i;
+
+ Assert(b1->strategy == PARTITION_STRATEGY_HASH &&
+ b2->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * If two hash partitioned tables have different greatest moduli,
+ * their partition schemes don't match. For hash partitioned table,
+ * the greatest modulus is given by the last datum and number of
+ * partitions is given by ndatums.
+ */
+ if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ return false;
+
+ /*
+ * We arrange the partitions in the ascending order of their modulus and
+ * remainders. Also every modulus is factor of next larger modulus.
+ * Therefore we can safely store index of a given partition in indexes
+ * array at remainder of that partition. Also entries at (remainder + N *
+ * modulus) positions in indexes array are all same for (modulus,
+ * remainder) specification for any partition. Thus datums array from both
+ * the given bounds are same, if and only if their indexes array will be
+ * same. So, it suffices to compare indexes array.
+ */
+ for (i = 0; i < greatest_modulus; i++)
+ if (b1->indexes[i] != b2->indexes[i])
+ return false;
+
+#ifdef USE_ASSERT_CHECKING
+
+ /*
+ * Nonetheless make sure that the bounds are indeed same when the indexes
+ * match. Hash partition bound stores modulus and remainder at
+ * b1->datums[i][0] and b1->datums[i][1] position respectively.
+ */
+ for (i = 0; i < b1->ndatums; i++)
+ Assert((b1->datums[i][0] == b2->datums[i][0] &&
+ b1->datums[i][1] == b2->datums[i][1]));
+#endif
+
+ return true;
+}
+
/*
* Are two partition bound collections logically equal?
*
@@ -680,41 +740,8 @@ partition_bounds_equal(int partnatts, int16 *parttyplen, bool *parttypbyval,
if (b1->strategy == PARTITION_STRATEGY_HASH)
{
- int greatest_modulus = get_hash_partition_greatest_modulus(b1);
-
- /*
- * If two hash partitioned tables have different greatest moduli,
- * their partition schemes don't match.
- */
- if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ if (!partition_hbounds_equal(b1, b2))
return false;
-
- /*
- * We arrange the partitions in the ascending order of their moduli
- * and remainders. Also every modulus is factor of next larger
- * modulus. Therefore we can safely store index of a given partition
- * in indexes array at remainder of that partition. Also entries at
- * (remainder + N * modulus) positions in indexes array are all same
- * for (modulus, remainder) specification for any partition. Thus
- * datums array from both the given bounds are same, if and only if
- * their indexes array will be same. So, it suffices to compare
- * indexes array.
- */
- for (i = 0; i < greatest_modulus; i++)
- if (b1->indexes[i] != b2->indexes[i])
- return false;
-
-#ifdef USE_ASSERT_CHECKING
-
- /*
- * Nonetheless make sure that the bounds are indeed same when the
- * indexes match. Hash partition bound stores modulus and remainder
- * at b1->datums[i][0] and b1->datums[i][1] position respectively.
- */
- for (i = 0; i < b1->ndatums; i++)
- Assert((b1->datums[i][0] == b2->datums[i][0] &&
- b1->datums[i][1] == b2->datums[i][1]));
-#endif
}
else
{
--
2.19.2
[text/x-patch] 0002-Partition-wise-join-for-1-1-1-0-0-1-partition-match-v17.patch (69.9K, ../../5C52E1AB.2080500@lab.ntt.co.jp/3-0002-Partition-wise-join-for-1-1-1-0-0-1-partition-match-v17.patch)
download | inline diff:
From a5290bd315d8009ef46d22e170c0ccd5b9dbf968 Mon Sep 17 00:00:00 2001
From: Etsuro Fujita <efujita@postgresql.org>
Date: Thu, 31 Jan 2019 20:26:21 +0900
Subject: [PATCH 2/3] Partition-wise join for 1:1, 1:0, 0:1 partition
matching.
Earlier version of partition-wise join implementation allowed
partition-wise join between two relations with exactly same partition
bounds. This commit allows partition-wise join to be applied under
following conditions
1. the partition bounds of joining relations are such that rows from
given partition on one side join can join with rows from maximum one
partition on the other side i.e. bounds of a given partition on one
side match/overlap with those of maximum one partition on the other
side. If the mapping happens to be m:n where m > 1 or n > 1, we have
to gang multiple partition relations together into a single relation.
This means that we have to add simple relations during join
processing, something which is not supported right now. ALso, in such
a case, different pairs of joining relations can produce different
partition bounds for the same join relation, which again is not
supported right now.
2. For every partition on outer side that can contribute to the result
of an OUTER join, there exists at least one (taken along with item 1,
it means exactly one) matching partition on the inner side. To
support partition-wise join when the inner matching partition doesn't
exist, we have to add a dummy base relation corresponding to the
non-existent inner partition. We don't have support to add base
relations during join processing.
3. For hash partitioned tables however, we support partition-wise join
only when the bounds exactly match. For hash partitioning it's unusual
to have missing partitions and hence generic partition matching is not
required.
With advanced partition matching, we won't be able to apply
partition-wise join when there are missing matching partitions. So for
a given N-way join, some sub-joins may not be partitioned, while the
overall N-way join is partitioned. We can not try partition-wise join
when one or both of the joining relations are not partitioned in one
of the pairs of joining relation. Skip partition-wise join for that
pair.
An example is A IJ B LJ C where B has an extra partition compared to A
and C. Join B LJ C requires dummy relation to join the extra partition
from B to a missing partition from C, and hence can not use
partition-wise join right now and hence BC is not partitioned. The
extra partition in B gets eliminated in A IJ B and thus it can use
partition-wise join and is partitioned. Hence (AB)C can use
partition-wise join but not A(BC).
Not every pair of joining relation (including the one presented to
build_joinrel_partition_info()) for the same joinrel can use
partition-wise join or has both the relations partitioned. Hence we
calculate the partition bounds for the join relation in
try_partition_wise_join() instead of doing it here.
The partition bounds produced for the first pair that can use
partition-wise are saved in the RelOptInfo of the joinrel. Partition
bounds produced for subsequent pairs should match that produced by the
first pair.
Support for default partition in list partitioned tables
========================================================
When a list value is present in one of the joining relations and not
the other, and the other relation has default partition, match (join)
the partition containing that list value with the default partition.
If there are multiple matches, we can not proceed with the
partition-wise join similar to the case of matching non-default
partition. If the default partition happens to be on the outer side of
the join, the resulting join partition acts as a default partition as
it will contain all the values from the default partition. If
the partition containing the list value happens to be on the outer
side of the join, the resulting join partition is associated with the
list value, since no other partition key value from the default
partition makes it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a partition from the inner side,
if inner side has a list value that is not present in the outer side.
But if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Support for matching default partition in range partitioned tables
==================================================================
When a range is present in one of the joining relations and not the
other, and the other relation has default partition, match (join) the
partition corresponding range with the default partition. If two
ranges overlap but their ranges don't match exactly, the
non-overlapping portion from one range may join the previous
(non-overlapping portion near the lower bound, if exists), next
(non-overlapping portion near the upper bound, if exists) ranges from
the other relation or default partition from the other relation. This
causes multiple partitions on the other side to be joined with a
single partition on the first side; a case we don't support. Any range
from one side which doesn't overlap with any range on the other side,
may find its join partner in the default partition and the
corresponding range partition will need to be joined with the default
partition. If the default partition happens to be on the outer side
of the join, the resulting join partition acts as a default partition
as it will contain all the values from the default partition. If the
non-partition corresponding to the range happens to be on the outer
side of the join, the resulting join partition is associated with that
range, since partition key values from the default partition outside
that range won't make it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a non-default partition from the
inner side, if inner side has a range missing in the outer side. But
if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/optimizer/path/joinrels.c | 95 +-
src/backend/optimizer/util/relnode.c | 33 +-
src/backend/partitioning/partbounds.c | 1677 ++++++++++++++++++++++++-
src/include/partitioning/partbounds.h | 7 +
4 files changed, 1766 insertions(+), 46 deletions(-)
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index dfbbfdac6d..ca4d261bc1 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1320,25 +1320,31 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
{
bool rel1_is_simple = IS_SIMPLE_REL(rel1);
bool rel2_is_simple = IS_SIMPLE_REL(rel2);
- int nparts;
+ PartitionScheme part_scheme;
+ PartitionBoundInfo join_boundinfo;
+ List *parts1;
+ List *parts2;
+ ListCell *lc1;
+ ListCell *lc2;
int cnt_parts;
/* Guard against stack overflow due to overly deep partition hierarchy. */
check_stack_depth();
/* Nothing to do, if the join relation is not partitioned. */
- if (!IS_PARTITIONED_REL(joinrel))
+ if (joinrel->part_scheme == NULL)
return;
/* The join relation should have consider_partitionwise_join set. */
Assert(joinrel->consider_partitionwise_join);
/*
- * Since this join relation is partitioned, all the base relations
- * participating in this join must be partitioned and so are all the
- * intermediate join relations.
+ * We can not perform partition-wise join if either of the joining
+ * relations is not partitioned.
*/
- Assert(IS_PARTITIONED_REL(rel1) && IS_PARTITIONED_REL(rel2));
+ if (!IS_PARTITIONED_REL(rel1) || !IS_PARTITIONED_REL(rel2))
+ return;
+
Assert(REL_HAS_ALL_PART_PROPS(rel1) && REL_HAS_ALL_PART_PROPS(rel2));
/* The joining relations should have consider_partitionwise_join set. */
@@ -1351,32 +1357,63 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
*/
Assert(joinrel->part_scheme == rel1->part_scheme &&
joinrel->part_scheme == rel2->part_scheme);
+ part_scheme = joinrel->part_scheme;
/*
- * 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.
+ * Get the list of matching partitions to be joined along with the
+ * partition bounds of the join relation. Because of the restrictions
+ * imposed by partition matching algorithm, not every pair of joining
+ * relations for this join will be able to use partition-wise join. But all
+ * those pairs which can use partition-wise join will produce the same
+ * partition bounds for the join relation.
*/
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel1->boundinfo));
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel2->boundinfo));
+ join_boundinfo = partition_bounds_merge(part_scheme->partnatts,
+ part_scheme->partsupfunc,
+ part_scheme->partcollation,
+ rel1, rel2,
+ parent_sjinfo->jointype,
+ &parts1, &parts2);
+
+ if (join_boundinfo == NULL)
+ return;
- nparts = joinrel->nparts;
+ if (joinrel->boundinfo == NULL)
+ {
+ Assert(joinrel->nparts == 0 && joinrel->part_rels == NULL);
+ joinrel->boundinfo = join_boundinfo;
+ joinrel->nparts = list_length(parts1);
+ Assert(joinrel->nparts == list_length(parts2));
+ joinrel->part_rels =
+ (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+ joinrel->nparts);
+ }
+ else
+ {
+ Assert(partition_bounds_equal(part_scheme->partnatts,
+ part_scheme->parttyplen,
+ part_scheme->parttypbyval,
+ join_boundinfo, joinrel->boundinfo));
+ /*
+ * Every pair of joining relations should result in the same number
+ * of child-joins.
+ */
+ Assert(joinrel->nparts == list_length(parts1));
+ Assert(joinrel->nparts == list_length(parts2));
+ Assert(joinrel->part_rels);
+ }
/*
* Create child-join relations for this partitioned join, if those don't
* exist. Add paths to child-joins for a pair of child relations
* corresponding to the given pair of parent relations.
*/
- for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+ cnt_parts = 0;
+ forboth(lc1, parts1, lc2, parts2)
{
- RelOptInfo *child_rel1 = rel1->part_rels[cnt_parts];
- RelOptInfo *child_rel2 = rel2->part_rels[cnt_parts];
+ int part1 = lfirst_int(lc1);
+ int part2 = lfirst_int(lc2);
+ RelOptInfo *child_rel1;
+ RelOptInfo *child_rel2;
SpecialJoinInfo *child_sjinfo;
List *child_restrictlist;
RelOptInfo *child_joinrel;
@@ -1384,6 +1421,10 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
AppendRelInfo **appinfos;
int nappinfos;
+ Assert(part1 >= 0 && part2 >= 0);
+ child_rel1 = rel1->part_rels[part1];
+ child_rel2 = rel2->part_rels[part2];
+
/*
* If a child table has consider_partitionwise_join=false, it means
* that it's a dummy relation for which we skipped setting up tlist
@@ -1438,12 +1479,24 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
joinrel->part_rels[cnt_parts] = child_joinrel;
}
+ /*
+ * For every pair of joining relations, the set of matching partitions
+ * would change. However, the base relation partitions constituting
+ * the given child should remain same for all the joining pairs. Since
+ * the order in which children are stored in the array of child-joins,
+ * depends upon partition bounds of the join, which are same for all
+ * the joining pairs, every joining pair yields the child-joins in the
+ * same order.
+ */
Assert(bms_equal(child_joinrel->relids, child_joinrelids));
populate_joinrel_with_paths(root, child_rel1, child_rel2,
child_joinrel, child_sjinfo,
child_restrictlist);
+ cnt_parts++;
}
+
+ Assert(cnt_parts == joinrel->nparts);
}
/*
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index f04c6b76f4..a1561dd066 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1585,7 +1585,7 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
* of the way the query planner deduces implied equalities and reorders
* the joins. Please see optimizer/README for details.
*/
- if (!IS_PARTITIONED_REL(outer_rel) || !IS_PARTITIONED_REL(inner_rel) ||
+ if (outer_rel->part_scheme == NULL || inner_rel->part_scheme == NULL ||
!outer_rel->consider_partitionwise_join ||
!inner_rel->consider_partitionwise_join ||
outer_rel->part_scheme != inner_rel->part_scheme ||
@@ -1598,24 +1598,6 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
part_scheme = outer_rel->part_scheme;
- Assert(REL_HAS_ALL_PART_PROPS(outer_rel) &&
- REL_HAS_ALL_PART_PROPS(inner_rel));
-
- /*
- * For now, our partition matching algorithm can match partitions only
- * when the partition bounds of the joining relations are exactly same.
- * So, bail out otherwise.
- */
- if (outer_rel->nparts != inner_rel->nparts ||
- !partition_bounds_equal(part_scheme->partnatts,
- part_scheme->parttyplen,
- part_scheme->parttypbyval,
- outer_rel->boundinfo, inner_rel->boundinfo))
- {
- Assert(!IS_PARTITIONED_REL(joinrel));
- return;
- }
-
/*
* This function will be called only once for each joinrel, hence it
* should not have partition scheme, partition bounds, partition key
@@ -1627,17 +1609,20 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
/*
* Join relation is partitioned using the same partitioning scheme as the
- * joining relations and has same bounds.
+ * joining relations.
+ *
+ * Because of restrictions in partition_bounds_merge(), not every pair of
+ * joining relations (including the one presented to this function) for the
+ * same joinrel can use partition-wise join or has both the relations
+ * partitioned. Hence we calculate the partition bounds, number of
+ * partitions and child-join relations of the join relation when and if we
+ * find a suitable pair in try_partition_wise_join().
*/
joinrel->part_scheme = part_scheme;
- joinrel->boundinfo = outer_rel->boundinfo;
partnatts = joinrel->part_scheme->partnatts;
joinrel->partexprs = (List **) palloc0(sizeof(List *) * partnatts);
joinrel->nullable_partexprs =
(List **) palloc0(sizeof(List *) * partnatts);
- joinrel->nparts = outer_rel->nparts;
- joinrel->part_rels =
- (RelOptInfo **) palloc0(sizeof(RelOptInfo *) * joinrel->nparts);
/*
* Set the consider_partitionwise_join flag.
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index c492685d11..38e35f33fc 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -22,6 +22,7 @@
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
+#include "nodes/pathnodes.h"
#include "parser/parse_coerce.h"
#include "partitioning/partprune.h"
#include "partitioning/partbounds.h"
@@ -65,6 +66,12 @@ typedef struct PartitionRangeBound
bool lower; /* this is the lower (vs upper) bound */
} PartitionRangeBound;
+typedef struct PartitionMap
+{
+ int from;
+ int to;
+} PartitionMap;
+
static int32 qsort_partition_hbound_cmp(const void *a, const void *b);
static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
void *arg);
@@ -106,7 +113,58 @@ static void get_range_key_properties(PartitionKey key, int keynum,
static List *get_range_nulltest(PartitionKey key);
static bool partition_hbounds_equal(PartitionBoundInfo b1,
PartitionBoundInfo b2);
-
+static PartitionBoundInfo partition_range_bounds_merge(
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype, int partnatts,
+ FmgrInfo *supfuncs, Oid *collations);
+static PartitionBoundInfo partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *collations,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype);
+static PartitionBoundInfo partition_hash_bounds_merge(RelOptInfo *outer_rel,
+ RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype);
+static void generate_matching_part_pairs(PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ int nparts1, int nparts2,
+ JoinType jointype, int nparts,
+ List **parts1, List **parts2);
+static PartitionBoundInfo build_merged_partition_bounds(char strategy,
+ List *merged_datums, List *merged_indexes,
+ List *merged_contents, int null_index,
+ int default_index);
+static int map_and_merge_partitions(PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ int index1, int index2, int *next_index);
+static int32 partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *collations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2);
+static bool partition_range_cmp(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval);
+static bool partition_range_merge_next_lb(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes);
+static bool merge_default_partitions(PartitionBoundInfo outer_bi,
+ PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ JoinType jointype,
+ int *next_index, int *default_index);
+static bool merge_null_partitions(PartitionBoundInfo outer_bi,
+ PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ JoinType jointype,
+ int *next_index, int *null_index,
+ int *default_index);
/*
* get_qual_from_partbound
@@ -2941,3 +2999,1620 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
PG_RETURN_BOOL(rowHash % modulus == remainder);
}
+
+/*
+ * partition_bounds_merge
+ *
+ * The function produces the partition bounds for a join between two relations
+ * whose partition bounds are given. The function also returns two lists of
+ * partition indexes one for each of the joining relations. Both the lists
+ * contain the same number of elements. The partition indexes at the same
+ * positions in the lists indicate the pair partitions, one from each side, to
+ * be joined and the position itself corresponds to the index of partition
+ * produced by that child-join in the partitioned join.
+ *
+ * The function returns NULL if we can not find the matching pair of
+ * partitions. This happens if 1. multiple partitions on one side match with
+ * one partition on the other side. 2. a given partition on the outer side
+ * doesn't have a matching partition on the inner side. We can not support the
+ * first case since we don't have a way to represent multiple partitions as a
+ * single relation (RelOptInfo) and then perform join using the ganged
+ * relation. We can not support the second case since the missing inner
+ * partition needs to be represented as an empty relation and we don't have a
+ * way to introduce empty relation during join planning after creating paths
+ * for all the base relations.
+ */
+extern PartitionBoundInfo
+partition_bounds_merge(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts)
+{
+ PartitionBoundInfo merged_bounds;
+ PartitionBoundInfo outer_binfo = outer_rel->boundinfo,
+ inner_binfo = inner_rel->boundinfo;
+ char strategy = outer_binfo->strategy;
+
+ /* Bail out if partitioning strategies are different. */
+ if (outer_binfo->strategy != inner_binfo->strategy)
+ return NULL;
+
+ if (jointype != JOIN_LEFT && jointype != JOIN_INNER &&
+ jointype != JOIN_SEMI && jointype != JOIN_ANTI &&
+ jointype != JOIN_FULL)
+ elog(ERROR, "unexpected join type %d", jointype);
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+ switch (strategy)
+ {
+ case PARTITION_STRATEGY_LIST:
+ merged_bounds = partition_list_bounds_merge(partsupfunc,
+ partcollation,
+ outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype);
+ break;
+
+ case PARTITION_STRATEGY_RANGE:
+ merged_bounds = partition_range_bounds_merge(outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype, partnatts,
+ partsupfunc,
+ partcollation);
+ break;
+
+ case PARTITION_STRATEGY_HASH:
+ merged_bounds = partition_hash_bounds_merge(outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype);
+ break;
+
+ default:
+ elog(ERROR, "unexpected partition strategy: %d", strategy);
+ }
+
+ Assert(merged_bounds || (*outer_parts == NIL && *inner_parts == NIL));
+
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+
+ Assert((*outer_parts == NIL || *inner_parts != NIL) &&
+ (*inner_parts == NIL || *outer_parts != NIL));
+
+ return merged_bounds;
+}
+
+/*
+ * partition_get_range_bounds
+ *
+ * Given the index of lower bound in datums array, return lower and upper
+ * bounds and the index of the partition with that lower bound.
+ */
+static int
+partition_get_range_bounds(PartitionBoundInfo bi, int lb_index,
+ PartitionRangeBound *lower,
+ PartitionRangeBound *upper)
+{
+ int part_index;
+
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The lower bound should correspond to a valid partition. */
+ part_index = bi->indexes[lb_index + 1];
+ Assert(part_index >= 0);
+
+ lower->kind = bi->kind[lb_index];
+ lower->datums = bi->datums[lb_index];
+ lower->lower = true;
+ upper->kind = bi->kind[lb_index + 1];
+ upper->datums = bi->datums[lb_index + 1];
+ upper->lower = false;
+
+ return part_index;
+}
+
+/*
+ * partition_range_get_next_lb_index
+ *
+ * Given the index of lower bound in datums array return the
+ * index of lower bound of the next partition. When the given index corresponds
+ * to the last partition, return number of datums (ndatums).
+ */
+static int
+partition_range_get_next_lb_index(PartitionBoundInfo bi, int lb_index)
+{
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The partition index corresponding to the upper bound should be valid. */
+ Assert(bi->indexes[lb_index + 1] >= 0);
+
+ /*
+ * If there are no bounds left beyond the upper bound, we have reached the
+ * last partition.
+ */
+ if (lb_index + 2 < bi->ndatums)
+ {
+ /*
+ * If the bound next to the upper bound corresponds to no partition,
+ * that's the next lower bound of the next partition. Otherwise, the
+ * current upper bound is the lower bound of the next partition.
+ */
+ if (bi->indexes[lb_index + 2] < 0)
+ return lb_index + 2;
+ else
+ return lb_index + 1;
+ }
+ else
+ return bi->ndatums;
+}
+
+static int32
+partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2)
+{
+ return partition_rbound_cmp(partnatts, partsupfunc, partcollations,
+ bound1->datums, bound1->kind, bound1->lower,
+ bound2);
+}
+
+/*
+ * partition_range_cmp
+ *
+ * Compare the bounds of two range partitions. Set ub_cmpval <, = or > 0, if the
+ * first partition's upper bound is lower than, equal to or higher than the
+ * second partition's upper bound resp. Similarly set lb_cmpval <, = or > 0,
+ * if the first partition's lower bound is lower than, equal to or higher than
+ * the second partition's lower bound resp.
+ *
+ * Return true, if the ranges overlap, otherwise return false.
+ */
+static bool
+partition_range_cmp(int partnatts, FmgrInfo *partsupfuncs, Oid *partcollations,
+ PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval)
+{
+ bool overlap;
+
+ /*
+ * Compare upper bound of the first partition with the lower bound of the
+ * second and vice-versa. If lower bound is higher than the upper bound,
+ * the partitions are not overlapping. All other cases indicate overlapping
+ * partitions.
+ */
+ if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound1, upper_bound2) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = 1;
+ *lb_cmpval = 1;
+ }
+ else if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound2, upper_bound1) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = -1;
+ *lb_cmpval = -1;
+ }
+ else
+ {
+ overlap = true;
+ *ub_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, upper_bound1,
+ upper_bound2);
+ *lb_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, lower_bound1,
+ lower_bound2);
+ }
+
+ return overlap;
+}
+
+/*
+ * partition_range_merge
+ *
+ * Merge the partition bounds of given two partitions such that the join
+ * between the given two partitions fits merged bounds.
+ *
+ * "merged_upper" will be set to one of the given upper bounds and
+ * "merged_lower" will be set to one of the given lower bounds.
+ */
+static void
+partition_range_merge(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, JoinType jointype,
+ PartitionRangeBound *left_lb,
+ PartitionRangeBound *left_ub,
+ PartitionRangeBound *right_lb,
+ PartitionRangeBound *right_ub,
+ PartitionRangeBound **merged_lb,
+ PartitionRangeBound **merged_ub)
+{
+ /*
+ * An outer join will have all the rows from the outer side, so merged
+ * bounds will be same as the outer bounds. An inner join will have rows
+ * that fit both the bounds, thus lower merged bound will be higher of two
+ * lower bounds and upper merged bound will be lower of the two upper
+ * bounds.
+ */
+ switch (jointype)
+ {
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ *merged_ub = left_ub;
+ *merged_lb = left_lb;
+ break;
+
+ case JOIN_INNER:
+ case JOIN_SEMI:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) < 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) > 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ case JOIN_FULL:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) > 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) < 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ default:
+ elog(ERROR, "unexpected join type %d", jointype);
+ }
+
+ return;
+}
+
+/*
+ * Add the lower bound of the next range to the list of bounds, if the lower
+ * bound is higher or equal to the previous upper bound. If successful return
+ * true, otherwise false.
+ */
+static bool
+partition_range_merge_next_lb(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes)
+{
+ int cmpval;
+
+ if (!*merged_datums)
+ {
+ Assert(!*merged_kinds && !*merged_indexes);
+ cmpval = 1;
+ }
+ else
+ {
+ PartitionRangeBound prev_ub;
+
+ prev_ub.datums = llast(*merged_datums);
+ prev_ub.kind = llast(*merged_kinds);
+ prev_ub.lower = false;
+
+ cmpval = partition_rbound_cmp(partnatts, partsupfuncs, partcollations,
+ next_lb_datums, next_lb_kind, false,
+ &prev_ub);
+ }
+
+ /*
+ * The lower bound is lower than the last upper bound, thus does not fit
+ * the bounds created so far and hence can not be merged with the existing
+ * bounds.
+ */
+ if (cmpval < 0)
+ return false;
+
+ /*
+ * Add bounds of the new merged partition. If the next lower bound is
+ * higher than the last upper bound, add new range with index
+ * corresponding to the lower bound as -1. If the merged lower bound
+ * is same as the last merged upper bound, the last upper bound will be
+ * reused as the lower bound of the next range.
+ */
+ if (cmpval > 0)
+ {
+ *merged_datums = lappend(*merged_datums, next_lb_datums);
+ *merged_kinds = lappend(*merged_kinds, next_lb_kind);
+ *merged_indexes = lappend_int(*merged_indexes, -1);
+ }
+
+ return true;
+}
+
+/*
+ * handle_missing_partition
+ *
+ * If a range appears in one of the joining relations but not the other, a row
+ * in the corresponding partition will not have any join partner in the other
+ * relation, unless the other relation has a default partition. If a given list
+ * value is present in one joining relation but not the other, the default
+ * partition on the other side may contain that value.
+ *
+ * In both these cases, such an extra partition forms a joining pair with the
+ * default partition, if any, on the other side.
+ *
+ * If the default partition happens to be on the outer side of the join, the
+ * resultant partition will act as the default partition of the join relation.
+ * Otherwise the resultant partition will be associated with the range.
+ *
+ * When the default partition is not present in the other relation, the rows in
+ * the extra partition will be included in the bounds of the join result, if it
+ * appears on the outer side of the join, since all rows from the outer side
+ * are included in the join result.
+ *
+ * This function handles all these cases.
+ *
+ * maps_with_missing and missing_side_default are the partition maps (See
+ * partition_range/list_bounds_merge() for details) and the index of default
+ * partition respectively corresponding the side with missing partition.
+ *
+ * maps_with_extra and extra_part are the partition maps (See
+ * partition_range/list_bounds_merge() for details) and the index of extra
+ * partition respectively corresponding to the side with the extra partition.
+ *
+ * It returns true if the matching succeeds, otherwise returns false.
+ */
+static bool
+handle_missing_partition(PartitionMap *maps_with_missing,
+ PartitionMap *maps_with_extra,
+ int missing_side_default,
+ int extra_part,
+ bool missing_side_outer,
+ bool missing_side_inner,
+ int *next_index, int *default_index,
+ int *merged_index)
+{
+ bool missing_has_default = (missing_side_default != -1);
+
+ if (missing_has_default)
+ {
+ *merged_index = map_and_merge_partitions(maps_with_missing,
+ maps_with_extra,
+ missing_side_default,
+ extra_part,
+ next_index);
+ if (*merged_index < 0)
+ return false;
+
+ if (missing_side_outer)
+ {
+ /*
+ * Default partition on the outer side forms the default
+ * partition of the join result.
+ */
+ if (*default_index < 0)
+ *default_index = *merged_index;
+ else if(*default_index != *merged_index)
+ {
+ /*
+ * Ended up with default partition on the outer side
+ * being joined with multiple partitions on the inner
+ * side. We don't support this case.
+ */
+ return false;
+ }
+
+ /*
+ * Since the merged partition acts as a default partition, it
+ * doesn't need a separate index.
+ */
+ *merged_index = -1;
+ }
+ }
+ else if (missing_side_inner)
+ {
+ /*
+ * If this partition has already been mapped (say because we
+ * found an overlapping range earlier), we know where does it
+ * fit in the join result. Nothing to do in that case. Else
+ * create a new merged partition.
+ */
+ PartitionMap *extra_map = &maps_with_extra[extra_part];
+ if (extra_map->to < 0)
+ {
+ extra_map->to = *next_index;
+ *next_index = *next_index + 1;
+ *merged_index = extra_map->to;
+ }
+ }
+
+ return true;
+}
+
+static PartitionMap*
+init_partition_map(RelOptInfo *rel)
+{
+ int i, nparts = rel->nparts;
+ PartitionMap *map;
+
+ map = (PartitionMap *) palloc(sizeof(PartitionMap) * nparts);
+
+ for (i = 0; i < nparts; i++)
+ {
+ map[i].from = -1;
+ map[i].to = -1;
+ }
+
+ return map;
+}
+
+/*
+ * Allocate and initialize partition maps. We maintain four maps, two maps
+ * for each joining relation. pmap[i] gives the partition from the other
+ * relation which would join with ith partition of the given relation.
+ * Partition i from the given relation will join with partition pmap[i]
+ * from the other relation to produce partition mmap[i] of the join (merged
+ * partition).
+ *
+ * pmap[i] = -1 indicates that ith partition of a given relation does not
+ * have a matching partition from the other relation.
+ *
+ * mmap[i] = -1 indicates that ith partition of a given relation does not
+ * contribute to the join result. That can happen only when the given
+ * relation is the inner relation and it doesn't have a matching partition
+ * from the outer relation, hence pmap[i] should be -1.
+ *
+ * In case of an outer join, every partition of the outer join will appear
+ * in the join result, and thus has mmap[i] set for all i. But it's not
+ * necessary that every partition on the outer side will have a matching
+ * partition on the inner side. In such a case, we end up with pmap[i] = -1
+ * and mmap[i] != -1.
+ */
+
+/*
+ * partition_range_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for range partitioned tables.
+ */
+static PartitionBoundInfo
+partition_range_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype, int partnatts,
+ FmgrInfo *partsupfuncs, Oid *partcollations)
+
+{
+ PartitionMap *outer_maps = NULL;
+ PartitionMap *inner_maps = NULL;
+ int outer_part = 0;
+ int inner_part = 0;
+ PartitionBoundInfo merged_bounds = NULL;
+ int outer_lb_index;
+ int inner_lb_index;
+ int next_index;
+ int default_index = -1;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ List *merged_kinds = NIL;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int inner_default = inner_bi->default_index;
+ int outer_default = outer_bi->default_index;
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_RANGE);
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ outer_maps = init_partition_map(outer_rel);
+ inner_maps = init_partition_map(inner_rel);
+
+ /*
+ * Merge the ranges (partitions) from both sides. Every iteration compares
+ * a pair of ranges, one from each side, advancing to the next range from
+ * the side with smaller upper range bound. If upper bounds of ranges from
+ * both sides match exactly, both the sides are advanced. For a given pair
+ * of ranges, we decide whether the corresponding partition match or not.
+ * lb_index, for inner or outer side, keeps track of the index of lower bound
+ * datum in PartitionBoundInfo::datums of that side.
+ */
+ outer_lb_index = 0;
+ inner_lb_index = 0;
+ next_index = 0;
+ while (outer_lb_index < outer_bi->ndatums ||
+ inner_lb_index < inner_bi->ndatums)
+ {
+ PartitionRangeBound outer_lb, outer_ub,
+ inner_lb, inner_ub,
+ *merged_lb = NULL,
+ *merged_ub = NULL;
+
+ int merged_index = -1;
+ bool overlap;
+ bool finished_outer = false;
+ bool finished_inner = false;
+
+ /* Result of bounds comparison per partition_rbound_cmp(). */
+ int ub_cmpval; /* Upper bounds comparison result. */
+ int lb_cmpval; /* Lower bounds comparison result. */
+
+ /* Get the range bounds of the next pair of partitions. */
+ if (outer_lb_index < outer_bi->ndatums)
+ outer_part = partition_get_range_bounds(outer_bi, outer_lb_index,
+ &outer_lb, &outer_ub);
+ else
+ finished_outer = true;
+
+ if (inner_lb_index < inner_bi->ndatums)
+ inner_part = partition_get_range_bounds(inner_bi, inner_lb_index,
+ &inner_lb, &inner_ub);
+ else
+ finished_inner = true;
+
+ Assert(!finished_outer || !finished_inner);
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining partitions on the side
+ * which finishes later. For that we set the comparison parameters
+ * overlap, ub_cmpval and lb_cmpval in such a way that it appears as if
+ * the side which finishes earlier has an extra partition with lower
+ * and upper bounds higher than any other partition of the unfinished
+ * side. That way we advance the partitions on that side till all of
+ * them are exhausted.
+ */
+ if (finished_outer)
+ {
+ overlap = false;
+ ub_cmpval = 1;
+ lb_cmpval = 1;
+ }
+ else if (finished_inner)
+ {
+ overlap = false;
+ ub_cmpval = -1;
+ lb_cmpval = -1;
+ }
+ else
+ overlap = partition_range_cmp(partnatts, partsupfuncs, partcollations,
+ &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &ub_cmpval, &lb_cmpval);
+
+ if (overlap)
+ {
+ /*
+ * The rows from overlapping portion of ranges on both sides may
+ * join, hence the corresponding pair of partitions form a joining
+ * pair. Match them and produce the bounds of the joint partition
+ * and its index by merging the bounds according to the type of
+ * join.
+ */
+ partition_range_merge(partnatts, partsupfuncs, partcollations,
+ jointype, &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &merged_lb, &merged_ub);
+
+ merged_index = map_and_merge_partitions(outer_maps, inner_maps,
+ outer_part, inner_part,
+ &next_index);
+
+ if (merged_index < 0)
+ {
+ /* Failed to match the partitions. */
+ return NULL;
+ }
+
+ /*
+ * If the ranges overlap but don't exactly match, a row from
+ * non-overlapping portion of the range from one side of join may
+ * find its join partner in the previous or next overlapping
+ * partition or default partition on the other side , if such a
+ * partition exists. All those cases, if true, will cause one
+ * partition from that side to match at least two partitions on the
+ * other side; a case that we do not support now. Previous
+ * partition has been delt with in the previous iteration of this
+ * loop, next partition will be delt in the next iteration. We will
+ * deal with the default partition here.
+ */
+ if ((lb_cmpval < 0 && inner_has_default) ||
+ /* Non-overlapping range on the lower side of outer range. */
+ (lb_cmpval > 0 && outer_has_default) ||
+ /* Non-overlapping range on the lower side of inner range. */
+ (ub_cmpval < 0 && outer_has_default) ||
+ /* Non-overlapping range on the upper side of inner range. */
+ (ub_cmpval > 0 && inner_has_default))
+ /* Non-overlapping range on the upper side of outer range. */
+ return NULL;
+ }
+
+ if (ub_cmpval == 0)
+ {
+ /* Upper bounds of both the ranges match. */
+ Assert(overlap);
+
+ /* Move to the next pair of partitions. */
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+ else if (ub_cmpval < 0)
+ {
+ /* Upper bound of inner range higher than that of the outer. */
+
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the inner side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &outer_lb;
+ merged_ub = &outer_ub;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+ if (!handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ outer_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+ }
+
+ /* Move to the next partition on the outer side. */
+ Assert(!finished_outer);
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ }
+ else
+ {
+ Assert(ub_cmpval > 0);
+
+ /* Upper bound of outer range higher than that of the inner. */
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the outer side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &inner_lb;
+ merged_ub = &inner_ub;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ inner_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+ }
+
+ /* Move to the next partition on the inner side. */
+ Assert (!finished_inner);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+
+ if (merged_index < 0)
+ {
+ /* We didn't find a new merged partition. */
+ continue;
+ }
+
+ /*
+ * We have a valid partition index for the next partition of join. The
+ * partition should have valid range.
+ */
+ Assert(merged_lb && merged_ub);
+
+ /* Try merging new lower bound with the last upper bound. */
+ if (!partition_range_merge_next_lb(partnatts, partsupfuncs,
+ partcollations,
+ merged_lb->datums,
+ merged_lb->kind, &merged_datums,
+ &merged_kinds, &merged_indexes))
+ return NULL;
+
+ /* Add upper bound with the merged partition index. */
+ merged_datums = lappend(merged_datums, merged_ub->datums);
+ merged_kinds = lappend(merged_kinds, merged_ub->kind);
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ }
+
+ if (!merge_default_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index,
+ &default_index))
+ return NULL;
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_maps, inner_maps,
+ outer_nparts, inner_nparts,
+ jointype, next_index,
+ outer_parts, inner_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes,
+ merged_kinds,
+ -1, default_index);
+ }
+
+ /* Free any memory we used in this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ list_free(merged_kinds);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_list_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for list partitioned tables.
+ *
+ */
+static PartitionBoundInfo
+partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype)
+{
+ PartitionMap *outer_maps = NULL;
+ PartitionMap *inner_maps = NULL;
+ int cnto;
+ int cnti;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ int next_index = 0;
+ int null_index;
+ int default_index = -1;
+ PartitionBoundInfo merged_bounds = NULL;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int *outer_indexes = outer_bi->indexes;
+ int *inner_indexes = inner_bi->indexes;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_LIST);
+
+ /* List partitions do not require unbounded ranges. */
+ Assert(!outer_bi->kind && !inner_bi->kind);
+
+ outer_maps = init_partition_map(outer_rel);
+ inner_maps = init_partition_map(inner_rel);
+
+ /*
+ * Merge the list value datums from both sides. Every iteration compares a
+ * pair of datums, one from each side, advancing to the next datum from the
+ * side with smaller datum. If datums from both sides match exactly, both
+ * the sides are advanced. For a given pair of datums, we decide whether
+ * the corresponding partition match or not.
+ */
+ cnto = cnti = 0;
+ while (cnto < outer_bi->ndatums || cnti < inner_bi->ndatums)
+ {
+ Datum *odatums;
+ Datum *idatums;
+ int o_index;
+ int i_index;
+ int cmpval;
+ int merged_index = -1;
+ Datum *merged_datum;
+ bool finished_inner;
+ bool finished_outer;
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining datums on the side which
+ * finishes later. For that we set the comparison parameter cmpval in
+ * such a way that it appears as if the side which finishes earlier has
+ * an extra datum higher than any other datum on the unfinished side.
+ * That way we advance the datums on the unfinished side till all of
+ * its datums are exhausted.
+ */
+ if (cnto >= outer_bi->ndatums)
+ {
+ finished_outer = true;
+ odatums = NULL;
+ o_index = -1;
+ }
+ else
+ {
+ finished_outer = false;
+ odatums = outer_bi->datums[cnto];
+ o_index = outer_indexes[cnto];
+ }
+
+ if (cnti >= inner_bi->ndatums)
+ {
+ finished_inner = true;
+ idatums = NULL;
+ i_index = -1;
+ }
+ else
+ {
+ finished_inner = false;
+ idatums = inner_bi->datums[cnti];
+ i_index = inner_indexes[cnti];
+ }
+
+ /* If we exhausted both the sides, we won't enter the loop. */
+ Assert(!finished_inner || !finished_outer);
+
+ if (finished_outer)
+ cmpval = 1;
+ else if (finished_inner)
+ cmpval = -1;
+ else
+ {
+ /* Every list datum should map to a valid partition index. */
+ Assert(o_index >= 0 && i_index >= 0 &&
+ odatums != NULL && idatums != NULL);
+
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
+ partcollation[0],
+ odatums[0], idatums[0]));
+ }
+
+ if (cmpval == 0)
+ {
+ /*
+ * Datums match. Rows on either side with these datums as partition
+ * key value will join and will be part of the partition of the
+ * join result produced by joining the corresponding partitions.
+ * Match the corresponding partitions and if successful, add the
+ * datum to the list of merged datums with index of merged
+ * partition containing it.
+ */
+ merged_datum = odatums;
+ merged_index = map_and_merge_partitions(outer_maps, inner_maps,
+ o_index, i_index,
+ &next_index);
+
+ if (merged_index < 0)
+ return NULL;
+
+ /* Move to the next pair of bounds. */
+ cnto++;
+ cnti++;
+ }
+ else if (cmpval < 0)
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /* A datum missing from the inner side. */
+ merged_index = -1;
+ merged_datum = odatums;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ o_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+
+ /* Move to the next datum on the outer side. */
+ Assert(!finished_outer);
+ cnto++;
+ }
+ else
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ Assert(cmpval > 0);
+
+ /* A datum missing from the outer side. */
+ merged_index = -1;
+ merged_datum = idatums;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ i_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+
+ /* Move to the next datum on the right side. */
+ Assert(!finished_inner);
+ cnti++;
+ }
+
+ /*
+ * Add the list value with appropriate index in the list of datums, if
+ * we have associated a partition with this list value.
+ */
+ if (merged_index >= 0)
+ {
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ merged_datums = lappend(merged_datums, merged_datum);
+ }
+ }
+
+ if (!merge_null_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index, &null_index,
+ &default_index))
+ return NULL;
+
+ if (!merge_default_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index,
+ &default_index))
+ return NULL;
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_maps, inner_maps,
+ outer_nparts, inner_nparts,
+ jointype, next_index,
+ outer_parts, inner_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes, NIL,
+ null_index, default_index);
+ }
+
+ /* Free up all extra memory before returning from this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_bounds_merge()'s arm for hash partitioned tables.
+ *
+ * If the given two hash bounds are same, the function returns the first one
+ * without any change, alongwith the lists of matching partitions. Otherwise it
+ * returns NULL.
+ *
+ * We could try merging the bounds when both the bounds have same greatest
+ * modulii. But there seems to be hardly any requirement for the same.
+ */
+static PartitionBoundInfo
+partition_hash_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype)
+{
+ int nparts;
+ int cnt;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * Hash partitioned table does not have explicit NULL accepting partition
+ * and also does not have a default partition.
+ */
+ Assert(!partition_bound_has_default(outer_bi) &&
+ !partition_bound_has_default(inner_bi));
+ Assert(!partition_bound_accepts_nulls(outer_bi) &&
+ !partition_bound_accepts_nulls(inner_bi));
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+
+ if (outer_nparts != inner_nparts)
+ return NULL;
+ nparts = outer_nparts;
+
+ if (outer_bi->ndatums != inner_bi->ndatums ||
+ !partition_hbounds_equal(outer_bi, inner_bi))
+ return NULL;
+
+ /*
+ * Cook up list of matching partitions. Since bounds are exactly same the
+ * partitions at the same position from both the relations match.
+ */
+ for (cnt = 0; cnt < nparts; cnt++)
+ {
+ *outer_parts = lappend_int(*outer_parts, cnt);
+ *inner_parts = lappend_int(*inner_parts, cnt);
+ }
+
+ return outer_bi;
+}
+
+/*
+ * map_and_merge_partitions
+ *
+ * If the two given partitions (given by index1 and index2 resp.) are
+ * already mapped to each other return the index of corresponding partition in
+ * the merged set of partitions. If they do not have a merged partition
+ * associated with them, assign a new merged partition index. If the
+ * partitions are already mapped and their mapped partitions are different from
+ * each other, they can not be merged, so return -1.
+ *
+ * partmaps1[i] gives the mapping of partitions for both relations. It
+ * describes which partition of relation 2 matches ith partition of relation 1,
+ * and which partition in the merged set matches ith partition of relation 1
+ * maps to. Similarly for partmap2.
+ *
+ * index1 and index2 are the indexes of matching partition from respective
+ * relations.
+ *
+ * *next_index is used and incremented when the given partitions require a new
+ * merged partition.
+ */
+
+static int
+map_and_merge_partitions(PartitionMap *partmaps1, PartitionMap *partmaps2,
+ int index1, int index2, int *next_index)
+{
+ PartitionMap *partmap1 = &partmaps1[index1];
+ PartitionMap *partmap2 = &partmaps2[index2];
+ int merged_index;
+
+ /*
+ * If both the partitions are not mapped to each other, update the
+ * maps.
+ */
+ if (partmap1->from < 0 && partmap2->from < 0)
+ {
+ partmap1->from = index2;
+ partmap2->from = index1;
+ }
+
+ /*
+ * If the given to partitions map to each other, find the corresponding
+ * merged partition index .
+ */
+ if (partmap1->from == index2 && partmap2->from == index1)
+ {
+ /*
+ * If both the partitions are mapped to the same merged partition, get
+ * the index of merged partition.
+ */
+ if (partmap1->to == partmap2->to)
+ {
+ merged_index = partmap1->to;
+
+ /*
+ * If the given two partitions do not have a merged partition
+ * associated with them, allocate a new merged partition.
+ */
+ if (merged_index < 0)
+ {
+ merged_index = *next_index;
+ *next_index = *next_index + 1;
+ partmap1->to = merged_index;
+ partmap2->to = merged_index;
+ }
+ }
+
+ /*
+ * If partition from one relation was mapped to a merged partition but
+ * not the partition from the other relation, map the same merged
+ * partition to the partition from other relation, since matching
+ * partitions map to the same merged partition.
+ */
+ else if (partmap1->to >= 0 && partmap2->to < 0)
+ {
+ partmap2->to = partmap1->to;
+ merged_index = partmap1->to;
+ }
+ else if (partmap1->to < 0 && partmap2->to >= 0)
+ {
+ partmap1->to = partmap2->to;
+ merged_index = partmap2->to;
+ }
+ else
+ {
+ Assert(partmap1->to != partmap2->to &&
+ partmap1->to >= 0 && partmap2->to >= 0);
+
+ /*
+ * Both the partitions map to different merged partitions. This
+ * means that multiple partitions from one relation matches to one
+ * partition from the other relation. Partition-wise join does not
+ * handle this case right now, since it requires ganging multiple
+ * partitions together (into one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+ }
+ else
+ {
+ /*
+ * Multiple partitions from one relation map to one partition from the
+ * other relation. Partition-wise join does not handle this case right
+ * now, since it requires ganging multiple partitions together (into
+ * one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+
+ return merged_index;
+}
+
+/*
+ * generate_matching_part_pairs
+ *
+ * partmaps1 map each partition from either side of the join to a merged
+ * partition resp. E.g. partmaps1[i].to gives the merged partition to which ith
+ * partition of first relation maps. Similarly for partmap2. If
+ * partmaps1[i].to == partmaps2[j].to, i and j form the matching pair of
+ * partitions.
+ *
+ * Given these maps this function produces the list pairs of partitions which
+ * when joined produce the merged partitions in the order of merged partition
+ * indexes.
+ *
+ * nparts1 and nparts2 are the number of partitions of the joining relations
+ * resp.
+ *
+ * nparts is the number of merged partitions.
+ *
+ * If successful, the pairs of partitions are returned as two separate lists,
+ * parts1 and parts2 resp., one for each side. Otherwise, those lists will be
+ * set to NIL.
+ */
+static void
+generate_matching_part_pairs(PartitionMap *partmaps1, PartitionMap *partmaps2,
+ int nparts1, int nparts2,
+ JoinType jointype, int nparts,
+ List **matched_parts1, List **matched_parts2)
+{
+ bool merged = true;
+ int *matching1 = (int *) palloc(sizeof(int) * nparts),
+ *matching2 = (int *) palloc(sizeof(int) * nparts);
+ int i;
+
+ *matched_parts1 = NIL;
+ *matched_parts2 = NIL;
+
+ /* Set pairs of matching partitions. */
+ for (i = 0; i < nparts; i++)
+ {
+ if (i >= nparts1)
+ matching1[i] = -1;
+ else
+ {
+ PartitionMap outer_map = partmaps1[i];
+
+ if (outer_map.to >= 0)
+ {
+ Assert(outer_map.to < nparts);
+ matching1[outer_map.to] = i;
+ }
+ }
+
+ if (i >= nparts2)
+ matching2[i] = -1;
+ else
+ {
+ PartitionMap inner_map = partmaps2[i];
+
+ if (inner_map.to >= 0)
+ {
+ Assert(inner_map.to < nparts);
+ matching2[inner_map.to] = i;
+ }
+ }
+ }
+
+ /*
+ * If we have a partition missing on an inner side, we need to add a dummy
+ * relation which joins with the outer partition. If the inner relation
+ * happens to be a base relation, it will require adding a dummy child
+ * base relation during join processing. Right now, we freeze the base
+ * relation arrays like PlannerInfo::simple_rte_array after planning for
+ * base relations. Adding a new (dummy) base relation would require some
+ * changes to that. So, right now, we do not implement partition-wise join
+ * in such cases.
+ */
+ for (i = 0; i < nparts; i++)
+ {
+ int part1 = matching1[i];
+ int part2 = matching2[i];
+
+ /* At least one of the partitions should exist. */
+ Assert(part1 >= 0 || part2 >= 0);
+
+ switch (jointype)
+ {
+ case JOIN_INNER:
+ case JOIN_SEMI:
+
+ /*
+ * An inner or semi join can not return any row when the
+ * matching partition on either side is missing. We should
+ * have eliminated all such cases while merging the bounds.
+ */
+ Assert(part1 >= 0 && part2 >= 0);
+ break;
+
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ Assert(part1 >= 0);
+ if (part2 < 0)
+ merged = false;
+ break;
+
+ case JOIN_FULL:
+ if (part1 < 0 || part2 < 0)
+ merged = false;
+ break;
+
+ default:
+ elog(ERROR, "unrecognized join type: %d", (int) jointype);
+ }
+
+ if (!merged)
+ break;
+
+ *matched_parts1 = lappend_int(*matched_parts1, part1);
+ *matched_parts2 = lappend_int(*matched_parts2, part2);
+ }
+
+ pfree(matching1);
+ pfree(matching2);
+
+ if (!merged)
+ {
+ list_free(*matched_parts1);
+ list_free(*matched_parts2);
+ *matched_parts1 = NIL;
+ *matched_parts2 = NIL;
+ }
+}
+
+static PartitionBoundInfo
+build_merged_partition_bounds(char strategy, List *merged_datums,
+ List *merged_indexes, List *merged_kinds,
+ int null_index, int default_index)
+{
+ int cnt;
+ PartitionBoundInfo merged_bounds;
+ ListCell *lc;
+
+ /* We expect the same number of elements in datums and indexes lists. */
+ Assert(list_length(merged_datums) == list_length(merged_indexes));
+
+ merged_bounds = (PartitionBoundInfo) palloc(sizeof(PartitionBoundInfoData));
+ merged_bounds->strategy = strategy;
+ merged_bounds->ndatums = list_length(merged_datums);
+
+ if (strategy == PARTITION_STRATEGY_RANGE)
+ {
+ Assert(list_length(merged_datums) == list_length(merged_kinds));
+ merged_bounds->kind =
+ (PartitionRangeDatumKind **) palloc(sizeof(PartitionRangeDatumKind *) *
+ list_length(merged_kinds));
+ cnt = 0;
+ foreach(lc, merged_kinds)
+ merged_bounds->kind[cnt++] = lfirst(lc);
+
+ /* There are ndatums+1 indexes in case of range partitions */
+ merged_indexes = lappend_int(merged_indexes, -1);
+ }
+ else
+ merged_bounds->kind = NULL;
+
+ cnt = 0;
+ merged_bounds->datums = (Datum **) palloc(sizeof(Datum *) *
+ list_length(merged_datums));
+ foreach(lc, merged_datums)
+ merged_bounds->datums[cnt++] = lfirst(lc);
+
+ merged_bounds->indexes = (int *) palloc(sizeof(int) *
+ list_length(merged_indexes));
+ cnt = 0;
+ foreach(lc, merged_indexes)
+ merged_bounds->indexes[cnt++] = lfirst_int(lc);
+
+ merged_bounds->null_index = null_index;
+ merged_bounds->default_index = default_index;
+
+ return merged_bounds;
+}
+
+/*
+ * Merge default partitions from both sides, if any, and assign the default
+ * partition for the join result, if necessary.
+ *
+ * If both the relations have default partitions, try mapping those to each
+ * other. If the mapping succeeds corresponding merged partition will act as
+ * the default partition of the join result.
+ *
+ * If inner side of the join has default but not the outer side, rows in it
+ * won't appear in the join result. So don't create a default partition. If
+ * outer side of the join has default but not the inner side, rows in it will
+ * appear in the join result, so create a default merged partition.
+ */
+static bool
+merge_default_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps, PartitionMap *inner_maps,
+ JoinType jointype, int *next_index, int *default_index)
+{
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool merged = true;
+ PartitionMap *outer_default_map = NULL;
+ PartitionMap *inner_default_map = NULL;
+
+ if (outer_has_default)
+ outer_default_map = &outer_maps[outer_default];
+
+ if (inner_has_default)
+ inner_default_map = &inner_maps[inner_default];
+
+ if (!outer_has_default && !inner_has_default)
+ Assert(*default_index < 0);
+ else if (outer_default_map != NULL && inner_default_map == NULL)
+ {
+ if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (outer_default_map->to < 0)
+ {
+ outer_default_map->to = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = outer_default_map->to;
+ }
+ else
+ Assert(*default_index == outer_default_map->to);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else if (outer_default_map == NULL && inner_default_map != NULL)
+ {
+ if (jointype == JOIN_FULL)
+ {
+ if (inner_default_map->to < 0)
+ {
+ inner_default_map->to = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = inner_default_map->to;
+ }
+ else
+ Assert(*default_index == inner_default_map->to);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else
+ {
+ Assert(outer_has_default && inner_has_default);
+
+ *default_index = map_and_merge_partitions(outer_maps, inner_maps,
+ outer_default, inner_default,
+ next_index);
+
+ if (*default_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
+
+/*
+ * merge_null_partitions
+ *
+ * Merge NULL partitions, i.e. a partition that can hold NULL values for a list
+ * partitioned table, if any. Find the index of merged partition to which the
+ * NULL values would belong in the join result. If one joining relation has a
+ * NULL partition but not the other, try matching it with the default partition
+ * from the other relation since the default partition may have rows with NULL
+ * partition key. We can eliminate a NULL partition when it appears only on the
+ * inner side of the join and the outer side doesn't have a default partition.
+ *
+ * When the equality operator used for join is strict, two NULL values will not
+ * be considered as equal, and thus a NULL partition can be eliminated for an
+ * inner join. But we don't check the strictness operator here.
+ */
+static bool
+merge_null_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps, PartitionMap *inner_maps,
+ JoinType jointype, int *next_index,
+ int *null_index, int *default_index)
+{
+ bool outer_has_null = partition_bound_accepts_nulls(outer_bi);
+ bool inner_has_null = partition_bound_accepts_nulls(inner_bi);
+ int outer_ni = outer_bi->null_index;
+ int inner_ni = inner_bi->null_index;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool merged = true;
+
+ if (!outer_has_null && !inner_has_null)
+ *null_index = -1;
+ else if (outer_has_null && !inner_has_null)
+ {
+ int merged_index;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+
+ merged = handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ outer_ni,
+ missing_side_outer,
+ missing_side_inner, next_index,
+ default_index, &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join to which the outer null partition maps
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = outer_maps[outer_ni].to;
+ }
+ else if (!outer_has_null && inner_has_null)
+ {
+ int merged_index;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as OUTER
+ * relation. For INNER and SEMI join OUTER and INNER differentiation is
+ * immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+ merged = handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ inner_ni,
+ missing_side_outer,
+ missing_side_inner,
+ next_index, default_index,
+ &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join, to which the outer side null partition maps,
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = inner_maps[inner_ni].to;
+ }
+ else
+ {
+ /* Both the relations have NULL partitions, try merging them. */
+ *null_index = map_and_merge_partitions(outer_maps,
+ inner_maps,
+ outer_ni,
+ inner_ni,
+ next_index);
+ if (*null_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
diff --git a/src/include/partitioning/partbounds.h b/src/include/partitioning/partbounds.h
index b1ae39ad63..fb2dc1cbb1 100644
--- a/src/include/partitioning/partbounds.h
+++ b/src/include/partitioning/partbounds.h
@@ -16,6 +16,7 @@
#include "nodes/pg_list.h"
#include "partitioning/partdefs.h"
#include "utils/relcache.h"
+struct RelOptInfo; /* avoid including pathnodes.h here */
/*
@@ -107,5 +108,11 @@ extern int partition_range_datum_bsearch(FmgrInfo *partsupfunc,
int nvalues, Datum *values, bool *is_equal);
extern int partition_hash_bsearch(PartitionBoundInfo boundinfo,
int modulus, int remainder);
+extern PartitionBoundInfo partition_bounds_merge(int partnatts,
+ FmgrInfo *partsupfunc, Oid *partcollation,
+ struct RelOptInfo *outer_rel,
+ struct RelOptInfo *inner_rel,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts);
#endif /* PARTBOUNDS_H */
--
2.19.2
[text/x-patch] 0003-Tests-for-0-1-1-1-and-1-0-partition-matching-v17.patch (220.4K, ../../5C52E1AB.2080500@lab.ntt.co.jp/4-0003-Tests-for-0-1-1-1-and-1-0-partition-matching-v17.patch)
download | inline diff:
From 03bb2b2dc4b9d24c7f47a4eaeb16b6d3d166c742 Mon Sep 17 00:00:00 2001
From: Etsuro Fujita <efujita@postgresql.org>
Date: Thu, 31 Jan 2019 20:31:17 +0900
Subject: [PATCH 3/3] Tests for 0:1, 1:1 and 1:0 partition matching
Rajkumar Raghuvanshi and Ashutosh Bapat.
---
src/test/regress/expected/partition_join.out | 4131 +++++++++++++++---
src/test/regress/sql/partition_join.sql | 427 +-
2 files changed, 3855 insertions(+), 703 deletions(-)
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index c55de5d476..f19611c853 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -8,59 +8,86 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(21 rows)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
-(4 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+(7 rows)
-- left outer join, with whole-row reference; partitionwise join does not apply
EXPLAIN (COSTS OFF)
@@ -72,35 +99,50 @@ SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(22 rows)
SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- t1 | t2
---------------+--------------
- (0,0,0000) | (0,0,0000)
- (50,0,0050) |
- (100,0,0100) |
- (150,0,0150) | (0,150,0150)
- (200,0,0200) |
- (250,0,0250) |
- (300,0,0300) | (0,300,0300)
- (350,0,0350) |
- (400,0,0400) |
- (450,0,0450) | (0,450,0450)
- (500,0,0500) |
- (550,0,0550) |
-(12 rows)
+ t1 | t2
+----------------+----------------
+ (-250,0,-0250) |
+ (-200,0,-0200) |
+ (-150,0,-0150) | (0,-150,-0150)
+ (-100,0,-0100) |
+ (-50,0,-0050) |
+ (0,0,0000) | (0,0,0000)
+ (50,0,0050) |
+ (100,0,0100) |
+ (150,0,0150) | (0,150,0150)
+ (200,0,0200) |
+ (250,0,0250) |
+ (300,0,0300) | (0,300,0300)
+ (350,0,0350) |
+ (400,0,0400) |
+ (450,0,0450) | (0,450,0450)
+ (500,0,0500) |
+ (550,0,0550) |
+ (600,0,0600) | (0,600,0600)
+ (650,0,0650) |
+ (700,0,0700) |
+ (750,0,0750) | (0,750,0750)
+(21 rows)
-- right outer join
EXPLAIN (COSTS OFF)
@@ -112,35 +154,53 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHE
-> Append
-> Hash Right Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Right Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Hash Right Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-> Nested Loop Left Join
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p3 t2_3
Filter: (a = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t2_2.b)
-(20 rows)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
- | | 75 | 0075
- | | 225 | 0225
- | | 375 | 0375
- | | 525 | 0525
-(8 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+ | | -225 | -0225
+ | | -75 | -0075
+ | | 75 | 0075
+ | | 225 | 0225
+ | | 375 | 0375
+ | | 525 | 0525
+ | | 675 | 0675
+(14 rows)
-- full outer join, with placeholder vars
EXPLAIN (COSTS OFF)
@@ -148,8 +208,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
QUERY PLAN
------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b
+ Sort Key: prt1_p0.a, prt2_p0.b
-> Append
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ Filter: (((50) = prt1_p0.a) OR ((75) = prt2_p0.b))
+ -> Seq Scan on prt1_p0
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p1.a = prt2_p1.b)
Filter: (((50) = prt1_p1.a) OR ((75) = prt2_p1.b))
@@ -174,7 +242,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
-> Hash
-> Seq Scan on prt2_p3
Filter: (a = 0)
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ Filter: (((50) = prt1_p4.a) OR ((75) = prt2_p4.b))
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) WHERE t1.phv = t1.a OR t2.phv = t2.b ORDER BY t1.a, t2.b;
a | c | b | c
@@ -211,8 +287,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Hash Left Join
+ Hash Cond: (prt1_p0.a = b)
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Hash
+ -> Result
+ One-Time Filter: false
-> Hash Left Join
Hash Cond: (prt1_p1.a = b)
-> Seq Scan on prt1_p1
@@ -227,29 +310,42 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
-> Hash
-> Seq Scan on prt1_p2
Filter: ((a < 450) AND (b = 0))
-(17 rows)
+(24 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
-(9 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+(14 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
QUERY PLAN
------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = b)
+ Filter: ((prt1_p0.b = 0) OR (a = 0))
+ -> Seq Scan on prt1_p0
+ Filter: (a < 450)
+ -> Hash
+ -> Result
+ One-Time Filter: false
-> Hash Full Join
Hash Cond: (prt1_p1.a = b)
Filter: ((prt1_p1.b = 0) OR (a = 0))
@@ -274,64 +370,153 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JO
-> Hash
-> Result
One-Time Filter: false
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt2_p4.b = a)
+ Filter: ((b = 0) OR (prt2_p4.a = 0))
+ -> Seq Scan on prt2_p4
+ Filter: (b > 250)
+ -> Hash
+ -> Result
+ One-Time Filter: false
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
- | | 375 | 0375
- | | 450 | 0450
- | | 525 | 0525
-(12 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ | | 375 | 0375
+ | | 450 | 0450
+ | | 525 | 0525
+ | | 600 | 0600
+ | | 675 | 0675
+ | | 750 | 0750
+(20 rows)
-- Semi-join
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Semi Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Semi Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Nested Loop Semi Join
- Join Filter: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Materialize
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-(24 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(39 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p0 t2
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_2.b = t2_2.a)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p2 t2_2
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: (t1_3.b = t2_3.a)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt1_p3 t2_3
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.b = t2_4.a)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p4 t2_4
+ Filter: (b = 0)
+(37 rows)
+
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
@@ -342,27 +527,82 @@ SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS
-> Append
-> Hash Anti Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash Anti Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash Anti Join
Hash Cond: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p3 t2_2
-(17 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash Anti Join
+ Hash Cond: (t1_3.a = t2_3.b)
+ -> Seq Scan on prt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_3
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(27 rows)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
- sum | avg | sum | avg
--------+----------------------+------+---------------------
- 60000 | 300.0000000000000000 | 2400 | 12.0000000000000000
+ sum | avg | sum | avg
+-------+----------------------+------+--------------------
+ 95550 | 273.0000000000000000 | 2200 | 6.2857142857142857
(1 row)
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ QUERY PLAN
+--------------------------------------------------------------
+ Append
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Hash Anti Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(27 rows)
+
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ b | c
+------+-------
+ -225 | -0225
+ -75 | -0075
+ 75 | 0075
+ 225 | 0225
+ 375 | 0375
+ 525 | 0525
+ 675 | 0675
+(7 rows)
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -374,49 +614,74 @@ SELECT * FROM prt1 t1 LEFT JOIN LATERAL
Sort Key: t1.a
-> Append
-> Nested Loop Left Join
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p1_a on prt1_p1 t2
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
Index Cond: (a = t1.a)
- -> Index Scan using iprt2_p1_b on prt2_p1 t3
+ -> Index Scan using iprt2_p0_b on prt2_p0 t3
Index Cond: (b = t2.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_1
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
Index Cond: (a = t1_1.a)
- -> Index Scan using iprt2_p2_b on prt2_p2 t3_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t3_1
Index Cond: (b = t2_1.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_2
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
Index Cond: (a = t1_2.a)
- -> Index Scan using iprt2_p3_b on prt2_p3 t3_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t3_2
Index Cond: (b = t2_2.a)
-(27 rows)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.a)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t3_3
+ Index Cond: (b = t2_3.a)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.a)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t3_4
+ Index Cond: (b = t2_4.a)
+(43 rows)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, least(t1.a,t2.a,t3.b) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.a = ss.t2a WHERE t1.b = 0 ORDER BY t1.a;
- a | b | c | t2a | t3a | least
------+---+------+-----+-----+-------
- 0 | 0 | 0000 | 0 | 0 | 0
- 50 | 0 | 0050 | | |
- 100 | 0 | 0100 | | |
- 150 | 0 | 0150 | 150 | 0 | 150
- 200 | 0 | 0200 | | |
- 250 | 0 | 0250 | | |
- 300 | 0 | 0300 | 300 | 0 | 300
- 350 | 0 | 0350 | | |
- 400 | 0 | 0400 | | |
- 450 | 0 | 0450 | 450 | 0 | 450
- 500 | 0 | 0500 | | |
- 550 | 0 | 0550 | | |
-(12 rows)
+ a | b | c | t2a | t3a | least
+------+---+-------+------+-----+-------
+ -250 | 0 | -0250 | | |
+ -200 | 0 | -0200 | | |
+ -150 | 0 | -0150 | -150 | 0 | -150
+ -100 | 0 | -0100 | | |
+ -50 | 0 | -0050 | | |
+ 0 | 0 | 0000 | 0 | 0 | 0
+ 50 | 0 | 0050 | | |
+ 100 | 0 | 0100 | | |
+ 150 | 0 | 0150 | 150 | 0 | 150
+ 200 | 0 | 0200 | | |
+ 250 | 0 | 0250 | | |
+ 300 | 0 | 0300 | 300 | 0 | 300
+ 350 | 0 | 0350 | | |
+ 400 | 0 | 0400 | | |
+ 450 | 0 | 0450 | 450 | 0 | 450
+ 500 | 0 | 0500 | | |
+ 550 | 0 | 0550 | | |
+ 600 | 0 | 0600 | 600 | 0 | 600
+ 650 | 0 | 0650 | | |
+ 700 | 0 | 0700 | | |
+ 750 | 0 | 0750 | 750 | 0 | 750
+(21 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
@@ -430,64 +695,95 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
Hash Cond: ((t1.c)::text = (t2.c)::text)
Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Hash Join
Hash Cond: (t2.a = t3.b)
- -> Seq Scan on prt1_p1 t2
+ -> Seq Scan on prt1_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t3
+ -> Seq Scan on prt2_p0 t3
-> Hash Join
Hash Cond: (t2_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t2_1
+ -> Seq Scan on prt1_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p1 t3_1
-> Hash Join
Hash Cond: (t2_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p2 t2_2
-> Hash
- -> Seq Scan on prt2_p3 t3_2
-(26 rows)
+ -> Seq Scan on prt2_p2 t3_2
+ -> Hash Join
+ Hash Cond: (t2_3.a = t3_3.b)
+ -> Seq Scan on prt1_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t3_3
+ -> Hash Join
+ Hash Cond: (t2_4.a = t3_4.b)
+ -> Seq Scan on prt1_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t3_4
+(38 rows)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, t2.b t2b, t2.c t2c, least(t1.a,t2.a,t3.a) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.c = ss.t2c WHERE (t1.b + coalesce(ss.t2b, 0)) = 0 ORDER BY t1.a;
- a | t2a | t2c
------+-----+------
- 0 | 0 | 0000
- 50 | |
- 100 | |
- 150 | 150 | 0150
- 200 | |
- 250 | |
- 300 | 300 | 0300
- 350 | |
- 400 | |
- 450 | 450 | 0450
- 500 | |
- 550 | |
-(12 rows)
+ a | t2a | t2c
+------+------+-------
+ -250 | |
+ -200 | |
+ -150 | -150 | -0150
+ -100 | |
+ -50 | |
+ 0 | 0 | 0000
+ 50 | |
+ 100 | |
+ 150 | 150 | 0150
+ 200 | |
+ 250 | |
+ 300 | 300 | 0300
+ 350 | |
+ 400 | |
+ 450 | 450 | 0450
+ 500 | |
+ 550 | |
+ 600 | 600 | 0600
+ 650 | |
+ 700 | |
+ 750 | 750 | 0750
+(21 rows)
--
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
@@ -498,32 +794,49 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 =
-> Append
-> Hash Join
Hash Cond: (((t2.b + t2.a) / 2) = ((t1.a + t1.b) / 2))
- -> Seq Scan on prt2_e_p1 t2
+ -> Seq Scan on prt2_e_p0 t2
-> Hash
- -> Seq Scan on prt1_e_p1 t1
+ -> Seq Scan on prt1_e_p0 t1
Filter: (c = 0)
-> Hash Join
- Hash Cond: (((t2_1.b + t2_1.a) / 2) = ((t1_1.a + t1_1.b) / 2))
- -> Seq Scan on prt2_e_p2 t2_1
+ Hash Cond: (((t1_1.a + t1_1.b) / 2) = ((t2_1.b + t2_1.a) / 2))
+ -> Seq Scan on prt1_e_p1 t1_1
+ Filter: (c = 0)
-> Hash
- -> Seq Scan on prt1_e_p2 t1_1
- Filter: (c = 0)
+ -> Seq Scan on prt2_e_p1 t2_1
-> Hash Join
Hash Cond: (((t2_2.b + t2_2.a) / 2) = ((t1_2.a + t1_2.b) / 2))
- -> Seq Scan on prt2_e_p3 t2_2
+ -> Seq Scan on prt2_e_p2 t2_2
-> Hash
- -> Seq Scan on prt1_e_p3 t1_2
+ -> Seq Scan on prt1_e_p2 t1_2
Filter: (c = 0)
-(21 rows)
+ -> Hash Join
+ Hash Cond: (((t2_3.b + t2_3.a) / 2) = ((t1_3.a + t1_3.b) / 2))
+ -> Seq Scan on prt2_e_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t1_3
+ Filter: (c = 0)
+ -> Hash Join
+ Hash Cond: (((t2_4.b + t2_4.a) / 2) = ((t1_4.a + t1_4.b) / 2))
+ -> Seq Scan on prt2_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_4
+ Filter: (c = 0)
+(33 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 150 | 0 | 150 | 0
- 300 | 0 | 300 | 0
- 450 | 0 | 450 | 0
-(4 rows)
+ a | c | b | c
+------+---+------+---
+ -250 | 0 | -250 | 0
+ -100 | 0 | -100 | 0
+ 0 | 0 | 0 | 0
+ 0 | 0 | 0 | 0
+ 150 | 0 | 150 | 0
+ 300 | 0 | 300 | 0
+ 450 | 0 | 450 | 0
+ 600 | 0 | 600 | 0
+ 750 | 0 | 750 | 0
+(9 rows)
--
-- N-way join
@@ -536,154 +849,232 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = ((t3.a + t3.b) / 2))
+ Join Filter: (t1.a = t2.b)
-> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p1_ab2 on prt1_e_p1 t3
- Index Cond: (((a + b) / 2) = t2.b)
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
+ Index Cond: (b = ((t3.a + t3.b) / 2))
-> Nested Loop
Join Filter: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_1
+ -> Index Scan using iprt1_e_p4_ab2 on prt1_e_p1 t3_1
Index Cond: (((a + b) / 2) = t2_1.b)
-> Nested Loop
Join Filter: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_2
Index Cond: (((a + b) / 2) = t2_2.b)
-(33 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = ((t3_3.a + t3_3.b) / 2))
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (((a + b) / 2) = t2_3.b)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t2_4.b)
+ -> Hash Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (b = ((t3_4.a + t3_4.b) / 2))
+(52 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t3 WHERE t1.a = t2.b AND t1.a = (t3.a + t3.b)/2 AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
-(4 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(8 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
---------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Hash Right Join
Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_1.a + t3_1.b) / 2) = t1_1.a)
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
-> Hash
-> Hash Right Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_2.a + t3_2.b) / 2) = t1_2.a)
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
-> Hash
-> Hash Right Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(33 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (t1_3.a = ((a + b) / 2))
+ -> Hash Right Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(51 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
--------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1.a = ((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
Index Cond: (t1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t2_1
Index Cond: (t1_1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t2_2
Index Cond: (t1_2.a = b)
-(30 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t3_3.a + t3_3.b) / 2))
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Nested Loop Left Join
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = ((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (t1_4.a = b)
+(47 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- Cases with non-nullable expressions in subquery results;
-- make sure these go to null as expected
@@ -692,21 +1083,34 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
QUERY PLAN
----------------------------------------------------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b, ((prt1_e_p1.a + prt1_e_p1.b))
+ Sort Key: prt1_p0.a, prt2_p0.b, ((prt1_e_p0.a + prt1_e_p0.b))
-> Append
-> Hash Full Join
- Hash Cond: (prt1_p1.a = ((prt1_e_p1.a + prt1_e_p1.b) / 2))
- Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ Hash Cond: (prt1_p0.a = ((prt1_e_p0.a + prt1_e_p0.b) / 2))
+ Filter: ((prt1_p0.a = (50)) OR (prt2_p0.b = (75)) OR (((prt1_e_p0.a + prt1_e_p0.b) / 2) = (50)))
-> Hash Full Join
- Hash Cond: (prt1_p1.a = prt2_p1.b)
- -> Seq Scan on prt1_p1
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ -> Seq Scan on prt1_p0
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1
+ -> Seq Scan on prt2_p0
Filter: (a = 0)
-> Hash
- -> Seq Scan on prt1_e_p1
+ -> Seq Scan on prt1_e_p0
Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: (((prt1_e_p1.a + prt1_e_p1.b) / 2) = prt1_p1.a)
+ Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ -> Seq Scan on prt1_e_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Hash Full Join
+ Hash Cond: (prt1_p1.a = prt2_p1.b)
+ -> Seq Scan on prt1_p1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p2.a = ((prt1_e_p2.a + prt1_e_p2.b) / 2))
Filter: ((prt1_p2.a = (50)) OR (prt2_p2.b = (75)) OR (((prt1_e_p2.a + prt1_e_p2.b) / 2) = (50)))
@@ -733,7 +1137,20 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
-> Hash
-> Seq Scan on prt1_e_p3
Filter: (c = 0)
-(42 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = ((prt1_e_p4.a + prt1_e_p4.b) / 2))
+ Filter: ((prt1_p4.a = (50)) OR (prt2_p4.b = (75)) OR (((prt1_e_p4.a + prt1_e_p4.b) / 2) = (50)))
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_e_p4
+ Filter: (c = 0)
+(68 rows)
SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b)) FULL JOIN (SELECT 50 phv, * FROM prt1_e WHERE prt1_e.c = 0) t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.a = t1.phv OR t2.b = t2.phv OR (t3.a + t3.b)/2 = t3.phv ORDER BY t1.a, t2.b, t3.a + t3.b;
a | phv | b | phv | ?column? | phv
@@ -751,172 +1168,260 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHER
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = t1_3.b)
+ Join Filter: (t1.a = t1_5.b)
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Join
- Hash Cond: (((t2.a + t2.b) / 2) = t1_3.b)
- -> Seq Scan on prt1_e_p1 t2
+ Hash Cond: (((t2.a + t2.b) / 2) = t1_5.b)
+ -> Seq Scan on prt1_e_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t1_3
+ -> Seq Scan on prt2_p0 t1_5
Filter: (a = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
Index Cond: (a = ((t2.a + t2.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_1.a = t1_4.b)
+ Join Filter: (t1_1.a = t1_6.b)
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Join
- Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_4.b)
- -> Seq Scan on prt1_e_p2 t2_1
+ Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_6.b)
+ -> Seq Scan on prt1_e_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t1_4
+ -> Seq Scan on prt2_p1 t1_6
Filter: (a = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
Index Cond: (a = ((t2_1.a + t2_1.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_2.a = t1_5.b)
+ Join Filter: (t1_2.a = t1_7.b)
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Nested Loop
- -> Seq Scan on prt2_p3 t1_5
+ -> Seq Scan on prt2_p2 t1_7
Filter: (a = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_2
- Index Cond: (((a + b) / 2) = t1_5.b)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t2_2
+ Index Cond: (((a + b) / 2) = t1_7.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
Index Cond: (a = ((t2_2.a + t2_2.b) / 2))
Filter: (b = 0)
-(41 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = t1_8.b)
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t1_8
+ Filter: (a = 0)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_3
+ Index Cond: (((a + b) / 2) = t1_8.b)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t2_3.a + t2_3.b) / 2))
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t1_9.b)
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Join
+ Hash Cond: (((t2_4.a + t2_4.b) / 2) = t1_9.b)
+ -> Seq Scan on prt1_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t1_9
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = ((t2_4.a + t2_4.b) / 2))
+ Filter: (b = 0)
+(66 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHERE t1.a = 0 AND t1.b = (t2.a + t2.b)/2) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
--------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Nested Loop
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Semi Join
- Hash Cond: (t1_3.b = ((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt2_p1 t1_3
+ Hash Cond: (t1_5.b = ((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt2_p0 t1_5
-> Hash
- -> Seq Scan on prt1_e_p1 t1_6
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
- Index Cond: (a = t1_3.b)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t1_5.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Semi Join
- Hash Cond: (t1_4.b = ((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt2_p2 t1_4
+ Hash Cond: (t1_6.b = ((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt2_p1 t1_6
-> Hash
- -> Seq Scan on prt1_e_p2 t1_7
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
- Index Cond: (a = t1_4.b)
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
+ Index Cond: (a = t1_6.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Hash Semi Join
- Hash Cond: (t1_5.b = ((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt2_p3 t1_5
+ Hash Cond: (t1_7.b = ((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt2_p2 t1_7
-> Hash
- -> Seq Scan on prt1_e_p3 t1_8
+ -> Seq Scan on prt1_e_p2 t1_12
Filter: (c = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t1_5.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t1_7.b)
Filter: (b = 0)
-(39 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Hash Semi Join
+ Hash Cond: (t1_8.b = ((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt2_p3 t1_8
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t1_13
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t1_8.b)
+ Filter: (b = 0)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Semi Join
+ Hash Cond: (t1_9.b = ((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt2_p4 t1_9
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = t1_9.b)
+ Filter: (b = 0)
+(63 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
-- test merge joins
SET enable_hashjoin TO off;
SET enable_nestloop TO off;
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
-----------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------
Merge Append
Sort Key: t1.a
-> Merge Semi Join
- Merge Cond: (t1.a = t1_3.b)
+ Merge Cond: (t1.a = t1_5.b)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_3.b = (((t1_6.a + t1_6.b) / 2)))
+ Merge Cond: (t1_5.b = (((t1_10.a + t1_10.b) / 2)))
-> Sort
- Sort Key: t1_3.b
- -> Seq Scan on prt2_p1 t1_3
+ Sort Key: t1_5.b
+ -> Seq Scan on prt2_p0 t1_5
-> Sort
- Sort Key: (((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt1_e_p1 t1_6
+ Sort Key: (((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_1.a = t1_4.b)
+ Merge Cond: (t1_1.a = t1_6.b)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_4.b = (((t1_7.a + t1_7.b) / 2)))
+ Merge Cond: (t1_6.b = (((t1_11.a + t1_11.b) / 2)))
-> Sort
- Sort Key: t1_4.b
- -> Seq Scan on prt2_p2 t1_4
+ Sort Key: t1_6.b
+ -> Seq Scan on prt2_p1 t1_6
-> Sort
- Sort Key: (((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt1_e_p2 t1_7
+ Sort Key: (((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_2.a = t1_5.b)
+ Merge Cond: (t1_2.a = t1_7.b)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_5.b = (((t1_8.a + t1_8.b) / 2)))
+ Merge Cond: (t1_7.b = (((t1_12.a + t1_12.b) / 2)))
-> Sort
- Sort Key: t1_5.b
- -> Seq Scan on prt2_p3 t1_5
+ Sort Key: t1_7.b
+ -> Seq Scan on prt2_p2 t1_7
-> Sort
- Sort Key: (((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt1_e_p3 t1_8
+ Sort Key: (((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt1_e_p2 t1_12
Filter: (c = 0)
-(47 rows)
+ -> Merge Semi Join
+ Merge Cond: (t1_3.a = t1_8.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_8.b = (((t1_13.a + t1_13.b) / 2)))
+ -> Sort
+ Sort Key: t1_8.b
+ -> Seq Scan on prt2_p3 t1_8
+ -> Sort
+ Sort Key: (((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt1_e_p3 t1_13
+ Filter: (c = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_4.a = t1_9.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_9.b = (((t1_14.a + t1_14.b) / 2)))
+ -> Sort
+ Sort Key: t1_9.b
+ -> Seq Scan on prt2_p4 t1_9
+ -> Sort
+ Sort Key: (((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+(77 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
@@ -933,14 +1438,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3.a + t3.b) / 2)) = t1.a)
-> Sort
Sort Key: (((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Sort
Sort Key: t2.b
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Merge Left Join
Merge Cond: (t1_1.a = t2_1.b)
-> Sort
@@ -949,14 +1454,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_1.a + t3_1.b) / 2)) = t1_1.a)
-> Sort
Sort Key: (((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Sort
Sort Key: t2_1.b
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Merge Left Join
Merge Cond: (t1_2.a = t2_2.b)
-> Sort
@@ -965,32 +1470,74 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_2.a + t3_2.b) / 2)) = t1_2.a)
-> Sort
Sort Key: (((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Sort
Sort Key: t2_2.b
- -> Seq Scan on prt2_p3 t2_2
-(51 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Merge Left Join
+ Merge Cond: (t1_3.a = t2_3.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_3.a + t3_3.b) / 2)) = t1_3.a)
+ -> Sort
+ Sort Key: (((t3_3.a + t3_3.b) / 2))
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ -> Sort
+ Sort Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ -> Merge Left Join
+ Merge Cond: (t1_4.a = t2_4.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_4.a + t3_4.b) / 2)) = t1_4.a)
+ -> Sort
+ Sort Key: (((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ -> Sort
+ Sort Key: t2_4.b
+ -> Seq Scan on prt2_p4 t2_4
+(83 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- MergeAppend on nullable column
EXPLAIN (COSTS OFF)
@@ -998,8 +1545,18 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Merge Left Join
+ Merge Cond: (prt1_p0.a = b)
+ -> Sort
+ Sort Key: prt1_p0.a
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Sort
+ Sort Key: b
+ -> Result
+ One-Time Filter: false
-> Merge Left Join
Merge Cond: (prt1_p1.a = b)
-> Sort
@@ -1020,21 +1577,26 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
Sort Key: prt2_p2.b
-> Seq Scan on prt2_p2
Filter: (b > 250)
-(23 rows)
+(33 rows)
SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | b
------+-----
- 0 |
- 50 |
- 100 |
- 150 |
- 200 |
- 250 |
- 300 | 300
- 350 |
- 400 |
-(9 rows)
+ a | b
+------+-----
+ -250 |
+ -200 |
+ -150 |
+ -100 |
+ -50 |
+ 0 |
+ 50 |
+ 100 |
+ 150 |
+ 200 |
+ 250 |
+ 300 | 300
+ 350 |
+ 400 |
+(14 rows)
-- merge join when expression with whole-row reference needs to be sorted;
-- partitionwise join does not apply
@@ -1048,175 +1610,2412 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
Sort Key: t1.a, ((((t1.*)::prt1))::text)
-> Result
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Sort
Sort Key: t2.b, ((((t2.*)::prt2))::text)
-> Result
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
-(16 rows)
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+(20 rows)
SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.b ORDER BY t1.a;
- a | b
-----+----
- 0 | 0
- 6 | 6
- 12 | 12
- 18 | 18
- 24 | 24
-(5 rows)
+ a | b
+-----+-----
+ -24 | -24
+ -18 | -18
+ -12 | -12
+ -6 | -6
+ 0 | 0
+ 6 | 6
+ 12 | 12
+ 18 | 18
+ 24 | 24
+(9 rows)
RESET enable_hashjoin;
RESET enable_nestloop;
---
--- partitioned by multiple columns
---
-CREATE TABLE prt1_m (a int, b int, c int) PARTITION BY RANGE(a, ((a + b)/2));
-CREATE TABLE prt1_m_p1 PARTITION OF prt1_m FOR VALUES FROM (0, 0) TO (250, 250);
-CREATE TABLE prt1_m_p2 PARTITION OF prt1_m FOR VALUES FROM (250, 250) TO (500, 500);
-CREATE TABLE prt1_m_p3 PARTITION OF prt1_m FOR VALUES FROM (500, 500) TO (600, 600);
-INSERT INTO prt1_m SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
-ANALYZE prt1_m;
-CREATE TABLE prt2_m (a int, b int, c int) PARTITION BY RANGE(((b + a)/2), b);
-CREATE TABLE prt2_m_p1 PARTITION OF prt2_m FOR VALUES FROM (0, 0) TO (250, 250);
-CREATE TABLE prt2_m_p2 PARTITION OF prt2_m FOR VALUES FROM (250, 250) TO (500, 500);
-CREATE TABLE prt2_m_p3 PARTITION OF prt2_m FOR VALUES FROM (500, 500) TO (600, 600);
-INSERT INTO prt2_m SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
-ANALYZE prt2_m;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
- QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+ -> Seq Scan on prt2_p3 t2_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_4
+ Filter: (b = 0)
+(22 rows)
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p1 t2
+ -> Hash
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p2 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p3 t1_2
+ Filter: (b = 0)
+(21 rows)
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -150 | -0150 | 0 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 0 | 0150
+ 300 | 0300 | 0 | 0300
+ 450 | 0450 | 0 | 0450
+ 600 | 0600 | 0 | 0600
+ 750 | 0750 | 0 | 0750
+(7 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | 0 | -0150
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | 0 | 0000
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | 0 | 0150
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 0 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ 450 | 0450 | 0 | 0450
+ 500 | 0500 | |
+ 550 | 0550 | |
+ 600 | 0600 | 0 | 0600
+ 650 | 0650 | |
+ 700 | 0700 | |
+ 750 | 0750 | 0 | 0750
+(21 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Semi Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Append
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
+ Index Cond: (a = t1_1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(28 rows)
+
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Anti Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Anti Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -250 | 0 | -0250
+ -200 | 0 | -0200
+ -100 | 0 | -0100
+ -50 | 0 | -0050
+ 50 | 0 | 0050
+ 100 | 0 | 0100
+ 200 | 0 | 0200
+ 250 | 0 | 0250
+ 350 | 0 | 0350
+ 400 | 0 | 0400
+ 500 | 0 | 0500
+ 550 | 0 | 0550
+ 650 | 0 | 0650
+ 700 | 0 | 0700
+(14 rows)
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ QUERY PLAN
+---------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t3.c
+ -> Append
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t3
+ Index Cond: (a = t2.b)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t2.b)
+ -> Hash Right Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t3_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t3_2
+ Index Cond: (a = t2_2.b)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t2_2.b)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t3_3
+ Index Cond: (a = t2_3.b)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(47 rows)
+
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ a | a | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.b
+ -> Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(24 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: (t1.a = t2.b)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.a, 0)) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------
+ Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(22 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Join
+ Hash Cond: (t1.a = t2.b)
+ Join Filter: ((t1.b + t2.a) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+--
+-- partitioned by multiple columns
+--
+CREATE TABLE prt1_m (a int, b int, c int) PARTITION BY RANGE(a, ((a + b)/2));
+CREATE TABLE prt1_m_p1 PARTITION OF prt1_m FOR VALUES FROM (0, 0) TO (250, 250);
+CREATE TABLE prt1_m_p2 PARTITION OF prt1_m FOR VALUES FROM (250, 250) TO (500, 500);
+CREATE TABLE prt1_m_p3 PARTITION OF prt1_m FOR VALUES FROM (500, 500) TO (600, 600);
+INSERT INTO prt1_m SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+ANALYZE prt1_m;
+CREATE TABLE prt2_m (a int, b int, c int) PARTITION BY RANGE(((b + a)/2), b);
+CREATE TABLE prt2_m_p1 PARTITION OF prt2_m FOR VALUES FROM (0, 0) TO (250, 250);
+CREATE TABLE prt2_m_p2 PARTITION OF prt2_m FOR VALUES FROM (250, 250) TO (500, 500);
+CREATE TABLE prt2_m_p3 PARTITION OF prt2_m FOR VALUES FROM (500, 500) TO (600, 600);
+INSERT INTO prt2_m SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+ANALYZE prt2_m;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------------------------------------------
+ Sort
+ Sort Key: prt1_m_p1.a, prt2_m_p1.b
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p1.a = ((prt2_m_p1.b + prt2_m_p1.a) / 2)) AND (((prt1_m_p1.a + prt1_m_p1.b) / 2) = prt2_m_p1.b))
+ -> Seq Scan on prt1_m_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p1
+ Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p2.a = ((prt2_m_p2.b + prt2_m_p2.a) / 2)) AND (((prt1_m_p2.a + prt1_m_p2.b) / 2) = prt2_m_p2.b))
+ -> Seq Scan on prt1_m_p2
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p2
+ Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: ((prt1_m_p3.a = ((prt2_m_p3.b + prt2_m_p3.a) / 2)) AND (((prt1_m_p3.a + prt1_m_p3.b) / 2) = prt2_m_p3.b))
+ -> Seq Scan on prt1_m_p3
+ Filter: (c = 0)
+ -> Hash
+ -> Seq Scan on prt2_m_p3
+ Filter: (c = 0)
+(24 rows)
+
+SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
+ a | c | b | c
+-----+---+-----+---
+ 0 | 0 | 0 | 0
+ 50 | 0 | |
+ 100 | 0 | |
+ 150 | 0 | 150 | 0
+ 200 | 0 | |
+ 250 | 0 | |
+ 300 | 0 | 300 | 0
+ 350 | 0 | |
+ 400 | 0 | |
+ 450 | 0 | 450 | 0
+ 500 | 0 | |
+ 550 | 0 | |
+ | | 75 | 0
+ | | 225 | 0
+ | | 375 | 0
+ | | 525 | 0
+(16 rows)
+
+--
+-- tests for list partitioned tables.
+--
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 470 | 0 | 0011
+(1 row)
+
+--
+-- list partitioned by expression
+--
+CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
+ANALYZE plt1_e;
+-- test partition matching with N-way join
+EXPLAIN (COSTS OFF)
+SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+ QUERY PLAN
+------------------------------------------------------------------------------------------------
+ GroupAggregate
+ Group Key: t1.c, t2.c, t3.c
+ -> Sort
+ Sort Key: t1.c, t3.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = ltrim(t3.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t2.b = t1.b) AND ((t2.c)::text = (t1.c)::text))
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt1_e_p4 t3
+ -> Hash Join
+ Hash Cond: ((t1_1.c)::text = ltrim(t3_1.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t1_1.b = t2_1.b) AND ((t1_1.c)::text = (t2_1.c)::text))
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_e_p1 t3_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = ltrim(t3_2.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t1_2.b = t2_2.b) AND ((t1_2.c)::text = (t2_2.c)::text))
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_e_p2 t3_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = ltrim(t3_3.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t2_3.b = t1_3.b) AND ((t2_3.c)::text = (t1_3.c)::text))
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt1_e_p3 t3_3
+(41 rows)
+
+SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+ avg | avg | avg | c | c | c
+----------------------+---------------------+----------------------+------+------+------
+ 246.5000000000000000 | 22.4666666666666667 | 268.9666666666666667 | 0000 | 0000 | 0000
+ 248.5000000000000000 | 21.3333333333333333 | 269.8333333333333333 | 0002 | 0002 | 0002
+ 249.5000000000000000 | 22.3333333333333333 | 271.8333333333333333 | 0003 | 0003 | 0003
+ 250.5000000000000000 | 23.3333333333333333 | 273.8333333333333333 | 0004 | 0004 | 0004
+ 251.5000000000000000 | 22.7666666666666667 | 274.2666666666666667 | 0005 | 0005 | 0005
+ 252.5000000000000000 | 22.2000000000000000 | 274.7000000000000000 | 0006 | 0006 | 0006
+ 246.0000000000000000 | 23.9655172413793103 | 269.9655172413793103 | 0008 | 0008 | 0008
+ 247.0000000000000000 | 23.3448275862068966 | 270.3448275862068966 | 0009 | 0009 | 0009
+(8 rows)
+
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 470 | 0011
+ | | 235 | 0014
+(8 rows)
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 235 | 0014
+ | | 470 | 0011
+(10 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 47 | 0 | 0013
+ 235 | 0 | 0014
+ 470 | 0 | 0011
+(3 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+----------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Materialize
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(20 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Materialize
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+---
+ 470 | 0 |
+(1 row)
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
Sort
- Sort Key: prt1_m_p1.a, prt2_m_p1.b
- -> Append
- -> Hash Full Join
- Hash Cond: ((prt1_m_p1.a = ((prt2_m_p1.b + prt2_m_p1.a) / 2)) AND (((prt1_m_p1.a + prt1_m_p1.b) / 2) = prt2_m_p1.b))
- -> Seq Scan on prt1_m_p1
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p1
- Filter: (c = 0)
- -> Hash Full Join
- Hash Cond: ((prt1_m_p2.a = ((prt2_m_p2.b + prt2_m_p2.a) / 2)) AND (((prt1_m_p2.a + prt1_m_p2.b) / 2) = prt2_m_p2.b))
- -> Seq Scan on prt1_m_p2
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p2
- Filter: (c = 0)
- -> Hash Full Join
- Hash Cond: ((prt1_m_p3.a = ((prt2_m_p3.b + prt2_m_p3.a) / 2)) AND (((prt1_m_p3.a + prt1_m_p3.b) / 2) = prt2_m_p3.b))
- -> Seq Scan on prt1_m_p3
- Filter: (c = 0)
- -> Hash
- -> Seq Scan on prt2_m_p3
- Filter: (c = 0)
-(24 rows)
+ Sort Key: t2.a
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
-SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1 FULL JOIN (SELECT * FROM prt2_m WHERE prt2_m.c = 0) t2 ON (t1.a = (t2.b + t2.a)/2 AND t2.b = (t1.a + t1.b)/2) ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 50 | 0 | |
- 100 | 0 | |
- 150 | 0 | 150 | 0
- 200 | 0 | |
- 250 | 0 | |
- 300 | 0 | 300 | 0
- 350 | 0 | |
- 400 | 0 | |
- 450 | 0 | 450 | 0
- 500 | 0 | |
- 550 | 0 | |
- | | 75 | 0
- | | 225 | 0
- | | 375 | 0
- | | 525 | 0
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
(16 rows)
---
--- tests for list partitioned tables.
---
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
---
--- list partitioned by expression
---
-CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1_e;
--- test partition matching with N-way join
+-- semi join
EXPLAIN (COSTS OFF)
-SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- QUERY PLAN
---------------------------------------------------------------------------------
- GroupAggregate
- Group Key: t1.c, t2.c, t3.c
- -> Sort
- Sort Key: t1.c, t3.c
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
-> Append
- -> Hash Join
- Hash Cond: (t1.c = ltrim(t3.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1.b = t2.b) AND (t1.c = t2.c))
- -> Seq Scan on plt1_p1 t1
- -> Hash
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_e_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.c = ltrim(t3_1.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1_1.b = t2_1.b) AND (t1_1.c = t2_1.c))
- -> Seq Scan on plt1_p2 t1_1
- -> Hash
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_e_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.c = ltrim(t3_2.c, 'A'::text))
- -> Hash Join
- Hash Cond: ((t1_2.b = t2_2.b) AND (t1_2.c = t2_2.c))
- -> Seq Scan on plt1_p3 t1_2
- -> Hash
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_e_p3 t3_2
-(32 rows)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(22 rows)
-SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- avg | avg | avg | c | c | c
-----------------------+----------------------+-----------------------+------+------+-------
- 24.0000000000000000 | 24.0000000000000000 | 48.0000000000000000 | 0000 | 0000 | A0000
- 75.0000000000000000 | 75.0000000000000000 | 148.0000000000000000 | 0001 | 0001 | A0001
- 123.0000000000000000 | 123.0000000000000000 | 248.0000000000000000 | 0002 | 0002 | A0002
- 174.0000000000000000 | 174.0000000000000000 | 348.0000000000000000 | 0003 | 0003 | A0003
- 225.0000000000000000 | 225.0000000000000000 | 448.0000000000000000 | 0004 | 0004 | A0004
- 273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
- 324.0000000000000000 | 324.0000000000000000 | 648.0000000000000000 | 0006 | 0006 | A0006
- 375.0000000000000000 | 375.0000000000000000 | 748.0000000000000000 | 0007 | 0007 | A0007
- 423.0000000000000000 | 423.0000000000000000 | 848.0000000000000000 | 0008 | 0008 | A0008
- 474.0000000000000000 | 474.0000000000000000 | 948.0000000000000000 | 0009 | 0009 | A0009
- 525.0000000000000000 | 525.0000000000000000 | 1048.0000000000000000 | 0010 | 0010 | A0010
- 573.0000000000000000 | 573.0000000000000000 | 1148.0000000000000000 | 0011 | 0011 | A0011
-(12 rows)
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(22 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(19 rows)
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
@@ -1241,22 +4040,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
--------------------------------------------------
Hash Left Join
Hash Cond: (t2.b = a)
- -> Append
- -> Hash Join
- Hash Cond: (t3.a = t2.b)
- -> Seq Scan on prt1_p1 t3
- -> Hash
- -> Seq Scan on prt2_p1 t2
- -> Hash Join
- Hash Cond: (t3_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t3_1
- -> Hash
- -> Seq Scan on prt2_p2 t2_1
- -> Hash Join
- Hash Cond: (t3_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t3_2
- -> Hash
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash Join
+ Hash Cond: (t3.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t3
+ -> Seq Scan on prt1_p1 t3_1
+ -> Seq Scan on prt1_p2 t3_2
+ -> Seq Scan on prt1_p3 t3_3
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Result
One-Time Filter: false
@@ -1271,16 +4070,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
-> Hash Left Join
Hash Cond: (t2.b = a)
-> Append
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
Filter: (a = 0)
-> Hash
-> Result
One-Time Filter: false
-(14 rows)
+(20 rows)
--
-- tests for hash partitioned tables.
@@ -1356,41 +4161,9 @@ SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, ph
273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
(6 rows)
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
- Sort
- Sort Key: t1.a
- -> Append
- -> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
- -> Hash
- -> Seq Scan on prt1_p1 t1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
- -> Hash
- -> Seq Scan on prt1_p2 t1_1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
- -> Hash
- -> Seq Scan on prt1_p3 t1_2
- Filter: (b = 0)
-(21 rows)
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
@@ -1405,26 +4178,24 @@ SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c
Sort Key: t1.c
-> HashAggregate
Group Key: t1.c, t2.c
- -> Append
- -> Hash Join
- Hash Cond: (t2.c = t1.c)
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_p1 t1
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_1.c = t1_1.c)
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p1 t1_1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_2.c = t1_2.c)
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p2 t1_2
Filter: ((a % 25) = 0)
-(23 rows)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: ((a % 25) = 0)
+(21 rows)
--
-- multiple levels of partitioning
@@ -1826,64 +4597,70 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2 WHERE t1.a = t2.a;
Hash Join
Hash Cond: (t1.a = t2.a)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Seq Scan on prt4_n_p1 t2
-> Seq Scan on prt4_n_p2 t2_1
-> Seq Scan on prt4_n_p3 t2_2
-(11 rows)
+(13 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2, prt2 t3 WHERE t1.a = t2.a and t1.a = t3.b;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------
Hash Join
- Hash Cond: (t2.a = t1.a)
+ Hash Cond: (t3.b = t1.a)
-> Append
- -> Seq Scan on prt4_n_p1 t2
- -> Seq Scan on prt4_n_p2 t2_1
- -> Seq Scan on prt4_n_p3 t2_2
+ -> Seq Scan on prt2_p0 t3
+ -> Seq Scan on prt2_p1 t3_1
+ -> Seq Scan on prt2_p2 t3_2
+ -> Seq Scan on prt2_p3 t3_3
+ -> Seq Scan on prt2_p4 t3_4
+ -> Seq Scan on prt2_p5 t3_5
-> Hash
- -> Append
- -> Hash Join
- Hash Cond: (t1.a = t3.b)
- -> Seq Scan on prt1_p1 t1
- -> Hash
- -> Seq Scan on prt2_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t1_1
- -> Hash
- -> Seq Scan on prt2_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t1_2
- -> Hash
- -> Seq Scan on prt2_p3 t3_2
+ -> Hash Join
+ Hash Cond: (t1.a = t2.a)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt4_n_p1 t2
+ -> Seq Scan on prt4_n_p2 t2_1
+ -> Seq Scan on prt4_n_p3 t2_2
(23 rows)
-- partitionwise join can not be applied if there are no equi-join conditions
-- between partition keys
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON (t1.a < t2.b);
- QUERY PLAN
----------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------
Nested Loop Left Join
+ Join Filter: (t1.a < t2.b)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
- -> Append
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
- Index Cond: (t1.a < b)
-(12 rows)
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Materialize
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(16 rows)
-- equi-join with join condition on partial keys does not qualify for
-- partitionwise join
@@ -1969,16 +4746,17 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 JOIN prt2_n t2 ON (t1.c = t2.c) JOI
-> Seq Scan on prt2_n_p2 t2_1
-> Hash
-> Hash Join
- Hash Cond: (t3.c = (t1.c)::text)
+ Hash Cond: ((t3.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on plt1_p1 t3
- -> Seq Scan on plt1_p2 t3_1
- -> Seq Scan on plt1_p3 t3_2
+ -> Seq Scan on plt1_p4 t3
+ -> Seq Scan on plt1_p1 t3_1
+ -> Seq Scan on plt1_p2 t3_2
+ -> Seq Scan on plt1_p3 t3_3
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(16 rows)
+(17 rows)
-- partitionwise join can not be applied for a join between list and range
-- partitioned table
@@ -1989,14 +4767,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 FULL JOIN prt1 t2 ON (t1.c = t2.c);
Hash Full Join
Hash Cond: ((t2.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on prt1_p1 t2
- -> Seq Scan on prt1_p2 t2_1
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(10 rows)
+(12 rows)
-- partitionwise join can not be applied if only one of joining table has
-- default partition
@@ -2012,16 +4792,23 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b =
-> Hash Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
diff --git a/src/test/regress/sql/partition_join.sql b/src/test/regress/sql/partition_join.sql
index c1c9859651..0e884835fb 100644
--- a/src/test/regress/sql/partition_join.sql
+++ b/src/test/regress/sql/partition_join.sql
@@ -10,25 +10,39 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
@@ -67,11 +81,19 @@ EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -93,20 +115,30 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
@@ -169,6 +201,128 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
RESET enable_hashjoin;
RESET enable_nestloop;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
--
-- partitioned by multiple columns
--
@@ -193,28 +347,79 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1
--
-- tests for list partitioned tables.
--
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
--
-- list partitioned by expression
--
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
ANALYZE plt1_e;
-- test partition matching with N-way join
@@ -222,6 +427,175 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.a = 1 AND t1.a = 2;
@@ -267,27 +641,18 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
ALTER TABLE plt2 DETACH PARTITION plt2_p3;
ALTER TABLE plt2 ATTACH PARTITION plt2_p3 DEFAULT;
ANALYZE plt2;
-
EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.a % 25 = 0 GROUP BY t1.c, t2.c ORDER BY t1.c, t2.c;
+
--
-- multiple levels of partitioning
--
--
2.19.2
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
@ 2019-02-04 05:35 ` amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: amul sul @ 2019-02-04 05:35 UTC (permalink / raw)
To: Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; +Cc: Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers; ashutosh.bapat.oss@gmail.com
There are few whitespaces in 0002 patch that I have fixed in the attached
version.
Rest of the patches are untouched.
Ill continue my review and testing.
Regards,
Amul
On Thu, Jan 31, 2019 at 5:26 PM Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
wrote:
> (2019/01/22 21:38), Etsuro Fujita wrote:
> > Will continue to review.
>
> I rebased the patch set against the latest HEAD. Attached is a new
> version. I'll move this to the next CF, and continue to review it.
>
> Best regards,
> Etsuro Fujita
>
Attachments:
[application/octet-stream] 0001-Hash-partition-bound-equality-refactoring-v18.patch (5.1K, ../../CAAJ_b94O7pphWZ1LkJ7tygyzH-h+EBrvc_ahuktmW7u3s2v0BQ@mail.gmail.com/3-0001-Hash-partition-bound-equality-refactoring-v18.patch)
download | inline diff:
From a4b338f1225bcf9d5d3636f73537a5d1d2bee000 Mon Sep 17 00:00:00 2001
From: Etsuro Fujita <efujita@postgresql.org>
Date: Thu, 31 Jan 2019 19:18:18 +0900
Subject: [PATCH 1/3] Hash partition bound equality refactoring.
Separate the code to check whether two given hash bounds are equal into a
separate function, so that it can be called from multiple places. Right now
it's only caller is partition_bounds_equal() but later we will use it for
merging partition bounds.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/partitioning/partbounds.c | 95 +++++++++++++++++----------
1 file changed, 61 insertions(+), 34 deletions(-)
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index d478ae7e19..c492685d11 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -104,6 +104,9 @@ static void get_range_key_properties(PartitionKey key, int keynum,
Expr **keyCol,
Const **lower_val, Const **upper_val);
static List *get_range_nulltest(PartitionKey key);
+static bool partition_hbounds_equal(PartitionBoundInfo b1,
+ PartitionBoundInfo b2);
+
/*
* get_qual_from_partbound
@@ -652,6 +655,63 @@ create_range_bounds(PartitionBoundSpec **boundspecs, int nparts,
return boundinfo;
}
+/*
+ * Are two hash partition bound collections logically equal?
+ *
+ * Hash partition bounds store modulus and remainder in datums array which are
+ * always integers irrespective of the number of partition keys and their data
+ * types. Hence we can compare the hash bound collection without any partition
+ * key specific information. Separating this logic in a function which does not
+ * require partition key specific information allows it be called from places
+ * where the partition key specific information is not completely available.
+ */
+static bool
+partition_hbounds_equal(PartitionBoundInfo b1, PartitionBoundInfo b2)
+{
+ int greatest_modulus = get_hash_partition_greatest_modulus(b1);
+ int i;
+
+ Assert(b1->strategy == PARTITION_STRATEGY_HASH &&
+ b2->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * If two hash partitioned tables have different greatest moduli,
+ * their partition schemes don't match. For hash partitioned table,
+ * the greatest modulus is given by the last datum and number of
+ * partitions is given by ndatums.
+ */
+ if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ return false;
+
+ /*
+ * We arrange the partitions in the ascending order of their modulus and
+ * remainders. Also every modulus is factor of next larger modulus.
+ * Therefore we can safely store index of a given partition in indexes
+ * array at remainder of that partition. Also entries at (remainder + N *
+ * modulus) positions in indexes array are all same for (modulus,
+ * remainder) specification for any partition. Thus datums array from both
+ * the given bounds are same, if and only if their indexes array will be
+ * same. So, it suffices to compare indexes array.
+ */
+ for (i = 0; i < greatest_modulus; i++)
+ if (b1->indexes[i] != b2->indexes[i])
+ return false;
+
+#ifdef USE_ASSERT_CHECKING
+
+ /*
+ * Nonetheless make sure that the bounds are indeed same when the indexes
+ * match. Hash partition bound stores modulus and remainder at
+ * b1->datums[i][0] and b1->datums[i][1] position respectively.
+ */
+ for (i = 0; i < b1->ndatums; i++)
+ Assert((b1->datums[i][0] == b2->datums[i][0] &&
+ b1->datums[i][1] == b2->datums[i][1]));
+#endif
+
+ return true;
+}
+
/*
* Are two partition bound collections logically equal?
*
@@ -680,41 +740,8 @@ partition_bounds_equal(int partnatts, int16 *parttyplen, bool *parttypbyval,
if (b1->strategy == PARTITION_STRATEGY_HASH)
{
- int greatest_modulus = get_hash_partition_greatest_modulus(b1);
-
- /*
- * If two hash partitioned tables have different greatest moduli,
- * their partition schemes don't match.
- */
- if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ if (!partition_hbounds_equal(b1, b2))
return false;
-
- /*
- * We arrange the partitions in the ascending order of their moduli
- * and remainders. Also every modulus is factor of next larger
- * modulus. Therefore we can safely store index of a given partition
- * in indexes array at remainder of that partition. Also entries at
- * (remainder + N * modulus) positions in indexes array are all same
- * for (modulus, remainder) specification for any partition. Thus
- * datums array from both the given bounds are same, if and only if
- * their indexes array will be same. So, it suffices to compare
- * indexes array.
- */
- for (i = 0; i < greatest_modulus; i++)
- if (b1->indexes[i] != b2->indexes[i])
- return false;
-
-#ifdef USE_ASSERT_CHECKING
-
- /*
- * Nonetheless make sure that the bounds are indeed same when the
- * indexes match. Hash partition bound stores modulus and remainder
- * at b1->datums[i][0] and b1->datums[i][1] position respectively.
- */
- for (i = 0; i < b1->ndatums; i++)
- Assert((b1->datums[i][0] == b2->datums[i][0] &&
- b1->datums[i][1] == b2->datums[i][1]));
-#endif
}
else
{
--
2.18.0
[application/octet-stream] 0002-Partition-wise-join-for-1-1-1-0-0-1-partition-matchi-v18.patch (69.8K, ../../CAAJ_b94O7pphWZ1LkJ7tygyzH-h+EBrvc_ahuktmW7u3s2v0BQ@mail.gmail.com/4-0002-Partition-wise-join-for-1-1-1-0-0-1-partition-matchi-v18.patch)
download | inline diff:
From 292460a9c6f490b74405e8ac44a2de275472b1ed Mon Sep 17 00:00:00 2001
From: Amul Sul <amul.sul@enterprisedb.com>
Date: Sun, 3 Feb 2019 23:51:15 -0500
Subject: [PATCH 2/3] Partition-wise join for 1:1, 1:0, 0:1 partition matching.
Earlier version of partition-wise join implementation allowed
partition-wise join between two relations with exactly same partition
bounds. This commit allows partition-wise join to be applied under
following conditions
1. the partition bounds of joining relations are such that rows from
given partition on one side join can join with rows from maximum one
partition on the other side i.e. bounds of a given partition on one
side match/overlap with those of maximum one partition on the other
side. If the mapping happens to be m:n where m > 1 or n > 1, we have
to gang multiple partition relations together into a single relation.
This means that we have to add simple relations during join
processing, something which is not supported right now. ALso, in such
a case, different pairs of joining relations can produce different
partition bounds for the same join relation, which again is not
supported right now.
2. For every partition on outer side that can contribute to the result
of an OUTER join, there exists at least one (taken along with item 1,
it means exactly one) matching partition on the inner side. To
support partition-wise join when the inner matching partition doesn't
exist, we have to add a dummy base relation corresponding to the
non-existent inner partition. We don't have support to add base
relations during join processing.
3. For hash partitioned tables however, we support partition-wise join
only when the bounds exactly match. For hash partitioning it's unusual
to have missing partitions and hence generic partition matching is not
required.
With advanced partition matching, we won't be able to apply
partition-wise join when there are missing matching partitions. So for
a given N-way join, some sub-joins may not be partitioned, while the
overall N-way join is partitioned. We can not try partition-wise join
when one or both of the joining relations are not partitioned in one
of the pairs of joining relation. Skip partition-wise join for that
pair.
An example is A IJ B LJ C where B has an extra partition compared to A
and C. Join B LJ C requires dummy relation to join the extra partition
from B to a missing partition from C, and hence can not use
partition-wise join right now and hence BC is not partitioned. The
extra partition in B gets eliminated in A IJ B and thus it can use
partition-wise join and is partitioned. Hence (AB)C can use
partition-wise join but not A(BC).
Not every pair of joining relation (including the one presented to
build_joinrel_partition_info()) for the same joinrel can use
partition-wise join or has both the relations partitioned. Hence we
calculate the partition bounds for the join relation in
try_partition_wise_join() instead of doing it here.
The partition bounds produced for the first pair that can use
partition-wise are saved in the RelOptInfo of the joinrel. Partition
bounds produced for subsequent pairs should match that produced by the
first pair.
Support for default partition in list partitioned tables
========================================================
When a list value is present in one of the joining relations and not
the other, and the other relation has default partition, match (join)
the partition containing that list value with the default partition.
If there are multiple matches, we can not proceed with the
partition-wise join similar to the case of matching non-default
partition. If the default partition happens to be on the outer side of
the join, the resulting join partition acts as a default partition as
it will contain all the values from the default partition. If
the partition containing the list value happens to be on the outer
side of the join, the resulting join partition is associated with the
list value, since no other partition key value from the default
partition makes it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a partition from the inner side,
if inner side has a list value that is not present in the outer side.
But if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Support for matching default partition in range partitioned tables
==================================================================
When a range is present in one of the joining relations and not the
other, and the other relation has default partition, match (join) the
partition corresponding range with the default partition. If two
ranges overlap but their ranges don't match exactly, the
non-overlapping portion from one range may join the previous
(non-overlapping portion near the lower bound, if exists), next
(non-overlapping portion near the upper bound, if exists) ranges from
the other relation or default partition from the other relation. This
causes multiple partitions on the other side to be joined with a
single partition on the first side; a case we don't support. Any range
from one side which doesn't overlap with any range on the other side,
may find its join partner in the default partition and the
corresponding range partition will need to be joined with the default
partition. If the default partition happens to be on the outer side
of the join, the resulting join partition acts as a default partition
as it will contain all the values from the default partition. If the
non-partition corresponding to the range happens to be on the outer
side of the join, the resulting join partition is associated with that
range, since partition key values from the default partition outside
that range won't make it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a non-default partition from the
inner side, if inner side has a range missing in the outer side. But
if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/optimizer/path/joinrels.c | 95 +-
src/backend/optimizer/util/relnode.c | 33 +-
src/backend/partitioning/partbounds.c | 1677 ++++++++++++++++++++++++-
src/include/partitioning/partbounds.h | 7 +
4 files changed, 1766 insertions(+), 46 deletions(-)
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index dfbbfdac6d..ca4d261bc1 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1320,25 +1320,31 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
{
bool rel1_is_simple = IS_SIMPLE_REL(rel1);
bool rel2_is_simple = IS_SIMPLE_REL(rel2);
- int nparts;
+ PartitionScheme part_scheme;
+ PartitionBoundInfo join_boundinfo;
+ List *parts1;
+ List *parts2;
+ ListCell *lc1;
+ ListCell *lc2;
int cnt_parts;
/* Guard against stack overflow due to overly deep partition hierarchy. */
check_stack_depth();
/* Nothing to do, if the join relation is not partitioned. */
- if (!IS_PARTITIONED_REL(joinrel))
+ if (joinrel->part_scheme == NULL)
return;
/* The join relation should have consider_partitionwise_join set. */
Assert(joinrel->consider_partitionwise_join);
/*
- * Since this join relation is partitioned, all the base relations
- * participating in this join must be partitioned and so are all the
- * intermediate join relations.
+ * We can not perform partition-wise join if either of the joining
+ * relations is not partitioned.
*/
- Assert(IS_PARTITIONED_REL(rel1) && IS_PARTITIONED_REL(rel2));
+ if (!IS_PARTITIONED_REL(rel1) || !IS_PARTITIONED_REL(rel2))
+ return;
+
Assert(REL_HAS_ALL_PART_PROPS(rel1) && REL_HAS_ALL_PART_PROPS(rel2));
/* The joining relations should have consider_partitionwise_join set. */
@@ -1351,32 +1357,63 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
*/
Assert(joinrel->part_scheme == rel1->part_scheme &&
joinrel->part_scheme == rel2->part_scheme);
+ part_scheme = joinrel->part_scheme;
/*
- * 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.
+ * Get the list of matching partitions to be joined along with the
+ * partition bounds of the join relation. Because of the restrictions
+ * imposed by partition matching algorithm, not every pair of joining
+ * relations for this join will be able to use partition-wise join. But all
+ * those pairs which can use partition-wise join will produce the same
+ * partition bounds for the join relation.
*/
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel1->boundinfo));
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel2->boundinfo));
+ join_boundinfo = partition_bounds_merge(part_scheme->partnatts,
+ part_scheme->partsupfunc,
+ part_scheme->partcollation,
+ rel1, rel2,
+ parent_sjinfo->jointype,
+ &parts1, &parts2);
+
+ if (join_boundinfo == NULL)
+ return;
- nparts = joinrel->nparts;
+ if (joinrel->boundinfo == NULL)
+ {
+ Assert(joinrel->nparts == 0 && joinrel->part_rels == NULL);
+ joinrel->boundinfo = join_boundinfo;
+ joinrel->nparts = list_length(parts1);
+ Assert(joinrel->nparts == list_length(parts2));
+ joinrel->part_rels =
+ (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+ joinrel->nparts);
+ }
+ else
+ {
+ Assert(partition_bounds_equal(part_scheme->partnatts,
+ part_scheme->parttyplen,
+ part_scheme->parttypbyval,
+ join_boundinfo, joinrel->boundinfo));
+ /*
+ * Every pair of joining relations should result in the same number
+ * of child-joins.
+ */
+ Assert(joinrel->nparts == list_length(parts1));
+ Assert(joinrel->nparts == list_length(parts2));
+ Assert(joinrel->part_rels);
+ }
/*
* Create child-join relations for this partitioned join, if those don't
* exist. Add paths to child-joins for a pair of child relations
* corresponding to the given pair of parent relations.
*/
- for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+ cnt_parts = 0;
+ forboth(lc1, parts1, lc2, parts2)
{
- RelOptInfo *child_rel1 = rel1->part_rels[cnt_parts];
- RelOptInfo *child_rel2 = rel2->part_rels[cnt_parts];
+ int part1 = lfirst_int(lc1);
+ int part2 = lfirst_int(lc2);
+ RelOptInfo *child_rel1;
+ RelOptInfo *child_rel2;
SpecialJoinInfo *child_sjinfo;
List *child_restrictlist;
RelOptInfo *child_joinrel;
@@ -1384,6 +1421,10 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
AppendRelInfo **appinfos;
int nappinfos;
+ Assert(part1 >= 0 && part2 >= 0);
+ child_rel1 = rel1->part_rels[part1];
+ child_rel2 = rel2->part_rels[part2];
+
/*
* If a child table has consider_partitionwise_join=false, it means
* that it's a dummy relation for which we skipped setting up tlist
@@ -1438,12 +1479,24 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
joinrel->part_rels[cnt_parts] = child_joinrel;
}
+ /*
+ * For every pair of joining relations, the set of matching partitions
+ * would change. However, the base relation partitions constituting
+ * the given child should remain same for all the joining pairs. Since
+ * the order in which children are stored in the array of child-joins,
+ * depends upon partition bounds of the join, which are same for all
+ * the joining pairs, every joining pair yields the child-joins in the
+ * same order.
+ */
Assert(bms_equal(child_joinrel->relids, child_joinrelids));
populate_joinrel_with_paths(root, child_rel1, child_rel2,
child_joinrel, child_sjinfo,
child_restrictlist);
+ cnt_parts++;
}
+
+ Assert(cnt_parts == joinrel->nparts);
}
/*
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index f04c6b76f4..a1561dd066 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1585,7 +1585,7 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
* of the way the query planner deduces implied equalities and reorders
* the joins. Please see optimizer/README for details.
*/
- if (!IS_PARTITIONED_REL(outer_rel) || !IS_PARTITIONED_REL(inner_rel) ||
+ if (outer_rel->part_scheme == NULL || inner_rel->part_scheme == NULL ||
!outer_rel->consider_partitionwise_join ||
!inner_rel->consider_partitionwise_join ||
outer_rel->part_scheme != inner_rel->part_scheme ||
@@ -1598,24 +1598,6 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
part_scheme = outer_rel->part_scheme;
- Assert(REL_HAS_ALL_PART_PROPS(outer_rel) &&
- REL_HAS_ALL_PART_PROPS(inner_rel));
-
- /*
- * For now, our partition matching algorithm can match partitions only
- * when the partition bounds of the joining relations are exactly same.
- * So, bail out otherwise.
- */
- if (outer_rel->nparts != inner_rel->nparts ||
- !partition_bounds_equal(part_scheme->partnatts,
- part_scheme->parttyplen,
- part_scheme->parttypbyval,
- outer_rel->boundinfo, inner_rel->boundinfo))
- {
- Assert(!IS_PARTITIONED_REL(joinrel));
- return;
- }
-
/*
* This function will be called only once for each joinrel, hence it
* should not have partition scheme, partition bounds, partition key
@@ -1627,17 +1609,20 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
/*
* Join relation is partitioned using the same partitioning scheme as the
- * joining relations and has same bounds.
+ * joining relations.
+ *
+ * Because of restrictions in partition_bounds_merge(), not every pair of
+ * joining relations (including the one presented to this function) for the
+ * same joinrel can use partition-wise join or has both the relations
+ * partitioned. Hence we calculate the partition bounds, number of
+ * partitions and child-join relations of the join relation when and if we
+ * find a suitable pair in try_partition_wise_join().
*/
joinrel->part_scheme = part_scheme;
- joinrel->boundinfo = outer_rel->boundinfo;
partnatts = joinrel->part_scheme->partnatts;
joinrel->partexprs = (List **) palloc0(sizeof(List *) * partnatts);
joinrel->nullable_partexprs =
(List **) palloc0(sizeof(List *) * partnatts);
- joinrel->nparts = outer_rel->nparts;
- joinrel->part_rels =
- (RelOptInfo **) palloc0(sizeof(RelOptInfo *) * joinrel->nparts);
/*
* Set the consider_partitionwise_join flag.
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index c492685d11..42287100e4 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -22,6 +22,7 @@
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
+#include "nodes/pathnodes.h"
#include "parser/parse_coerce.h"
#include "partitioning/partprune.h"
#include "partitioning/partbounds.h"
@@ -65,6 +66,12 @@ typedef struct PartitionRangeBound
bool lower; /* this is the lower (vs upper) bound */
} PartitionRangeBound;
+typedef struct PartitionMap
+{
+ int from;
+ int to;
+} PartitionMap;
+
static int32 qsort_partition_hbound_cmp(const void *a, const void *b);
static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
void *arg);
@@ -106,7 +113,58 @@ static void get_range_key_properties(PartitionKey key, int keynum,
static List *get_range_nulltest(PartitionKey key);
static bool partition_hbounds_equal(PartitionBoundInfo b1,
PartitionBoundInfo b2);
-
+static PartitionBoundInfo partition_range_bounds_merge(
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype, int partnatts,
+ FmgrInfo *supfuncs, Oid *collations);
+static PartitionBoundInfo partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *collations,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype);
+static PartitionBoundInfo partition_hash_bounds_merge(RelOptInfo *outer_rel,
+ RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype);
+static void generate_matching_part_pairs(PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ int nparts1, int nparts2,
+ JoinType jointype, int nparts,
+ List **parts1, List **parts2);
+static PartitionBoundInfo build_merged_partition_bounds(char strategy,
+ List *merged_datums, List *merged_indexes,
+ List *merged_contents, int null_index,
+ int default_index);
+static int map_and_merge_partitions(PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ int index1, int index2, int *next_index);
+static int32 partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *collations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2);
+static bool partition_range_cmp(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval);
+static bool partition_range_merge_next_lb(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes);
+static bool merge_default_partitions(PartitionBoundInfo outer_bi,
+ PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ JoinType jointype,
+ int *next_index, int *default_index);
+static bool merge_null_partitions(PartitionBoundInfo outer_bi,
+ PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ JoinType jointype,
+ int *next_index, int *null_index,
+ int *default_index);
/*
* get_qual_from_partbound
@@ -2941,3 +2999,1620 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
PG_RETURN_BOOL(rowHash % modulus == remainder);
}
+
+/*
+ * partition_bounds_merge
+ *
+ * The function produces the partition bounds for a join between two relations
+ * whose partition bounds are given. The function also returns two lists of
+ * partition indexes one for each of the joining relations. Both the lists
+ * contain the same number of elements. The partition indexes at the same
+ * positions in the lists indicate the pair partitions, one from each side, to
+ * be joined and the position itself corresponds to the index of partition
+ * produced by that child-join in the partitioned join.
+ *
+ * The function returns NULL if we can not find the matching pair of
+ * partitions. This happens if 1. multiple partitions on one side match with
+ * one partition on the other side. 2. a given partition on the outer side
+ * doesn't have a matching partition on the inner side. We can not support the
+ * first case since we don't have a way to represent multiple partitions as a
+ * single relation (RelOptInfo) and then perform join using the ganged
+ * relation. We can not support the second case since the missing inner
+ * partition needs to be represented as an empty relation and we don't have a
+ * way to introduce empty relation during join planning after creating paths
+ * for all the base relations.
+ */
+extern PartitionBoundInfo
+partition_bounds_merge(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts)
+{
+ PartitionBoundInfo merged_bounds;
+ PartitionBoundInfo outer_binfo = outer_rel->boundinfo,
+ inner_binfo = inner_rel->boundinfo;
+ char strategy = outer_binfo->strategy;
+
+ /* Bail out if partitioning strategies are different. */
+ if (outer_binfo->strategy != inner_binfo->strategy)
+ return NULL;
+
+ if (jointype != JOIN_LEFT && jointype != JOIN_INNER &&
+ jointype != JOIN_SEMI && jointype != JOIN_ANTI &&
+ jointype != JOIN_FULL)
+ elog(ERROR, "unexpected join type %d", jointype);
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+ switch (strategy)
+ {
+ case PARTITION_STRATEGY_LIST:
+ merged_bounds = partition_list_bounds_merge(partsupfunc,
+ partcollation,
+ outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype);
+ break;
+
+ case PARTITION_STRATEGY_RANGE:
+ merged_bounds = partition_range_bounds_merge(outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype, partnatts,
+ partsupfunc,
+ partcollation);
+ break;
+
+ case PARTITION_STRATEGY_HASH:
+ merged_bounds = partition_hash_bounds_merge(outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype);
+ break;
+
+ default:
+ elog(ERROR, "unexpected partition strategy: %d", strategy);
+ }
+
+ Assert(merged_bounds || (*outer_parts == NIL && *inner_parts == NIL));
+
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+
+ Assert((*outer_parts == NIL || *inner_parts != NIL) &&
+ (*inner_parts == NIL || *outer_parts != NIL));
+
+ return merged_bounds;
+}
+
+/*
+ * partition_get_range_bounds
+ *
+ * Given the index of lower bound in datums array, return lower and upper
+ * bounds and the index of the partition with that lower bound.
+ */
+static int
+partition_get_range_bounds(PartitionBoundInfo bi, int lb_index,
+ PartitionRangeBound *lower,
+ PartitionRangeBound *upper)
+{
+ int part_index;
+
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The lower bound should correspond to a valid partition. */
+ part_index = bi->indexes[lb_index + 1];
+ Assert(part_index >= 0);
+
+ lower->kind = bi->kind[lb_index];
+ lower->datums = bi->datums[lb_index];
+ lower->lower = true;
+ upper->kind = bi->kind[lb_index + 1];
+ upper->datums = bi->datums[lb_index + 1];
+ upper->lower = false;
+
+ return part_index;
+}
+
+/*
+ * partition_range_get_next_lb_index
+ *
+ * Given the index of lower bound in datums array return the
+ * index of lower bound of the next partition. When the given index corresponds
+ * to the last partition, return number of datums (ndatums).
+ */
+static int
+partition_range_get_next_lb_index(PartitionBoundInfo bi, int lb_index)
+{
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The partition index corresponding to the upper bound should be valid. */
+ Assert(bi->indexes[lb_index + 1] >= 0);
+
+ /*
+ * If there are no bounds left beyond the upper bound, we have reached the
+ * last partition.
+ */
+ if (lb_index + 2 < bi->ndatums)
+ {
+ /*
+ * If the bound next to the upper bound corresponds to no partition,
+ * that's the next lower bound of the next partition. Otherwise, the
+ * current upper bound is the lower bound of the next partition.
+ */
+ if (bi->indexes[lb_index + 2] < 0)
+ return lb_index + 2;
+ else
+ return lb_index + 1;
+ }
+ else
+ return bi->ndatums;
+}
+
+static int32
+partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2)
+{
+ return partition_rbound_cmp(partnatts, partsupfunc, partcollations,
+ bound1->datums, bound1->kind, bound1->lower,
+ bound2);
+}
+
+/*
+ * partition_range_cmp
+ *
+ * Compare the bounds of two range partitions. Set ub_cmpval <, = or > 0, if the
+ * first partition's upper bound is lower than, equal to or higher than the
+ * second partition's upper bound resp. Similarly set lb_cmpval <, = or > 0,
+ * if the first partition's lower bound is lower than, equal to or higher than
+ * the second partition's lower bound resp.
+ *
+ * Return true, if the ranges overlap, otherwise return false.
+ */
+static bool
+partition_range_cmp(int partnatts, FmgrInfo *partsupfuncs, Oid *partcollations,
+ PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval)
+{
+ bool overlap;
+
+ /*
+ * Compare upper bound of the first partition with the lower bound of the
+ * second and vice-versa. If lower bound is higher than the upper bound,
+ * the partitions are not overlapping. All other cases indicate overlapping
+ * partitions.
+ */
+ if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound1, upper_bound2) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = 1;
+ *lb_cmpval = 1;
+ }
+ else if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound2, upper_bound1) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = -1;
+ *lb_cmpval = -1;
+ }
+ else
+ {
+ overlap = true;
+ *ub_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, upper_bound1,
+ upper_bound2);
+ *lb_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, lower_bound1,
+ lower_bound2);
+ }
+
+ return overlap;
+}
+
+/*
+ * partition_range_merge
+ *
+ * Merge the partition bounds of given two partitions such that the join
+ * between the given two partitions fits merged bounds.
+ *
+ * "merged_upper" will be set to one of the given upper bounds and
+ * "merged_lower" will be set to one of the given lower bounds.
+ */
+static void
+partition_range_merge(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, JoinType jointype,
+ PartitionRangeBound *left_lb,
+ PartitionRangeBound *left_ub,
+ PartitionRangeBound *right_lb,
+ PartitionRangeBound *right_ub,
+ PartitionRangeBound **merged_lb,
+ PartitionRangeBound **merged_ub)
+{
+ /*
+ * An outer join will have all the rows from the outer side, so merged
+ * bounds will be same as the outer bounds. An inner join will have rows
+ * that fit both the bounds, thus lower merged bound will be higher of two
+ * lower bounds and upper merged bound will be lower of the two upper
+ * bounds.
+ */
+ switch (jointype)
+ {
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ *merged_ub = left_ub;
+ *merged_lb = left_lb;
+ break;
+
+ case JOIN_INNER:
+ case JOIN_SEMI:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) < 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) > 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ case JOIN_FULL:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) > 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) < 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ default:
+ elog(ERROR, "unexpected join type %d", jointype);
+ }
+
+ return;
+}
+
+/*
+ * Add the lower bound of the next range to the list of bounds, if the lower
+ * bound is higher or equal to the previous upper bound. If successful return
+ * true, otherwise false.
+ */
+static bool
+partition_range_merge_next_lb(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes)
+{
+ int cmpval;
+
+ if (!*merged_datums)
+ {
+ Assert(!*merged_kinds && !*merged_indexes);
+ cmpval = 1;
+ }
+ else
+ {
+ PartitionRangeBound prev_ub;
+
+ prev_ub.datums = llast(*merged_datums);
+ prev_ub.kind = llast(*merged_kinds);
+ prev_ub.lower = false;
+
+ cmpval = partition_rbound_cmp(partnatts, partsupfuncs, partcollations,
+ next_lb_datums, next_lb_kind, false,
+ &prev_ub);
+ }
+
+ /*
+ * The lower bound is lower than the last upper bound, thus does not fit
+ * the bounds created so far and hence can not be merged with the existing
+ * bounds.
+ */
+ if (cmpval < 0)
+ return false;
+
+ /*
+ * Add bounds of the new merged partition. If the next lower bound is
+ * higher than the last upper bound, add new range with index
+ * corresponding to the lower bound as -1. If the merged lower bound
+ * is same as the last merged upper bound, the last upper bound will be
+ * reused as the lower bound of the next range.
+ */
+ if (cmpval > 0)
+ {
+ *merged_datums = lappend(*merged_datums, next_lb_datums);
+ *merged_kinds = lappend(*merged_kinds, next_lb_kind);
+ *merged_indexes = lappend_int(*merged_indexes, -1);
+ }
+
+ return true;
+}
+
+/*
+ * handle_missing_partition
+ *
+ * If a range appears in one of the joining relations but not the other, a row
+ * in the corresponding partition will not have any join partner in the other
+ * relation, unless the other relation has a default partition. If a given list
+ * value is present in one joining relation but not the other, the default
+ * partition on the other side may contain that value.
+ *
+ * In both these cases, such an extra partition forms a joining pair with the
+ * default partition, if any, on the other side.
+ *
+ * If the default partition happens to be on the outer side of the join, the
+ * resultant partition will act as the default partition of the join relation.
+ * Otherwise the resultant partition will be associated with the range.
+ *
+ * When the default partition is not present in the other relation, the rows in
+ * the extra partition will be included in the bounds of the join result, if it
+ * appears on the outer side of the join, since all rows from the outer side
+ * are included in the join result.
+ *
+ * This function handles all these cases.
+ *
+ * maps_with_missing and missing_side_default are the partition maps (See
+ * partition_range/list_bounds_merge() for details) and the index of default
+ * partition respectively corresponding the side with missing partition.
+ *
+ * maps_with_extra and extra_part are the partition maps (See
+ * partition_range/list_bounds_merge() for details) and the index of extra
+ * partition respectively corresponding to the side with the extra partition.
+ *
+ * It returns true if the matching succeeds, otherwise returns false.
+ */
+static bool
+handle_missing_partition(PartitionMap *maps_with_missing,
+ PartitionMap *maps_with_extra,
+ int missing_side_default,
+ int extra_part,
+ bool missing_side_outer,
+ bool missing_side_inner,
+ int *next_index, int *default_index,
+ int *merged_index)
+{
+ bool missing_has_default = (missing_side_default != -1);
+
+ if (missing_has_default)
+ {
+ *merged_index = map_and_merge_partitions(maps_with_missing,
+ maps_with_extra,
+ missing_side_default,
+ extra_part,
+ next_index);
+ if (*merged_index < 0)
+ return false;
+
+ if (missing_side_outer)
+ {
+ /*
+ * Default partition on the outer side forms the default
+ * partition of the join result.
+ */
+ if (*default_index < 0)
+ *default_index = *merged_index;
+ else if(*default_index != *merged_index)
+ {
+ /*
+ * Ended up with default partition on the outer side
+ * being joined with multiple partitions on the inner
+ * side. We don't support this case.
+ */
+ return false;
+ }
+
+ /*
+ * Since the merged partition acts as a default partition, it
+ * doesn't need a separate index.
+ */
+ *merged_index = -1;
+ }
+ }
+ else if (missing_side_inner)
+ {
+ /*
+ * If this partition has already been mapped (say because we
+ * found an overlapping range earlier), we know where does it
+ * fit in the join result. Nothing to do in that case. Else
+ * create a new merged partition.
+ */
+ PartitionMap *extra_map = &maps_with_extra[extra_part];
+ if (extra_map->to < 0)
+ {
+ extra_map->to = *next_index;
+ *next_index = *next_index + 1;
+ *merged_index = extra_map->to;
+ }
+ }
+
+ return true;
+}
+
+static PartitionMap*
+init_partition_map(RelOptInfo *rel)
+{
+ int i, nparts = rel->nparts;
+ PartitionMap *map;
+
+ map = (PartitionMap *) palloc(sizeof(PartitionMap) * nparts);
+
+ for (i = 0; i < nparts; i++)
+ {
+ map[i].from = -1;
+ map[i].to = -1;
+ }
+
+ return map;
+}
+
+/*
+ * Allocate and initialize partition maps. We maintain four maps, two maps
+ * for each joining relation. pmap[i] gives the partition from the other
+ * relation which would join with ith partition of the given relation.
+ * Partition i from the given relation will join with partition pmap[i]
+ * from the other relation to produce partition mmap[i] of the join (merged
+ * partition).
+ *
+ * pmap[i] = -1 indicates that ith partition of a given relation does not
+ * have a matching partition from the other relation.
+ *
+ * mmap[i] = -1 indicates that ith partition of a given relation does not
+ * contribute to the join result. That can happen only when the given
+ * relation is the inner relation and it doesn't have a matching partition
+ * from the outer relation, hence pmap[i] should be -1.
+ *
+ * In case of an outer join, every partition of the outer join will appear
+ * in the join result, and thus has mmap[i] set for all i. But it's not
+ * necessary that every partition on the outer side will have a matching
+ * partition on the inner side. In such a case, we end up with pmap[i] = -1
+ * and mmap[i] != -1.
+ */
+
+/*
+ * partition_range_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for range partitioned tables.
+ */
+static PartitionBoundInfo
+partition_range_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype, int partnatts,
+ FmgrInfo *partsupfuncs, Oid *partcollations)
+
+{
+ PartitionMap *outer_maps = NULL;
+ PartitionMap *inner_maps = NULL;
+ int outer_part = 0;
+ int inner_part = 0;
+ PartitionBoundInfo merged_bounds = NULL;
+ int outer_lb_index;
+ int inner_lb_index;
+ int next_index;
+ int default_index = -1;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ List *merged_kinds = NIL;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int inner_default = inner_bi->default_index;
+ int outer_default = outer_bi->default_index;
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_RANGE);
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ outer_maps = init_partition_map(outer_rel);
+ inner_maps = init_partition_map(inner_rel);
+
+ /*
+ * Merge the ranges (partitions) from both sides. Every iteration compares
+ * a pair of ranges, one from each side, advancing to the next range from
+ * the side with smaller upper range bound. If upper bounds of ranges from
+ * both sides match exactly, both the sides are advanced. For a given pair
+ * of ranges, we decide whether the corresponding partition match or not.
+ * lb_index, for inner or outer side, keeps track of the index of lower bound
+ * datum in PartitionBoundInfo::datums of that side.
+ */
+ outer_lb_index = 0;
+ inner_lb_index = 0;
+ next_index = 0;
+ while (outer_lb_index < outer_bi->ndatums ||
+ inner_lb_index < inner_bi->ndatums)
+ {
+ PartitionRangeBound outer_lb, outer_ub,
+ inner_lb, inner_ub,
+ *merged_lb = NULL,
+ *merged_ub = NULL;
+
+ int merged_index = -1;
+ bool overlap;
+ bool finished_outer = false;
+ bool finished_inner = false;
+
+ /* Result of bounds comparison per partition_rbound_cmp(). */
+ int ub_cmpval; /* Upper bounds comparison result. */
+ int lb_cmpval; /* Lower bounds comparison result. */
+
+ /* Get the range bounds of the next pair of partitions. */
+ if (outer_lb_index < outer_bi->ndatums)
+ outer_part = partition_get_range_bounds(outer_bi, outer_lb_index,
+ &outer_lb, &outer_ub);
+ else
+ finished_outer = true;
+
+ if (inner_lb_index < inner_bi->ndatums)
+ inner_part = partition_get_range_bounds(inner_bi, inner_lb_index,
+ &inner_lb, &inner_ub);
+ else
+ finished_inner = true;
+
+ Assert(!finished_outer || !finished_inner);
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining partitions on the side
+ * which finishes later. For that we set the comparison parameters
+ * overlap, ub_cmpval and lb_cmpval in such a way that it appears as if
+ * the side which finishes earlier has an extra partition with lower
+ * and upper bounds higher than any other partition of the unfinished
+ * side. That way we advance the partitions on that side till all of
+ * them are exhausted.
+ */
+ if (finished_outer)
+ {
+ overlap = false;
+ ub_cmpval = 1;
+ lb_cmpval = 1;
+ }
+ else if (finished_inner)
+ {
+ overlap = false;
+ ub_cmpval = -1;
+ lb_cmpval = -1;
+ }
+ else
+ overlap = partition_range_cmp(partnatts, partsupfuncs, partcollations,
+ &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &ub_cmpval, &lb_cmpval);
+
+ if (overlap)
+ {
+ /*
+ * The rows from overlapping portion of ranges on both sides may
+ * join, hence the corresponding pair of partitions form a joining
+ * pair. Match them and produce the bounds of the joint partition
+ * and its index by merging the bounds according to the type of
+ * join.
+ */
+ partition_range_merge(partnatts, partsupfuncs, partcollations,
+ jointype, &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &merged_lb, &merged_ub);
+
+ merged_index = map_and_merge_partitions(outer_maps, inner_maps,
+ outer_part, inner_part,
+ &next_index);
+
+ if (merged_index < 0)
+ {
+ /* Failed to match the partitions. */
+ return NULL;
+ }
+
+ /*
+ * If the ranges overlap but don't exactly match, a row from
+ * non-overlapping portion of the range from one side of join may
+ * find its join partner in the previous or next overlapping
+ * partition or default partition on the other side , if such a
+ * partition exists. All those cases, if true, will cause one
+ * partition from that side to match at least two partitions on the
+ * other side; a case that we do not support now. Previous
+ * partition has been delt with in the previous iteration of this
+ * loop, next partition will be delt in the next iteration. We will
+ * deal with the default partition here.
+ */
+ if ((lb_cmpval < 0 && inner_has_default) ||
+ /* Non-overlapping range on the lower side of outer range. */
+ (lb_cmpval > 0 && outer_has_default) ||
+ /* Non-overlapping range on the lower side of inner range. */
+ (ub_cmpval < 0 && outer_has_default) ||
+ /* Non-overlapping range on the upper side of inner range. */
+ (ub_cmpval > 0 && inner_has_default))
+ /* Non-overlapping range on the upper side of outer range. */
+ return NULL;
+ }
+
+ if (ub_cmpval == 0)
+ {
+ /* Upper bounds of both the ranges match. */
+ Assert(overlap);
+
+ /* Move to the next pair of partitions. */
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+ else if (ub_cmpval < 0)
+ {
+ /* Upper bound of inner range higher than that of the outer. */
+
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the inner side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &outer_lb;
+ merged_ub = &outer_ub;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+ if (!handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ outer_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+ }
+
+ /* Move to the next partition on the outer side. */
+ Assert(!finished_outer);
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ }
+ else
+ {
+ Assert(ub_cmpval > 0);
+
+ /* Upper bound of outer range higher than that of the inner. */
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the outer side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &inner_lb;
+ merged_ub = &inner_ub;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ inner_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+ }
+
+ /* Move to the next partition on the inner side. */
+ Assert (!finished_inner);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+
+ if (merged_index < 0)
+ {
+ /* We didn't find a new merged partition. */
+ continue;
+ }
+
+ /*
+ * We have a valid partition index for the next partition of join. The
+ * partition should have valid range.
+ */
+ Assert(merged_lb && merged_ub);
+
+ /* Try merging new lower bound with the last upper bound. */
+ if (!partition_range_merge_next_lb(partnatts, partsupfuncs,
+ partcollations,
+ merged_lb->datums,
+ merged_lb->kind, &merged_datums,
+ &merged_kinds, &merged_indexes))
+ return NULL;
+
+ /* Add upper bound with the merged partition index. */
+ merged_datums = lappend(merged_datums, merged_ub->datums);
+ merged_kinds = lappend(merged_kinds, merged_ub->kind);
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ }
+
+ if (!merge_default_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index,
+ &default_index))
+ return NULL;
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_maps, inner_maps,
+ outer_nparts, inner_nparts,
+ jointype, next_index,
+ outer_parts, inner_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes,
+ merged_kinds,
+ -1, default_index);
+ }
+
+ /* Free any memory we used in this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ list_free(merged_kinds);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_list_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for list partitioned tables.
+ *
+ */
+static PartitionBoundInfo
+partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype)
+{
+ PartitionMap *outer_maps = NULL;
+ PartitionMap *inner_maps = NULL;
+ int cnto;
+ int cnti;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ int next_index = 0;
+ int null_index;
+ int default_index = -1;
+ PartitionBoundInfo merged_bounds = NULL;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int *outer_indexes = outer_bi->indexes;
+ int *inner_indexes = inner_bi->indexes;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_LIST);
+
+ /* List partitions do not require unbounded ranges. */
+ Assert(!outer_bi->kind && !inner_bi->kind);
+
+ outer_maps = init_partition_map(outer_rel);
+ inner_maps = init_partition_map(inner_rel);
+
+ /*
+ * Merge the list value datums from both sides. Every iteration compares a
+ * pair of datums, one from each side, advancing to the next datum from the
+ * side with smaller datum. If datums from both sides match exactly, both
+ * the sides are advanced. For a given pair of datums, we decide whether
+ * the corresponding partition match or not.
+ */
+ cnto = cnti = 0;
+ while (cnto < outer_bi->ndatums || cnti < inner_bi->ndatums)
+ {
+ Datum *odatums;
+ Datum *idatums;
+ int o_index;
+ int i_index;
+ int cmpval;
+ int merged_index = -1;
+ Datum *merged_datum;
+ bool finished_inner;
+ bool finished_outer;
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining datums on the side which
+ * finishes later. For that we set the comparison parameter cmpval in
+ * such a way that it appears as if the side which finishes earlier has
+ * an extra datum higher than any other datum on the unfinished side.
+ * That way we advance the datums on the unfinished side till all of
+ * its datums are exhausted.
+ */
+ if (cnto >= outer_bi->ndatums)
+ {
+ finished_outer = true;
+ odatums = NULL;
+ o_index = -1;
+ }
+ else
+ {
+ finished_outer = false;
+ odatums = outer_bi->datums[cnto];
+ o_index = outer_indexes[cnto];
+ }
+
+ if (cnti >= inner_bi->ndatums)
+ {
+ finished_inner = true;
+ idatums = NULL;
+ i_index = -1;
+ }
+ else
+ {
+ finished_inner = false;
+ idatums = inner_bi->datums[cnti];
+ i_index = inner_indexes[cnti];
+ }
+
+ /* If we exhausted both the sides, we won't enter the loop. */
+ Assert(!finished_inner || !finished_outer);
+
+ if (finished_outer)
+ cmpval = 1;
+ else if (finished_inner)
+ cmpval = -1;
+ else
+ {
+ /* Every list datum should map to a valid partition index. */
+ Assert(o_index >= 0 && i_index >= 0 &&
+ odatums != NULL && idatums != NULL);
+
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
+ partcollation[0],
+ odatums[0], idatums[0]));
+ }
+
+ if (cmpval == 0)
+ {
+ /*
+ * Datums match. Rows on either side with these datums as partition
+ * key value will join and will be part of the partition of the
+ * join result produced by joining the corresponding partitions.
+ * Match the corresponding partitions and if successful, add the
+ * datum to the list of merged datums with index of merged
+ * partition containing it.
+ */
+ merged_datum = odatums;
+ merged_index = map_and_merge_partitions(outer_maps, inner_maps,
+ o_index, i_index,
+ &next_index);
+
+ if (merged_index < 0)
+ return NULL;
+
+ /* Move to the next pair of bounds. */
+ cnto++;
+ cnti++;
+ }
+ else if (cmpval < 0)
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /* A datum missing from the inner side. */
+ merged_index = -1;
+ merged_datum = odatums;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ o_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+
+ /* Move to the next datum on the outer side. */
+ Assert(!finished_outer);
+ cnto++;
+ }
+ else
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ Assert(cmpval > 0);
+
+ /* A datum missing from the outer side. */
+ merged_index = -1;
+ merged_datum = idatums;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ i_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+
+ /* Move to the next datum on the right side. */
+ Assert(!finished_inner);
+ cnti++;
+ }
+
+ /*
+ * Add the list value with appropriate index in the list of datums, if
+ * we have associated a partition with this list value.
+ */
+ if (merged_index >= 0)
+ {
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ merged_datums = lappend(merged_datums, merged_datum);
+ }
+ }
+
+ if (!merge_null_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index, &null_index,
+ &default_index))
+ return NULL;
+
+ if (!merge_default_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index,
+ &default_index))
+ return NULL;
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_maps, inner_maps,
+ outer_nparts, inner_nparts,
+ jointype, next_index,
+ outer_parts, inner_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes, NIL,
+ null_index, default_index);
+ }
+
+ /* Free up all extra memory before returning from this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_bounds_merge()'s arm for hash partitioned tables.
+ *
+ * If the given two hash bounds are same, the function returns the first one
+ * without any change, alongwith the lists of matching partitions. Otherwise it
+ * returns NULL.
+ *
+ * We could try merging the bounds when both the bounds have same greatest
+ * modulii. But there seems to be hardly any requirement for the same.
+ */
+static PartitionBoundInfo
+partition_hash_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype)
+{
+ int nparts;
+ int cnt;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * Hash partitioned table does not have explicit NULL accepting partition
+ * and also does not have a default partition.
+ */
+ Assert(!partition_bound_has_default(outer_bi) &&
+ !partition_bound_has_default(inner_bi));
+ Assert(!partition_bound_accepts_nulls(outer_bi) &&
+ !partition_bound_accepts_nulls(inner_bi));
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+
+ if (outer_nparts != inner_nparts)
+ return NULL;
+ nparts = outer_nparts;
+
+ if (outer_bi->ndatums != inner_bi->ndatums ||
+ !partition_hbounds_equal(outer_bi, inner_bi))
+ return NULL;
+
+ /*
+ * Cook up list of matching partitions. Since bounds are exactly same the
+ * partitions at the same position from both the relations match.
+ */
+ for (cnt = 0; cnt < nparts; cnt++)
+ {
+ *outer_parts = lappend_int(*outer_parts, cnt);
+ *inner_parts = lappend_int(*inner_parts, cnt);
+ }
+
+ return outer_bi;
+}
+
+/*
+ * map_and_merge_partitions
+ *
+ * If the two given partitions (given by index1 and index2 resp.) are
+ * already mapped to each other return the index of corresponding partition in
+ * the merged set of partitions. If they do not have a merged partition
+ * associated with them, assign a new merged partition index. If the
+ * partitions are already mapped and their mapped partitions are different from
+ * each other, they can not be merged, so return -1.
+ *
+ * partmaps1[i] gives the mapping of partitions for both relations. It
+ * describes which partition of relation 2 matches ith partition of relation 1,
+ * and which partition in the merged set matches ith partition of relation 1
+ * maps to. Similarly for partmap2.
+ *
+ * index1 and index2 are the indexes of matching partition from respective
+ * relations.
+ *
+ * *next_index is used and incremented when the given partitions require a new
+ * merged partition.
+ */
+
+static int
+map_and_merge_partitions(PartitionMap *partmaps1, PartitionMap *partmaps2,
+ int index1, int index2, int *next_index)
+{
+ PartitionMap *partmap1 = &partmaps1[index1];
+ PartitionMap *partmap2 = &partmaps2[index2];
+ int merged_index;
+
+ /*
+ * If both the partitions are not mapped to each other, update the
+ * maps.
+ */
+ if (partmap1->from < 0 && partmap2->from < 0)
+ {
+ partmap1->from = index2;
+ partmap2->from = index1;
+ }
+
+ /*
+ * If the given to partitions map to each other, find the corresponding
+ * merged partition index .
+ */
+ if (partmap1->from == index2 && partmap2->from == index1)
+ {
+ /*
+ * If both the partitions are mapped to the same merged partition, get
+ * the index of merged partition.
+ */
+ if (partmap1->to == partmap2->to)
+ {
+ merged_index = partmap1->to;
+
+ /*
+ * If the given two partitions do not have a merged partition
+ * associated with them, allocate a new merged partition.
+ */
+ if (merged_index < 0)
+ {
+ merged_index = *next_index;
+ *next_index = *next_index + 1;
+ partmap1->to = merged_index;
+ partmap2->to = merged_index;
+ }
+ }
+
+ /*
+ * If partition from one relation was mapped to a merged partition but
+ * not the partition from the other relation, map the same merged
+ * partition to the partition from other relation, since matching
+ * partitions map to the same merged partition.
+ */
+ else if (partmap1->to >= 0 && partmap2->to < 0)
+ {
+ partmap2->to = partmap1->to;
+ merged_index = partmap1->to;
+ }
+ else if (partmap1->to < 0 && partmap2->to >= 0)
+ {
+ partmap1->to = partmap2->to;
+ merged_index = partmap2->to;
+ }
+ else
+ {
+ Assert(partmap1->to != partmap2->to &&
+ partmap1->to >= 0 && partmap2->to >= 0);
+
+ /*
+ * Both the partitions map to different merged partitions. This
+ * means that multiple partitions from one relation matches to one
+ * partition from the other relation. Partition-wise join does not
+ * handle this case right now, since it requires ganging multiple
+ * partitions together (into one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+ }
+ else
+ {
+ /*
+ * Multiple partitions from one relation map to one partition from the
+ * other relation. Partition-wise join does not handle this case right
+ * now, since it requires ganging multiple partitions together (into
+ * one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+
+ return merged_index;
+}
+
+/*
+ * generate_matching_part_pairs
+ *
+ * partmaps1 map each partition from either side of the join to a merged
+ * partition resp. E.g. partmaps1[i].to gives the merged partition to which ith
+ * partition of first relation maps. Similarly for partmap2. If
+ * partmaps1[i].to == partmaps2[j].to, i and j form the matching pair of
+ * partitions.
+ *
+ * Given these maps this function produces the list pairs of partitions which
+ * when joined produce the merged partitions in the order of merged partition
+ * indexes.
+ *
+ * nparts1 and nparts2 are the number of partitions of the joining relations
+ * resp.
+ *
+ * nparts is the number of merged partitions.
+ *
+ * If successful, the pairs of partitions are returned as two separate lists,
+ * parts1 and parts2 resp., one for each side. Otherwise, those lists will be
+ * set to NIL.
+ */
+static void
+generate_matching_part_pairs(PartitionMap *partmaps1, PartitionMap *partmaps2,
+ int nparts1, int nparts2,
+ JoinType jointype, int nparts,
+ List **matched_parts1, List **matched_parts2)
+{
+ bool merged = true;
+ int *matching1 = (int *) palloc(sizeof(int) * nparts),
+ *matching2 = (int *) palloc(sizeof(int) * nparts);
+ int i;
+
+ *matched_parts1 = NIL;
+ *matched_parts2 = NIL;
+
+ /* Set pairs of matching partitions. */
+ for (i = 0; i < nparts; i++)
+ {
+ if (i >= nparts1)
+ matching1[i] = -1;
+ else
+ {
+ PartitionMap outer_map = partmaps1[i];
+
+ if (outer_map.to >= 0)
+ {
+ Assert(outer_map.to < nparts);
+ matching1[outer_map.to] = i;
+ }
+ }
+
+ if (i >= nparts2)
+ matching2[i] = -1;
+ else
+ {
+ PartitionMap inner_map = partmaps2[i];
+
+ if (inner_map.to >= 0)
+ {
+ Assert(inner_map.to < nparts);
+ matching2[inner_map.to] = i;
+ }
+ }
+ }
+
+ /*
+ * If we have a partition missing on an inner side, we need to add a dummy
+ * relation which joins with the outer partition. If the inner relation
+ * happens to be a base relation, it will require adding a dummy child
+ * base relation during join processing. Right now, we freeze the base
+ * relation arrays like PlannerInfo::simple_rte_array after planning for
+ * base relations. Adding a new (dummy) base relation would require some
+ * changes to that. So, right now, we do not implement partition-wise join
+ * in such cases.
+ */
+ for (i = 0; i < nparts; i++)
+ {
+ int part1 = matching1[i];
+ int part2 = matching2[i];
+
+ /* At least one of the partitions should exist. */
+ Assert(part1 >= 0 || part2 >= 0);
+
+ switch (jointype)
+ {
+ case JOIN_INNER:
+ case JOIN_SEMI:
+
+ /*
+ * An inner or semi join can not return any row when the
+ * matching partition on either side is missing. We should
+ * have eliminated all such cases while merging the bounds.
+ */
+ Assert(part1 >= 0 && part2 >= 0);
+ break;
+
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ Assert(part1 >= 0);
+ if (part2 < 0)
+ merged = false;
+ break;
+
+ case JOIN_FULL:
+ if (part1 < 0 || part2 < 0)
+ merged = false;
+ break;
+
+ default:
+ elog(ERROR, "unrecognized join type: %d", (int) jointype);
+ }
+
+ if (!merged)
+ break;
+
+ *matched_parts1 = lappend_int(*matched_parts1, part1);
+ *matched_parts2 = lappend_int(*matched_parts2, part2);
+ }
+
+ pfree(matching1);
+ pfree(matching2);
+
+ if (!merged)
+ {
+ list_free(*matched_parts1);
+ list_free(*matched_parts2);
+ *matched_parts1 = NIL;
+ *matched_parts2 = NIL;
+ }
+}
+
+static PartitionBoundInfo
+build_merged_partition_bounds(char strategy, List *merged_datums,
+ List *merged_indexes, List *merged_kinds,
+ int null_index, int default_index)
+{
+ int cnt;
+ PartitionBoundInfo merged_bounds;
+ ListCell *lc;
+
+ /* We expect the same number of elements in datums and indexes lists. */
+ Assert(list_length(merged_datums) == list_length(merged_indexes));
+
+ merged_bounds = (PartitionBoundInfo) palloc(sizeof(PartitionBoundInfoData));
+ merged_bounds->strategy = strategy;
+ merged_bounds->ndatums = list_length(merged_datums);
+
+ if (strategy == PARTITION_STRATEGY_RANGE)
+ {
+ Assert(list_length(merged_datums) == list_length(merged_kinds));
+ merged_bounds->kind =
+ (PartitionRangeDatumKind **) palloc(sizeof(PartitionRangeDatumKind *) *
+ list_length(merged_kinds));
+ cnt = 0;
+ foreach(lc, merged_kinds)
+ merged_bounds->kind[cnt++] = lfirst(lc);
+
+ /* There are ndatums+1 indexes in case of range partitions */
+ merged_indexes = lappend_int(merged_indexes, -1);
+ }
+ else
+ merged_bounds->kind = NULL;
+
+ cnt = 0;
+ merged_bounds->datums = (Datum **) palloc(sizeof(Datum *) *
+ list_length(merged_datums));
+ foreach(lc, merged_datums)
+ merged_bounds->datums[cnt++] = lfirst(lc);
+
+ merged_bounds->indexes = (int *) palloc(sizeof(int) *
+ list_length(merged_indexes));
+ cnt = 0;
+ foreach(lc, merged_indexes)
+ merged_bounds->indexes[cnt++] = lfirst_int(lc);
+
+ merged_bounds->null_index = null_index;
+ merged_bounds->default_index = default_index;
+
+ return merged_bounds;
+}
+
+/*
+ * Merge default partitions from both sides, if any, and assign the default
+ * partition for the join result, if necessary.
+ *
+ * If both the relations have default partitions, try mapping those to each
+ * other. If the mapping succeeds corresponding merged partition will act as
+ * the default partition of the join result.
+ *
+ * If inner side of the join has default but not the outer side, rows in it
+ * won't appear in the join result. So don't create a default partition. If
+ * outer side of the join has default but not the inner side, rows in it will
+ * appear in the join result, so create a default merged partition.
+ */
+static bool
+merge_default_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps, PartitionMap *inner_maps,
+ JoinType jointype, int *next_index, int *default_index)
+{
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool merged = true;
+ PartitionMap *outer_default_map = NULL;
+ PartitionMap *inner_default_map = NULL;
+
+ if (outer_has_default)
+ outer_default_map = &outer_maps[outer_default];
+
+ if (inner_has_default)
+ inner_default_map = &inner_maps[inner_default];
+
+ if (!outer_has_default && !inner_has_default)
+ Assert(*default_index < 0);
+ else if (outer_default_map != NULL && inner_default_map == NULL)
+ {
+ if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (outer_default_map->to < 0)
+ {
+ outer_default_map->to = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = outer_default_map->to;
+ }
+ else
+ Assert(*default_index == outer_default_map->to);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else if (outer_default_map == NULL && inner_default_map != NULL)
+ {
+ if (jointype == JOIN_FULL)
+ {
+ if (inner_default_map->to < 0)
+ {
+ inner_default_map->to = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = inner_default_map->to;
+ }
+ else
+ Assert(*default_index == inner_default_map->to);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else
+ {
+ Assert(outer_has_default && inner_has_default);
+
+ *default_index = map_and_merge_partitions(outer_maps, inner_maps,
+ outer_default, inner_default,
+ next_index);
+
+ if (*default_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
+
+/*
+ * merge_null_partitions
+ *
+ * Merge NULL partitions, i.e. a partition that can hold NULL values for a list
+ * partitioned table, if any. Find the index of merged partition to which the
+ * NULL values would belong in the join result. If one joining relation has a
+ * NULL partition but not the other, try matching it with the default partition
+ * from the other relation since the default partition may have rows with NULL
+ * partition key. We can eliminate a NULL partition when it appears only on the
+ * inner side of the join and the outer side doesn't have a default partition.
+ *
+ * When the equality operator used for join is strict, two NULL values will not
+ * be considered as equal, and thus a NULL partition can be eliminated for an
+ * inner join. But we don't check the strictness operator here.
+ */
+static bool
+merge_null_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps, PartitionMap *inner_maps,
+ JoinType jointype, int *next_index,
+ int *null_index, int *default_index)
+{
+ bool outer_has_null = partition_bound_accepts_nulls(outer_bi);
+ bool inner_has_null = partition_bound_accepts_nulls(inner_bi);
+ int outer_ni = outer_bi->null_index;
+ int inner_ni = inner_bi->null_index;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool merged = true;
+
+ if (!outer_has_null && !inner_has_null)
+ *null_index = -1;
+ else if (outer_has_null && !inner_has_null)
+ {
+ int merged_index;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+
+ merged = handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ outer_ni,
+ missing_side_outer,
+ missing_side_inner, next_index,
+ default_index, &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join to which the outer null partition maps
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = outer_maps[outer_ni].to;
+ }
+ else if (!outer_has_null && inner_has_null)
+ {
+ int merged_index;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as OUTER
+ * relation. For INNER and SEMI join OUTER and INNER differentiation is
+ * immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+ merged = handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ inner_ni,
+ missing_side_outer,
+ missing_side_inner,
+ next_index, default_index,
+ &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join, to which the outer side null partition maps,
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = inner_maps[inner_ni].to;
+ }
+ else
+ {
+ /* Both the relations have NULL partitions, try merging them. */
+ *null_index = map_and_merge_partitions(outer_maps,
+ inner_maps,
+ outer_ni,
+ inner_ni,
+ next_index);
+ if (*null_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
diff --git a/src/include/partitioning/partbounds.h b/src/include/partitioning/partbounds.h
index b1ae39ad63..fb2dc1cbb1 100644
--- a/src/include/partitioning/partbounds.h
+++ b/src/include/partitioning/partbounds.h
@@ -16,6 +16,7 @@
#include "nodes/pg_list.h"
#include "partitioning/partdefs.h"
#include "utils/relcache.h"
+struct RelOptInfo; /* avoid including pathnodes.h here */
/*
@@ -107,5 +108,11 @@ extern int partition_range_datum_bsearch(FmgrInfo *partsupfunc,
int nvalues, Datum *values, bool *is_equal);
extern int partition_hash_bsearch(PartitionBoundInfo boundinfo,
int modulus, int remainder);
+extern PartitionBoundInfo partition_bounds_merge(int partnatts,
+ FmgrInfo *partsupfunc, Oid *partcollation,
+ struct RelOptInfo *outer_rel,
+ struct RelOptInfo *inner_rel,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts);
#endif /* PARTBOUNDS_H */
--
2.18.0
[application/octet-stream] 0003-Tests-for-0-1-1-1-and-1-0-partition-matching-v18.patch (213.3K, ../../CAAJ_b94O7pphWZ1LkJ7tygyzH-h+EBrvc_ahuktmW7u3s2v0BQ@mail.gmail.com/5-0003-Tests-for-0-1-1-1-and-1-0-partition-matching-v18.patch)
download | inline diff:
From 2529b4613ffcf2e7683e3d279f3a363c7d8647ca Mon Sep 17 00:00:00 2001
From: Etsuro Fujita <efujita@postgresql.org>
Date: Thu, 31 Jan 2019 20:31:17 +0900
Subject: [PATCH 3/3] Tests for 0:1, 1:1 and 1:0 partition matching
Rajkumar Raghuvanshi and Ashutosh Bapat.
---
src/test/regress/expected/partition_join.out | 3955 +++++++++++++++---
src/test/regress/sql/partition_join.sql | 427 +-
2 files changed, 3767 insertions(+), 615 deletions(-)
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index c55de5d476..f19611c853 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -8,59 +8,86 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(21 rows)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
-(4 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+(7 rows)
-- left outer join, with whole-row reference; partitionwise join does not apply
EXPLAIN (COSTS OFF)
@@ -72,35 +99,50 @@ SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(22 rows)
SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- t1 | t2
---------------+--------------
- (0,0,0000) | (0,0,0000)
- (50,0,0050) |
- (100,0,0100) |
- (150,0,0150) | (0,150,0150)
- (200,0,0200) |
- (250,0,0250) |
- (300,0,0300) | (0,300,0300)
- (350,0,0350) |
- (400,0,0400) |
- (450,0,0450) | (0,450,0450)
- (500,0,0500) |
- (550,0,0550) |
-(12 rows)
+ t1 | t2
+----------------+----------------
+ (-250,0,-0250) |
+ (-200,0,-0200) |
+ (-150,0,-0150) | (0,-150,-0150)
+ (-100,0,-0100) |
+ (-50,0,-0050) |
+ (0,0,0000) | (0,0,0000)
+ (50,0,0050) |
+ (100,0,0100) |
+ (150,0,0150) | (0,150,0150)
+ (200,0,0200) |
+ (250,0,0250) |
+ (300,0,0300) | (0,300,0300)
+ (350,0,0350) |
+ (400,0,0400) |
+ (450,0,0450) | (0,450,0450)
+ (500,0,0500) |
+ (550,0,0550) |
+ (600,0,0600) | (0,600,0600)
+ (650,0,0650) |
+ (700,0,0700) |
+ (750,0,0750) | (0,750,0750)
+(21 rows)
-- right outer join
EXPLAIN (COSTS OFF)
@@ -112,35 +154,53 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHE
-> Append
-> Hash Right Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Right Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Hash Right Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-> Nested Loop Left Join
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p3 t2_3
Filter: (a = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t2_2.b)
-(20 rows)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
- | | 75 | 0075
- | | 225 | 0225
- | | 375 | 0375
- | | 525 | 0525
-(8 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+ | | -225 | -0225
+ | | -75 | -0075
+ | | 75 | 0075
+ | | 225 | 0225
+ | | 375 | 0375
+ | | 525 | 0525
+ | | 675 | 0675
+(14 rows)
-- full outer join, with placeholder vars
EXPLAIN (COSTS OFF)
@@ -148,8 +208,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
QUERY PLAN
------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b
+ Sort Key: prt1_p0.a, prt2_p0.b
-> Append
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ Filter: (((50) = prt1_p0.a) OR ((75) = prt2_p0.b))
+ -> Seq Scan on prt1_p0
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p1.a = prt2_p1.b)
Filter: (((50) = prt1_p1.a) OR ((75) = prt2_p1.b))
@@ -174,7 +242,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
-> Hash
-> Seq Scan on prt2_p3
Filter: (a = 0)
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ Filter: (((50) = prt1_p4.a) OR ((75) = prt2_p4.b))
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) WHERE t1.phv = t1.a OR t2.phv = t2.b ORDER BY t1.a, t2.b;
a | c | b | c
@@ -211,8 +287,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Hash Left Join
+ Hash Cond: (prt1_p0.a = b)
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Hash
+ -> Result
+ One-Time Filter: false
-> Hash Left Join
Hash Cond: (prt1_p1.a = b)
-> Seq Scan on prt1_p1
@@ -227,29 +310,42 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
-> Hash
-> Seq Scan on prt1_p2
Filter: ((a < 450) AND (b = 0))
-(17 rows)
+(24 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
-(9 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+(14 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
QUERY PLAN
------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = b)
+ Filter: ((prt1_p0.b = 0) OR (a = 0))
+ -> Seq Scan on prt1_p0
+ Filter: (a < 450)
+ -> Hash
+ -> Result
+ One-Time Filter: false
-> Hash Full Join
Hash Cond: (prt1_p1.a = b)
Filter: ((prt1_p1.b = 0) OR (a = 0))
@@ -274,64 +370,153 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JO
-> Hash
-> Result
One-Time Filter: false
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt2_p4.b = a)
+ Filter: ((b = 0) OR (prt2_p4.a = 0))
+ -> Seq Scan on prt2_p4
+ Filter: (b > 250)
+ -> Hash
+ -> Result
+ One-Time Filter: false
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
- | | 375 | 0375
- | | 450 | 0450
- | | 525 | 0525
-(12 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ | | 375 | 0375
+ | | 450 | 0450
+ | | 525 | 0525
+ | | 600 | 0600
+ | | 675 | 0675
+ | | 750 | 0750
+(20 rows)
-- Semi-join
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Semi Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Semi Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Nested Loop Semi Join
- Join Filter: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Materialize
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-(24 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(39 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p0 t2
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_2.b = t2_2.a)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p2 t2_2
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: (t1_3.b = t2_3.a)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt1_p3 t2_3
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.b = t2_4.a)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p4 t2_4
+ Filter: (b = 0)
+(37 rows)
+
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
@@ -342,27 +527,82 @@ SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS
-> Append
-> Hash Anti Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash Anti Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash Anti Join
Hash Cond: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p3 t2_2
-(17 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash Anti Join
+ Hash Cond: (t1_3.a = t2_3.b)
+ -> Seq Scan on prt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_3
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(27 rows)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
- sum | avg | sum | avg
--------+----------------------+------+---------------------
- 60000 | 300.0000000000000000 | 2400 | 12.0000000000000000
+ sum | avg | sum | avg
+-------+----------------------+------+--------------------
+ 95550 | 273.0000000000000000 | 2200 | 6.2857142857142857
(1 row)
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ QUERY PLAN
+--------------------------------------------------------------
+ Append
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Hash Anti Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(27 rows)
+
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ b | c
+------+-------
+ -225 | -0225
+ -75 | -0075
+ 75 | 0075
+ 225 | 0225
+ 375 | 0375
+ 525 | 0525
+ 675 | 0675
+(7 rows)
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -374,49 +614,74 @@ SELECT * FROM prt1 t1 LEFT JOIN LATERAL
Sort Key: t1.a
-> Append
-> Nested Loop Left Join
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p1_a on prt1_p1 t2
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
Index Cond: (a = t1.a)
- -> Index Scan using iprt2_p1_b on prt2_p1 t3
+ -> Index Scan using iprt2_p0_b on prt2_p0 t3
Index Cond: (b = t2.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_1
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
Index Cond: (a = t1_1.a)
- -> Index Scan using iprt2_p2_b on prt2_p2 t3_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t3_1
Index Cond: (b = t2_1.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_2
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
Index Cond: (a = t1_2.a)
- -> Index Scan using iprt2_p3_b on prt2_p3 t3_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t3_2
Index Cond: (b = t2_2.a)
-(27 rows)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.a)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t3_3
+ Index Cond: (b = t2_3.a)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.a)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t3_4
+ Index Cond: (b = t2_4.a)
+(43 rows)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, least(t1.a,t2.a,t3.b) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.a = ss.t2a WHERE t1.b = 0 ORDER BY t1.a;
- a | b | c | t2a | t3a | least
------+---+------+-----+-----+-------
- 0 | 0 | 0000 | 0 | 0 | 0
- 50 | 0 | 0050 | | |
- 100 | 0 | 0100 | | |
- 150 | 0 | 0150 | 150 | 0 | 150
- 200 | 0 | 0200 | | |
- 250 | 0 | 0250 | | |
- 300 | 0 | 0300 | 300 | 0 | 300
- 350 | 0 | 0350 | | |
- 400 | 0 | 0400 | | |
- 450 | 0 | 0450 | 450 | 0 | 450
- 500 | 0 | 0500 | | |
- 550 | 0 | 0550 | | |
-(12 rows)
+ a | b | c | t2a | t3a | least
+------+---+-------+------+-----+-------
+ -250 | 0 | -0250 | | |
+ -200 | 0 | -0200 | | |
+ -150 | 0 | -0150 | -150 | 0 | -150
+ -100 | 0 | -0100 | | |
+ -50 | 0 | -0050 | | |
+ 0 | 0 | 0000 | 0 | 0 | 0
+ 50 | 0 | 0050 | | |
+ 100 | 0 | 0100 | | |
+ 150 | 0 | 0150 | 150 | 0 | 150
+ 200 | 0 | 0200 | | |
+ 250 | 0 | 0250 | | |
+ 300 | 0 | 0300 | 300 | 0 | 300
+ 350 | 0 | 0350 | | |
+ 400 | 0 | 0400 | | |
+ 450 | 0 | 0450 | 450 | 0 | 450
+ 500 | 0 | 0500 | | |
+ 550 | 0 | 0550 | | |
+ 600 | 0 | 0600 | 600 | 0 | 600
+ 650 | 0 | 0650 | | |
+ 700 | 0 | 0700 | | |
+ 750 | 0 | 0750 | 750 | 0 | 750
+(21 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
@@ -430,64 +695,95 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
Hash Cond: ((t1.c)::text = (t2.c)::text)
Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Hash Join
Hash Cond: (t2.a = t3.b)
- -> Seq Scan on prt1_p1 t2
+ -> Seq Scan on prt1_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t3
+ -> Seq Scan on prt2_p0 t3
-> Hash Join
Hash Cond: (t2_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t2_1
+ -> Seq Scan on prt1_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p1 t3_1
-> Hash Join
Hash Cond: (t2_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p2 t2_2
-> Hash
- -> Seq Scan on prt2_p3 t3_2
-(26 rows)
+ -> Seq Scan on prt2_p2 t3_2
+ -> Hash Join
+ Hash Cond: (t2_3.a = t3_3.b)
+ -> Seq Scan on prt1_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t3_3
+ -> Hash Join
+ Hash Cond: (t2_4.a = t3_4.b)
+ -> Seq Scan on prt1_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t3_4
+(38 rows)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, t2.b t2b, t2.c t2c, least(t1.a,t2.a,t3.a) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.c = ss.t2c WHERE (t1.b + coalesce(ss.t2b, 0)) = 0 ORDER BY t1.a;
- a | t2a | t2c
------+-----+------
- 0 | 0 | 0000
- 50 | |
- 100 | |
- 150 | 150 | 0150
- 200 | |
- 250 | |
- 300 | 300 | 0300
- 350 | |
- 400 | |
- 450 | 450 | 0450
- 500 | |
- 550 | |
-(12 rows)
+ a | t2a | t2c
+------+------+-------
+ -250 | |
+ -200 | |
+ -150 | -150 | -0150
+ -100 | |
+ -50 | |
+ 0 | 0 | 0000
+ 50 | |
+ 100 | |
+ 150 | 150 | 0150
+ 200 | |
+ 250 | |
+ 300 | 300 | 0300
+ 350 | |
+ 400 | |
+ 450 | 450 | 0450
+ 500 | |
+ 550 | |
+ 600 | 600 | 0600
+ 650 | |
+ 700 | |
+ 750 | 750 | 0750
+(21 rows)
--
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
@@ -498,32 +794,49 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 =
-> Append
-> Hash Join
Hash Cond: (((t2.b + t2.a) / 2) = ((t1.a + t1.b) / 2))
- -> Seq Scan on prt2_e_p1 t2
+ -> Seq Scan on prt2_e_p0 t2
-> Hash
- -> Seq Scan on prt1_e_p1 t1
+ -> Seq Scan on prt1_e_p0 t1
Filter: (c = 0)
-> Hash Join
- Hash Cond: (((t2_1.b + t2_1.a) / 2) = ((t1_1.a + t1_1.b) / 2))
- -> Seq Scan on prt2_e_p2 t2_1
+ Hash Cond: (((t1_1.a + t1_1.b) / 2) = ((t2_1.b + t2_1.a) / 2))
+ -> Seq Scan on prt1_e_p1 t1_1
+ Filter: (c = 0)
-> Hash
- -> Seq Scan on prt1_e_p2 t1_1
- Filter: (c = 0)
+ -> Seq Scan on prt2_e_p1 t2_1
-> Hash Join
Hash Cond: (((t2_2.b + t2_2.a) / 2) = ((t1_2.a + t1_2.b) / 2))
- -> Seq Scan on prt2_e_p3 t2_2
+ -> Seq Scan on prt2_e_p2 t2_2
-> Hash
- -> Seq Scan on prt1_e_p3 t1_2
+ -> Seq Scan on prt1_e_p2 t1_2
Filter: (c = 0)
-(21 rows)
+ -> Hash Join
+ Hash Cond: (((t2_3.b + t2_3.a) / 2) = ((t1_3.a + t1_3.b) / 2))
+ -> Seq Scan on prt2_e_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t1_3
+ Filter: (c = 0)
+ -> Hash Join
+ Hash Cond: (((t2_4.b + t2_4.a) / 2) = ((t1_4.a + t1_4.b) / 2))
+ -> Seq Scan on prt2_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_4
+ Filter: (c = 0)
+(33 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 150 | 0 | 150 | 0
- 300 | 0 | 300 | 0
- 450 | 0 | 450 | 0
-(4 rows)
+ a | c | b | c
+------+---+------+---
+ -250 | 0 | -250 | 0
+ -100 | 0 | -100 | 0
+ 0 | 0 | 0 | 0
+ 0 | 0 | 0 | 0
+ 150 | 0 | 150 | 0
+ 300 | 0 | 300 | 0
+ 450 | 0 | 450 | 0
+ 600 | 0 | 600 | 0
+ 750 | 0 | 750 | 0
+(9 rows)
--
-- N-way join
@@ -536,154 +849,232 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = ((t3.a + t3.b) / 2))
+ Join Filter: (t1.a = t2.b)
-> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p1_ab2 on prt1_e_p1 t3
- Index Cond: (((a + b) / 2) = t2.b)
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
+ Index Cond: (b = ((t3.a + t3.b) / 2))
-> Nested Loop
Join Filter: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_1
+ -> Index Scan using iprt1_e_p4_ab2 on prt1_e_p1 t3_1
Index Cond: (((a + b) / 2) = t2_1.b)
-> Nested Loop
Join Filter: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_2
Index Cond: (((a + b) / 2) = t2_2.b)
-(33 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = ((t3_3.a + t3_3.b) / 2))
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (((a + b) / 2) = t2_3.b)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t2_4.b)
+ -> Hash Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (b = ((t3_4.a + t3_4.b) / 2))
+(52 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t3 WHERE t1.a = t2.b AND t1.a = (t3.a + t3.b)/2 AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
-(4 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(8 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
---------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Hash Right Join
Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_1.a + t3_1.b) / 2) = t1_1.a)
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
-> Hash
-> Hash Right Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_2.a + t3_2.b) / 2) = t1_2.a)
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
-> Hash
-> Hash Right Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(33 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (t1_3.a = ((a + b) / 2))
+ -> Hash Right Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(51 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
--------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1.a = ((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
Index Cond: (t1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t2_1
Index Cond: (t1_1.a = b)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t2_2
Index Cond: (t1_2.a = b)
-(30 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t3_3.a + t3_3.b) / 2))
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Nested Loop Left Join
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = ((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (t1_4.a = b)
+(47 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- Cases with non-nullable expressions in subquery results;
-- make sure these go to null as expected
@@ -692,21 +1083,34 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
QUERY PLAN
----------------------------------------------------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b, ((prt1_e_p1.a + prt1_e_p1.b))
+ Sort Key: prt1_p0.a, prt2_p0.b, ((prt1_e_p0.a + prt1_e_p0.b))
-> Append
-> Hash Full Join
- Hash Cond: (prt1_p1.a = ((prt1_e_p1.a + prt1_e_p1.b) / 2))
- Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ Hash Cond: (prt1_p0.a = ((prt1_e_p0.a + prt1_e_p0.b) / 2))
+ Filter: ((prt1_p0.a = (50)) OR (prt2_p0.b = (75)) OR (((prt1_e_p0.a + prt1_e_p0.b) / 2) = (50)))
-> Hash Full Join
- Hash Cond: (prt1_p1.a = prt2_p1.b)
- -> Seq Scan on prt1_p1
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ -> Seq Scan on prt1_p0
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1
+ -> Seq Scan on prt2_p0
Filter: (a = 0)
-> Hash
- -> Seq Scan on prt1_e_p1
+ -> Seq Scan on prt1_e_p0
Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: (((prt1_e_p1.a + prt1_e_p1.b) / 2) = prt1_p1.a)
+ Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ -> Seq Scan on prt1_e_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Hash Full Join
+ Hash Cond: (prt1_p1.a = prt2_p1.b)
+ -> Seq Scan on prt1_p1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p2.a = ((prt1_e_p2.a + prt1_e_p2.b) / 2))
Filter: ((prt1_p2.a = (50)) OR (prt2_p2.b = (75)) OR (((prt1_e_p2.a + prt1_e_p2.b) / 2) = (50)))
@@ -733,7 +1137,20 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
-> Hash
-> Seq Scan on prt1_e_p3
Filter: (c = 0)
-(42 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = ((prt1_e_p4.a + prt1_e_p4.b) / 2))
+ Filter: ((prt1_p4.a = (50)) OR (prt2_p4.b = (75)) OR (((prt1_e_p4.a + prt1_e_p4.b) / 2) = (50)))
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_e_p4
+ Filter: (c = 0)
+(68 rows)
SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b)) FULL JOIN (SELECT 50 phv, * FROM prt1_e WHERE prt1_e.c = 0) t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.a = t1.phv OR t2.b = t2.phv OR (t3.a + t3.b)/2 = t3.phv ORDER BY t1.a, t2.b, t3.a + t3.b;
a | phv | b | phv | ?column? | phv
@@ -751,172 +1168,260 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHER
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = t1_3.b)
+ Join Filter: (t1.a = t1_5.b)
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Join
- Hash Cond: (((t2.a + t2.b) / 2) = t1_3.b)
- -> Seq Scan on prt1_e_p1 t2
+ Hash Cond: (((t2.a + t2.b) / 2) = t1_5.b)
+ -> Seq Scan on prt1_e_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t1_3
+ -> Seq Scan on prt2_p0 t1_5
Filter: (a = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
Index Cond: (a = ((t2.a + t2.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_1.a = t1_4.b)
+ Join Filter: (t1_1.a = t1_6.b)
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Join
- Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_4.b)
- -> Seq Scan on prt1_e_p2 t2_1
+ Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_6.b)
+ -> Seq Scan on prt1_e_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t1_4
+ -> Seq Scan on prt2_p1 t1_6
Filter: (a = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
Index Cond: (a = ((t2_1.a + t2_1.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_2.a = t1_5.b)
+ Join Filter: (t1_2.a = t1_7.b)
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Nested Loop
- -> Seq Scan on prt2_p3 t1_5
+ -> Seq Scan on prt2_p2 t1_7
Filter: (a = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_2
- Index Cond: (((a + b) / 2) = t1_5.b)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t2_2
+ Index Cond: (((a + b) / 2) = t1_7.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
Index Cond: (a = ((t2_2.a + t2_2.b) / 2))
Filter: (b = 0)
-(41 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = t1_8.b)
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t1_8
+ Filter: (a = 0)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_3
+ Index Cond: (((a + b) / 2) = t1_8.b)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t2_3.a + t2_3.b) / 2))
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t1_9.b)
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Join
+ Hash Cond: (((t2_4.a + t2_4.b) / 2) = t1_9.b)
+ -> Seq Scan on prt1_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t1_9
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = ((t2_4.a + t2_4.b) / 2))
+ Filter: (b = 0)
+(66 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHERE t1.a = 0 AND t1.b = (t2.a + t2.b)/2) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
--------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Nested Loop
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Semi Join
- Hash Cond: (t1_3.b = ((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt2_p1 t1_3
+ Hash Cond: (t1_5.b = ((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt2_p0 t1_5
-> Hash
- -> Seq Scan on prt1_e_p1 t1_6
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
- Index Cond: (a = t1_3.b)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t1_5.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Semi Join
- Hash Cond: (t1_4.b = ((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt2_p2 t1_4
+ Hash Cond: (t1_6.b = ((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt2_p1 t1_6
-> Hash
- -> Seq Scan on prt1_e_p2 t1_7
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
- Index Cond: (a = t1_4.b)
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
+ Index Cond: (a = t1_6.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Hash Semi Join
- Hash Cond: (t1_5.b = ((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt2_p3 t1_5
+ Hash Cond: (t1_7.b = ((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt2_p2 t1_7
-> Hash
- -> Seq Scan on prt1_e_p3 t1_8
+ -> Seq Scan on prt1_e_p2 t1_12
Filter: (c = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t1_5.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t1_7.b)
Filter: (b = 0)
-(39 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Hash Semi Join
+ Hash Cond: (t1_8.b = ((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt2_p3 t1_8
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t1_13
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t1_8.b)
+ Filter: (b = 0)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Semi Join
+ Hash Cond: (t1_9.b = ((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt2_p4 t1_9
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = t1_9.b)
+ Filter: (b = 0)
+(63 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
-- test merge joins
SET enable_hashjoin TO off;
SET enable_nestloop TO off;
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
-----------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------
Merge Append
Sort Key: t1.a
-> Merge Semi Join
- Merge Cond: (t1.a = t1_3.b)
+ Merge Cond: (t1.a = t1_5.b)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_3.b = (((t1_6.a + t1_6.b) / 2)))
+ Merge Cond: (t1_5.b = (((t1_10.a + t1_10.b) / 2)))
-> Sort
- Sort Key: t1_3.b
- -> Seq Scan on prt2_p1 t1_3
+ Sort Key: t1_5.b
+ -> Seq Scan on prt2_p0 t1_5
-> Sort
- Sort Key: (((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt1_e_p1 t1_6
+ Sort Key: (((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_1.a = t1_4.b)
+ Merge Cond: (t1_1.a = t1_6.b)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_4.b = (((t1_7.a + t1_7.b) / 2)))
+ Merge Cond: (t1_6.b = (((t1_11.a + t1_11.b) / 2)))
-> Sort
- Sort Key: t1_4.b
- -> Seq Scan on prt2_p2 t1_4
+ Sort Key: t1_6.b
+ -> Seq Scan on prt2_p1 t1_6
-> Sort
- Sort Key: (((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt1_e_p2 t1_7
+ Sort Key: (((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_2.a = t1_5.b)
+ Merge Cond: (t1_2.a = t1_7.b)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_5.b = (((t1_8.a + t1_8.b) / 2)))
+ Merge Cond: (t1_7.b = (((t1_12.a + t1_12.b) / 2)))
-> Sort
- Sort Key: t1_5.b
- -> Seq Scan on prt2_p3 t1_5
+ Sort Key: t1_7.b
+ -> Seq Scan on prt2_p2 t1_7
-> Sort
- Sort Key: (((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt1_e_p3 t1_8
+ Sort Key: (((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt1_e_p2 t1_12
Filter: (c = 0)
-(47 rows)
+ -> Merge Semi Join
+ Merge Cond: (t1_3.a = t1_8.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_8.b = (((t1_13.a + t1_13.b) / 2)))
+ -> Sort
+ Sort Key: t1_8.b
+ -> Seq Scan on prt2_p3 t1_8
+ -> Sort
+ Sort Key: (((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt1_e_p3 t1_13
+ Filter: (c = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_4.a = t1_9.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_9.b = (((t1_14.a + t1_14.b) / 2)))
+ -> Sort
+ Sort Key: t1_9.b
+ -> Seq Scan on prt2_p4 t1_9
+ -> Sort
+ Sort Key: (((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+(77 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
@@ -933,14 +1438,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3.a + t3.b) / 2)) = t1.a)
-> Sort
Sort Key: (((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Sort
Sort Key: t2.b
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Merge Left Join
Merge Cond: (t1_1.a = t2_1.b)
-> Sort
@@ -949,14 +1454,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_1.a + t3_1.b) / 2)) = t1_1.a)
-> Sort
Sort Key: (((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Sort
Sort Key: t2_1.b
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Merge Left Join
Merge Cond: (t1_2.a = t2_2.b)
-> Sort
@@ -965,32 +1470,74 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_2.a + t3_2.b) / 2)) = t1_2.a)
-> Sort
Sort Key: (((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Sort
Sort Key: t2_2.b
- -> Seq Scan on prt2_p3 t2_2
-(51 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Merge Left Join
+ Merge Cond: (t1_3.a = t2_3.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_3.a + t3_3.b) / 2)) = t1_3.a)
+ -> Sort
+ Sort Key: (((t3_3.a + t3_3.b) / 2))
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ -> Sort
+ Sort Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ -> Merge Left Join
+ Merge Cond: (t1_4.a = t2_4.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_4.a + t3_4.b) / 2)) = t1_4.a)
+ -> Sort
+ Sort Key: (((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ -> Sort
+ Sort Key: t2_4.b
+ -> Seq Scan on prt2_p4 t2_4
+(83 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- MergeAppend on nullable column
EXPLAIN (COSTS OFF)
@@ -998,8 +1545,18 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Merge Left Join
+ Merge Cond: (prt1_p0.a = b)
+ -> Sort
+ Sort Key: prt1_p0.a
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Sort
+ Sort Key: b
+ -> Result
+ One-Time Filter: false
-> Merge Left Join
Merge Cond: (prt1_p1.a = b)
-> Sort
@@ -1020,21 +1577,26 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
Sort Key: prt2_p2.b
-> Seq Scan on prt2_p2
Filter: (b > 250)
-(23 rows)
+(33 rows)
SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | b
------+-----
- 0 |
- 50 |
- 100 |
- 150 |
- 200 |
- 250 |
- 300 | 300
- 350 |
- 400 |
-(9 rows)
+ a | b
+------+-----
+ -250 |
+ -200 |
+ -150 |
+ -100 |
+ -50 |
+ 0 |
+ 50 |
+ 100 |
+ 150 |
+ 200 |
+ 250 |
+ 300 | 300
+ 350 |
+ 400 |
+(14 rows)
-- merge join when expression with whole-row reference needs to be sorted;
-- partitionwise join does not apply
@@ -1048,30 +1610,797 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
Sort Key: t1.a, ((((t1.*)::prt1))::text)
-> Result
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Sort
Sort Key: t2.b, ((((t2.*)::prt2))::text)
-> Result
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
-(16 rows)
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+(20 rows)
SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.b ORDER BY t1.a;
- a | b
-----+----
- 0 | 0
- 6 | 6
- 12 | 12
- 18 | 18
- 24 | 24
-(5 rows)
+ a | b
+-----+-----
+ -24 | -24
+ -18 | -18
+ -12 | -12
+ -6 | -6
+ 0 | 0
+ 6 | 6
+ 12 | 12
+ 18 | 18
+ 24 | 24
+(9 rows)
RESET enable_hashjoin;
RESET enable_nestloop;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+ -> Seq Scan on prt2_p3 t2_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_4
+ Filter: (b = 0)
+(22 rows)
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p1 t2
+ -> Hash
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p2 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p3 t1_2
+ Filter: (b = 0)
+(21 rows)
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -150 | -0150 | 0 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 0 | 0150
+ 300 | 0300 | 0 | 0300
+ 450 | 0450 | 0 | 0450
+ 600 | 0600 | 0 | 0600
+ 750 | 0750 | 0 | 0750
+(7 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (t1_3.a = b)
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | 0 | -0150
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | 0 | 0000
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | 0 | 0150
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 0 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ 450 | 0450 | 0 | 0450
+ 500 | 0500 | |
+ 550 | 0550 | |
+ 600 | 0600 | 0 | 0600
+ 650 | 0650 | |
+ 700 | 0700 | |
+ 750 | 0750 | 0 | 0750
+(21 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Semi Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Append
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
+ Index Cond: (a = t1_1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(28 rows)
+
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Anti Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Anti Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -250 | 0 | -0250
+ -200 | 0 | -0200
+ -100 | 0 | -0100
+ -50 | 0 | -0050
+ 50 | 0 | 0050
+ 100 | 0 | 0100
+ 200 | 0 | 0200
+ 250 | 0 | 0250
+ 350 | 0 | 0350
+ 400 | 0 | 0400
+ 500 | 0 | 0500
+ 550 | 0 | 0550
+ 650 | 0 | 0650
+ 700 | 0 | 0700
+(14 rows)
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ QUERY PLAN
+---------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t3.c
+ -> Append
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t3
+ Index Cond: (a = t2.b)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t2.b)
+ -> Hash Right Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t3_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t3_2
+ Index Cond: (a = t2_2.b)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t2_2.b)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t3_3
+ Index Cond: (a = t2_3.b)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(47 rows)
+
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ a | a | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.b
+ -> Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(24 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: (t1.a = t2.b)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.a, 0)) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------
+ Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(22 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Join
+ Hash Cond: (t1.a = t2.b)
+ Join Filter: ((t1.b + t2.a) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
--
-- partitioned by multiple columns
--
@@ -1141,82 +2470,1552 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1
--
-- tests for list partitioned tables.
--
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 470 | 0 | 0011
+(1 row)
+
--
-- list partitioned by expression
--
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
ANALYZE plt1_e;
-- test partition matching with N-way join
EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- QUERY PLAN
---------------------------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------------------------------------
GroupAggregate
Group Key: t1.c, t2.c, t3.c
-> Sort
Sort Key: t1.c, t3.c
-> Append
-> Hash Join
- Hash Cond: (t1.c = ltrim(t3.c, 'A'::text))
+ Hash Cond: ((t1.c)::text = ltrim(t3.c, 'A'::text))
-> Hash Join
- Hash Cond: ((t1.b = t2.b) AND (t1.c = t2.c))
- -> Seq Scan on plt1_p1 t1
+ Hash Cond: ((t2.b = t1.b) AND ((t2.c)::text = (t1.c)::text))
+ -> Seq Scan on plt2_p4 t2
-> Hash
- -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt1_p4 t1
-> Hash
- -> Seq Scan on plt1_e_p1 t3
+ -> Seq Scan on plt1_e_p4 t3
-> Hash Join
- Hash Cond: (t1_1.c = ltrim(t3_1.c, 'A'::text))
+ Hash Cond: ((t1_1.c)::text = ltrim(t3_1.c, 'A'::text))
-> Hash Join
- Hash Cond: ((t1_1.b = t2_1.b) AND (t1_1.c = t2_1.c))
- -> Seq Scan on plt1_p2 t1_1
+ Hash Cond: ((t1_1.b = t2_1.b) AND ((t1_1.c)::text = (t2_1.c)::text))
+ -> Seq Scan on plt1_p1 t1_1
-> Hash
- -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p1 t2_1
-> Hash
- -> Seq Scan on plt1_e_p2 t3_1
+ -> Seq Scan on plt1_e_p1 t3_1
-> Hash Join
- Hash Cond: (t1_2.c = ltrim(t3_2.c, 'A'::text))
+ Hash Cond: ((t1_2.c)::text = ltrim(t3_2.c, 'A'::text))
-> Hash Join
- Hash Cond: ((t1_2.b = t2_2.b) AND (t1_2.c = t2_2.c))
- -> Seq Scan on plt1_p3 t1_2
+ Hash Cond: ((t1_2.b = t2_2.b) AND ((t1_2.c)::text = (t2_2.c)::text))
+ -> Seq Scan on plt1_p2 t1_2
-> Hash
- -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p2 t2_2
-> Hash
- -> Seq Scan on plt1_e_p3 t3_2
-(32 rows)
+ -> Seq Scan on plt1_e_p2 t3_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = ltrim(t3_3.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t2_3.b = t1_3.b) AND ((t2_3.c)::text = (t1_3.c)::text))
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt1_e_p3 t3_3
+(41 rows)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- avg | avg | avg | c | c | c
-----------------------+----------------------+-----------------------+------+------+-------
- 24.0000000000000000 | 24.0000000000000000 | 48.0000000000000000 | 0000 | 0000 | A0000
- 75.0000000000000000 | 75.0000000000000000 | 148.0000000000000000 | 0001 | 0001 | A0001
- 123.0000000000000000 | 123.0000000000000000 | 248.0000000000000000 | 0002 | 0002 | A0002
- 174.0000000000000000 | 174.0000000000000000 | 348.0000000000000000 | 0003 | 0003 | A0003
- 225.0000000000000000 | 225.0000000000000000 | 448.0000000000000000 | 0004 | 0004 | A0004
- 273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
- 324.0000000000000000 | 324.0000000000000000 | 648.0000000000000000 | 0006 | 0006 | A0006
- 375.0000000000000000 | 375.0000000000000000 | 748.0000000000000000 | 0007 | 0007 | A0007
- 423.0000000000000000 | 423.0000000000000000 | 848.0000000000000000 | 0008 | 0008 | A0008
- 474.0000000000000000 | 474.0000000000000000 | 948.0000000000000000 | 0009 | 0009 | A0009
- 525.0000000000000000 | 525.0000000000000000 | 1048.0000000000000000 | 0010 | 0010 | A0010
- 573.0000000000000000 | 573.0000000000000000 | 1148.0000000000000000 | 0011 | 0011 | A0011
-(12 rows)
+ avg | avg | avg | c | c | c
+----------------------+---------------------+----------------------+------+------+------
+ 246.5000000000000000 | 22.4666666666666667 | 268.9666666666666667 | 0000 | 0000 | 0000
+ 248.5000000000000000 | 21.3333333333333333 | 269.8333333333333333 | 0002 | 0002 | 0002
+ 249.5000000000000000 | 22.3333333333333333 | 271.8333333333333333 | 0003 | 0003 | 0003
+ 250.5000000000000000 | 23.3333333333333333 | 273.8333333333333333 | 0004 | 0004 | 0004
+ 251.5000000000000000 | 22.7666666666666667 | 274.2666666666666667 | 0005 | 0005 | 0005
+ 252.5000000000000000 | 22.2000000000000000 | 274.7000000000000000 | 0006 | 0006 | 0006
+ 246.0000000000000000 | 23.9655172413793103 | 269.9655172413793103 | 0008 | 0008 | 0008
+ 247.0000000000000000 | 23.3448275862068966 | 270.3448275862068966 | 0009 | 0009 | 0009
+(8 rows)
+
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 470 | 0011
+ | | 235 | 0014
+(8 rows)
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 235 | 0014
+ | | 470 | 0011
+(10 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 47 | 0 | 0013
+ 235 | 0 | 0014
+ 470 | 0 | 0011
+(3 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+----------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Materialize
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(20 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Materialize
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+---
+ 470 | 0 |
+(1 row)
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(22 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(22 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(19 rows)
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
@@ -1241,22 +4040,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
--------------------------------------------------
Hash Left Join
Hash Cond: (t2.b = a)
- -> Append
- -> Hash Join
- Hash Cond: (t3.a = t2.b)
- -> Seq Scan on prt1_p1 t3
- -> Hash
- -> Seq Scan on prt2_p1 t2
- -> Hash Join
- Hash Cond: (t3_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t3_1
- -> Hash
- -> Seq Scan on prt2_p2 t2_1
- -> Hash Join
- Hash Cond: (t3_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t3_2
- -> Hash
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash Join
+ Hash Cond: (t3.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t3
+ -> Seq Scan on prt1_p1 t3_1
+ -> Seq Scan on prt1_p2 t3_2
+ -> Seq Scan on prt1_p3 t3_3
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Result
One-Time Filter: false
@@ -1271,16 +4070,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
-> Hash Left Join
Hash Cond: (t2.b = a)
-> Append
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
Filter: (a = 0)
-> Hash
-> Result
One-Time Filter: false
-(14 rows)
+(20 rows)
--
-- tests for hash partitioned tables.
@@ -1356,41 +4161,9 @@ SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, ph
273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
(6 rows)
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
- Sort
- Sort Key: t1.a
- -> Append
- -> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
- -> Hash
- -> Seq Scan on prt1_p1 t1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
- -> Hash
- -> Seq Scan on prt1_p2 t1_1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
- -> Hash
- -> Seq Scan on prt1_p3 t1_2
- Filter: (b = 0)
-(21 rows)
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
@@ -1405,26 +4178,24 @@ SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c
Sort Key: t1.c
-> HashAggregate
Group Key: t1.c, t2.c
- -> Append
- -> Hash Join
- Hash Cond: (t2.c = t1.c)
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_p1 t1
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_1.c = t1_1.c)
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p1 t1_1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_2.c = t1_2.c)
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p2 t1_2
Filter: ((a % 25) = 0)
-(23 rows)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: ((a % 25) = 0)
+(21 rows)
--
-- multiple levels of partitioning
@@ -1826,64 +4597,70 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2 WHERE t1.a = t2.a;
Hash Join
Hash Cond: (t1.a = t2.a)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Seq Scan on prt4_n_p1 t2
-> Seq Scan on prt4_n_p2 t2_1
-> Seq Scan on prt4_n_p3 t2_2
-(11 rows)
+(13 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2, prt2 t3 WHERE t1.a = t2.a and t1.a = t3.b;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------
Hash Join
- Hash Cond: (t2.a = t1.a)
+ Hash Cond: (t3.b = t1.a)
-> Append
- -> Seq Scan on prt4_n_p1 t2
- -> Seq Scan on prt4_n_p2 t2_1
- -> Seq Scan on prt4_n_p3 t2_2
+ -> Seq Scan on prt2_p0 t3
+ -> Seq Scan on prt2_p1 t3_1
+ -> Seq Scan on prt2_p2 t3_2
+ -> Seq Scan on prt2_p3 t3_3
+ -> Seq Scan on prt2_p4 t3_4
+ -> Seq Scan on prt2_p5 t3_5
-> Hash
- -> Append
- -> Hash Join
- Hash Cond: (t1.a = t3.b)
- -> Seq Scan on prt1_p1 t1
- -> Hash
- -> Seq Scan on prt2_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t1_1
- -> Hash
- -> Seq Scan on prt2_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t1_2
- -> Hash
- -> Seq Scan on prt2_p3 t3_2
+ -> Hash Join
+ Hash Cond: (t1.a = t2.a)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt4_n_p1 t2
+ -> Seq Scan on prt4_n_p2 t2_1
+ -> Seq Scan on prt4_n_p3 t2_2
(23 rows)
-- partitionwise join can not be applied if there are no equi-join conditions
-- between partition keys
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON (t1.a < t2.b);
- QUERY PLAN
----------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------
Nested Loop Left Join
+ Join Filter: (t1.a < t2.b)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
- -> Append
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
- Index Cond: (t1.a < b)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
- Index Cond: (t1.a < b)
-(12 rows)
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Materialize
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(16 rows)
-- equi-join with join condition on partial keys does not qualify for
-- partitionwise join
@@ -1969,16 +4746,17 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 JOIN prt2_n t2 ON (t1.c = t2.c) JOI
-> Seq Scan on prt2_n_p2 t2_1
-> Hash
-> Hash Join
- Hash Cond: (t3.c = (t1.c)::text)
+ Hash Cond: ((t3.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on plt1_p1 t3
- -> Seq Scan on plt1_p2 t3_1
- -> Seq Scan on plt1_p3 t3_2
+ -> Seq Scan on plt1_p4 t3
+ -> Seq Scan on plt1_p1 t3_1
+ -> Seq Scan on plt1_p2 t3_2
+ -> Seq Scan on plt1_p3 t3_3
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(16 rows)
+(17 rows)
-- partitionwise join can not be applied for a join between list and range
-- partitioned table
@@ -1989,14 +4767,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 FULL JOIN prt1 t2 ON (t1.c = t2.c);
Hash Full Join
Hash Cond: ((t2.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on prt1_p1 t2
- -> Seq Scan on prt1_p2 t2_1
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(10 rows)
+(12 rows)
-- partitionwise join can not be applied if only one of joining table has
-- default partition
@@ -2012,16 +4792,23 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b =
-> Hash Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
diff --git a/src/test/regress/sql/partition_join.sql b/src/test/regress/sql/partition_join.sql
index c1c9859651..0e884835fb 100644
--- a/src/test/regress/sql/partition_join.sql
+++ b/src/test/regress/sql/partition_join.sql
@@ -10,25 +10,39 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
@@ -67,11 +81,19 @@ EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -93,20 +115,30 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
@@ -169,6 +201,128 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
RESET enable_hashjoin;
RESET enable_nestloop;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
--
-- partitioned by multiple columns
--
@@ -193,28 +347,79 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1
--
-- tests for list partitioned tables.
--
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
--
-- list partitioned by expression
--
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
ANALYZE plt1_e;
-- test partition matching with N-way join
@@ -222,6 +427,175 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.a = 1 AND t1.a = 2;
@@ -267,27 +641,18 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
ALTER TABLE plt2 DETACH PARTITION plt2_p3;
ALTER TABLE plt2 ATTACH PARTITION plt2_p3 DEFAULT;
ANALYZE plt2;
-
EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.a % 25 = 0 GROUP BY t1.c, t2.c ORDER BY t1.c, t2.c;
+
--
-- multiple levels of partitioning
--
--
2.18.0
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
@ 2019-03-05 10:14 ` amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
0 siblings, 1 reply; 154+ messages in thread
From: amul sul @ 2019-03-05 10:14 UTC (permalink / raw)
To: Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; +Cc: Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers; ashutosh.bapat.oss@gmail.com
Attached is the rebased atop of the latest master head(35bc0ec7c8).
Regards,
Amul Sul
On Mon, Feb 4, 2019 at 11:05 AM amul sul <sulamul@gmail.com> wrote:
> There are few whitespaces in 0002 patch that I have fixed in the attached
> version.
> Rest of the patches are untouched.
>
> Ill continue my review and testing.
>
> Regards,
> Amul
>
> On Thu, Jan 31, 2019 at 5:26 PM Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
> wrote:
>
>> (2019/01/22 21:38), Etsuro Fujita wrote:
>> > Will continue to review.
>>
>> I rebased the patch set against the latest HEAD. Attached is a new
>> version. I'll move this to the next CF, and continue to review it.
>>
>> Best regards,
>> Etsuro Fujita
>>
>
Attachments:
[application/x-patch] 0001-Hash-partition-bound-equality-refactoring-v19.patch (5.1K, ../../CAAJ_b95ja_Uyy8Q51Muh5TNEoWSbHCoMFGOEOHUQLxUWvA3Csg@mail.gmail.com/3-0001-Hash-partition-bound-equality-refactoring-v19.patch)
download | inline diff:
From b65bc94d63f453ac0e2e757bcd28661cabc6c549 Mon Sep 17 00:00:00 2001
From: Etsuro Fujita <efujita@postgresql.org>
Date: Thu, 31 Jan 2019 19:18:18 +0900
Subject: [PATCH 1/3] Hash partition bound equality refactoring.
Separate the code to check whether two given hash bounds are equal into a
separate function, so that it can be called from multiple places. Right now
it's only caller is partition_bounds_equal() but later we will use it for
merging partition bounds.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/partitioning/partbounds.c | 95 +++++++++++++++++----------
1 file changed, 61 insertions(+), 34 deletions(-)
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index e71eb3793b..637e05e5ca 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -106,6 +106,9 @@ static void get_range_key_properties(PartitionKey key, int keynum,
Expr **keyCol,
Const **lower_val, Const **upper_val);
static List *get_range_nulltest(PartitionKey key);
+static bool partition_hbounds_equal(PartitionBoundInfo b1,
+ PartitionBoundInfo b2);
+
/*
* get_qual_from_partbound
@@ -654,6 +657,63 @@ create_range_bounds(PartitionBoundSpec **boundspecs, int nparts,
return boundinfo;
}
+/*
+ * Are two hash partition bound collections logically equal?
+ *
+ * Hash partition bounds store modulus and remainder in datums array which are
+ * always integers irrespective of the number of partition keys and their data
+ * types. Hence we can compare the hash bound collection without any partition
+ * key specific information. Separating this logic in a function which does not
+ * require partition key specific information allows it be called from places
+ * where the partition key specific information is not completely available.
+ */
+static bool
+partition_hbounds_equal(PartitionBoundInfo b1, PartitionBoundInfo b2)
+{
+ int greatest_modulus = get_hash_partition_greatest_modulus(b1);
+ int i;
+
+ Assert(b1->strategy == PARTITION_STRATEGY_HASH &&
+ b2->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * If two hash partitioned tables have different greatest moduli,
+ * their partition schemes don't match. For hash partitioned table,
+ * the greatest modulus is given by the last datum and number of
+ * partitions is given by ndatums.
+ */
+ if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ return false;
+
+ /*
+ * We arrange the partitions in the ascending order of their modulus and
+ * remainders. Also every modulus is factor of next larger modulus.
+ * Therefore we can safely store index of a given partition in indexes
+ * array at remainder of that partition. Also entries at (remainder + N *
+ * modulus) positions in indexes array are all same for (modulus,
+ * remainder) specification for any partition. Thus datums array from both
+ * the given bounds are same, if and only if their indexes array will be
+ * same. So, it suffices to compare indexes array.
+ */
+ for (i = 0; i < greatest_modulus; i++)
+ if (b1->indexes[i] != b2->indexes[i])
+ return false;
+
+#ifdef USE_ASSERT_CHECKING
+
+ /*
+ * Nonetheless make sure that the bounds are indeed same when the indexes
+ * match. Hash partition bound stores modulus and remainder at
+ * b1->datums[i][0] and b1->datums[i][1] position respectively.
+ */
+ for (i = 0; i < b1->ndatums; i++)
+ Assert((b1->datums[i][0] == b2->datums[i][0] &&
+ b1->datums[i][1] == b2->datums[i][1]));
+#endif
+
+ return true;
+}
+
/*
* Are two partition bound collections logically equal?
*
@@ -682,41 +742,8 @@ partition_bounds_equal(int partnatts, int16 *parttyplen, bool *parttypbyval,
if (b1->strategy == PARTITION_STRATEGY_HASH)
{
- int greatest_modulus = get_hash_partition_greatest_modulus(b1);
-
- /*
- * If two hash partitioned tables have different greatest moduli,
- * their partition schemes don't match.
- */
- if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ if (!partition_hbounds_equal(b1, b2))
return false;
-
- /*
- * We arrange the partitions in the ascending order of their moduli
- * and remainders. Also every modulus is factor of next larger
- * modulus. Therefore we can safely store index of a given partition
- * in indexes array at remainder of that partition. Also entries at
- * (remainder + N * modulus) positions in indexes array are all same
- * for (modulus, remainder) specification for any partition. Thus
- * datums array from both the given bounds are same, if and only if
- * their indexes array will be same. So, it suffices to compare
- * indexes array.
- */
- for (i = 0; i < greatest_modulus; i++)
- if (b1->indexes[i] != b2->indexes[i])
- return false;
-
-#ifdef USE_ASSERT_CHECKING
-
- /*
- * Nonetheless make sure that the bounds are indeed same when the
- * indexes match. Hash partition bound stores modulus and remainder
- * at b1->datums[i][0] and b1->datums[i][1] position respectively.
- */
- for (i = 0; i < b1->ndatums; i++)
- Assert((b1->datums[i][0] == b2->datums[i][0] &&
- b1->datums[i][1] == b2->datums[i][1]));
-#endif
}
else
{
--
2.18.0
[application/x-patch] 0002-Partition-wise-join-for-1-1-1-0-0-1-partition-matchi-v19.patch (69.8K, ../../CAAJ_b95ja_Uyy8Q51Muh5TNEoWSbHCoMFGOEOHUQLxUWvA3Csg@mail.gmail.com/4-0002-Partition-wise-join-for-1-1-1-0-0-1-partition-matchi-v19.patch)
download | inline diff:
From a6fc8476fac4f062e296ad6260207fa144a3a12d Mon Sep 17 00:00:00 2001
From: Amul Sul <amul.sul@enterprisedb.com>
Date: Mon, 4 Mar 2019 23:49:47 -0500
Subject: [PATCH 2/3] Partition-wise join for 1:1, 1:0, 0:1 partition matching.
Earlier version of partition-wise join implementation allowed
partition-wise join between two relations with exactly same partition
bounds. This commit allows partition-wise join to be applied under
following conditions
1. the partition bounds of joining relations are such that rows from
given partition on one side join can join with rows from maximum one
partition on the other side i.e. bounds of a given partition on one
side match/overlap with those of maximum one partition on the other
side. If the mapping happens to be m:n where m > 1 or n > 1, we have
to gang multiple partition relations together into a single relation.
This means that we have to add simple relations during join
processing, something which is not supported right now. ALso, in such
a case, different pairs of joining relations can produce different
partition bounds for the same join relation, which again is not
supported right now.
2. For every partition on outer side that can contribute to the result
of an OUTER join, there exists at least one (taken along with item 1,
it means exactly one) matching partition on the inner side. To
support partition-wise join when the inner matching partition doesn't
exist, we have to add a dummy base relation corresponding to the
non-existent inner partition. We don't have support to add base
relations during join processing.
3. For hash partitioned tables however, we support partition-wise join
only when the bounds exactly match. For hash partitioning it's unusual
to have missing partitions and hence generic partition matching is not
required.
With advanced partition matching, we won't be able to apply
partition-wise join when there are missing matching partitions. So for
a given N-way join, some sub-joins may not be partitioned, while the
overall N-way join is partitioned. We can not try partition-wise join
when one or both of the joining relations are not partitioned in one
of the pairs of joining relation. Skip partition-wise join for that
pair.
An example is A IJ B LJ C where B has an extra partition compared to A
and C. Join B LJ C requires dummy relation to join the extra partition
from B to a missing partition from C, and hence can not use
partition-wise join right now and hence BC is not partitioned. The
extra partition in B gets eliminated in A IJ B and thus it can use
partition-wise join and is partitioned. Hence (AB)C can use
partition-wise join but not A(BC).
Not every pair of joining relation (including the one presented to
build_joinrel_partition_info()) for the same joinrel can use
partition-wise join or has both the relations partitioned. Hence we
calculate the partition bounds for the join relation in
try_partition_wise_join() instead of doing it here.
The partition bounds produced for the first pair that can use
partition-wise are saved in the RelOptInfo of the joinrel. Partition
bounds produced for subsequent pairs should match that produced by the
first pair.
Support for default partition in list partitioned tables
========================================================
When a list value is present in one of the joining relations and not
the other, and the other relation has default partition, match (join)
the partition containing that list value with the default partition.
If there are multiple matches, we can not proceed with the
partition-wise join similar to the case of matching non-default
partition. If the default partition happens to be on the outer side of
the join, the resulting join partition acts as a default partition as
it will contain all the values from the default partition. If
the partition containing the list value happens to be on the outer
side of the join, the resulting join partition is associated with the
list value, since no other partition key value from the default
partition makes it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a partition from the inner side,
if inner side has a list value that is not present in the outer side.
But if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Support for matching default partition in range partitioned tables
==================================================================
When a range is present in one of the joining relations and not the
other, and the other relation has default partition, match (join) the
partition corresponding range with the default partition. If two
ranges overlap but their ranges don't match exactly, the
non-overlapping portion from one range may join the previous
(non-overlapping portion near the lower bound, if exists), next
(non-overlapping portion near the upper bound, if exists) ranges from
the other relation or default partition from the other relation. This
causes multiple partitions on the other side to be joined with a
single partition on the first side; a case we don't support. Any range
from one side which doesn't overlap with any range on the other side,
may find its join partner in the default partition and the
corresponding range partition will need to be joined with the default
partition. If the default partition happens to be on the outer side
of the join, the resulting join partition acts as a default partition
as it will contain all the values from the default partition. If the
non-partition corresponding to the range happens to be on the outer
side of the join, the resulting join partition is associated with that
range, since partition key values from the default partition outside
that range won't make it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a non-default partition from the
inner side, if inner side has a range missing in the outer side. But
if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/optimizer/path/joinrels.c | 95 +-
src/backend/optimizer/util/relnode.c | 33 +-
src/backend/partitioning/partbounds.c | 1677 ++++++++++++++++++++++++-
src/include/partitioning/partbounds.h | 7 +
4 files changed, 1766 insertions(+), 46 deletions(-)
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index dfbbfdac6d..ca4d261bc1 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1320,25 +1320,31 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
{
bool rel1_is_simple = IS_SIMPLE_REL(rel1);
bool rel2_is_simple = IS_SIMPLE_REL(rel2);
- int nparts;
+ PartitionScheme part_scheme;
+ PartitionBoundInfo join_boundinfo;
+ List *parts1;
+ List *parts2;
+ ListCell *lc1;
+ ListCell *lc2;
int cnt_parts;
/* Guard against stack overflow due to overly deep partition hierarchy. */
check_stack_depth();
/* Nothing to do, if the join relation is not partitioned. */
- if (!IS_PARTITIONED_REL(joinrel))
+ if (joinrel->part_scheme == NULL)
return;
/* The join relation should have consider_partitionwise_join set. */
Assert(joinrel->consider_partitionwise_join);
/*
- * Since this join relation is partitioned, all the base relations
- * participating in this join must be partitioned and so are all the
- * intermediate join relations.
+ * We can not perform partition-wise join if either of the joining
+ * relations is not partitioned.
*/
- Assert(IS_PARTITIONED_REL(rel1) && IS_PARTITIONED_REL(rel2));
+ if (!IS_PARTITIONED_REL(rel1) || !IS_PARTITIONED_REL(rel2))
+ return;
+
Assert(REL_HAS_ALL_PART_PROPS(rel1) && REL_HAS_ALL_PART_PROPS(rel2));
/* The joining relations should have consider_partitionwise_join set. */
@@ -1351,32 +1357,63 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
*/
Assert(joinrel->part_scheme == rel1->part_scheme &&
joinrel->part_scheme == rel2->part_scheme);
+ part_scheme = joinrel->part_scheme;
/*
- * 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.
+ * Get the list of matching partitions to be joined along with the
+ * partition bounds of the join relation. Because of the restrictions
+ * imposed by partition matching algorithm, not every pair of joining
+ * relations for this join will be able to use partition-wise join. But all
+ * those pairs which can use partition-wise join will produce the same
+ * partition bounds for the join relation.
*/
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel1->boundinfo));
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel2->boundinfo));
+ join_boundinfo = partition_bounds_merge(part_scheme->partnatts,
+ part_scheme->partsupfunc,
+ part_scheme->partcollation,
+ rel1, rel2,
+ parent_sjinfo->jointype,
+ &parts1, &parts2);
+
+ if (join_boundinfo == NULL)
+ return;
- nparts = joinrel->nparts;
+ if (joinrel->boundinfo == NULL)
+ {
+ Assert(joinrel->nparts == 0 && joinrel->part_rels == NULL);
+ joinrel->boundinfo = join_boundinfo;
+ joinrel->nparts = list_length(parts1);
+ Assert(joinrel->nparts == list_length(parts2));
+ joinrel->part_rels =
+ (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+ joinrel->nparts);
+ }
+ else
+ {
+ Assert(partition_bounds_equal(part_scheme->partnatts,
+ part_scheme->parttyplen,
+ part_scheme->parttypbyval,
+ join_boundinfo, joinrel->boundinfo));
+ /*
+ * Every pair of joining relations should result in the same number
+ * of child-joins.
+ */
+ Assert(joinrel->nparts == list_length(parts1));
+ Assert(joinrel->nparts == list_length(parts2));
+ Assert(joinrel->part_rels);
+ }
/*
* Create child-join relations for this partitioned join, if those don't
* exist. Add paths to child-joins for a pair of child relations
* corresponding to the given pair of parent relations.
*/
- for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+ cnt_parts = 0;
+ forboth(lc1, parts1, lc2, parts2)
{
- RelOptInfo *child_rel1 = rel1->part_rels[cnt_parts];
- RelOptInfo *child_rel2 = rel2->part_rels[cnt_parts];
+ int part1 = lfirst_int(lc1);
+ int part2 = lfirst_int(lc2);
+ RelOptInfo *child_rel1;
+ RelOptInfo *child_rel2;
SpecialJoinInfo *child_sjinfo;
List *child_restrictlist;
RelOptInfo *child_joinrel;
@@ -1384,6 +1421,10 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
AppendRelInfo **appinfos;
int nappinfos;
+ Assert(part1 >= 0 && part2 >= 0);
+ child_rel1 = rel1->part_rels[part1];
+ child_rel2 = rel2->part_rels[part2];
+
/*
* If a child table has consider_partitionwise_join=false, it means
* that it's a dummy relation for which we skipped setting up tlist
@@ -1438,12 +1479,24 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
joinrel->part_rels[cnt_parts] = child_joinrel;
}
+ /*
+ * For every pair of joining relations, the set of matching partitions
+ * would change. However, the base relation partitions constituting
+ * the given child should remain same for all the joining pairs. Since
+ * the order in which children are stored in the array of child-joins,
+ * depends upon partition bounds of the join, which are same for all
+ * the joining pairs, every joining pair yields the child-joins in the
+ * same order.
+ */
Assert(bms_equal(child_joinrel->relids, child_joinrelids));
populate_joinrel_with_paths(root, child_rel1, child_rel2,
child_joinrel, child_sjinfo,
child_restrictlist);
+ cnt_parts++;
}
+
+ Assert(cnt_parts == joinrel->nparts);
}
/*
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 4130514952..6354213854 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1594,7 +1594,7 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
* of the way the query planner deduces implied equalities and reorders
* the joins. Please see optimizer/README for details.
*/
- if (!IS_PARTITIONED_REL(outer_rel) || !IS_PARTITIONED_REL(inner_rel) ||
+ if (outer_rel->part_scheme == NULL || inner_rel->part_scheme == NULL ||
!outer_rel->consider_partitionwise_join ||
!inner_rel->consider_partitionwise_join ||
outer_rel->part_scheme != inner_rel->part_scheme ||
@@ -1607,24 +1607,6 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
part_scheme = outer_rel->part_scheme;
- Assert(REL_HAS_ALL_PART_PROPS(outer_rel) &&
- REL_HAS_ALL_PART_PROPS(inner_rel));
-
- /*
- * For now, our partition matching algorithm can match partitions only
- * when the partition bounds of the joining relations are exactly same.
- * So, bail out otherwise.
- */
- if (outer_rel->nparts != inner_rel->nparts ||
- !partition_bounds_equal(part_scheme->partnatts,
- part_scheme->parttyplen,
- part_scheme->parttypbyval,
- outer_rel->boundinfo, inner_rel->boundinfo))
- {
- Assert(!IS_PARTITIONED_REL(joinrel));
- return;
- }
-
/*
* This function will be called only once for each joinrel, hence it
* should not have partition scheme, partition bounds, partition key
@@ -1636,17 +1618,20 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
/*
* Join relation is partitioned using the same partitioning scheme as the
- * joining relations and has same bounds.
+ * joining relations.
+ *
+ * Because of restrictions in partition_bounds_merge(), not every pair of
+ * joining relations (including the one presented to this function) for the
+ * same joinrel can use partition-wise join or has both the relations
+ * partitioned. Hence we calculate the partition bounds, number of
+ * partitions and child-join relations of the join relation when and if we
+ * find a suitable pair in try_partition_wise_join().
*/
joinrel->part_scheme = part_scheme;
- joinrel->boundinfo = outer_rel->boundinfo;
partnatts = joinrel->part_scheme->partnatts;
joinrel->partexprs = (List **) palloc0(sizeof(List *) * partnatts);
joinrel->nullable_partexprs =
(List **) palloc0(sizeof(List *) * partnatts);
- joinrel->nparts = outer_rel->nparts;
- joinrel->part_rels =
- (RelOptInfo **) palloc0(sizeof(RelOptInfo *) * joinrel->nparts);
/*
* Set the consider_partitionwise_join flag.
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index 637e05e5ca..eca5ce946e 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -23,6 +23,7 @@
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
+#include "nodes/pathnodes.h"
#include "parser/parse_coerce.h"
#include "partitioning/partbounds.h"
#include "partitioning/partdesc.h"
@@ -67,6 +68,12 @@ typedef struct PartitionRangeBound
bool lower; /* this is the lower (vs upper) bound */
} PartitionRangeBound;
+typedef struct PartitionMap
+{
+ int from;
+ int to;
+} PartitionMap;
+
static int32 qsort_partition_hbound_cmp(const void *a, const void *b);
static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
void *arg);
@@ -108,7 +115,58 @@ static void get_range_key_properties(PartitionKey key, int keynum,
static List *get_range_nulltest(PartitionKey key);
static bool partition_hbounds_equal(PartitionBoundInfo b1,
PartitionBoundInfo b2);
-
+static PartitionBoundInfo partition_range_bounds_merge(
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype, int partnatts,
+ FmgrInfo *supfuncs, Oid *collations);
+static PartitionBoundInfo partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *collations,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype);
+static PartitionBoundInfo partition_hash_bounds_merge(RelOptInfo *outer_rel,
+ RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype);
+static void generate_matching_part_pairs(PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ int nparts1, int nparts2,
+ JoinType jointype, int nparts,
+ List **parts1, List **parts2);
+static PartitionBoundInfo build_merged_partition_bounds(char strategy,
+ List *merged_datums, List *merged_indexes,
+ List *merged_contents, int null_index,
+ int default_index);
+static int map_and_merge_partitions(PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ int index1, int index2, int *next_index);
+static int32 partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *collations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2);
+static bool partition_range_cmp(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval);
+static bool partition_range_merge_next_lb(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes);
+static bool merge_default_partitions(PartitionBoundInfo outer_bi,
+ PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ JoinType jointype,
+ int *next_index, int *default_index);
+static bool merge_null_partitions(PartitionBoundInfo outer_bi,
+ PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ JoinType jointype,
+ int *next_index, int *null_index,
+ int *default_index);
/*
* get_qual_from_partbound
@@ -2943,3 +3001,1620 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
PG_RETURN_BOOL(rowHash % modulus == remainder);
}
+
+/*
+ * partition_bounds_merge
+ *
+ * The function produces the partition bounds for a join between two relations
+ * whose partition bounds are given. The function also returns two lists of
+ * partition indexes one for each of the joining relations. Both the lists
+ * contain the same number of elements. The partition indexes at the same
+ * positions in the lists indicate the pair partitions, one from each side, to
+ * be joined and the position itself corresponds to the index of partition
+ * produced by that child-join in the partitioned join.
+ *
+ * The function returns NULL if we can not find the matching pair of
+ * partitions. This happens if 1. multiple partitions on one side match with
+ * one partition on the other side. 2. a given partition on the outer side
+ * doesn't have a matching partition on the inner side. We can not support the
+ * first case since we don't have a way to represent multiple partitions as a
+ * single relation (RelOptInfo) and then perform join using the ganged
+ * relation. We can not support the second case since the missing inner
+ * partition needs to be represented as an empty relation and we don't have a
+ * way to introduce empty relation during join planning after creating paths
+ * for all the base relations.
+ */
+extern PartitionBoundInfo
+partition_bounds_merge(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts)
+{
+ PartitionBoundInfo merged_bounds;
+ PartitionBoundInfo outer_binfo = outer_rel->boundinfo,
+ inner_binfo = inner_rel->boundinfo;
+ char strategy = outer_binfo->strategy;
+
+ /* Bail out if partitioning strategies are different. */
+ if (outer_binfo->strategy != inner_binfo->strategy)
+ return NULL;
+
+ if (jointype != JOIN_LEFT && jointype != JOIN_INNER &&
+ jointype != JOIN_SEMI && jointype != JOIN_ANTI &&
+ jointype != JOIN_FULL)
+ elog(ERROR, "unexpected join type %d", jointype);
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+ switch (strategy)
+ {
+ case PARTITION_STRATEGY_LIST:
+ merged_bounds = partition_list_bounds_merge(partsupfunc,
+ partcollation,
+ outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype);
+ break;
+
+ case PARTITION_STRATEGY_RANGE:
+ merged_bounds = partition_range_bounds_merge(outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype, partnatts,
+ partsupfunc,
+ partcollation);
+ break;
+
+ case PARTITION_STRATEGY_HASH:
+ merged_bounds = partition_hash_bounds_merge(outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype);
+ break;
+
+ default:
+ elog(ERROR, "unexpected partition strategy: %d", strategy);
+ }
+
+ Assert(merged_bounds || (*outer_parts == NIL && *inner_parts == NIL));
+
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+
+ Assert((*outer_parts == NIL || *inner_parts != NIL) &&
+ (*inner_parts == NIL || *outer_parts != NIL));
+
+ return merged_bounds;
+}
+
+/*
+ * partition_get_range_bounds
+ *
+ * Given the index of lower bound in datums array, return lower and upper
+ * bounds and the index of the partition with that lower bound.
+ */
+static int
+partition_get_range_bounds(PartitionBoundInfo bi, int lb_index,
+ PartitionRangeBound *lower,
+ PartitionRangeBound *upper)
+{
+ int part_index;
+
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The lower bound should correspond to a valid partition. */
+ part_index = bi->indexes[lb_index + 1];
+ Assert(part_index >= 0);
+
+ lower->kind = bi->kind[lb_index];
+ lower->datums = bi->datums[lb_index];
+ lower->lower = true;
+ upper->kind = bi->kind[lb_index + 1];
+ upper->datums = bi->datums[lb_index + 1];
+ upper->lower = false;
+
+ return part_index;
+}
+
+/*
+ * partition_range_get_next_lb_index
+ *
+ * Given the index of lower bound in datums array return the
+ * index of lower bound of the next partition. When the given index corresponds
+ * to the last partition, return number of datums (ndatums).
+ */
+static int
+partition_range_get_next_lb_index(PartitionBoundInfo bi, int lb_index)
+{
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The partition index corresponding to the upper bound should be valid. */
+ Assert(bi->indexes[lb_index + 1] >= 0);
+
+ /*
+ * If there are no bounds left beyond the upper bound, we have reached the
+ * last partition.
+ */
+ if (lb_index + 2 < bi->ndatums)
+ {
+ /*
+ * If the bound next to the upper bound corresponds to no partition,
+ * that's the next lower bound of the next partition. Otherwise, the
+ * current upper bound is the lower bound of the next partition.
+ */
+ if (bi->indexes[lb_index + 2] < 0)
+ return lb_index + 2;
+ else
+ return lb_index + 1;
+ }
+ else
+ return bi->ndatums;
+}
+
+static int32
+partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2)
+{
+ return partition_rbound_cmp(partnatts, partsupfunc, partcollations,
+ bound1->datums, bound1->kind, bound1->lower,
+ bound2);
+}
+
+/*
+ * partition_range_cmp
+ *
+ * Compare the bounds of two range partitions. Set ub_cmpval <, = or > 0, if the
+ * first partition's upper bound is lower than, equal to or higher than the
+ * second partition's upper bound resp. Similarly set lb_cmpval <, = or > 0,
+ * if the first partition's lower bound is lower than, equal to or higher than
+ * the second partition's lower bound resp.
+ *
+ * Return true, if the ranges overlap, otherwise return false.
+ */
+static bool
+partition_range_cmp(int partnatts, FmgrInfo *partsupfuncs, Oid *partcollations,
+ PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval)
+{
+ bool overlap;
+
+ /*
+ * Compare upper bound of the first partition with the lower bound of the
+ * second and vice-versa. If lower bound is higher than the upper bound,
+ * the partitions are not overlapping. All other cases indicate overlapping
+ * partitions.
+ */
+ if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound1, upper_bound2) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = 1;
+ *lb_cmpval = 1;
+ }
+ else if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound2, upper_bound1) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = -1;
+ *lb_cmpval = -1;
+ }
+ else
+ {
+ overlap = true;
+ *ub_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, upper_bound1,
+ upper_bound2);
+ *lb_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, lower_bound1,
+ lower_bound2);
+ }
+
+ return overlap;
+}
+
+/*
+ * partition_range_merge
+ *
+ * Merge the partition bounds of given two partitions such that the join
+ * between the given two partitions fits merged bounds.
+ *
+ * "merged_upper" will be set to one of the given upper bounds and
+ * "merged_lower" will be set to one of the given lower bounds.
+ */
+static void
+partition_range_merge(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, JoinType jointype,
+ PartitionRangeBound *left_lb,
+ PartitionRangeBound *left_ub,
+ PartitionRangeBound *right_lb,
+ PartitionRangeBound *right_ub,
+ PartitionRangeBound **merged_lb,
+ PartitionRangeBound **merged_ub)
+{
+ /*
+ * An outer join will have all the rows from the outer side, so merged
+ * bounds will be same as the outer bounds. An inner join will have rows
+ * that fit both the bounds, thus lower merged bound will be higher of two
+ * lower bounds and upper merged bound will be lower of the two upper
+ * bounds.
+ */
+ switch (jointype)
+ {
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ *merged_ub = left_ub;
+ *merged_lb = left_lb;
+ break;
+
+ case JOIN_INNER:
+ case JOIN_SEMI:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) < 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) > 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ case JOIN_FULL:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) > 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) < 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ default:
+ elog(ERROR, "unexpected join type %d", jointype);
+ }
+
+ return;
+}
+
+/*
+ * Add the lower bound of the next range to the list of bounds, if the lower
+ * bound is higher or equal to the previous upper bound. If successful return
+ * true, otherwise false.
+ */
+static bool
+partition_range_merge_next_lb(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes)
+{
+ int cmpval;
+
+ if (!*merged_datums)
+ {
+ Assert(!*merged_kinds && !*merged_indexes);
+ cmpval = 1;
+ }
+ else
+ {
+ PartitionRangeBound prev_ub;
+
+ prev_ub.datums = llast(*merged_datums);
+ prev_ub.kind = llast(*merged_kinds);
+ prev_ub.lower = false;
+
+ cmpval = partition_rbound_cmp(partnatts, partsupfuncs, partcollations,
+ next_lb_datums, next_lb_kind, false,
+ &prev_ub);
+ }
+
+ /*
+ * The lower bound is lower than the last upper bound, thus does not fit
+ * the bounds created so far and hence can not be merged with the existing
+ * bounds.
+ */
+ if (cmpval < 0)
+ return false;
+
+ /*
+ * Add bounds of the new merged partition. If the next lower bound is
+ * higher than the last upper bound, add new range with index
+ * corresponding to the lower bound as -1. If the merged lower bound
+ * is same as the last merged upper bound, the last upper bound will be
+ * reused as the lower bound of the next range.
+ */
+ if (cmpval > 0)
+ {
+ *merged_datums = lappend(*merged_datums, next_lb_datums);
+ *merged_kinds = lappend(*merged_kinds, next_lb_kind);
+ *merged_indexes = lappend_int(*merged_indexes, -1);
+ }
+
+ return true;
+}
+
+/*
+ * handle_missing_partition
+ *
+ * If a range appears in one of the joining relations but not the other, a row
+ * in the corresponding partition will not have any join partner in the other
+ * relation, unless the other relation has a default partition. If a given list
+ * value is present in one joining relation but not the other, the default
+ * partition on the other side may contain that value.
+ *
+ * In both these cases, such an extra partition forms a joining pair with the
+ * default partition, if any, on the other side.
+ *
+ * If the default partition happens to be on the outer side of the join, the
+ * resultant partition will act as the default partition of the join relation.
+ * Otherwise the resultant partition will be associated with the range.
+ *
+ * When the default partition is not present in the other relation, the rows in
+ * the extra partition will be included in the bounds of the join result, if it
+ * appears on the outer side of the join, since all rows from the outer side
+ * are included in the join result.
+ *
+ * This function handles all these cases.
+ *
+ * maps_with_missing and missing_side_default are the partition maps (See
+ * partition_range/list_bounds_merge() for details) and the index of default
+ * partition respectively corresponding the side with missing partition.
+ *
+ * maps_with_extra and extra_part are the partition maps (See
+ * partition_range/list_bounds_merge() for details) and the index of extra
+ * partition respectively corresponding to the side with the extra partition.
+ *
+ * It returns true if the matching succeeds, otherwise returns false.
+ */
+static bool
+handle_missing_partition(PartitionMap *maps_with_missing,
+ PartitionMap *maps_with_extra,
+ int missing_side_default,
+ int extra_part,
+ bool missing_side_outer,
+ bool missing_side_inner,
+ int *next_index, int *default_index,
+ int *merged_index)
+{
+ bool missing_has_default = (missing_side_default != -1);
+
+ if (missing_has_default)
+ {
+ *merged_index = map_and_merge_partitions(maps_with_missing,
+ maps_with_extra,
+ missing_side_default,
+ extra_part,
+ next_index);
+ if (*merged_index < 0)
+ return false;
+
+ if (missing_side_outer)
+ {
+ /*
+ * Default partition on the outer side forms the default
+ * partition of the join result.
+ */
+ if (*default_index < 0)
+ *default_index = *merged_index;
+ else if(*default_index != *merged_index)
+ {
+ /*
+ * Ended up with default partition on the outer side
+ * being joined with multiple partitions on the inner
+ * side. We don't support this case.
+ */
+ return false;
+ }
+
+ /*
+ * Since the merged partition acts as a default partition, it
+ * doesn't need a separate index.
+ */
+ *merged_index = -1;
+ }
+ }
+ else if (missing_side_inner)
+ {
+ /*
+ * If this partition has already been mapped (say because we
+ * found an overlapping range earlier), we know where does it
+ * fit in the join result. Nothing to do in that case. Else
+ * create a new merged partition.
+ */
+ PartitionMap *extra_map = &maps_with_extra[extra_part];
+ if (extra_map->to < 0)
+ {
+ extra_map->to = *next_index;
+ *next_index = *next_index + 1;
+ *merged_index = extra_map->to;
+ }
+ }
+
+ return true;
+}
+
+static PartitionMap*
+init_partition_map(RelOptInfo *rel)
+{
+ int i, nparts = rel->nparts;
+ PartitionMap *map;
+
+ map = (PartitionMap *) palloc(sizeof(PartitionMap) * nparts);
+
+ for (i = 0; i < nparts; i++)
+ {
+ map[i].from = -1;
+ map[i].to = -1;
+ }
+
+ return map;
+}
+
+/*
+ * Allocate and initialize partition maps. We maintain four maps, two maps
+ * for each joining relation. pmap[i] gives the partition from the other
+ * relation which would join with ith partition of the given relation.
+ * Partition i from the given relation will join with partition pmap[i]
+ * from the other relation to produce partition mmap[i] of the join (merged
+ * partition).
+ *
+ * pmap[i] = -1 indicates that ith partition of a given relation does not
+ * have a matching partition from the other relation.
+ *
+ * mmap[i] = -1 indicates that ith partition of a given relation does not
+ * contribute to the join result. That can happen only when the given
+ * relation is the inner relation and it doesn't have a matching partition
+ * from the outer relation, hence pmap[i] should be -1.
+ *
+ * In case of an outer join, every partition of the outer join will appear
+ * in the join result, and thus has mmap[i] set for all i. But it's not
+ * necessary that every partition on the outer side will have a matching
+ * partition on the inner side. In such a case, we end up with pmap[i] = -1
+ * and mmap[i] != -1.
+ */
+
+/*
+ * partition_range_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for range partitioned tables.
+ */
+static PartitionBoundInfo
+partition_range_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype, int partnatts,
+ FmgrInfo *partsupfuncs, Oid *partcollations)
+
+{
+ PartitionMap *outer_maps = NULL;
+ PartitionMap *inner_maps = NULL;
+ int outer_part = 0;
+ int inner_part = 0;
+ PartitionBoundInfo merged_bounds = NULL;
+ int outer_lb_index;
+ int inner_lb_index;
+ int next_index;
+ int default_index = -1;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ List *merged_kinds = NIL;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int inner_default = inner_bi->default_index;
+ int outer_default = outer_bi->default_index;
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_RANGE);
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ outer_maps = init_partition_map(outer_rel);
+ inner_maps = init_partition_map(inner_rel);
+
+ /*
+ * Merge the ranges (partitions) from both sides. Every iteration compares
+ * a pair of ranges, one from each side, advancing to the next range from
+ * the side with smaller upper range bound. If upper bounds of ranges from
+ * both sides match exactly, both the sides are advanced. For a given pair
+ * of ranges, we decide whether the corresponding partition match or not.
+ * lb_index, for inner or outer side, keeps track of the index of lower bound
+ * datum in PartitionBoundInfo::datums of that side.
+ */
+ outer_lb_index = 0;
+ inner_lb_index = 0;
+ next_index = 0;
+ while (outer_lb_index < outer_bi->ndatums ||
+ inner_lb_index < inner_bi->ndatums)
+ {
+ PartitionRangeBound outer_lb, outer_ub,
+ inner_lb, inner_ub,
+ *merged_lb = NULL,
+ *merged_ub = NULL;
+
+ int merged_index = -1;
+ bool overlap;
+ bool finished_outer = false;
+ bool finished_inner = false;
+
+ /* Result of bounds comparison per partition_rbound_cmp(). */
+ int ub_cmpval; /* Upper bounds comparison result. */
+ int lb_cmpval; /* Lower bounds comparison result. */
+
+ /* Get the range bounds of the next pair of partitions. */
+ if (outer_lb_index < outer_bi->ndatums)
+ outer_part = partition_get_range_bounds(outer_bi, outer_lb_index,
+ &outer_lb, &outer_ub);
+ else
+ finished_outer = true;
+
+ if (inner_lb_index < inner_bi->ndatums)
+ inner_part = partition_get_range_bounds(inner_bi, inner_lb_index,
+ &inner_lb, &inner_ub);
+ else
+ finished_inner = true;
+
+ Assert(!finished_outer || !finished_inner);
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining partitions on the side
+ * which finishes later. For that we set the comparison parameters
+ * overlap, ub_cmpval and lb_cmpval in such a way that it appears as if
+ * the side which finishes earlier has an extra partition with lower
+ * and upper bounds higher than any other partition of the unfinished
+ * side. That way we advance the partitions on that side till all of
+ * them are exhausted.
+ */
+ if (finished_outer)
+ {
+ overlap = false;
+ ub_cmpval = 1;
+ lb_cmpval = 1;
+ }
+ else if (finished_inner)
+ {
+ overlap = false;
+ ub_cmpval = -1;
+ lb_cmpval = -1;
+ }
+ else
+ overlap = partition_range_cmp(partnatts, partsupfuncs, partcollations,
+ &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &ub_cmpval, &lb_cmpval);
+
+ if (overlap)
+ {
+ /*
+ * The rows from overlapping portion of ranges on both sides may
+ * join, hence the corresponding pair of partitions form a joining
+ * pair. Match them and produce the bounds of the joint partition
+ * and its index by merging the bounds according to the type of
+ * join.
+ */
+ partition_range_merge(partnatts, partsupfuncs, partcollations,
+ jointype, &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &merged_lb, &merged_ub);
+
+ merged_index = map_and_merge_partitions(outer_maps, inner_maps,
+ outer_part, inner_part,
+ &next_index);
+
+ if (merged_index < 0)
+ {
+ /* Failed to match the partitions. */
+ return NULL;
+ }
+
+ /*
+ * If the ranges overlap but don't exactly match, a row from
+ * non-overlapping portion of the range from one side of join may
+ * find its join partner in the previous or next overlapping
+ * partition or default partition on the other side , if such a
+ * partition exists. All those cases, if true, will cause one
+ * partition from that side to match at least two partitions on the
+ * other side; a case that we do not support now. Previous
+ * partition has been delt with in the previous iteration of this
+ * loop, next partition will be delt in the next iteration. We will
+ * deal with the default partition here.
+ */
+ if ((lb_cmpval < 0 && inner_has_default) ||
+ /* Non-overlapping range on the lower side of outer range. */
+ (lb_cmpval > 0 && outer_has_default) ||
+ /* Non-overlapping range on the lower side of inner range. */
+ (ub_cmpval < 0 && outer_has_default) ||
+ /* Non-overlapping range on the upper side of inner range. */
+ (ub_cmpval > 0 && inner_has_default))
+ /* Non-overlapping range on the upper side of outer range. */
+ return NULL;
+ }
+
+ if (ub_cmpval == 0)
+ {
+ /* Upper bounds of both the ranges match. */
+ Assert(overlap);
+
+ /* Move to the next pair of partitions. */
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+ else if (ub_cmpval < 0)
+ {
+ /* Upper bound of inner range higher than that of the outer. */
+
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the inner side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &outer_lb;
+ merged_ub = &outer_ub;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+ if (!handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ outer_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+ }
+
+ /* Move to the next partition on the outer side. */
+ Assert(!finished_outer);
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ }
+ else
+ {
+ Assert(ub_cmpval > 0);
+
+ /* Upper bound of outer range higher than that of the inner. */
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the outer side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &inner_lb;
+ merged_ub = &inner_ub;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ inner_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+ }
+
+ /* Move to the next partition on the inner side. */
+ Assert (!finished_inner);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+
+ if (merged_index < 0)
+ {
+ /* We didn't find a new merged partition. */
+ continue;
+ }
+
+ /*
+ * We have a valid partition index for the next partition of join. The
+ * partition should have valid range.
+ */
+ Assert(merged_lb && merged_ub);
+
+ /* Try merging new lower bound with the last upper bound. */
+ if (!partition_range_merge_next_lb(partnatts, partsupfuncs,
+ partcollations,
+ merged_lb->datums,
+ merged_lb->kind, &merged_datums,
+ &merged_kinds, &merged_indexes))
+ return NULL;
+
+ /* Add upper bound with the merged partition index. */
+ merged_datums = lappend(merged_datums, merged_ub->datums);
+ merged_kinds = lappend(merged_kinds, merged_ub->kind);
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ }
+
+ if (!merge_default_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index,
+ &default_index))
+ return NULL;
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_maps, inner_maps,
+ outer_nparts, inner_nparts,
+ jointype, next_index,
+ outer_parts, inner_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes,
+ merged_kinds,
+ -1, default_index);
+ }
+
+ /* Free any memory we used in this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ list_free(merged_kinds);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_list_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for list partitioned tables.
+ *
+ */
+static PartitionBoundInfo
+partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype)
+{
+ PartitionMap *outer_maps = NULL;
+ PartitionMap *inner_maps = NULL;
+ int cnto;
+ int cnti;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ int next_index = 0;
+ int null_index;
+ int default_index = -1;
+ PartitionBoundInfo merged_bounds = NULL;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int *outer_indexes = outer_bi->indexes;
+ int *inner_indexes = inner_bi->indexes;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_LIST);
+
+ /* List partitions do not require unbounded ranges. */
+ Assert(!outer_bi->kind && !inner_bi->kind);
+
+ outer_maps = init_partition_map(outer_rel);
+ inner_maps = init_partition_map(inner_rel);
+
+ /*
+ * Merge the list value datums from both sides. Every iteration compares a
+ * pair of datums, one from each side, advancing to the next datum from the
+ * side with smaller datum. If datums from both sides match exactly, both
+ * the sides are advanced. For a given pair of datums, we decide whether
+ * the corresponding partition match or not.
+ */
+ cnto = cnti = 0;
+ while (cnto < outer_bi->ndatums || cnti < inner_bi->ndatums)
+ {
+ Datum *odatums;
+ Datum *idatums;
+ int o_index;
+ int i_index;
+ int cmpval;
+ int merged_index = -1;
+ Datum *merged_datum;
+ bool finished_inner;
+ bool finished_outer;
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining datums on the side which
+ * finishes later. For that we set the comparison parameter cmpval in
+ * such a way that it appears as if the side which finishes earlier has
+ * an extra datum higher than any other datum on the unfinished side.
+ * That way we advance the datums on the unfinished side till all of
+ * its datums are exhausted.
+ */
+ if (cnto >= outer_bi->ndatums)
+ {
+ finished_outer = true;
+ odatums = NULL;
+ o_index = -1;
+ }
+ else
+ {
+ finished_outer = false;
+ odatums = outer_bi->datums[cnto];
+ o_index = outer_indexes[cnto];
+ }
+
+ if (cnti >= inner_bi->ndatums)
+ {
+ finished_inner = true;
+ idatums = NULL;
+ i_index = -1;
+ }
+ else
+ {
+ finished_inner = false;
+ idatums = inner_bi->datums[cnti];
+ i_index = inner_indexes[cnti];
+ }
+
+ /* If we exhausted both the sides, we won't enter the loop. */
+ Assert(!finished_inner || !finished_outer);
+
+ if (finished_outer)
+ cmpval = 1;
+ else if (finished_inner)
+ cmpval = -1;
+ else
+ {
+ /* Every list datum should map to a valid partition index. */
+ Assert(o_index >= 0 && i_index >= 0 &&
+ odatums != NULL && idatums != NULL);
+
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
+ partcollation[0],
+ odatums[0], idatums[0]));
+ }
+
+ if (cmpval == 0)
+ {
+ /*
+ * Datums match. Rows on either side with these datums as partition
+ * key value will join and will be part of the partition of the
+ * join result produced by joining the corresponding partitions.
+ * Match the corresponding partitions and if successful, add the
+ * datum to the list of merged datums with index of merged
+ * partition containing it.
+ */
+ merged_datum = odatums;
+ merged_index = map_and_merge_partitions(outer_maps, inner_maps,
+ o_index, i_index,
+ &next_index);
+
+ if (merged_index < 0)
+ return NULL;
+
+ /* Move to the next pair of bounds. */
+ cnto++;
+ cnti++;
+ }
+ else if (cmpval < 0)
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /* A datum missing from the inner side. */
+ merged_index = -1;
+ merged_datum = odatums;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ o_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+
+ /* Move to the next datum on the outer side. */
+ Assert(!finished_outer);
+ cnto++;
+ }
+ else
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ Assert(cmpval > 0);
+
+ /* A datum missing from the outer side. */
+ merged_index = -1;
+ merged_datum = idatums;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ i_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+
+ /* Move to the next datum on the right side. */
+ Assert(!finished_inner);
+ cnti++;
+ }
+
+ /*
+ * Add the list value with appropriate index in the list of datums, if
+ * we have associated a partition with this list value.
+ */
+ if (merged_index >= 0)
+ {
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ merged_datums = lappend(merged_datums, merged_datum);
+ }
+ }
+
+ if (!merge_null_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index, &null_index,
+ &default_index))
+ return NULL;
+
+ if (!merge_default_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index,
+ &default_index))
+ return NULL;
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_maps, inner_maps,
+ outer_nparts, inner_nparts,
+ jointype, next_index,
+ outer_parts, inner_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes, NIL,
+ null_index, default_index);
+ }
+
+ /* Free up all extra memory before returning from this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_bounds_merge()'s arm for hash partitioned tables.
+ *
+ * If the given two hash bounds are same, the function returns the first one
+ * without any change, alongwith the lists of matching partitions. Otherwise it
+ * returns NULL.
+ *
+ * We could try merging the bounds when both the bounds have same greatest
+ * modulii. But there seems to be hardly any requirement for the same.
+ */
+static PartitionBoundInfo
+partition_hash_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype)
+{
+ int nparts;
+ int cnt;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * Hash partitioned table does not have explicit NULL accepting partition
+ * and also does not have a default partition.
+ */
+ Assert(!partition_bound_has_default(outer_bi) &&
+ !partition_bound_has_default(inner_bi));
+ Assert(!partition_bound_accepts_nulls(outer_bi) &&
+ !partition_bound_accepts_nulls(inner_bi));
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+
+ if (outer_nparts != inner_nparts)
+ return NULL;
+ nparts = outer_nparts;
+
+ if (outer_bi->ndatums != inner_bi->ndatums ||
+ !partition_hbounds_equal(outer_bi, inner_bi))
+ return NULL;
+
+ /*
+ * Cook up list of matching partitions. Since bounds are exactly same the
+ * partitions at the same position from both the relations match.
+ */
+ for (cnt = 0; cnt < nparts; cnt++)
+ {
+ *outer_parts = lappend_int(*outer_parts, cnt);
+ *inner_parts = lappend_int(*inner_parts, cnt);
+ }
+
+ return outer_bi;
+}
+
+/*
+ * map_and_merge_partitions
+ *
+ * If the two given partitions (given by index1 and index2 resp.) are
+ * already mapped to each other return the index of corresponding partition in
+ * the merged set of partitions. If they do not have a merged partition
+ * associated with them, assign a new merged partition index. If the
+ * partitions are already mapped and their mapped partitions are different from
+ * each other, they can not be merged, so return -1.
+ *
+ * partmaps1[i] gives the mapping of partitions for both relations. It
+ * describes which partition of relation 2 matches ith partition of relation 1,
+ * and which partition in the merged set matches ith partition of relation 1
+ * maps to. Similarly for partmap2.
+ *
+ * index1 and index2 are the indexes of matching partition from respective
+ * relations.
+ *
+ * *next_index is used and incremented when the given partitions require a new
+ * merged partition.
+ */
+
+static int
+map_and_merge_partitions(PartitionMap *partmaps1, PartitionMap *partmaps2,
+ int index1, int index2, int *next_index)
+{
+ PartitionMap *partmap1 = &partmaps1[index1];
+ PartitionMap *partmap2 = &partmaps2[index2];
+ int merged_index;
+
+ /*
+ * If both the partitions are not mapped to each other, update the
+ * maps.
+ */
+ if (partmap1->from < 0 && partmap2->from < 0)
+ {
+ partmap1->from = index2;
+ partmap2->from = index1;
+ }
+
+ /*
+ * If the given to partitions map to each other, find the corresponding
+ * merged partition index .
+ */
+ if (partmap1->from == index2 && partmap2->from == index1)
+ {
+ /*
+ * If both the partitions are mapped to the same merged partition, get
+ * the index of merged partition.
+ */
+ if (partmap1->to == partmap2->to)
+ {
+ merged_index = partmap1->to;
+
+ /*
+ * If the given two partitions do not have a merged partition
+ * associated with them, allocate a new merged partition.
+ */
+ if (merged_index < 0)
+ {
+ merged_index = *next_index;
+ *next_index = *next_index + 1;
+ partmap1->to = merged_index;
+ partmap2->to = merged_index;
+ }
+ }
+
+ /*
+ * If partition from one relation was mapped to a merged partition but
+ * not the partition from the other relation, map the same merged
+ * partition to the partition from other relation, since matching
+ * partitions map to the same merged partition.
+ */
+ else if (partmap1->to >= 0 && partmap2->to < 0)
+ {
+ partmap2->to = partmap1->to;
+ merged_index = partmap1->to;
+ }
+ else if (partmap1->to < 0 && partmap2->to >= 0)
+ {
+ partmap1->to = partmap2->to;
+ merged_index = partmap2->to;
+ }
+ else
+ {
+ Assert(partmap1->to != partmap2->to &&
+ partmap1->to >= 0 && partmap2->to >= 0);
+
+ /*
+ * Both the partitions map to different merged partitions. This
+ * means that multiple partitions from one relation matches to one
+ * partition from the other relation. Partition-wise join does not
+ * handle this case right now, since it requires ganging multiple
+ * partitions together (into one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+ }
+ else
+ {
+ /*
+ * Multiple partitions from one relation map to one partition from the
+ * other relation. Partition-wise join does not handle this case right
+ * now, since it requires ganging multiple partitions together (into
+ * one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+
+ return merged_index;
+}
+
+/*
+ * generate_matching_part_pairs
+ *
+ * partmaps1 map each partition from either side of the join to a merged
+ * partition resp. E.g. partmaps1[i].to gives the merged partition to which ith
+ * partition of first relation maps. Similarly for partmap2. If
+ * partmaps1[i].to == partmaps2[j].to, i and j form the matching pair of
+ * partitions.
+ *
+ * Given these maps this function produces the list pairs of partitions which
+ * when joined produce the merged partitions in the order of merged partition
+ * indexes.
+ *
+ * nparts1 and nparts2 are the number of partitions of the joining relations
+ * resp.
+ *
+ * nparts is the number of merged partitions.
+ *
+ * If successful, the pairs of partitions are returned as two separate lists,
+ * parts1 and parts2 resp., one for each side. Otherwise, those lists will be
+ * set to NIL.
+ */
+static void
+generate_matching_part_pairs(PartitionMap *partmaps1, PartitionMap *partmaps2,
+ int nparts1, int nparts2,
+ JoinType jointype, int nparts,
+ List **matched_parts1, List **matched_parts2)
+{
+ bool merged = true;
+ int *matching1 = (int *) palloc(sizeof(int) * nparts),
+ *matching2 = (int *) palloc(sizeof(int) * nparts);
+ int i;
+
+ *matched_parts1 = NIL;
+ *matched_parts2 = NIL;
+
+ /* Set pairs of matching partitions. */
+ for (i = 0; i < nparts; i++)
+ {
+ if (i >= nparts1)
+ matching1[i] = -1;
+ else
+ {
+ PartitionMap outer_map = partmaps1[i];
+
+ if (outer_map.to >= 0)
+ {
+ Assert(outer_map.to < nparts);
+ matching1[outer_map.to] = i;
+ }
+ }
+
+ if (i >= nparts2)
+ matching2[i] = -1;
+ else
+ {
+ PartitionMap inner_map = partmaps2[i];
+
+ if (inner_map.to >= 0)
+ {
+ Assert(inner_map.to < nparts);
+ matching2[inner_map.to] = i;
+ }
+ }
+ }
+
+ /*
+ * If we have a partition missing on an inner side, we need to add a dummy
+ * relation which joins with the outer partition. If the inner relation
+ * happens to be a base relation, it will require adding a dummy child
+ * base relation during join processing. Right now, we freeze the base
+ * relation arrays like PlannerInfo::simple_rte_array after planning for
+ * base relations. Adding a new (dummy) base relation would require some
+ * changes to that. So, right now, we do not implement partition-wise join
+ * in such cases.
+ */
+ for (i = 0; i < nparts; i++)
+ {
+ int part1 = matching1[i];
+ int part2 = matching2[i];
+
+ /* At least one of the partitions should exist. */
+ Assert(part1 >= 0 || part2 >= 0);
+
+ switch (jointype)
+ {
+ case JOIN_INNER:
+ case JOIN_SEMI:
+
+ /*
+ * An inner or semi join can not return any row when the
+ * matching partition on either side is missing. We should
+ * have eliminated all such cases while merging the bounds.
+ */
+ Assert(part1 >= 0 && part2 >= 0);
+ break;
+
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ Assert(part1 >= 0);
+ if (part2 < 0)
+ merged = false;
+ break;
+
+ case JOIN_FULL:
+ if (part1 < 0 || part2 < 0)
+ merged = false;
+ break;
+
+ default:
+ elog(ERROR, "unrecognized join type: %d", (int) jointype);
+ }
+
+ if (!merged)
+ break;
+
+ *matched_parts1 = lappend_int(*matched_parts1, part1);
+ *matched_parts2 = lappend_int(*matched_parts2, part2);
+ }
+
+ pfree(matching1);
+ pfree(matching2);
+
+ if (!merged)
+ {
+ list_free(*matched_parts1);
+ list_free(*matched_parts2);
+ *matched_parts1 = NIL;
+ *matched_parts2 = NIL;
+ }
+}
+
+static PartitionBoundInfo
+build_merged_partition_bounds(char strategy, List *merged_datums,
+ List *merged_indexes, List *merged_kinds,
+ int null_index, int default_index)
+{
+ int cnt;
+ PartitionBoundInfo merged_bounds;
+ ListCell *lc;
+
+ /* We expect the same number of elements in datums and indexes lists. */
+ Assert(list_length(merged_datums) == list_length(merged_indexes));
+
+ merged_bounds = (PartitionBoundInfo) palloc(sizeof(PartitionBoundInfoData));
+ merged_bounds->strategy = strategy;
+ merged_bounds->ndatums = list_length(merged_datums);
+
+ if (strategy == PARTITION_STRATEGY_RANGE)
+ {
+ Assert(list_length(merged_datums) == list_length(merged_kinds));
+ merged_bounds->kind =
+ (PartitionRangeDatumKind **) palloc(sizeof(PartitionRangeDatumKind *) *
+ list_length(merged_kinds));
+ cnt = 0;
+ foreach(lc, merged_kinds)
+ merged_bounds->kind[cnt++] = lfirst(lc);
+
+ /* There are ndatums+1 indexes in case of range partitions */
+ merged_indexes = lappend_int(merged_indexes, -1);
+ }
+ else
+ merged_bounds->kind = NULL;
+
+ cnt = 0;
+ merged_bounds->datums = (Datum **) palloc(sizeof(Datum *) *
+ list_length(merged_datums));
+ foreach(lc, merged_datums)
+ merged_bounds->datums[cnt++] = lfirst(lc);
+
+ merged_bounds->indexes = (int *) palloc(sizeof(int) *
+ list_length(merged_indexes));
+ cnt = 0;
+ foreach(lc, merged_indexes)
+ merged_bounds->indexes[cnt++] = lfirst_int(lc);
+
+ merged_bounds->null_index = null_index;
+ merged_bounds->default_index = default_index;
+
+ return merged_bounds;
+}
+
+/*
+ * Merge default partitions from both sides, if any, and assign the default
+ * partition for the join result, if necessary.
+ *
+ * If both the relations have default partitions, try mapping those to each
+ * other. If the mapping succeeds corresponding merged partition will act as
+ * the default partition of the join result.
+ *
+ * If inner side of the join has default but not the outer side, rows in it
+ * won't appear in the join result. So don't create a default partition. If
+ * outer side of the join has default but not the inner side, rows in it will
+ * appear in the join result, so create a default merged partition.
+ */
+static bool
+merge_default_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps, PartitionMap *inner_maps,
+ JoinType jointype, int *next_index, int *default_index)
+{
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool merged = true;
+ PartitionMap *outer_default_map = NULL;
+ PartitionMap *inner_default_map = NULL;
+
+ if (outer_has_default)
+ outer_default_map = &outer_maps[outer_default];
+
+ if (inner_has_default)
+ inner_default_map = &inner_maps[inner_default];
+
+ if (!outer_has_default && !inner_has_default)
+ Assert(*default_index < 0);
+ else if (outer_default_map != NULL && inner_default_map == NULL)
+ {
+ if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (outer_default_map->to < 0)
+ {
+ outer_default_map->to = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = outer_default_map->to;
+ }
+ else
+ Assert(*default_index == outer_default_map->to);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else if (outer_default_map == NULL && inner_default_map != NULL)
+ {
+ if (jointype == JOIN_FULL)
+ {
+ if (inner_default_map->to < 0)
+ {
+ inner_default_map->to = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = inner_default_map->to;
+ }
+ else
+ Assert(*default_index == inner_default_map->to);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else
+ {
+ Assert(outer_has_default && inner_has_default);
+
+ *default_index = map_and_merge_partitions(outer_maps, inner_maps,
+ outer_default, inner_default,
+ next_index);
+
+ if (*default_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
+
+/*
+ * merge_null_partitions
+ *
+ * Merge NULL partitions, i.e. a partition that can hold NULL values for a list
+ * partitioned table, if any. Find the index of merged partition to which the
+ * NULL values would belong in the join result. If one joining relation has a
+ * NULL partition but not the other, try matching it with the default partition
+ * from the other relation since the default partition may have rows with NULL
+ * partition key. We can eliminate a NULL partition when it appears only on the
+ * inner side of the join and the outer side doesn't have a default partition.
+ *
+ * When the equality operator used for join is strict, two NULL values will not
+ * be considered as equal, and thus a NULL partition can be eliminated for an
+ * inner join. But we don't check the strictness operator here.
+ */
+static bool
+merge_null_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps, PartitionMap *inner_maps,
+ JoinType jointype, int *next_index,
+ int *null_index, int *default_index)
+{
+ bool outer_has_null = partition_bound_accepts_nulls(outer_bi);
+ bool inner_has_null = partition_bound_accepts_nulls(inner_bi);
+ int outer_ni = outer_bi->null_index;
+ int inner_ni = inner_bi->null_index;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool merged = true;
+
+ if (!outer_has_null && !inner_has_null)
+ *null_index = -1;
+ else if (outer_has_null && !inner_has_null)
+ {
+ int merged_index;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+
+ merged = handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ outer_ni,
+ missing_side_outer,
+ missing_side_inner, next_index,
+ default_index, &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join to which the outer null partition maps
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = outer_maps[outer_ni].to;
+ }
+ else if (!outer_has_null && inner_has_null)
+ {
+ int merged_index;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as OUTER
+ * relation. For INNER and SEMI join OUTER and INNER differentiation is
+ * immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+ merged = handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ inner_ni,
+ missing_side_outer,
+ missing_side_inner,
+ next_index, default_index,
+ &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join, to which the outer side null partition maps,
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = inner_maps[inner_ni].to;
+ }
+ else
+ {
+ /* Both the relations have NULL partitions, try merging them. */
+ *null_index = map_and_merge_partitions(outer_maps,
+ inner_maps,
+ outer_ni,
+ inner_ni,
+ next_index);
+ if (*null_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
diff --git a/src/include/partitioning/partbounds.h b/src/include/partitioning/partbounds.h
index b1ae39ad63..fb2dc1cbb1 100644
--- a/src/include/partitioning/partbounds.h
+++ b/src/include/partitioning/partbounds.h
@@ -16,6 +16,7 @@
#include "nodes/pg_list.h"
#include "partitioning/partdefs.h"
#include "utils/relcache.h"
+struct RelOptInfo; /* avoid including pathnodes.h here */
/*
@@ -107,5 +108,11 @@ extern int partition_range_datum_bsearch(FmgrInfo *partsupfunc,
int nvalues, Datum *values, bool *is_equal);
extern int partition_hash_bsearch(PartitionBoundInfo boundinfo,
int modulus, int remainder);
+extern PartitionBoundInfo partition_bounds_merge(int partnatts,
+ FmgrInfo *partsupfunc, Oid *partcollation,
+ struct RelOptInfo *outer_rel,
+ struct RelOptInfo *inner_rel,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts);
#endif /* PARTBOUNDS_H */
--
2.18.0
[application/x-patch] 0003-Tests-for-0-1-1-1-and-1-0-partition-matching-v19.patch (213.3K, ../../CAAJ_b95ja_Uyy8Q51Muh5TNEoWSbHCoMFGOEOHUQLxUWvA3Csg@mail.gmail.com/5-0003-Tests-for-0-1-1-1-and-1-0-partition-matching-v19.patch)
download | inline diff:
From 445852d92d377d62dac7d1e15446a683baeb9164 Mon Sep 17 00:00:00 2001
From: Amul Sul <amul.sul@enterprisedb.com>
Date: Tue, 5 Mar 2019 00:40:55 -0500
Subject: [PATCH 3/3] Tests for 0:1, 1:1 and 1:0 partition matching
Rajkumar Raghuvanshi and Ashutosh Bapat.
---
src/test/regress/expected/partition_join.out | 3955 +++++++++++++++---
src/test/regress/sql/partition_join.sql | 427 +-
2 files changed, 3767 insertions(+), 615 deletions(-)
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index bbdc373782..7954ba2c91 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -8,59 +8,86 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(21 rows)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
-(4 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+(7 rows)
-- left outer join, with whole-row reference; partitionwise join does not apply
EXPLAIN (COSTS OFF)
@@ -72,35 +99,50 @@ SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(22 rows)
SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- t1 | t2
---------------+--------------
- (0,0,0000) | (0,0,0000)
- (50,0,0050) |
- (100,0,0100) |
- (150,0,0150) | (0,150,0150)
- (200,0,0200) |
- (250,0,0250) |
- (300,0,0300) | (0,300,0300)
- (350,0,0350) |
- (400,0,0400) |
- (450,0,0450) | (0,450,0450)
- (500,0,0500) |
- (550,0,0550) |
-(12 rows)
+ t1 | t2
+----------------+----------------
+ (-250,0,-0250) |
+ (-200,0,-0200) |
+ (-150,0,-0150) | (0,-150,-0150)
+ (-100,0,-0100) |
+ (-50,0,-0050) |
+ (0,0,0000) | (0,0,0000)
+ (50,0,0050) |
+ (100,0,0100) |
+ (150,0,0150) | (0,150,0150)
+ (200,0,0200) |
+ (250,0,0250) |
+ (300,0,0300) | (0,300,0300)
+ (350,0,0350) |
+ (400,0,0400) |
+ (450,0,0450) | (0,450,0450)
+ (500,0,0500) |
+ (550,0,0550) |
+ (600,0,0600) | (0,600,0600)
+ (650,0,0650) |
+ (700,0,0700) |
+ (750,0,0750) | (0,750,0750)
+(21 rows)
-- right outer join
EXPLAIN (COSTS OFF)
@@ -112,35 +154,53 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHE
-> Append
-> Hash Right Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Right Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Hash Right Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-> Nested Loop Left Join
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p3 t2_3
Filter: (a = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t2_2.b)
-(20 rows)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
- | | 75 | 0075
- | | 225 | 0225
- | | 375 | 0375
- | | 525 | 0525
-(8 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+ | | -225 | -0225
+ | | -75 | -0075
+ | | 75 | 0075
+ | | 225 | 0225
+ | | 375 | 0375
+ | | 525 | 0525
+ | | 675 | 0675
+(14 rows)
-- full outer join, with placeholder vars
EXPLAIN (COSTS OFF)
@@ -148,8 +208,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
QUERY PLAN
------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b
+ Sort Key: prt1_p0.a, prt2_p0.b
-> Append
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ Filter: (((50) = prt1_p0.a) OR ((75) = prt2_p0.b))
+ -> Seq Scan on prt1_p0
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p1.a = prt2_p1.b)
Filter: (((50) = prt1_p1.a) OR ((75) = prt2_p1.b))
@@ -174,7 +242,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
-> Hash
-> Seq Scan on prt2_p3
Filter: (a = 0)
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ Filter: (((50) = prt1_p4.a) OR ((75) = prt2_p4.b))
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) WHERE t1.phv = t1.a OR t2.phv = t2.b ORDER BY t1.a, t2.b;
a | c | b | c
@@ -211,8 +287,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Hash Left Join
+ Hash Cond: (prt1_p0.a = b)
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Hash
+ -> Result
+ One-Time Filter: false
-> Hash Left Join
Hash Cond: (prt1_p1.a = b)
-> Seq Scan on prt1_p1
@@ -227,29 +310,42 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
-> Hash
-> Seq Scan on prt1_p2
Filter: ((a < 450) AND (b = 0))
-(17 rows)
+(24 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
-(9 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+(14 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
QUERY PLAN
------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = b)
+ Filter: ((prt1_p0.b = 0) OR (a = 0))
+ -> Seq Scan on prt1_p0
+ Filter: (a < 450)
+ -> Hash
+ -> Result
+ One-Time Filter: false
-> Hash Full Join
Hash Cond: (prt1_p1.a = b)
Filter: ((prt1_p1.b = 0) OR (a = 0))
@@ -274,64 +370,153 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JO
-> Hash
-> Result
One-Time Filter: false
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt2_p4.b = a)
+ Filter: ((b = 0) OR (prt2_p4.a = 0))
+ -> Seq Scan on prt2_p4
+ Filter: (b > 250)
+ -> Hash
+ -> Result
+ One-Time Filter: false
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
- | | 375 | 0375
- | | 450 | 0450
- | | 525 | 0525
-(12 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ | | 375 | 0375
+ | | 450 | 0450
+ | | 525 | 0525
+ | | 600 | 0600
+ | | 675 | 0675
+ | | 750 | 0750
+(20 rows)
-- Semi-join
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Semi Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Semi Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Nested Loop Semi Join
- Join Filter: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Materialize
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-(24 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(39 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p0 t2
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_2.b = t2_2.a)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p2 t2_2
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: (t1_3.b = t2_3.a)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt1_p3 t2_3
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.b = t2_4.a)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p4 t2_4
+ Filter: (b = 0)
+(37 rows)
+
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
@@ -342,27 +527,82 @@ SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS
-> Append
-> Hash Anti Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash Anti Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash Anti Join
Hash Cond: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p3 t2_2
-(17 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash Anti Join
+ Hash Cond: (t1_3.a = t2_3.b)
+ -> Seq Scan on prt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_3
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(27 rows)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
- sum | avg | sum | avg
--------+----------------------+------+---------------------
- 60000 | 300.0000000000000000 | 2400 | 12.0000000000000000
+ sum | avg | sum | avg
+-------+----------------------+------+--------------------
+ 95550 | 273.0000000000000000 | 2200 | 6.2857142857142857
(1 row)
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ QUERY PLAN
+--------------------------------------------------------------
+ Append
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Hash Anti Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(27 rows)
+
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ b | c
+------+-------
+ -225 | -0225
+ -75 | -0075
+ 75 | 0075
+ 225 | 0225
+ 375 | 0375
+ 525 | 0525
+ 675 | 0675
+(7 rows)
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -374,49 +614,74 @@ SELECT * FROM prt1 t1 LEFT JOIN LATERAL
Sort Key: t1.a
-> Append
-> Nested Loop Left Join
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p1_a on prt1_p1 t2
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
Index Cond: (a = t1.a)
- -> Index Scan using iprt2_p1_b on prt2_p1 t3
+ -> Index Scan using iprt2_p0_b on prt2_p0 t3
Index Cond: (b = t2.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_1
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
Index Cond: (a = t1_1.a)
- -> Index Scan using iprt2_p2_b on prt2_p2 t3_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t3_1
Index Cond: (b = t2_1.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_2
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
Index Cond: (a = t1_2.a)
- -> Index Scan using iprt2_p3_b on prt2_p3 t3_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t3_2
Index Cond: (b = t2_2.a)
-(27 rows)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.a)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t3_3
+ Index Cond: (b = t2_3.a)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.a)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t3_4
+ Index Cond: (b = t2_4.a)
+(43 rows)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, least(t1.a,t2.a,t3.b) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.a = ss.t2a WHERE t1.b = 0 ORDER BY t1.a;
- a | b | c | t2a | t3a | least
------+---+------+-----+-----+-------
- 0 | 0 | 0000 | 0 | 0 | 0
- 50 | 0 | 0050 | | |
- 100 | 0 | 0100 | | |
- 150 | 0 | 0150 | 150 | 0 | 150
- 200 | 0 | 0200 | | |
- 250 | 0 | 0250 | | |
- 300 | 0 | 0300 | 300 | 0 | 300
- 350 | 0 | 0350 | | |
- 400 | 0 | 0400 | | |
- 450 | 0 | 0450 | 450 | 0 | 450
- 500 | 0 | 0500 | | |
- 550 | 0 | 0550 | | |
-(12 rows)
+ a | b | c | t2a | t3a | least
+------+---+-------+------+-----+-------
+ -250 | 0 | -0250 | | |
+ -200 | 0 | -0200 | | |
+ -150 | 0 | -0150 | -150 | 0 | -150
+ -100 | 0 | -0100 | | |
+ -50 | 0 | -0050 | | |
+ 0 | 0 | 0000 | 0 | 0 | 0
+ 50 | 0 | 0050 | | |
+ 100 | 0 | 0100 | | |
+ 150 | 0 | 0150 | 150 | 0 | 150
+ 200 | 0 | 0200 | | |
+ 250 | 0 | 0250 | | |
+ 300 | 0 | 0300 | 300 | 0 | 300
+ 350 | 0 | 0350 | | |
+ 400 | 0 | 0400 | | |
+ 450 | 0 | 0450 | 450 | 0 | 450
+ 500 | 0 | 0500 | | |
+ 550 | 0 | 0550 | | |
+ 600 | 0 | 0600 | 600 | 0 | 600
+ 650 | 0 | 0650 | | |
+ 700 | 0 | 0700 | | |
+ 750 | 0 | 0750 | 750 | 0 | 750
+(21 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
@@ -430,64 +695,95 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
Hash Cond: ((t1.c)::text = (t2.c)::text)
Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Hash Join
Hash Cond: (t2.a = t3.b)
- -> Seq Scan on prt1_p1 t2
+ -> Seq Scan on prt1_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t3
+ -> Seq Scan on prt2_p0 t3
-> Hash Join
Hash Cond: (t2_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t2_1
+ -> Seq Scan on prt1_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p1 t3_1
-> Hash Join
Hash Cond: (t2_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p2 t2_2
-> Hash
- -> Seq Scan on prt2_p3 t3_2
-(26 rows)
+ -> Seq Scan on prt2_p2 t3_2
+ -> Hash Join
+ Hash Cond: (t2_3.a = t3_3.b)
+ -> Seq Scan on prt1_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t3_3
+ -> Hash Join
+ Hash Cond: (t2_4.a = t3_4.b)
+ -> Seq Scan on prt1_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t3_4
+(38 rows)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, t2.b t2b, t2.c t2c, least(t1.a,t2.a,t3.a) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.c = ss.t2c WHERE (t1.b + coalesce(ss.t2b, 0)) = 0 ORDER BY t1.a;
- a | t2a | t2c
------+-----+------
- 0 | 0 | 0000
- 50 | |
- 100 | |
- 150 | 150 | 0150
- 200 | |
- 250 | |
- 300 | 300 | 0300
- 350 | |
- 400 | |
- 450 | 450 | 0450
- 500 | |
- 550 | |
-(12 rows)
+ a | t2a | t2c
+------+------+-------
+ -250 | |
+ -200 | |
+ -150 | -150 | -0150
+ -100 | |
+ -50 | |
+ 0 | 0 | 0000
+ 50 | |
+ 100 | |
+ 150 | 150 | 0150
+ 200 | |
+ 250 | |
+ 300 | 300 | 0300
+ 350 | |
+ 400 | |
+ 450 | 450 | 0450
+ 500 | |
+ 550 | |
+ 600 | 600 | 0600
+ 650 | |
+ 700 | |
+ 750 | 750 | 0750
+(21 rows)
--
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
@@ -498,32 +794,49 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 =
-> Append
-> Hash Join
Hash Cond: (((t2.b + t2.a) / 2) = ((t1.a + t1.b) / 2))
- -> Seq Scan on prt2_e_p1 t2
+ -> Seq Scan on prt2_e_p0 t2
-> Hash
- -> Seq Scan on prt1_e_p1 t1
+ -> Seq Scan on prt1_e_p0 t1
Filter: (c = 0)
-> Hash Join
- Hash Cond: (((t2_1.b + t2_1.a) / 2) = ((t1_1.a + t1_1.b) / 2))
- -> Seq Scan on prt2_e_p2 t2_1
+ Hash Cond: (((t1_1.a + t1_1.b) / 2) = ((t2_1.b + t2_1.a) / 2))
+ -> Seq Scan on prt1_e_p1 t1_1
+ Filter: (c = 0)
-> Hash
- -> Seq Scan on prt1_e_p2 t1_1
- Filter: (c = 0)
+ -> Seq Scan on prt2_e_p1 t2_1
-> Hash Join
Hash Cond: (((t2_2.b + t2_2.a) / 2) = ((t1_2.a + t1_2.b) / 2))
- -> Seq Scan on prt2_e_p3 t2_2
+ -> Seq Scan on prt2_e_p2 t2_2
-> Hash
- -> Seq Scan on prt1_e_p3 t1_2
+ -> Seq Scan on prt1_e_p2 t1_2
Filter: (c = 0)
-(21 rows)
+ -> Hash Join
+ Hash Cond: (((t2_3.b + t2_3.a) / 2) = ((t1_3.a + t1_3.b) / 2))
+ -> Seq Scan on prt2_e_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t1_3
+ Filter: (c = 0)
+ -> Hash Join
+ Hash Cond: (((t2_4.b + t2_4.a) / 2) = ((t1_4.a + t1_4.b) / 2))
+ -> Seq Scan on prt2_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_4
+ Filter: (c = 0)
+(33 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 150 | 0 | 150 | 0
- 300 | 0 | 300 | 0
- 450 | 0 | 450 | 0
-(4 rows)
+ a | c | b | c
+------+---+------+---
+ -250 | 0 | -250 | 0
+ -100 | 0 | -100 | 0
+ 0 | 0 | 0 | 0
+ 0 | 0 | 0 | 0
+ 150 | 0 | 150 | 0
+ 300 | 0 | 300 | 0
+ 450 | 0 | 450 | 0
+ 600 | 0 | 600 | 0
+ 750 | 0 | 750 | 0
+(9 rows)
--
-- N-way join
@@ -536,154 +849,232 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = ((t3.a + t3.b) / 2))
+ Join Filter: (t1.a = t2.b)
-> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p1_ab2 on prt1_e_p1 t3
- Index Cond: (((a + b) / 2) = t2.b)
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
+ Index Cond: (b = ((t3.a + t3.b) / 2))
-> Nested Loop
Join Filter: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_1
+ -> Index Scan using iprt1_e_p4_ab2 on prt1_e_p1 t3_1
Index Cond: (((a + b) / 2) = t2_1.b)
-> Nested Loop
Join Filter: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_2
Index Cond: (((a + b) / 2) = t2_2.b)
-(33 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = ((t3_3.a + t3_3.b) / 2))
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (((a + b) / 2) = t2_3.b)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t2_4.b)
+ -> Hash Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (b = ((t3_4.a + t3_4.b) / 2))
+(52 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t3 WHERE t1.a = t2.b AND t1.a = (t3.a + t3.b)/2 AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
-(4 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(8 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
---------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Hash Right Join
Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_1.a + t3_1.b) / 2) = t1_1.a)
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
-> Hash
-> Hash Right Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_2.a + t3_2.b) / 2) = t1_2.a)
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
-> Hash
-> Hash Right Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(33 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (((a + b) / 2) = t1_3.a)
+ -> Hash Right Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(51 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
--------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1.a = ((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
Index Cond: (b = t1.a)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t2_1
Index Cond: (b = t1_1.a)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t2_2
Index Cond: (b = t1_2.a)
-(30 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t3_3.a + t3_3.b) / 2))
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Nested Loop Left Join
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = ((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (b = t1_4.a)
+(47 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- Cases with non-nullable expressions in subquery results;
-- make sure these go to null as expected
@@ -692,21 +1083,34 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
QUERY PLAN
----------------------------------------------------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b, ((prt1_e_p1.a + prt1_e_p1.b))
+ Sort Key: prt1_p0.a, prt2_p0.b, ((prt1_e_p0.a + prt1_e_p0.b))
-> Append
-> Hash Full Join
- Hash Cond: (prt1_p1.a = ((prt1_e_p1.a + prt1_e_p1.b) / 2))
- Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ Hash Cond: (prt1_p0.a = ((prt1_e_p0.a + prt1_e_p0.b) / 2))
+ Filter: ((prt1_p0.a = (50)) OR (prt2_p0.b = (75)) OR (((prt1_e_p0.a + prt1_e_p0.b) / 2) = (50)))
-> Hash Full Join
- Hash Cond: (prt1_p1.a = prt2_p1.b)
- -> Seq Scan on prt1_p1
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ -> Seq Scan on prt1_p0
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1
+ -> Seq Scan on prt2_p0
Filter: (a = 0)
-> Hash
- -> Seq Scan on prt1_e_p1
+ -> Seq Scan on prt1_e_p0
Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: (((prt1_e_p1.a + prt1_e_p1.b) / 2) = prt1_p1.a)
+ Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ -> Seq Scan on prt1_e_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Hash Full Join
+ Hash Cond: (prt1_p1.a = prt2_p1.b)
+ -> Seq Scan on prt1_p1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p2.a = ((prt1_e_p2.a + prt1_e_p2.b) / 2))
Filter: ((prt1_p2.a = (50)) OR (prt2_p2.b = (75)) OR (((prt1_e_p2.a + prt1_e_p2.b) / 2) = (50)))
@@ -733,7 +1137,20 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
-> Hash
-> Seq Scan on prt1_e_p3
Filter: (c = 0)
-(42 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = ((prt1_e_p4.a + prt1_e_p4.b) / 2))
+ Filter: ((prt1_p4.a = (50)) OR (prt2_p4.b = (75)) OR (((prt1_e_p4.a + prt1_e_p4.b) / 2) = (50)))
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_e_p4
+ Filter: (c = 0)
+(68 rows)
SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b)) FULL JOIN (SELECT 50 phv, * FROM prt1_e WHERE prt1_e.c = 0) t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.a = t1.phv OR t2.b = t2.phv OR (t3.a + t3.b)/2 = t3.phv ORDER BY t1.a, t2.b, t3.a + t3.b;
a | phv | b | phv | ?column? | phv
@@ -751,172 +1168,260 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHER
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = t1_3.b)
+ Join Filter: (t1.a = t1_5.b)
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Join
- Hash Cond: (((t2.a + t2.b) / 2) = t1_3.b)
- -> Seq Scan on prt1_e_p1 t2
+ Hash Cond: (((t2.a + t2.b) / 2) = t1_5.b)
+ -> Seq Scan on prt1_e_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t1_3
+ -> Seq Scan on prt2_p0 t1_5
Filter: (a = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
Index Cond: (a = ((t2.a + t2.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_1.a = t1_4.b)
+ Join Filter: (t1_1.a = t1_6.b)
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Join
- Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_4.b)
- -> Seq Scan on prt1_e_p2 t2_1
+ Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_6.b)
+ -> Seq Scan on prt1_e_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t1_4
+ -> Seq Scan on prt2_p1 t1_6
Filter: (a = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
Index Cond: (a = ((t2_1.a + t2_1.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_2.a = t1_5.b)
+ Join Filter: (t1_2.a = t1_7.b)
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Nested Loop
- -> Seq Scan on prt2_p3 t1_5
+ -> Seq Scan on prt2_p2 t1_7
Filter: (a = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_2
- Index Cond: (((a + b) / 2) = t1_5.b)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t2_2
+ Index Cond: (((a + b) / 2) = t1_7.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
Index Cond: (a = ((t2_2.a + t2_2.b) / 2))
Filter: (b = 0)
-(41 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = t1_8.b)
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t1_8
+ Filter: (a = 0)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_3
+ Index Cond: (((a + b) / 2) = t1_8.b)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t2_3.a + t2_3.b) / 2))
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t1_9.b)
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Join
+ Hash Cond: (((t2_4.a + t2_4.b) / 2) = t1_9.b)
+ -> Seq Scan on prt1_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t1_9
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = ((t2_4.a + t2_4.b) / 2))
+ Filter: (b = 0)
+(66 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHERE t1.a = 0 AND t1.b = (t2.a + t2.b)/2) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
--------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Nested Loop
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Semi Join
- Hash Cond: (t1_3.b = ((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt2_p1 t1_3
+ Hash Cond: (t1_5.b = ((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt2_p0 t1_5
-> Hash
- -> Seq Scan on prt1_e_p1 t1_6
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
- Index Cond: (a = t1_3.b)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t1_5.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Semi Join
- Hash Cond: (t1_4.b = ((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt2_p2 t1_4
+ Hash Cond: (t1_6.b = ((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt2_p1 t1_6
-> Hash
- -> Seq Scan on prt1_e_p2 t1_7
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
- Index Cond: (a = t1_4.b)
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
+ Index Cond: (a = t1_6.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Hash Semi Join
- Hash Cond: (t1_5.b = ((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt2_p3 t1_5
+ Hash Cond: (t1_7.b = ((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt2_p2 t1_7
-> Hash
- -> Seq Scan on prt1_e_p3 t1_8
+ -> Seq Scan on prt1_e_p2 t1_12
Filter: (c = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t1_5.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t1_7.b)
Filter: (b = 0)
-(39 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Hash Semi Join
+ Hash Cond: (t1_8.b = ((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt2_p3 t1_8
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t1_13
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t1_8.b)
+ Filter: (b = 0)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Semi Join
+ Hash Cond: (t1_9.b = ((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt2_p4 t1_9
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = t1_9.b)
+ Filter: (b = 0)
+(63 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
-- test merge joins
SET enable_hashjoin TO off;
SET enable_nestloop TO off;
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
-----------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------
Merge Append
Sort Key: t1.a
-> Merge Semi Join
- Merge Cond: (t1.a = t1_3.b)
+ Merge Cond: (t1.a = t1_5.b)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_3.b = (((t1_6.a + t1_6.b) / 2)))
+ Merge Cond: (t1_5.b = (((t1_10.a + t1_10.b) / 2)))
-> Sort
- Sort Key: t1_3.b
- -> Seq Scan on prt2_p1 t1_3
+ Sort Key: t1_5.b
+ -> Seq Scan on prt2_p0 t1_5
-> Sort
- Sort Key: (((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt1_e_p1 t1_6
+ Sort Key: (((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_1.a = t1_4.b)
+ Merge Cond: (t1_1.a = t1_6.b)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_4.b = (((t1_7.a + t1_7.b) / 2)))
+ Merge Cond: (t1_6.b = (((t1_11.a + t1_11.b) / 2)))
-> Sort
- Sort Key: t1_4.b
- -> Seq Scan on prt2_p2 t1_4
+ Sort Key: t1_6.b
+ -> Seq Scan on prt2_p1 t1_6
-> Sort
- Sort Key: (((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt1_e_p2 t1_7
+ Sort Key: (((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_2.a = t1_5.b)
+ Merge Cond: (t1_2.a = t1_7.b)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_5.b = (((t1_8.a + t1_8.b) / 2)))
+ Merge Cond: (t1_7.b = (((t1_12.a + t1_12.b) / 2)))
-> Sort
- Sort Key: t1_5.b
- -> Seq Scan on prt2_p3 t1_5
+ Sort Key: t1_7.b
+ -> Seq Scan on prt2_p2 t1_7
-> Sort
- Sort Key: (((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt1_e_p3 t1_8
+ Sort Key: (((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt1_e_p2 t1_12
Filter: (c = 0)
-(47 rows)
+ -> Merge Semi Join
+ Merge Cond: (t1_3.a = t1_8.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_8.b = (((t1_13.a + t1_13.b) / 2)))
+ -> Sort
+ Sort Key: t1_8.b
+ -> Seq Scan on prt2_p3 t1_8
+ -> Sort
+ Sort Key: (((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt1_e_p3 t1_13
+ Filter: (c = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_4.a = t1_9.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_9.b = (((t1_14.a + t1_14.b) / 2)))
+ -> Sort
+ Sort Key: t1_9.b
+ -> Seq Scan on prt2_p4 t1_9
+ -> Sort
+ Sort Key: (((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+(77 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
@@ -933,14 +1438,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3.a + t3.b) / 2)) = t1.a)
-> Sort
Sort Key: (((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Sort
Sort Key: t2.b
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Merge Left Join
Merge Cond: (t1_1.a = t2_1.b)
-> Sort
@@ -949,14 +1454,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_1.a + t3_1.b) / 2)) = t1_1.a)
-> Sort
Sort Key: (((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Sort
Sort Key: t2_1.b
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Merge Left Join
Merge Cond: (t1_2.a = t2_2.b)
-> Sort
@@ -965,32 +1470,74 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_2.a + t3_2.b) / 2)) = t1_2.a)
-> Sort
Sort Key: (((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Sort
Sort Key: t2_2.b
- -> Seq Scan on prt2_p3 t2_2
-(51 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Merge Left Join
+ Merge Cond: (t1_3.a = t2_3.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_3.a + t3_3.b) / 2)) = t1_3.a)
+ -> Sort
+ Sort Key: (((t3_3.a + t3_3.b) / 2))
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ -> Sort
+ Sort Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ -> Merge Left Join
+ Merge Cond: (t1_4.a = t2_4.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_4.a + t3_4.b) / 2)) = t1_4.a)
+ -> Sort
+ Sort Key: (((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ -> Sort
+ Sort Key: t2_4.b
+ -> Seq Scan on prt2_p4 t2_4
+(83 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- MergeAppend on nullable column
EXPLAIN (COSTS OFF)
@@ -998,8 +1545,18 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Merge Left Join
+ Merge Cond: (prt1_p0.a = b)
+ -> Sort
+ Sort Key: prt1_p0.a
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Sort
+ Sort Key: b
+ -> Result
+ One-Time Filter: false
-> Merge Left Join
Merge Cond: (prt1_p1.a = b)
-> Sort
@@ -1020,21 +1577,26 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
Sort Key: prt2_p2.b
-> Seq Scan on prt2_p2
Filter: (b > 250)
-(23 rows)
+(33 rows)
SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | b
------+-----
- 0 |
- 50 |
- 100 |
- 150 |
- 200 |
- 250 |
- 300 | 300
- 350 |
- 400 |
-(9 rows)
+ a | b
+------+-----
+ -250 |
+ -200 |
+ -150 |
+ -100 |
+ -50 |
+ 0 |
+ 50 |
+ 100 |
+ 150 |
+ 200 |
+ 250 |
+ 300 | 300
+ 350 |
+ 400 |
+(14 rows)
-- merge join when expression with whole-row reference needs to be sorted;
-- partitionwise join does not apply
@@ -1048,30 +1610,797 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
Sort Key: t1.a, ((((t1.*)::prt1))::text)
-> Result
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Sort
Sort Key: t2.b, ((((t2.*)::prt2))::text)
-> Result
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
-(16 rows)
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+(20 rows)
SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.b ORDER BY t1.a;
- a | b
-----+----
- 0 | 0
- 6 | 6
- 12 | 12
- 18 | 18
- 24 | 24
-(5 rows)
+ a | b
+-----+-----
+ -24 | -24
+ -18 | -18
+ -12 | -12
+ -6 | -6
+ 0 | 0
+ 6 | 6
+ 12 | 12
+ 18 | 18
+ 24 | 24
+(9 rows)
RESET enable_hashjoin;
RESET enable_nestloop;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+ -> Seq Scan on prt2_p3 t2_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_4
+ Filter: (b = 0)
+(22 rows)
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p1 t2
+ -> Hash
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p2 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p3 t1_2
+ Filter: (b = 0)
+(21 rows)
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -150 | -0150 | 0 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 0 | 0150
+ 300 | 0300 | 0 | 0300
+ 450 | 0450 | 0 | 0450
+ 600 | 0600 | 0 | 0600
+ 750 | 0750 | 0 | 0750
+(7 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | 0 | -0150
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | 0 | 0000
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | 0 | 0150
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 0 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ 450 | 0450 | 0 | 0450
+ 500 | 0500 | |
+ 550 | 0550 | |
+ 600 | 0600 | 0 | 0600
+ 650 | 0650 | |
+ 700 | 0700 | |
+ 750 | 0750 | 0 | 0750
+(21 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Semi Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Append
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
+ Index Cond: (a = t1_1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(28 rows)
+
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Anti Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Anti Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -250 | 0 | -0250
+ -200 | 0 | -0200
+ -100 | 0 | -0100
+ -50 | 0 | -0050
+ 50 | 0 | 0050
+ 100 | 0 | 0100
+ 200 | 0 | 0200
+ 250 | 0 | 0250
+ 350 | 0 | 0350
+ 400 | 0 | 0400
+ 500 | 0 | 0500
+ 550 | 0 | 0550
+ 650 | 0 | 0650
+ 700 | 0 | 0700
+(14 rows)
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ QUERY PLAN
+---------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t3.c
+ -> Append
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t3
+ Index Cond: (a = t2.b)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t2.b)
+ -> Hash Right Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t3_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t3_2
+ Index Cond: (a = t2_2.b)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t2_2.b)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t3_3
+ Index Cond: (a = t2_3.b)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(47 rows)
+
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ a | a | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.b
+ -> Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(24 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: (t1.a = t2.b)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.a, 0)) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------
+ Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(22 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Join
+ Hash Cond: (t1.a = t2.b)
+ Join Filter: ((t1.b + t2.a) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
--
-- partitioned by multiple columns
--
@@ -1141,82 +2470,1552 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1
--
-- tests for list partitioned tables.
--
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 470 | 0 | 0011
+(1 row)
+
--
-- list partitioned by expression
--
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
ANALYZE plt1_e;
-- test partition matching with N-way join
EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- QUERY PLAN
---------------------------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------------------------------------
GroupAggregate
Group Key: t1.c, t2.c, t3.c
-> Sort
Sort Key: t1.c, t3.c
-> Append
-> Hash Join
- Hash Cond: (t1.c = ltrim(t3.c, 'A'::text))
+ Hash Cond: ((t1.c)::text = ltrim(t3.c, 'A'::text))
-> Hash Join
- Hash Cond: ((t1.b = t2.b) AND (t1.c = t2.c))
- -> Seq Scan on plt1_p1 t1
+ Hash Cond: ((t2.b = t1.b) AND ((t2.c)::text = (t1.c)::text))
+ -> Seq Scan on plt2_p4 t2
-> Hash
- -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt1_p4 t1
-> Hash
- -> Seq Scan on plt1_e_p1 t3
+ -> Seq Scan on plt1_e_p4 t3
-> Hash Join
- Hash Cond: (t1_1.c = ltrim(t3_1.c, 'A'::text))
+ Hash Cond: ((t1_1.c)::text = ltrim(t3_1.c, 'A'::text))
-> Hash Join
- Hash Cond: ((t1_1.b = t2_1.b) AND (t1_1.c = t2_1.c))
- -> Seq Scan on plt1_p2 t1_1
+ Hash Cond: ((t1_1.b = t2_1.b) AND ((t1_1.c)::text = (t2_1.c)::text))
+ -> Seq Scan on plt1_p1 t1_1
-> Hash
- -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p1 t2_1
-> Hash
- -> Seq Scan on plt1_e_p2 t3_1
+ -> Seq Scan on plt1_e_p1 t3_1
-> Hash Join
- Hash Cond: (t1_2.c = ltrim(t3_2.c, 'A'::text))
+ Hash Cond: ((t1_2.c)::text = ltrim(t3_2.c, 'A'::text))
-> Hash Join
- Hash Cond: ((t1_2.b = t2_2.b) AND (t1_2.c = t2_2.c))
- -> Seq Scan on plt1_p3 t1_2
+ Hash Cond: ((t1_2.b = t2_2.b) AND ((t1_2.c)::text = (t2_2.c)::text))
+ -> Seq Scan on plt1_p2 t1_2
-> Hash
- -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p2 t2_2
-> Hash
- -> Seq Scan on plt1_e_p3 t3_2
-(32 rows)
+ -> Seq Scan on plt1_e_p2 t3_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = ltrim(t3_3.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t2_3.b = t1_3.b) AND ((t2_3.c)::text = (t1_3.c)::text))
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt1_e_p3 t3_3
+(41 rows)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- avg | avg | avg | c | c | c
-----------------------+----------------------+-----------------------+------+------+-------
- 24.0000000000000000 | 24.0000000000000000 | 48.0000000000000000 | 0000 | 0000 | A0000
- 75.0000000000000000 | 75.0000000000000000 | 148.0000000000000000 | 0001 | 0001 | A0001
- 123.0000000000000000 | 123.0000000000000000 | 248.0000000000000000 | 0002 | 0002 | A0002
- 174.0000000000000000 | 174.0000000000000000 | 348.0000000000000000 | 0003 | 0003 | A0003
- 225.0000000000000000 | 225.0000000000000000 | 448.0000000000000000 | 0004 | 0004 | A0004
- 273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
- 324.0000000000000000 | 324.0000000000000000 | 648.0000000000000000 | 0006 | 0006 | A0006
- 375.0000000000000000 | 375.0000000000000000 | 748.0000000000000000 | 0007 | 0007 | A0007
- 423.0000000000000000 | 423.0000000000000000 | 848.0000000000000000 | 0008 | 0008 | A0008
- 474.0000000000000000 | 474.0000000000000000 | 948.0000000000000000 | 0009 | 0009 | A0009
- 525.0000000000000000 | 525.0000000000000000 | 1048.0000000000000000 | 0010 | 0010 | A0010
- 573.0000000000000000 | 573.0000000000000000 | 1148.0000000000000000 | 0011 | 0011 | A0011
-(12 rows)
+ avg | avg | avg | c | c | c
+----------------------+---------------------+----------------------+------+------+------
+ 246.5000000000000000 | 22.4666666666666667 | 268.9666666666666667 | 0000 | 0000 | 0000
+ 248.5000000000000000 | 21.3333333333333333 | 269.8333333333333333 | 0002 | 0002 | 0002
+ 249.5000000000000000 | 22.3333333333333333 | 271.8333333333333333 | 0003 | 0003 | 0003
+ 250.5000000000000000 | 23.3333333333333333 | 273.8333333333333333 | 0004 | 0004 | 0004
+ 251.5000000000000000 | 22.7666666666666667 | 274.2666666666666667 | 0005 | 0005 | 0005
+ 252.5000000000000000 | 22.2000000000000000 | 274.7000000000000000 | 0006 | 0006 | 0006
+ 246.0000000000000000 | 23.9655172413793103 | 269.9655172413793103 | 0008 | 0008 | 0008
+ 247.0000000000000000 | 23.3448275862068966 | 270.3448275862068966 | 0009 | 0009 | 0009
+(8 rows)
+
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 470 | 0011
+ | | 235 | 0014
+(8 rows)
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 235 | 0014
+ | | 470 | 0011
+(10 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 47 | 0 | 0013
+ 235 | 0 | 0014
+ 470 | 0 | 0011
+(3 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+----------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Materialize
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(20 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Materialize
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+---
+ 470 | 0 |
+(1 row)
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(22 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(22 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(19 rows)
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
@@ -1241,22 +4040,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
--------------------------------------------------
Hash Left Join
Hash Cond: (t2.b = a)
- -> Append
- -> Hash Join
- Hash Cond: (t3.a = t2.b)
- -> Seq Scan on prt1_p1 t3
- -> Hash
- -> Seq Scan on prt2_p1 t2
- -> Hash Join
- Hash Cond: (t3_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t3_1
- -> Hash
- -> Seq Scan on prt2_p2 t2_1
- -> Hash Join
- Hash Cond: (t3_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t3_2
- -> Hash
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash Join
+ Hash Cond: (t3.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t3
+ -> Seq Scan on prt1_p1 t3_1
+ -> Seq Scan on prt1_p2 t3_2
+ -> Seq Scan on prt1_p3 t3_3
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Result
One-Time Filter: false
@@ -1271,16 +4070,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
-> Hash Left Join
Hash Cond: (t2.b = a)
-> Append
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
Filter: (a = 0)
-> Hash
-> Result
One-Time Filter: false
-(14 rows)
+(20 rows)
--
-- tests for hash partitioned tables.
@@ -1356,41 +4161,9 @@ SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, ph
273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
(6 rows)
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
- Sort
- Sort Key: t1.a
- -> Append
- -> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
- -> Hash
- -> Seq Scan on prt1_p1 t1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
- -> Hash
- -> Seq Scan on prt1_p2 t1_1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
- -> Hash
- -> Seq Scan on prt1_p3 t1_2
- Filter: (b = 0)
-(21 rows)
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
@@ -1405,26 +4178,24 @@ SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c
Sort Key: t1.c
-> HashAggregate
Group Key: t1.c, t2.c
- -> Append
- -> Hash Join
- Hash Cond: (t2.c = t1.c)
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_p1 t1
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_1.c = t1_1.c)
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p1 t1_1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_2.c = t1_2.c)
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p2 t1_2
Filter: ((a % 25) = 0)
-(23 rows)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: ((a % 25) = 0)
+(21 rows)
--
-- multiple levels of partitioning
@@ -1826,64 +4597,70 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2 WHERE t1.a = t2.a;
Hash Join
Hash Cond: (t1.a = t2.a)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Seq Scan on prt4_n_p1 t2
-> Seq Scan on prt4_n_p2 t2_1
-> Seq Scan on prt4_n_p3 t2_2
-(11 rows)
+(13 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2, prt2 t3 WHERE t1.a = t2.a and t1.a = t3.b;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------
Hash Join
- Hash Cond: (t2.a = t1.a)
+ Hash Cond: (t3.b = t1.a)
-> Append
- -> Seq Scan on prt4_n_p1 t2
- -> Seq Scan on prt4_n_p2 t2_1
- -> Seq Scan on prt4_n_p3 t2_2
+ -> Seq Scan on prt2_p0 t3
+ -> Seq Scan on prt2_p1 t3_1
+ -> Seq Scan on prt2_p2 t3_2
+ -> Seq Scan on prt2_p3 t3_3
+ -> Seq Scan on prt2_p4 t3_4
+ -> Seq Scan on prt2_p5 t3_5
-> Hash
- -> Append
- -> Hash Join
- Hash Cond: (t1.a = t3.b)
- -> Seq Scan on prt1_p1 t1
- -> Hash
- -> Seq Scan on prt2_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t1_1
- -> Hash
- -> Seq Scan on prt2_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t1_2
- -> Hash
- -> Seq Scan on prt2_p3 t3_2
+ -> Hash Join
+ Hash Cond: (t1.a = t2.a)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt4_n_p1 t2
+ -> Seq Scan on prt4_n_p2 t2_1
+ -> Seq Scan on prt4_n_p3 t2_2
(23 rows)
-- partitionwise join can not be applied if there are no equi-join conditions
-- between partition keys
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON (t1.a < t2.b);
- QUERY PLAN
----------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------
Nested Loop Left Join
+ Join Filter: (t1.a < t2.b)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
- -> Append
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
- Index Cond: (b > t1.a)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
- Index Cond: (b > t1.a)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
- Index Cond: (b > t1.a)
-(12 rows)
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Materialize
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(16 rows)
-- equi-join with join condition on partial keys does not qualify for
-- partitionwise join
@@ -1969,16 +4746,17 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 JOIN prt2_n t2 ON (t1.c = t2.c) JOI
-> Seq Scan on prt2_n_p2 t2_1
-> Hash
-> Hash Join
- Hash Cond: (t3.c = (t1.c)::text)
+ Hash Cond: ((t3.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on plt1_p1 t3
- -> Seq Scan on plt1_p2 t3_1
- -> Seq Scan on plt1_p3 t3_2
+ -> Seq Scan on plt1_p4 t3
+ -> Seq Scan on plt1_p1 t3_1
+ -> Seq Scan on plt1_p2 t3_2
+ -> Seq Scan on plt1_p3 t3_3
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(16 rows)
+(17 rows)
-- partitionwise join can not be applied for a join between list and range
-- partitioned table
@@ -1989,14 +4767,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 FULL JOIN prt1 t2 ON (t1.c = t2.c);
Hash Full Join
Hash Cond: ((t2.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on prt1_p1 t2
- -> Seq Scan on prt1_p2 t2_1
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(10 rows)
+(12 rows)
-- partitionwise join can not be applied if only one of joining table has
-- default partition
@@ -2012,16 +4792,23 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b =
-> Hash Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
diff --git a/src/test/regress/sql/partition_join.sql b/src/test/regress/sql/partition_join.sql
index c1c9859651..0e884835fb 100644
--- a/src/test/regress/sql/partition_join.sql
+++ b/src/test/regress/sql/partition_join.sql
@@ -10,25 +10,39 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
@@ -67,11 +81,19 @@ EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -93,20 +115,30 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
@@ -169,6 +201,128 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
RESET enable_hashjoin;
RESET enable_nestloop;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
--
-- partitioned by multiple columns
--
@@ -193,28 +347,79 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1
--
-- tests for list partitioned tables.
--
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
--
-- list partitioned by expression
--
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
ANALYZE plt1_e;
-- test partition matching with N-way join
@@ -222,6 +427,175 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.a = 1 AND t1.a = 2;
@@ -267,27 +641,18 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
ALTER TABLE plt2 DETACH PARTITION plt2_p3;
ALTER TABLE plt2 ATTACH PARTITION plt2_p3 DEFAULT;
ANALYZE plt2;
-
EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.a % 25 = 0 GROUP BY t1.c, t2.c ORDER BY t1.c, t2.c;
+
--
-- multiple levels of partitioning
--
--
2.18.0
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
@ 2019-03-07 06:24 ` Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Rajkumar Raghuwanshi @ 2019-03-07 06:24 UTC (permalink / raw)
To: amul sul <sulamul@gmail.com>; +Cc: Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers; ashutosh.bapat.oss@gmail.com
On Tue, Mar 5, 2019 at 3:45 PM amul sul <sulamul@gmail.com> wrote:
> Attached is the rebased atop of the latest master head(35bc0ec7c8).
>
thanks Amul, patches applied cleanly on PG head.
While testing this I got a server crash with below test case.
CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
INSERT INTO plt1 SELECT i, i % 47, to_char(i % 17, 'FM0000') FROM
generate_series(0, 500) i WHERE i % 17 NOT IN (7, 11, 12, 13, 14, 15,16);
INSERT INTO plt1 SELECT i, i % 47, case when i % 17 = 7 then NULL else
to_char(i % 17, 'FM0000') end FROM generate_series(0, 500) i WHERE i % 17
IN (7,8,9);
ANALYSE plt1;
CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
INSERT INTO plt2 SELECT i, i % 47, to_char(i % 17, 'FM0000') FROM
generate_series(0, 500) i WHERE i % 17 NOT IN (1, 10, 11, 13, 14, 15, 16);
INSERT INTO plt2 SELECT i, i % 47, case when i % 17 = 11 then NULL else
to_char(i % 17, 'FM0000') end FROM generate_series(0, 500) i WHERE i % 17
IN (0,11,12);
ANALYZE plt2;
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005',
'0006');
CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
INSERT INTO plt1_e SELECT i, i % 47, to_char(i % 17, 'FM0000') FROM
generate_series(0, 500) i WHERE i % 17 NOT IN (1, 7, 10, 11, 12, 13, 14,
15, 16);
ANALYZE plt1_e;
EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM
plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c
GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
server closed the connection unexpectedly
This probably means the server terminated abnormally
before or while processing the request.
The connection to the server was lost. Attempting reset: Failed.
below is stack trace, looks like some indexes got corrupted, please take a
look.
Core was generated by `postgres: edb postgres [local]
EXPLAIN '.
Program terminated with signal 11, Segmentation fault.
#0 0x0000000000821aee in map_and_merge_partitions (partmaps1=0x2c1c8a8,
partmaps2=0x2c1c8e0, index1=45540240, index2=0, next_index=0x7ffeebd43d3c)
at partbounds.c:4162
4162 if (partmap1->from < 0 && partmap2->from < 0)
Missing separate debuginfos, use: debuginfo-install
keyutils-libs-1.4-5.el6.x86_64 krb5-libs-1.10.3-65.el6.x86_64
libcom_err-1.41.12-24.el6.x86_64 libselinux-2.0.94-7.el6.x86_64
openssl-1.0.1e-57.el6.x86_64 zlib-1.2.3-29.el6.x86_64
(gdb) bt
#0 0x0000000000821aee in map_and_merge_partitions (partmaps1=0x2c1c8a8,
partmaps2=0x2c1c8e0, *index1=45540240*, index2=0,
next_index=0x7ffeebd43d3c) at partbounds.c:4162
#1 0x00000000008226c3 in merge_null_partitions (outer_bi=0x2b6e338,
inner_bi=0x2bf90b0, outer_maps=0x2c1c8a8, inner_maps=0x2c1c8e0,
jointype=JOIN_INNER,
next_index=0x7ffeebd43d3c, null_index=0x7ffeebd43d38,
default_index=0x7ffeebd43d34) at partbounds.c:4610
#2 0x0000000000821726 in partition_list_bounds_merge
(partsupfunc=0x2ba3548, partcollation=0x2ba34e8, outer_rel=0x2b6ce40,
inner_rel=0x2bf8d28, outer_parts=0x7ffeebd43ed8,
inner_parts=0x7ffeebd43ed0, jointype=JOIN_INNER) at partbounds.c:4031
#3 0x000000000081ff5d in partition_bounds_merge (partnatts=1,
partsupfunc=0x2ba3548, partcollation=0x2ba34e8, outer_rel=0x2b6ce40,
inner_rel=0x2bf8d28, jointype=JOIN_INNER,
outer_parts=0x7ffeebd43ed8, inner_parts=0x7ffeebd43ed0) at
partbounds.c:3053
#4 0x00000000007c610f in try_partitionwise_join (root=0x2be2a28,
rel1=0x2b6ce40, rel2=0x2bf8d28, joinrel=0x2c1b0f0,
parent_sjinfo=0x7ffeebd44010,
parent_restrictlist=0x2c1c070) at joinrels.c:1370
#5 0x00000000007c5521 in populate_joinrel_with_paths (root=0x2be2a28,
rel1=0x2b6ce40, rel2=0x2bf8d28, joinrel=0x2c1b0f0, sjinfo=0x7ffeebd44010,
restrictlist=0x2c1c070)
at joinrels.c:914
#6 0x00000000007c4f48 in make_join_rel (root=0x2be2a28, rel1=0x2b6ce40,
rel2=0x2bf8d28) at joinrels.c:748
#7 0x00000000007c4514 in make_rels_by_clause_joins (root=0x2be2a28,
old_rel=0x2b6ce40, other_rels=0x2bae4d8) at joinrels.c:294
#8 0x00000000007c41c8 in join_search_one_level (root=0x2be2a28, level=3)
at joinrels.c:116
#9 0x00000000007abe59 in standard_join_search (root=0x2be2a28,
levels_needed=3, initial_rels=0x2bae500) at allpaths.c:2716
#10 0x00000000007abdca in make_rel_from_joinlist (root=0x2be2a28,
joinlist=0x2bfbae8) at allpaths.c:2647
#11 0x00000000007a86b0 in make_one_rel (root=0x2be2a28, joinlist=0x2bfbae8)
at allpaths.c:227
#12 0x00000000007dada1 in query_planner (root=0x2be2a28, tlist=0x2ba01c8,
qp_callback=0x7e0b25 <standard_qp_callback>, qp_extra=0x7ffeebd44390) at
planmain.c:265
#13 0x00000000007ddf83 in grouping_planner (root=0x2be2a28,
inheritance_update=false, tuple_fraction=0) at planner.c:1929
#14 0x00000000007dc5f5 in subquery_planner (glob=0x2be2990,
parse=0x2c0e8c8, parent_root=0x0, hasRecursion=false, tuple_fraction=0) at
planner.c:997
#15 0x00000000007db1b6 in standard_planner (parse=0x2c0e8c8,
cursorOptions=256, boundParams=0x0) at planner.c:416
#16 0x00000000007daef7 in planner (parse=0x2c0e8c8, cursorOptions=256,
boundParams=0x0) at planner.c:276
#17 0x00000000008e15c5 in pg_plan_query (querytree=0x2c0e8c8,
cursorOptions=256, boundParams=0x0) at postgres.c:878
#18 0x00000000006562cc in ExplainOneQuery (query=0x2c0e8c8,
cursorOptions=256, into=0x0, es=0x2c0e0a0,
queryString=0x2aa24d8 "EXPLAIN (COSTS OFF)\nSELECT avg(t1.a),
avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM\nplt1 t1, plt2 t2,
plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c,
t2.c, t3.c ORDER BY t1"..., params=0x0, queryEnv=0x0) at explain.c:364
Thanks & Regards,
Rajkumar Raghuwanshi
QMG, EnterpriseDB.
> Regards,
> Amul Sul
>
> On Mon, Feb 4, 2019 at 11:05 AM amul sul <sulamul@gmail.com> wrote:
>
>> There are few whitespaces in 0002 patch that I have fixed in the attached
>> version.
>> Rest of the patches are untouched.
>>
>> Ill continue my review and testing.
>>
>> Regards,
>> Amul
>>
>> On Thu, Jan 31, 2019 at 5:26 PM Etsuro Fujita <
>> fujita.etsuro@lab.ntt.co.jp> wrote:
>>
>>> (2019/01/22 21:38), Etsuro Fujita wrote:
>>> > Will continue to review.
>>>
>>> I rebased the patch set against the latest HEAD. Attached is a new
>>> version. I'll move this to the next CF, and continue to review it.
>>>
>>> Best regards,
>>> Etsuro Fujita
>>>
>>
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
@ 2019-03-07 07:32 ` amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: amul sul @ 2019-03-07 07:32 UTC (permalink / raw)
To: Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; +Cc: Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers; ashutosh.bapat.oss@gmail.com
Thanks Rajkumar,
I am looking into this.
Regards,
Amul
On Thu, Mar 7, 2019 at 11:54 AM Rajkumar Raghuwanshi <
rajkumar.raghuwanshi@enterprisedb.com> wrote:
>
>
> On Tue, Mar 5, 2019 at 3:45 PM amul sul <sulamul@gmail.com> wrote:
>
>> Attached is the rebased atop of the latest master head(35bc0ec7c8).
>>
> thanks Amul, patches applied cleanly on PG head.
>
> While testing this I got a server crash with below test case.
>
> CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
> CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN
> ('0001','0002','0003');
> CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN
> ('0004','0005','0006');
> CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
> CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
> INSERT INTO plt1 SELECT i, i % 47, to_char(i % 17, 'FM0000') FROM
> generate_series(0, 500) i WHERE i % 17 NOT IN (7, 11, 12, 13, 14, 15,16);
> INSERT INTO plt1 SELECT i, i % 47, case when i % 17 = 7 then NULL else
> to_char(i % 17, 'FM0000') end FROM generate_series(0, 500) i WHERE i % 17
> IN (7,8,9);
> ANALYSE plt1;
>
> CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
> CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
> CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN
> ('0004','0005','0006');
> CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN
> ('0007','0008','0009');
> CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
> INSERT INTO plt2 SELECT i, i % 47, to_char(i % 17, 'FM0000') FROM
> generate_series(0, 500) i WHERE i % 17 NOT IN (1, 10, 11, 13, 14, 15, 16);
> INSERT INTO plt2 SELECT i, i % 47, case when i % 17 = 11 then NULL else
> to_char(i % 17, 'FM0000') end FROM generate_series(0, 500) i WHERE i % 17
> IN (0,11,12);
> ANALYZE plt2;
>
> CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c,
> 'A'));
> CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
> CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005',
> '0006');
> CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
> CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
> INSERT INTO plt1_e SELECT i, i % 47, to_char(i % 17, 'FM0000') FROM
> generate_series(0, 500) i WHERE i % 17 NOT IN (1, 7, 10, 11, 12, 13, 14,
> 15, 16);
> ANALYZE plt1_e;
>
> EXPLAIN (COSTS OFF)
> SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM
> plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c
> GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
> server closed the connection unexpectedly
> This probably means the server terminated abnormally
> before or while processing the request.
> The connection to the server was lost. Attempting reset: Failed.
>
> below is stack trace, looks like some indexes got corrupted, please take
> a look.
>
> Core was generated by `postgres: edb postgres [local]
> EXPLAIN '.
> Program terminated with signal 11, Segmentation fault.
> #0 0x0000000000821aee in map_and_merge_partitions (partmaps1=0x2c1c8a8,
> partmaps2=0x2c1c8e0, index1=45540240, index2=0, next_index=0x7ffeebd43d3c)
> at partbounds.c:4162
> 4162 if (partmap1->from < 0 && partmap2->from < 0)
> Missing separate debuginfos, use: debuginfo-install
> keyutils-libs-1.4-5.el6.x86_64 krb5-libs-1.10.3-65.el6.x86_64
> libcom_err-1.41.12-24.el6.x86_64 libselinux-2.0.94-7.el6.x86_64
> openssl-1.0.1e-57.el6.x86_64 zlib-1.2.3-29.el6.x86_64
> (gdb) bt
> #0 0x0000000000821aee in map_and_merge_partitions (partmaps1=0x2c1c8a8,
> partmaps2=0x2c1c8e0, *index1=45540240*, index2=0,
> next_index=0x7ffeebd43d3c) at partbounds.c:4162
> #1 0x00000000008226c3 in merge_null_partitions (outer_bi=0x2b6e338,
> inner_bi=0x2bf90b0, outer_maps=0x2c1c8a8, inner_maps=0x2c1c8e0,
> jointype=JOIN_INNER,
> next_index=0x7ffeebd43d3c, null_index=0x7ffeebd43d38,
> default_index=0x7ffeebd43d34) at partbounds.c:4610
> #2 0x0000000000821726 in partition_list_bounds_merge
> (partsupfunc=0x2ba3548, partcollation=0x2ba34e8, outer_rel=0x2b6ce40,
> inner_rel=0x2bf8d28, outer_parts=0x7ffeebd43ed8,
> inner_parts=0x7ffeebd43ed0, jointype=JOIN_INNER) at partbounds.c:4031
> #3 0x000000000081ff5d in partition_bounds_merge (partnatts=1,
> partsupfunc=0x2ba3548, partcollation=0x2ba34e8, outer_rel=0x2b6ce40,
> inner_rel=0x2bf8d28, jointype=JOIN_INNER,
> outer_parts=0x7ffeebd43ed8, inner_parts=0x7ffeebd43ed0) at
> partbounds.c:3053
> #4 0x00000000007c610f in try_partitionwise_join (root=0x2be2a28,
> rel1=0x2b6ce40, rel2=0x2bf8d28, joinrel=0x2c1b0f0,
> parent_sjinfo=0x7ffeebd44010,
> parent_restrictlist=0x2c1c070) at joinrels.c:1370
> #5 0x00000000007c5521 in populate_joinrel_with_paths (root=0x2be2a28,
> rel1=0x2b6ce40, rel2=0x2bf8d28, joinrel=0x2c1b0f0, sjinfo=0x7ffeebd44010,
> restrictlist=0x2c1c070)
> at joinrels.c:914
> #6 0x00000000007c4f48 in make_join_rel (root=0x2be2a28, rel1=0x2b6ce40,
> rel2=0x2bf8d28) at joinrels.c:748
> #7 0x00000000007c4514 in make_rels_by_clause_joins (root=0x2be2a28,
> old_rel=0x2b6ce40, other_rels=0x2bae4d8) at joinrels.c:294
> #8 0x00000000007c41c8 in join_search_one_level (root=0x2be2a28, level=3)
> at joinrels.c:116
> #9 0x00000000007abe59 in standard_join_search (root=0x2be2a28,
> levels_needed=3, initial_rels=0x2bae500) at allpaths.c:2716
> #10 0x00000000007abdca in make_rel_from_joinlist (root=0x2be2a28,
> joinlist=0x2bfbae8) at allpaths.c:2647
> #11 0x00000000007a86b0 in make_one_rel (root=0x2be2a28,
> joinlist=0x2bfbae8) at allpaths.c:227
> #12 0x00000000007dada1 in query_planner (root=0x2be2a28, tlist=0x2ba01c8,
> qp_callback=0x7e0b25 <standard_qp_callback>, qp_extra=0x7ffeebd44390) at
> planmain.c:265
> #13 0x00000000007ddf83 in grouping_planner (root=0x2be2a28,
> inheritance_update=false, tuple_fraction=0) at planner.c:1929
> #14 0x00000000007dc5f5 in subquery_planner (glob=0x2be2990,
> parse=0x2c0e8c8, parent_root=0x0, hasRecursion=false, tuple_fraction=0) at
> planner.c:997
> #15 0x00000000007db1b6 in standard_planner (parse=0x2c0e8c8,
> cursorOptions=256, boundParams=0x0) at planner.c:416
> #16 0x00000000007daef7 in planner (parse=0x2c0e8c8, cursorOptions=256,
> boundParams=0x0) at planner.c:276
> #17 0x00000000008e15c5 in pg_plan_query (querytree=0x2c0e8c8,
> cursorOptions=256, boundParams=0x0) at postgres.c:878
> #18 0x00000000006562cc in ExplainOneQuery (query=0x2c0e8c8,
> cursorOptions=256, into=0x0, es=0x2c0e0a0,
> queryString=0x2aa24d8 "EXPLAIN (COSTS OFF)\nSELECT avg(t1.a),
> avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM\nplt1 t1, plt2 t2,
> plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c,
> t2.c, t3.c ORDER BY t1"..., params=0x0, queryEnv=0x0) at explain.c:364
>
> Thanks & Regards,
> Rajkumar Raghuwanshi
> QMG, EnterpriseDB.
>
>
>> Regards,
>> Amul Sul
>>
>> On Mon, Feb 4, 2019 at 11:05 AM amul sul <sulamul@gmail.com> wrote:
>>
>>> There are few whitespaces in 0002 patch that I have fixed in the
>>> attached version.
>>> Rest of the patches are untouched.
>>>
>>> Ill continue my review and testing.
>>>
>>> Regards,
>>> Amul
>>>
>>> On Thu, Jan 31, 2019 at 5:26 PM Etsuro Fujita <
>>> fujita.etsuro@lab.ntt.co.jp> wrote:
>>>
>>>> (2019/01/22 21:38), Etsuro Fujita wrote:
>>>> > Will continue to review.
>>>>
>>>> I rebased the patch set against the latest HEAD. Attached is a new
>>>> version. I'll move this to the next CF, and continue to review it.
>>>>
>>>> Best regards,
>>>> Etsuro Fujita
>>>>
>>>
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
@ 2019-03-07 14:50 ` amul sul <sulamul@gmail.com>
2019-03-08 08:42 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-11 02:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
0 siblings, 2 replies; 154+ messages in thread
From: amul sul @ 2019-03-07 14:50 UTC (permalink / raw)
To: Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; +Cc: Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers; ashutosh.bapat.oss@gmail.com
On Thu, Mar 7, 2019 at 1:02 PM amul sul <sulamul@gmail.com> wrote:
> Thanks Rajkumar,
>
> I am looking into this.
>
>
The crash happens when none of the if-else branch of
handle_missing_partition()
evaluates and returns merged_index unassigned.
Let me explain, in Rajkumar 's test case, the join type is JOIN_INNER. When
only outer rel has null partition, merge_null_partitions() function calls
handle_missing_partition() with missing_side_inner = false and
missing_side_outer = false argument value which fails to set merged_index.
In the attached patch, I tried to fix this case by setting merged_index
explicitly which fixes the reported crash.
Regards,
Amul
> On Thu, Mar 7, 2019 at 11:54 AM Rajkumar Raghuwanshi <
> rajkumar.raghuwanshi@enterprisedb.com> wrote:
>
>>
>>
>> On Tue, Mar 5, 2019 at 3:45 PM amul sul <sulamul@gmail.com> wrote:
>>
>>> Attached is the rebased atop of the latest master head(35bc0ec7c8).
>>>
>> thanks Amul, patches applied cleanly on PG head.
>>
>> While testing this I got a server crash with below test case.
>>
>> CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
>> CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN
>> ('0001','0002','0003');
>> CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN
>> ('0004','0005','0006');
>> CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
>> CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
>> INSERT INTO plt1 SELECT i, i % 47, to_char(i % 17, 'FM0000') FROM
>> generate_series(0, 500) i WHERE i % 17 NOT IN (7, 11, 12, 13, 14, 15,16);
>> INSERT INTO plt1 SELECT i, i % 47, case when i % 17 = 7 then NULL else
>> to_char(i % 17, 'FM0000') end FROM generate_series(0, 500) i WHERE i % 17
>> IN (7,8,9);
>> ANALYSE plt1;
>>
>> CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
>> CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
>> CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN
>> ('0004','0005','0006');
>> CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN
>> ('0007','0008','0009');
>> CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
>> INSERT INTO plt2 SELECT i, i % 47, to_char(i % 17, 'FM0000') FROM
>> generate_series(0, 500) i WHERE i % 17 NOT IN (1, 10, 11, 13, 14, 15, 16);
>> INSERT INTO plt2 SELECT i, i % 47, case when i % 17 = 11 then NULL else
>> to_char(i % 17, 'FM0000') end FROM generate_series(0, 500) i WHERE i % 17
>> IN (0,11,12);
>> ANALYZE plt2;
>>
>> CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c,
>> 'A'));
>> CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
>> CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005',
>> '0006');
>> CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
>> CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
>> INSERT INTO plt1_e SELECT i, i % 47, to_char(i % 17, 'FM0000') FROM
>> generate_series(0, 500) i WHERE i % 17 NOT IN (1, 7, 10, 11, 12, 13, 14,
>> 15, 16);
>> ANALYZE plt1_e;
>>
>> EXPLAIN (COSTS OFF)
>> SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM
>> plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c
>> GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
>> server closed the connection unexpectedly
>> This probably means the server terminated abnormally
>> before or while processing the request.
>> The connection to the server was lost. Attempting reset: Failed.
>>
>> below is stack trace, looks like some indexes got corrupted, please take
>> a look.
>>
>> Core was generated by `postgres: edb postgres [local]
>> EXPLAIN '.
>> Program terminated with signal 11, Segmentation fault.
>> #0 0x0000000000821aee in map_and_merge_partitions (partmaps1=0x2c1c8a8,
>> partmaps2=0x2c1c8e0, index1=45540240, index2=0, next_index=0x7ffeebd43d3c)
>> at partbounds.c:4162
>> 4162 if (partmap1->from < 0 && partmap2->from < 0)
>> Missing separate debuginfos, use: debuginfo-install
>> keyutils-libs-1.4-5.el6.x86_64 krb5-libs-1.10.3-65.el6.x86_64
>> libcom_err-1.41.12-24.el6.x86_64 libselinux-2.0.94-7.el6.x86_64
>> openssl-1.0.1e-57.el6.x86_64 zlib-1.2.3-29.el6.x86_64
>> (gdb) bt
>> #0 0x0000000000821aee in map_and_merge_partitions (partmaps1=0x2c1c8a8,
>> partmaps2=0x2c1c8e0, *index1=45540240*, index2=0,
>> next_index=0x7ffeebd43d3c) at partbounds.c:4162
>> #1 0x00000000008226c3 in merge_null_partitions (outer_bi=0x2b6e338,
>> inner_bi=0x2bf90b0, outer_maps=0x2c1c8a8, inner_maps=0x2c1c8e0,
>> jointype=JOIN_INNER,
>> next_index=0x7ffeebd43d3c, null_index=0x7ffeebd43d38,
>> default_index=0x7ffeebd43d34) at partbounds.c:4610
>> #2 0x0000000000821726 in partition_list_bounds_merge
>> (partsupfunc=0x2ba3548, partcollation=0x2ba34e8, outer_rel=0x2b6ce40,
>> inner_rel=0x2bf8d28, outer_parts=0x7ffeebd43ed8,
>> inner_parts=0x7ffeebd43ed0, jointype=JOIN_INNER) at partbounds.c:4031
>> #3 0x000000000081ff5d in partition_bounds_merge (partnatts=1,
>> partsupfunc=0x2ba3548, partcollation=0x2ba34e8, outer_rel=0x2b6ce40,
>> inner_rel=0x2bf8d28, jointype=JOIN_INNER,
>> outer_parts=0x7ffeebd43ed8, inner_parts=0x7ffeebd43ed0) at
>> partbounds.c:3053
>> #4 0x00000000007c610f in try_partitionwise_join (root=0x2be2a28,
>> rel1=0x2b6ce40, rel2=0x2bf8d28, joinrel=0x2c1b0f0,
>> parent_sjinfo=0x7ffeebd44010,
>> parent_restrictlist=0x2c1c070) at joinrels.c:1370
>> #5 0x00000000007c5521 in populate_joinrel_with_paths (root=0x2be2a28,
>> rel1=0x2b6ce40, rel2=0x2bf8d28, joinrel=0x2c1b0f0, sjinfo=0x7ffeebd44010,
>> restrictlist=0x2c1c070)
>> at joinrels.c:914
>> #6 0x00000000007c4f48 in make_join_rel (root=0x2be2a28, rel1=0x2b6ce40,
>> rel2=0x2bf8d28) at joinrels.c:748
>> #7 0x00000000007c4514 in make_rels_by_clause_joins (root=0x2be2a28,
>> old_rel=0x2b6ce40, other_rels=0x2bae4d8) at joinrels.c:294
>> #8 0x00000000007c41c8 in join_search_one_level (root=0x2be2a28, level=3)
>> at joinrels.c:116
>> #9 0x00000000007abe59 in standard_join_search (root=0x2be2a28,
>> levels_needed=3, initial_rels=0x2bae500) at allpaths.c:2716
>> #10 0x00000000007abdca in make_rel_from_joinlist (root=0x2be2a28,
>> joinlist=0x2bfbae8) at allpaths.c:2647
>> #11 0x00000000007a86b0 in make_one_rel (root=0x2be2a28,
>> joinlist=0x2bfbae8) at allpaths.c:227
>> #12 0x00000000007dada1 in query_planner (root=0x2be2a28, tlist=0x2ba01c8,
>> qp_callback=0x7e0b25 <standard_qp_callback>, qp_extra=0x7ffeebd44390) at
>> planmain.c:265
>> #13 0x00000000007ddf83 in grouping_planner (root=0x2be2a28,
>> inheritance_update=false, tuple_fraction=0) at planner.c:1929
>> #14 0x00000000007dc5f5 in subquery_planner (glob=0x2be2990,
>> parse=0x2c0e8c8, parent_root=0x0, hasRecursion=false, tuple_fraction=0) at
>> planner.c:997
>> #15 0x00000000007db1b6 in standard_planner (parse=0x2c0e8c8,
>> cursorOptions=256, boundParams=0x0) at planner.c:416
>> #16 0x00000000007daef7 in planner (parse=0x2c0e8c8, cursorOptions=256,
>> boundParams=0x0) at planner.c:276
>> #17 0x00000000008e15c5 in pg_plan_query (querytree=0x2c0e8c8,
>> cursorOptions=256, boundParams=0x0) at postgres.c:878
>> #18 0x00000000006562cc in ExplainOneQuery (query=0x2c0e8c8,
>> cursorOptions=256, into=0x0, es=0x2c0e0a0,
>> queryString=0x2aa24d8 "EXPLAIN (COSTS OFF)\nSELECT avg(t1.a),
>> avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM\nplt1 t1, plt2 t2,
>> plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c,
>> t2.c, t3.c ORDER BY t1"..., params=0x0, queryEnv=0x0) at explain.c:364
>>
>> Thanks & Regards,
>> Rajkumar Raghuwanshi
>> QMG, EnterpriseDB.
>>
>>
>>> Regards,
>>> Amul Sul
>>>
>>> On Mon, Feb 4, 2019 at 11:05 AM amul sul <sulamul@gmail.com> wrote:
>>>
>>>> There are few whitespaces in 0002 patch that I have fixed in the
>>>> attached version.
>>>> Rest of the patches are untouched.
>>>>
>>>> Ill continue my review and testing.
>>>>
>>>> Regards,
>>>> Amul
>>>>
>>>> On Thu, Jan 31, 2019 at 5:26 PM Etsuro Fujita <
>>>> fujita.etsuro@lab.ntt.co.jp> wrote:
>>>>
>>>>> (2019/01/22 21:38), Etsuro Fujita wrote:
>>>>> > Will continue to review.
>>>>>
>>>>> I rebased the patch set against the latest HEAD. Attached is a new
>>>>> version. I'll move this to the next CF, and continue to review it.
>>>>>
>>>>> Best regards,
>>>>> Etsuro Fujita
>>>>>
>>>>
Attachments:
[application/octet-stream] 0002-Partition-wise-join-for-1-1-1-0-0-1-partition-matchi-v20.patch (70.0K, ../../CAAJ_b94RqnFw3zJN2njaCTfGWYDtpdhPBu6_-vMn1xDLctL5+w@mail.gmail.com/3-0002-Partition-wise-join-for-1-1-1-0-0-1-partition-matchi-v20.patch)
download | inline diff:
From 497bf4f3a78f3acb36a711253c03d9bf4516fd00 Mon Sep 17 00:00:00 2001
From: Amul Sul <amul.sul@enterprisedb.com>
Date: Mon, 4 Mar 2019 23:49:47 -0500
Subject: [PATCH 2/3] Partition-wise join for 1:1, 1:0, 0:1 partition matching.
Earlier version of partition-wise join implementation allowed
partition-wise join between two relations with exactly same partition
bounds. This commit allows partition-wise join to be applied under
following conditions
1. the partition bounds of joining relations are such that rows from
given partition on one side join can join with rows from maximum one
partition on the other side i.e. bounds of a given partition on one
side match/overlap with those of maximum one partition on the other
side. If the mapping happens to be m:n where m > 1 or n > 1, we have
to gang multiple partition relations together into a single relation.
This means that we have to add simple relations during join
processing, something which is not supported right now. ALso, in such
a case, different pairs of joining relations can produce different
partition bounds for the same join relation, which again is not
supported right now.
2. For every partition on outer side that can contribute to the result
of an OUTER join, there exists at least one (taken along with item 1,
it means exactly one) matching partition on the inner side. To
support partition-wise join when the inner matching partition doesn't
exist, we have to add a dummy base relation corresponding to the
non-existent inner partition. We don't have support to add base
relations during join processing.
3. For hash partitioned tables however, we support partition-wise join
only when the bounds exactly match. For hash partitioning it's unusual
to have missing partitions and hence generic partition matching is not
required.
With advanced partition matching, we won't be able to apply
partition-wise join when there are missing matching partitions. So for
a given N-way join, some sub-joins may not be partitioned, while the
overall N-way join is partitioned. We can not try partition-wise join
when one or both of the joining relations are not partitioned in one
of the pairs of joining relation. Skip partition-wise join for that
pair.
An example is A IJ B LJ C where B has an extra partition compared to A
and C. Join B LJ C requires dummy relation to join the extra partition
from B to a missing partition from C, and hence can not use
partition-wise join right now and hence BC is not partitioned. The
extra partition in B gets eliminated in A IJ B and thus it can use
partition-wise join and is partitioned. Hence (AB)C can use
partition-wise join but not A(BC).
Not every pair of joining relation (including the one presented to
build_joinrel_partition_info()) for the same joinrel can use
partition-wise join or has both the relations partitioned. Hence we
calculate the partition bounds for the join relation in
try_partition_wise_join() instead of doing it here.
The partition bounds produced for the first pair that can use
partition-wise are saved in the RelOptInfo of the joinrel. Partition
bounds produced for subsequent pairs should match that produced by the
first pair.
Support for default partition in list partitioned tables
========================================================
When a list value is present in one of the joining relations and not
the other, and the other relation has default partition, match (join)
the partition containing that list value with the default partition.
If there are multiple matches, we can not proceed with the
partition-wise join similar to the case of matching non-default
partition. If the default partition happens to be on the outer side of
the join, the resulting join partition acts as a default partition as
it will contain all the values from the default partition. If
the partition containing the list value happens to be on the outer
side of the join, the resulting join partition is associated with the
list value, since no other partition key value from the default
partition makes it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a partition from the inner side,
if inner side has a list value that is not present in the outer side.
But if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Support for matching default partition in range partitioned tables
==================================================================
When a range is present in one of the joining relations and not the
other, and the other relation has default partition, match (join) the
partition corresponding range with the default partition. If two
ranges overlap but their ranges don't match exactly, the
non-overlapping portion from one range may join the previous
(non-overlapping portion near the lower bound, if exists), next
(non-overlapping portion near the upper bound, if exists) ranges from
the other relation or default partition from the other relation. This
causes multiple partitions on the other side to be joined with a
single partition on the first side; a case we don't support. Any range
from one side which doesn't overlap with any range on the other side,
may find its join partner in the default partition and the
corresponding range partition will need to be joined with the default
partition. If the default partition happens to be on the outer side
of the join, the resulting join partition acts as a default partition
as it will contain all the values from the default partition. If the
non-partition corresponding to the range happens to be on the outer
side of the join, the resulting join partition is associated with that
range, since partition key values from the default partition outside
that range won't make it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a non-default partition from the
inner side, if inner side has a range missing in the outer side. But
if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/optimizer/path/joinrels.c | 95 +-
src/backend/optimizer/util/relnode.c | 33 +-
src/backend/partitioning/partbounds.c | 1682 ++++++++++++++++++++++++-
src/include/partitioning/partbounds.h | 7 +
4 files changed, 1771 insertions(+), 46 deletions(-)
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index dfbbfdac6d..ca4d261bc1 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1320,25 +1320,31 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
{
bool rel1_is_simple = IS_SIMPLE_REL(rel1);
bool rel2_is_simple = IS_SIMPLE_REL(rel2);
- int nparts;
+ PartitionScheme part_scheme;
+ PartitionBoundInfo join_boundinfo;
+ List *parts1;
+ List *parts2;
+ ListCell *lc1;
+ ListCell *lc2;
int cnt_parts;
/* Guard against stack overflow due to overly deep partition hierarchy. */
check_stack_depth();
/* Nothing to do, if the join relation is not partitioned. */
- if (!IS_PARTITIONED_REL(joinrel))
+ if (joinrel->part_scheme == NULL)
return;
/* The join relation should have consider_partitionwise_join set. */
Assert(joinrel->consider_partitionwise_join);
/*
- * Since this join relation is partitioned, all the base relations
- * participating in this join must be partitioned and so are all the
- * intermediate join relations.
+ * We can not perform partition-wise join if either of the joining
+ * relations is not partitioned.
*/
- Assert(IS_PARTITIONED_REL(rel1) && IS_PARTITIONED_REL(rel2));
+ if (!IS_PARTITIONED_REL(rel1) || !IS_PARTITIONED_REL(rel2))
+ return;
+
Assert(REL_HAS_ALL_PART_PROPS(rel1) && REL_HAS_ALL_PART_PROPS(rel2));
/* The joining relations should have consider_partitionwise_join set. */
@@ -1351,32 +1357,63 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
*/
Assert(joinrel->part_scheme == rel1->part_scheme &&
joinrel->part_scheme == rel2->part_scheme);
+ part_scheme = joinrel->part_scheme;
/*
- * 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.
+ * Get the list of matching partitions to be joined along with the
+ * partition bounds of the join relation. Because of the restrictions
+ * imposed by partition matching algorithm, not every pair of joining
+ * relations for this join will be able to use partition-wise join. But all
+ * those pairs which can use partition-wise join will produce the same
+ * partition bounds for the join relation.
*/
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel1->boundinfo));
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel2->boundinfo));
+ join_boundinfo = partition_bounds_merge(part_scheme->partnatts,
+ part_scheme->partsupfunc,
+ part_scheme->partcollation,
+ rel1, rel2,
+ parent_sjinfo->jointype,
+ &parts1, &parts2);
+
+ if (join_boundinfo == NULL)
+ return;
- nparts = joinrel->nparts;
+ if (joinrel->boundinfo == NULL)
+ {
+ Assert(joinrel->nparts == 0 && joinrel->part_rels == NULL);
+ joinrel->boundinfo = join_boundinfo;
+ joinrel->nparts = list_length(parts1);
+ Assert(joinrel->nparts == list_length(parts2));
+ joinrel->part_rels =
+ (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+ joinrel->nparts);
+ }
+ else
+ {
+ Assert(partition_bounds_equal(part_scheme->partnatts,
+ part_scheme->parttyplen,
+ part_scheme->parttypbyval,
+ join_boundinfo, joinrel->boundinfo));
+ /*
+ * Every pair of joining relations should result in the same number
+ * of child-joins.
+ */
+ Assert(joinrel->nparts == list_length(parts1));
+ Assert(joinrel->nparts == list_length(parts2));
+ Assert(joinrel->part_rels);
+ }
/*
* Create child-join relations for this partitioned join, if those don't
* exist. Add paths to child-joins for a pair of child relations
* corresponding to the given pair of parent relations.
*/
- for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+ cnt_parts = 0;
+ forboth(lc1, parts1, lc2, parts2)
{
- RelOptInfo *child_rel1 = rel1->part_rels[cnt_parts];
- RelOptInfo *child_rel2 = rel2->part_rels[cnt_parts];
+ int part1 = lfirst_int(lc1);
+ int part2 = lfirst_int(lc2);
+ RelOptInfo *child_rel1;
+ RelOptInfo *child_rel2;
SpecialJoinInfo *child_sjinfo;
List *child_restrictlist;
RelOptInfo *child_joinrel;
@@ -1384,6 +1421,10 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
AppendRelInfo **appinfos;
int nappinfos;
+ Assert(part1 >= 0 && part2 >= 0);
+ child_rel1 = rel1->part_rels[part1];
+ child_rel2 = rel2->part_rels[part2];
+
/*
* If a child table has consider_partitionwise_join=false, it means
* that it's a dummy relation for which we skipped setting up tlist
@@ -1438,12 +1479,24 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
joinrel->part_rels[cnt_parts] = child_joinrel;
}
+ /*
+ * For every pair of joining relations, the set of matching partitions
+ * would change. However, the base relation partitions constituting
+ * the given child should remain same for all the joining pairs. Since
+ * the order in which children are stored in the array of child-joins,
+ * depends upon partition bounds of the join, which are same for all
+ * the joining pairs, every joining pair yields the child-joins in the
+ * same order.
+ */
Assert(bms_equal(child_joinrel->relids, child_joinrelids));
populate_joinrel_with_paths(root, child_rel1, child_rel2,
child_joinrel, child_sjinfo,
child_restrictlist);
+ cnt_parts++;
}
+
+ Assert(cnt_parts == joinrel->nparts);
}
/*
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 4130514952..6354213854 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1594,7 +1594,7 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
* of the way the query planner deduces implied equalities and reorders
* the joins. Please see optimizer/README for details.
*/
- if (!IS_PARTITIONED_REL(outer_rel) || !IS_PARTITIONED_REL(inner_rel) ||
+ if (outer_rel->part_scheme == NULL || inner_rel->part_scheme == NULL ||
!outer_rel->consider_partitionwise_join ||
!inner_rel->consider_partitionwise_join ||
outer_rel->part_scheme != inner_rel->part_scheme ||
@@ -1607,24 +1607,6 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
part_scheme = outer_rel->part_scheme;
- Assert(REL_HAS_ALL_PART_PROPS(outer_rel) &&
- REL_HAS_ALL_PART_PROPS(inner_rel));
-
- /*
- * For now, our partition matching algorithm can match partitions only
- * when the partition bounds of the joining relations are exactly same.
- * So, bail out otherwise.
- */
- if (outer_rel->nparts != inner_rel->nparts ||
- !partition_bounds_equal(part_scheme->partnatts,
- part_scheme->parttyplen,
- part_scheme->parttypbyval,
- outer_rel->boundinfo, inner_rel->boundinfo))
- {
- Assert(!IS_PARTITIONED_REL(joinrel));
- return;
- }
-
/*
* This function will be called only once for each joinrel, hence it
* should not have partition scheme, partition bounds, partition key
@@ -1636,17 +1618,20 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
/*
* Join relation is partitioned using the same partitioning scheme as the
- * joining relations and has same bounds.
+ * joining relations.
+ *
+ * Because of restrictions in partition_bounds_merge(), not every pair of
+ * joining relations (including the one presented to this function) for the
+ * same joinrel can use partition-wise join or has both the relations
+ * partitioned. Hence we calculate the partition bounds, number of
+ * partitions and child-join relations of the join relation when and if we
+ * find a suitable pair in try_partition_wise_join().
*/
joinrel->part_scheme = part_scheme;
- joinrel->boundinfo = outer_rel->boundinfo;
partnatts = joinrel->part_scheme->partnatts;
joinrel->partexprs = (List **) palloc0(sizeof(List *) * partnatts);
joinrel->nullable_partexprs =
(List **) palloc0(sizeof(List *) * partnatts);
- joinrel->nparts = outer_rel->nparts;
- joinrel->part_rels =
- (RelOptInfo **) palloc0(sizeof(RelOptInfo *) * joinrel->nparts);
/*
* Set the consider_partitionwise_join flag.
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index 637e05e5ca..257d24f6e1 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -23,6 +23,7 @@
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
+#include "nodes/pathnodes.h"
#include "parser/parse_coerce.h"
#include "partitioning/partbounds.h"
#include "partitioning/partdesc.h"
@@ -67,6 +68,12 @@ typedef struct PartitionRangeBound
bool lower; /* this is the lower (vs upper) bound */
} PartitionRangeBound;
+typedef struct PartitionMap
+{
+ int from;
+ int to;
+} PartitionMap;
+
static int32 qsort_partition_hbound_cmp(const void *a, const void *b);
static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
void *arg);
@@ -108,7 +115,58 @@ static void get_range_key_properties(PartitionKey key, int keynum,
static List *get_range_nulltest(PartitionKey key);
static bool partition_hbounds_equal(PartitionBoundInfo b1,
PartitionBoundInfo b2);
-
+static PartitionBoundInfo partition_range_bounds_merge(
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype, int partnatts,
+ FmgrInfo *supfuncs, Oid *collations);
+static PartitionBoundInfo partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *collations,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype);
+static PartitionBoundInfo partition_hash_bounds_merge(RelOptInfo *outer_rel,
+ RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype);
+static void generate_matching_part_pairs(PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ int nparts1, int nparts2,
+ JoinType jointype, int nparts,
+ List **parts1, List **parts2);
+static PartitionBoundInfo build_merged_partition_bounds(char strategy,
+ List *merged_datums, List *merged_indexes,
+ List *merged_contents, int null_index,
+ int default_index);
+static int map_and_merge_partitions(PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ int index1, int index2, int *next_index);
+static int32 partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *collations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2);
+static bool partition_range_cmp(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval);
+static bool partition_range_merge_next_lb(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes);
+static bool merge_default_partitions(PartitionBoundInfo outer_bi,
+ PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ JoinType jointype,
+ int *next_index, int *default_index);
+static bool merge_null_partitions(PartitionBoundInfo outer_bi,
+ PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ JoinType jointype,
+ int *next_index, int *null_index,
+ int *default_index);
/*
* get_qual_from_partbound
@@ -2943,3 +3001,1625 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
PG_RETURN_BOOL(rowHash % modulus == remainder);
}
+
+/*
+ * partition_bounds_merge
+ *
+ * The function produces the partition bounds for a join between two relations
+ * whose partition bounds are given. The function also returns two lists of
+ * partition indexes one for each of the joining relations. Both the lists
+ * contain the same number of elements. The partition indexes at the same
+ * positions in the lists indicate the pair partitions, one from each side, to
+ * be joined and the position itself corresponds to the index of partition
+ * produced by that child-join in the partitioned join.
+ *
+ * The function returns NULL if we can not find the matching pair of
+ * partitions. This happens if 1. multiple partitions on one side match with
+ * one partition on the other side. 2. a given partition on the outer side
+ * doesn't have a matching partition on the inner side. We can not support the
+ * first case since we don't have a way to represent multiple partitions as a
+ * single relation (RelOptInfo) and then perform join using the ganged
+ * relation. We can not support the second case since the missing inner
+ * partition needs to be represented as an empty relation and we don't have a
+ * way to introduce empty relation during join planning after creating paths
+ * for all the base relations.
+ */
+extern PartitionBoundInfo
+partition_bounds_merge(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts)
+{
+ PartitionBoundInfo merged_bounds;
+ PartitionBoundInfo outer_binfo = outer_rel->boundinfo,
+ inner_binfo = inner_rel->boundinfo;
+ char strategy = outer_binfo->strategy;
+
+ /* Bail out if partitioning strategies are different. */
+ if (outer_binfo->strategy != inner_binfo->strategy)
+ return NULL;
+
+ if (jointype != JOIN_LEFT && jointype != JOIN_INNER &&
+ jointype != JOIN_SEMI && jointype != JOIN_ANTI &&
+ jointype != JOIN_FULL)
+ elog(ERROR, "unexpected join type %d", jointype);
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+ switch (strategy)
+ {
+ case PARTITION_STRATEGY_LIST:
+ merged_bounds = partition_list_bounds_merge(partsupfunc,
+ partcollation,
+ outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype);
+ break;
+
+ case PARTITION_STRATEGY_RANGE:
+ merged_bounds = partition_range_bounds_merge(outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype, partnatts,
+ partsupfunc,
+ partcollation);
+ break;
+
+ case PARTITION_STRATEGY_HASH:
+ merged_bounds = partition_hash_bounds_merge(outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype);
+ break;
+
+ default:
+ elog(ERROR, "unexpected partition strategy: %d", strategy);
+ }
+
+ Assert(merged_bounds || (*outer_parts == NIL && *inner_parts == NIL));
+
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+
+ Assert((*outer_parts == NIL || *inner_parts != NIL) &&
+ (*inner_parts == NIL || *outer_parts != NIL));
+
+ return merged_bounds;
+}
+
+/*
+ * partition_get_range_bounds
+ *
+ * Given the index of lower bound in datums array, return lower and upper
+ * bounds and the index of the partition with that lower bound.
+ */
+static int
+partition_get_range_bounds(PartitionBoundInfo bi, int lb_index,
+ PartitionRangeBound *lower,
+ PartitionRangeBound *upper)
+{
+ int part_index;
+
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The lower bound should correspond to a valid partition. */
+ part_index = bi->indexes[lb_index + 1];
+ Assert(part_index >= 0);
+
+ lower->kind = bi->kind[lb_index];
+ lower->datums = bi->datums[lb_index];
+ lower->lower = true;
+ upper->kind = bi->kind[lb_index + 1];
+ upper->datums = bi->datums[lb_index + 1];
+ upper->lower = false;
+
+ return part_index;
+}
+
+/*
+ * partition_range_get_next_lb_index
+ *
+ * Given the index of lower bound in datums array return the
+ * index of lower bound of the next partition. When the given index corresponds
+ * to the last partition, return number of datums (ndatums).
+ */
+static int
+partition_range_get_next_lb_index(PartitionBoundInfo bi, int lb_index)
+{
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The partition index corresponding to the upper bound should be valid. */
+ Assert(bi->indexes[lb_index + 1] >= 0);
+
+ /*
+ * If there are no bounds left beyond the upper bound, we have reached the
+ * last partition.
+ */
+ if (lb_index + 2 < bi->ndatums)
+ {
+ /*
+ * If the bound next to the upper bound corresponds to no partition,
+ * that's the next lower bound of the next partition. Otherwise, the
+ * current upper bound is the lower bound of the next partition.
+ */
+ if (bi->indexes[lb_index + 2] < 0)
+ return lb_index + 2;
+ else
+ return lb_index + 1;
+ }
+ else
+ return bi->ndatums;
+}
+
+static int32
+partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2)
+{
+ return partition_rbound_cmp(partnatts, partsupfunc, partcollations,
+ bound1->datums, bound1->kind, bound1->lower,
+ bound2);
+}
+
+/*
+ * partition_range_cmp
+ *
+ * Compare the bounds of two range partitions. Set ub_cmpval <, = or > 0, if the
+ * first partition's upper bound is lower than, equal to or higher than the
+ * second partition's upper bound resp. Similarly set lb_cmpval <, = or > 0,
+ * if the first partition's lower bound is lower than, equal to or higher than
+ * the second partition's lower bound resp.
+ *
+ * Return true, if the ranges overlap, otherwise return false.
+ */
+static bool
+partition_range_cmp(int partnatts, FmgrInfo *partsupfuncs, Oid *partcollations,
+ PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval)
+{
+ bool overlap;
+
+ /*
+ * Compare upper bound of the first partition with the lower bound of the
+ * second and vice-versa. If lower bound is higher than the upper bound,
+ * the partitions are not overlapping. All other cases indicate overlapping
+ * partitions.
+ */
+ if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound1, upper_bound2) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = 1;
+ *lb_cmpval = 1;
+ }
+ else if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound2, upper_bound1) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = -1;
+ *lb_cmpval = -1;
+ }
+ else
+ {
+ overlap = true;
+ *ub_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, upper_bound1,
+ upper_bound2);
+ *lb_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, lower_bound1,
+ lower_bound2);
+ }
+
+ return overlap;
+}
+
+/*
+ * partition_range_merge
+ *
+ * Merge the partition bounds of given two partitions such that the join
+ * between the given two partitions fits merged bounds.
+ *
+ * "merged_upper" will be set to one of the given upper bounds and
+ * "merged_lower" will be set to one of the given lower bounds.
+ */
+static void
+partition_range_merge(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, JoinType jointype,
+ PartitionRangeBound *left_lb,
+ PartitionRangeBound *left_ub,
+ PartitionRangeBound *right_lb,
+ PartitionRangeBound *right_ub,
+ PartitionRangeBound **merged_lb,
+ PartitionRangeBound **merged_ub)
+{
+ /*
+ * An outer join will have all the rows from the outer side, so merged
+ * bounds will be same as the outer bounds. An inner join will have rows
+ * that fit both the bounds, thus lower merged bound will be higher of two
+ * lower bounds and upper merged bound will be lower of the two upper
+ * bounds.
+ */
+ switch (jointype)
+ {
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ *merged_ub = left_ub;
+ *merged_lb = left_lb;
+ break;
+
+ case JOIN_INNER:
+ case JOIN_SEMI:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) < 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) > 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ case JOIN_FULL:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) > 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) < 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ default:
+ elog(ERROR, "unexpected join type %d", jointype);
+ }
+
+ return;
+}
+
+/*
+ * Add the lower bound of the next range to the list of bounds, if the lower
+ * bound is higher or equal to the previous upper bound. If successful return
+ * true, otherwise false.
+ */
+static bool
+partition_range_merge_next_lb(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes)
+{
+ int cmpval;
+
+ if (!*merged_datums)
+ {
+ Assert(!*merged_kinds && !*merged_indexes);
+ cmpval = 1;
+ }
+ else
+ {
+ PartitionRangeBound prev_ub;
+
+ prev_ub.datums = llast(*merged_datums);
+ prev_ub.kind = llast(*merged_kinds);
+ prev_ub.lower = false;
+
+ cmpval = partition_rbound_cmp(partnatts, partsupfuncs, partcollations,
+ next_lb_datums, next_lb_kind, false,
+ &prev_ub);
+ }
+
+ /*
+ * The lower bound is lower than the last upper bound, thus does not fit
+ * the bounds created so far and hence can not be merged with the existing
+ * bounds.
+ */
+ if (cmpval < 0)
+ return false;
+
+ /*
+ * Add bounds of the new merged partition. If the next lower bound is
+ * higher than the last upper bound, add new range with index
+ * corresponding to the lower bound as -1. If the merged lower bound
+ * is same as the last merged upper bound, the last upper bound will be
+ * reused as the lower bound of the next range.
+ */
+ if (cmpval > 0)
+ {
+ *merged_datums = lappend(*merged_datums, next_lb_datums);
+ *merged_kinds = lappend(*merged_kinds, next_lb_kind);
+ *merged_indexes = lappend_int(*merged_indexes, -1);
+ }
+
+ return true;
+}
+
+/*
+ * handle_missing_partition
+ *
+ * If a range appears in one of the joining relations but not the other, a row
+ * in the corresponding partition will not have any join partner in the other
+ * relation, unless the other relation has a default partition. If a given list
+ * value is present in one joining relation but not the other, the default
+ * partition on the other side may contain that value.
+ *
+ * In both these cases, such an extra partition forms a joining pair with the
+ * default partition, if any, on the other side.
+ *
+ * If the default partition happens to be on the outer side of the join, the
+ * resultant partition will act as the default partition of the join relation.
+ * Otherwise the resultant partition will be associated with the range.
+ *
+ * When the default partition is not present in the other relation, the rows in
+ * the extra partition will be included in the bounds of the join result, if it
+ * appears on the outer side of the join, since all rows from the outer side
+ * are included in the join result.
+ *
+ * This function handles all these cases.
+ *
+ * maps_with_missing and missing_side_default are the partition maps (See
+ * partition_range/list_bounds_merge() for details) and the index of default
+ * partition respectively corresponding the side with missing partition.
+ *
+ * maps_with_extra and extra_part are the partition maps (See
+ * partition_range/list_bounds_merge() for details) and the index of extra
+ * partition respectively corresponding to the side with the extra partition.
+ *
+ * It returns true if the matching succeeds, otherwise returns false.
+ */
+static bool
+handle_missing_partition(PartitionMap *maps_with_missing,
+ PartitionMap *maps_with_extra,
+ int missing_side_default,
+ int extra_part,
+ bool missing_side_outer,
+ bool missing_side_inner,
+ int *next_index, int *default_index,
+ int *merged_index)
+{
+ bool missing_has_default = (missing_side_default != -1);
+
+ if (missing_has_default)
+ {
+ *merged_index = map_and_merge_partitions(maps_with_missing,
+ maps_with_extra,
+ missing_side_default,
+ extra_part,
+ next_index);
+ if (*merged_index < 0)
+ return false;
+
+ if (missing_side_outer)
+ {
+ /*
+ * Default partition on the outer side forms the default
+ * partition of the join result.
+ */
+ if (*default_index < 0)
+ *default_index = *merged_index;
+ else if(*default_index != *merged_index)
+ {
+ /*
+ * Ended up with default partition on the outer side
+ * being joined with multiple partitions on the inner
+ * side. We don't support this case.
+ */
+ return false;
+ }
+
+ /*
+ * Since the merged partition acts as a default partition, it
+ * doesn't need a separate index.
+ */
+ *merged_index = -1;
+ }
+ }
+ else if (missing_side_inner)
+ {
+ /*
+ * If this partition has already been mapped (say because we
+ * found an overlapping range earlier), we know where does it
+ * fit in the join result. Nothing to do in that case. Else
+ * create a new merged partition.
+ */
+ PartitionMap *extra_map = &maps_with_extra[extra_part];
+ if (extra_map->to < 0)
+ {
+ extra_map->to = *next_index;
+ *next_index = *next_index + 1;
+ *merged_index = extra_map->to;
+ }
+ }
+ else
+ Assert(*merged_index < 0);
+
+ return true;
+}
+
+static PartitionMap*
+init_partition_map(RelOptInfo *rel)
+{
+ int i, nparts = rel->nparts;
+ PartitionMap *map;
+
+ map = (PartitionMap *) palloc(sizeof(PartitionMap) * nparts);
+
+ for (i = 0; i < nparts; i++)
+ {
+ map[i].from = -1;
+ map[i].to = -1;
+ }
+
+ return map;
+}
+
+/*
+ * Allocate and initialize partition maps. We maintain four maps, two maps
+ * for each joining relation. pmap[i] gives the partition from the other
+ * relation which would join with ith partition of the given relation.
+ * Partition i from the given relation will join with partition pmap[i]
+ * from the other relation to produce partition mmap[i] of the join (merged
+ * partition).
+ *
+ * pmap[i] = -1 indicates that ith partition of a given relation does not
+ * have a matching partition from the other relation.
+ *
+ * mmap[i] = -1 indicates that ith partition of a given relation does not
+ * contribute to the join result. That can happen only when the given
+ * relation is the inner relation and it doesn't have a matching partition
+ * from the outer relation, hence pmap[i] should be -1.
+ *
+ * In case of an outer join, every partition of the outer join will appear
+ * in the join result, and thus has mmap[i] set for all i. But it's not
+ * necessary that every partition on the outer side will have a matching
+ * partition on the inner side. In such a case, we end up with pmap[i] = -1
+ * and mmap[i] != -1.
+ */
+
+/*
+ * partition_range_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for range partitioned tables.
+ */
+static PartitionBoundInfo
+partition_range_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype, int partnatts,
+ FmgrInfo *partsupfuncs, Oid *partcollations)
+
+{
+ PartitionMap *outer_maps = NULL;
+ PartitionMap *inner_maps = NULL;
+ int outer_part = 0;
+ int inner_part = 0;
+ PartitionBoundInfo merged_bounds = NULL;
+ int outer_lb_index;
+ int inner_lb_index;
+ int next_index;
+ int default_index = -1;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ List *merged_kinds = NIL;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int inner_default = inner_bi->default_index;
+ int outer_default = outer_bi->default_index;
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_RANGE);
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ outer_maps = init_partition_map(outer_rel);
+ inner_maps = init_partition_map(inner_rel);
+
+ /*
+ * Merge the ranges (partitions) from both sides. Every iteration compares
+ * a pair of ranges, one from each side, advancing to the next range from
+ * the side with smaller upper range bound. If upper bounds of ranges from
+ * both sides match exactly, both the sides are advanced. For a given pair
+ * of ranges, we decide whether the corresponding partition match or not.
+ * lb_index, for inner or outer side, keeps track of the index of lower bound
+ * datum in PartitionBoundInfo::datums of that side.
+ */
+ outer_lb_index = 0;
+ inner_lb_index = 0;
+ next_index = 0;
+ while (outer_lb_index < outer_bi->ndatums ||
+ inner_lb_index < inner_bi->ndatums)
+ {
+ PartitionRangeBound outer_lb, outer_ub,
+ inner_lb, inner_ub,
+ *merged_lb = NULL,
+ *merged_ub = NULL;
+
+ int merged_index = -1;
+ bool overlap;
+ bool finished_outer = false;
+ bool finished_inner = false;
+
+ /* Result of bounds comparison per partition_rbound_cmp(). */
+ int ub_cmpval; /* Upper bounds comparison result. */
+ int lb_cmpval; /* Lower bounds comparison result. */
+
+ /* Get the range bounds of the next pair of partitions. */
+ if (outer_lb_index < outer_bi->ndatums)
+ outer_part = partition_get_range_bounds(outer_bi, outer_lb_index,
+ &outer_lb, &outer_ub);
+ else
+ finished_outer = true;
+
+ if (inner_lb_index < inner_bi->ndatums)
+ inner_part = partition_get_range_bounds(inner_bi, inner_lb_index,
+ &inner_lb, &inner_ub);
+ else
+ finished_inner = true;
+
+ Assert(!finished_outer || !finished_inner);
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining partitions on the side
+ * which finishes later. For that we set the comparison parameters
+ * overlap, ub_cmpval and lb_cmpval in such a way that it appears as if
+ * the side which finishes earlier has an extra partition with lower
+ * and upper bounds higher than any other partition of the unfinished
+ * side. That way we advance the partitions on that side till all of
+ * them are exhausted.
+ */
+ if (finished_outer)
+ {
+ overlap = false;
+ ub_cmpval = 1;
+ lb_cmpval = 1;
+ }
+ else if (finished_inner)
+ {
+ overlap = false;
+ ub_cmpval = -1;
+ lb_cmpval = -1;
+ }
+ else
+ overlap = partition_range_cmp(partnatts, partsupfuncs, partcollations,
+ &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &ub_cmpval, &lb_cmpval);
+
+ if (overlap)
+ {
+ /*
+ * The rows from overlapping portion of ranges on both sides may
+ * join, hence the corresponding pair of partitions form a joining
+ * pair. Match them and produce the bounds of the joint partition
+ * and its index by merging the bounds according to the type of
+ * join.
+ */
+ partition_range_merge(partnatts, partsupfuncs, partcollations,
+ jointype, &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &merged_lb, &merged_ub);
+
+ merged_index = map_and_merge_partitions(outer_maps, inner_maps,
+ outer_part, inner_part,
+ &next_index);
+
+ if (merged_index < 0)
+ {
+ /* Failed to match the partitions. */
+ return NULL;
+ }
+
+ /*
+ * If the ranges overlap but don't exactly match, a row from
+ * non-overlapping portion of the range from one side of join may
+ * find its join partner in the previous or next overlapping
+ * partition or default partition on the other side , if such a
+ * partition exists. All those cases, if true, will cause one
+ * partition from that side to match at least two partitions on the
+ * other side; a case that we do not support now. Previous
+ * partition has been delt with in the previous iteration of this
+ * loop, next partition will be delt in the next iteration. We will
+ * deal with the default partition here.
+ */
+ if ((lb_cmpval < 0 && inner_has_default) ||
+ /* Non-overlapping range on the lower side of outer range. */
+ (lb_cmpval > 0 && outer_has_default) ||
+ /* Non-overlapping range on the lower side of inner range. */
+ (ub_cmpval < 0 && outer_has_default) ||
+ /* Non-overlapping range on the upper side of inner range. */
+ (ub_cmpval > 0 && inner_has_default))
+ /* Non-overlapping range on the upper side of outer range. */
+ return NULL;
+ }
+
+ if (ub_cmpval == 0)
+ {
+ /* Upper bounds of both the ranges match. */
+ Assert(overlap);
+
+ /* Move to the next pair of partitions. */
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+ else if (ub_cmpval < 0)
+ {
+ /* Upper bound of inner range higher than that of the outer. */
+
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the inner side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &outer_lb;
+ merged_ub = &outer_ub;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+ if (!handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ outer_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+ }
+
+ /* Move to the next partition on the outer side. */
+ Assert(!finished_outer);
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ }
+ else
+ {
+ Assert(ub_cmpval > 0);
+
+ /* Upper bound of outer range higher than that of the inner. */
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the outer side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &inner_lb;
+ merged_ub = &inner_ub;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ inner_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+ }
+
+ /* Move to the next partition on the inner side. */
+ Assert (!finished_inner);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+
+ if (merged_index < 0)
+ {
+ /* We didn't find a new merged partition. */
+ continue;
+ }
+
+ /*
+ * We have a valid partition index for the next partition of join. The
+ * partition should have valid range.
+ */
+ Assert(merged_lb && merged_ub);
+
+ /* Try merging new lower bound with the last upper bound. */
+ if (!partition_range_merge_next_lb(partnatts, partsupfuncs,
+ partcollations,
+ merged_lb->datums,
+ merged_lb->kind, &merged_datums,
+ &merged_kinds, &merged_indexes))
+ return NULL;
+
+ /* Add upper bound with the merged partition index. */
+ merged_datums = lappend(merged_datums, merged_ub->datums);
+ merged_kinds = lappend(merged_kinds, merged_ub->kind);
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ }
+
+ if (!merge_default_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index,
+ &default_index))
+ return NULL;
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_maps, inner_maps,
+ outer_nparts, inner_nparts,
+ jointype, next_index,
+ outer_parts, inner_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes,
+ merged_kinds,
+ -1, default_index);
+ }
+
+ /* Free any memory we used in this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ list_free(merged_kinds);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_list_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for list partitioned tables.
+ *
+ */
+static PartitionBoundInfo
+partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype)
+{
+ PartitionMap *outer_maps = NULL;
+ PartitionMap *inner_maps = NULL;
+ int cnto;
+ int cnti;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ int next_index = 0;
+ int null_index = -1;
+ int default_index = -1;
+ PartitionBoundInfo merged_bounds = NULL;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int *outer_indexes = outer_bi->indexes;
+ int *inner_indexes = inner_bi->indexes;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_LIST);
+
+ /* List partitions do not require unbounded ranges. */
+ Assert(!outer_bi->kind && !inner_bi->kind);
+
+ outer_maps = init_partition_map(outer_rel);
+ inner_maps = init_partition_map(inner_rel);
+
+ /*
+ * Merge the list value datums from both sides. Every iteration compares a
+ * pair of datums, one from each side, advancing to the next datum from the
+ * side with smaller datum. If datums from both sides match exactly, both
+ * the sides are advanced. For a given pair of datums, we decide whether
+ * the corresponding partition match or not.
+ */
+ cnto = cnti = 0;
+ while (cnto < outer_bi->ndatums || cnti < inner_bi->ndatums)
+ {
+ Datum *odatums;
+ Datum *idatums;
+ int o_index;
+ int i_index;
+ int cmpval;
+ int merged_index = -1;
+ Datum *merged_datum;
+ bool finished_inner;
+ bool finished_outer;
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining datums on the side which
+ * finishes later. For that we set the comparison parameter cmpval in
+ * such a way that it appears as if the side which finishes earlier has
+ * an extra datum higher than any other datum on the unfinished side.
+ * That way we advance the datums on the unfinished side till all of
+ * its datums are exhausted.
+ */
+ if (cnto >= outer_bi->ndatums)
+ {
+ finished_outer = true;
+ odatums = NULL;
+ o_index = -1;
+ }
+ else
+ {
+ finished_outer = false;
+ odatums = outer_bi->datums[cnto];
+ o_index = outer_indexes[cnto];
+ }
+
+ if (cnti >= inner_bi->ndatums)
+ {
+ finished_inner = true;
+ idatums = NULL;
+ i_index = -1;
+ }
+ else
+ {
+ finished_inner = false;
+ idatums = inner_bi->datums[cnti];
+ i_index = inner_indexes[cnti];
+ }
+
+ /* If we exhausted both the sides, we won't enter the loop. */
+ Assert(!finished_inner || !finished_outer);
+
+ if (finished_outer)
+ cmpval = 1;
+ else if (finished_inner)
+ cmpval = -1;
+ else
+ {
+ /* Every list datum should map to a valid partition index. */
+ Assert(o_index >= 0 && i_index >= 0 &&
+ odatums != NULL && idatums != NULL);
+
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
+ partcollation[0],
+ odatums[0], idatums[0]));
+ }
+
+ if (cmpval == 0)
+ {
+ /*
+ * Datums match. Rows on either side with these datums as partition
+ * key value will join and will be part of the partition of the
+ * join result produced by joining the corresponding partitions.
+ * Match the corresponding partitions and if successful, add the
+ * datum to the list of merged datums with index of merged
+ * partition containing it.
+ */
+ merged_datum = odatums;
+ merged_index = map_and_merge_partitions(outer_maps, inner_maps,
+ o_index, i_index,
+ &next_index);
+
+ if (merged_index < 0)
+ return NULL;
+
+ /* Move to the next pair of bounds. */
+ cnto++;
+ cnti++;
+ }
+ else if (cmpval < 0)
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /* A datum missing from the inner side. */
+ merged_index = -1;
+ merged_datum = odatums;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ o_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+
+ /* Move to the next datum on the outer side. */
+ Assert(!finished_outer);
+ cnto++;
+ }
+ else
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ Assert(cmpval > 0);
+
+ /* A datum missing from the outer side. */
+ merged_index = -1;
+ merged_datum = idatums;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ i_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+
+ /* Move to the next datum on the right side. */
+ Assert(!finished_inner);
+ cnti++;
+ }
+
+ /*
+ * Add the list value with appropriate index in the list of datums, if
+ * we have associated a partition with this list value.
+ */
+ if (merged_index >= 0)
+ {
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ merged_datums = lappend(merged_datums, merged_datum);
+ }
+ }
+
+ if (!merge_null_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index, &null_index,
+ &default_index))
+ return NULL;
+
+ if (!merge_default_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index,
+ &default_index))
+ return NULL;
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_maps, inner_maps,
+ outer_nparts, inner_nparts,
+ jointype, next_index,
+ outer_parts, inner_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes, NIL,
+ null_index, default_index);
+ }
+
+ /* Free up all extra memory before returning from this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_bounds_merge()'s arm for hash partitioned tables.
+ *
+ * If the given two hash bounds are same, the function returns the first one
+ * without any change, alongwith the lists of matching partitions. Otherwise it
+ * returns NULL.
+ *
+ * We could try merging the bounds when both the bounds have same greatest
+ * modulii. But there seems to be hardly any requirement for the same.
+ */
+static PartitionBoundInfo
+partition_hash_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype)
+{
+ int nparts;
+ int cnt;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * Hash partitioned table does not have explicit NULL accepting partition
+ * and also does not have a default partition.
+ */
+ Assert(!partition_bound_has_default(outer_bi) &&
+ !partition_bound_has_default(inner_bi));
+ Assert(!partition_bound_accepts_nulls(outer_bi) &&
+ !partition_bound_accepts_nulls(inner_bi));
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+
+ if (outer_nparts != inner_nparts)
+ return NULL;
+ nparts = outer_nparts;
+
+ if (outer_bi->ndatums != inner_bi->ndatums ||
+ !partition_hbounds_equal(outer_bi, inner_bi))
+ return NULL;
+
+ /*
+ * Cook up list of matching partitions. Since bounds are exactly same the
+ * partitions at the same position from both the relations match.
+ */
+ for (cnt = 0; cnt < nparts; cnt++)
+ {
+ *outer_parts = lappend_int(*outer_parts, cnt);
+ *inner_parts = lappend_int(*inner_parts, cnt);
+ }
+
+ return outer_bi;
+}
+
+/*
+ * map_and_merge_partitions
+ *
+ * If the two given partitions (given by index1 and index2 resp.) are
+ * already mapped to each other return the index of corresponding partition in
+ * the merged set of partitions. If they do not have a merged partition
+ * associated with them, assign a new merged partition index. If the
+ * partitions are already mapped and their mapped partitions are different from
+ * each other, they can not be merged, so return -1.
+ *
+ * partmaps1[i] gives the mapping of partitions for both relations. It
+ * describes which partition of relation 2 matches ith partition of relation 1,
+ * and which partition in the merged set matches ith partition of relation 1
+ * maps to. Similarly for partmap2.
+ *
+ * index1 and index2 are the indexes of matching partition from respective
+ * relations.
+ *
+ * *next_index is used and incremented when the given partitions require a new
+ * merged partition.
+ */
+
+static int
+map_and_merge_partitions(PartitionMap *partmaps1, PartitionMap *partmaps2,
+ int index1, int index2, int *next_index)
+{
+ PartitionMap *partmap1 = &partmaps1[index1];
+ PartitionMap *partmap2 = &partmaps2[index2];
+ int merged_index;
+
+ /*
+ * If both the partitions are not mapped to each other, update the
+ * maps.
+ */
+ if (partmap1->from < 0 && partmap2->from < 0)
+ {
+ partmap1->from = index2;
+ partmap2->from = index1;
+ }
+
+ /*
+ * If the given to partitions map to each other, find the corresponding
+ * merged partition index .
+ */
+ if (partmap1->from == index2 && partmap2->from == index1)
+ {
+ /*
+ * If both the partitions are mapped to the same merged partition, get
+ * the index of merged partition.
+ */
+ if (partmap1->to == partmap2->to)
+ {
+ merged_index = partmap1->to;
+
+ /*
+ * If the given two partitions do not have a merged partition
+ * associated with them, allocate a new merged partition.
+ */
+ if (merged_index < 0)
+ {
+ merged_index = *next_index;
+ *next_index = *next_index + 1;
+ partmap1->to = merged_index;
+ partmap2->to = merged_index;
+ }
+ }
+
+ /*
+ * If partition from one relation was mapped to a merged partition but
+ * not the partition from the other relation, map the same merged
+ * partition to the partition from other relation, since matching
+ * partitions map to the same merged partition.
+ */
+ else if (partmap1->to >= 0 && partmap2->to < 0)
+ {
+ partmap2->to = partmap1->to;
+ merged_index = partmap1->to;
+ }
+ else if (partmap1->to < 0 && partmap2->to >= 0)
+ {
+ partmap1->to = partmap2->to;
+ merged_index = partmap2->to;
+ }
+ else
+ {
+ Assert(partmap1->to != partmap2->to &&
+ partmap1->to >= 0 && partmap2->to >= 0);
+
+ /*
+ * Both the partitions map to different merged partitions. This
+ * means that multiple partitions from one relation matches to one
+ * partition from the other relation. Partition-wise join does not
+ * handle this case right now, since it requires ganging multiple
+ * partitions together (into one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+ }
+ else
+ {
+ /*
+ * Multiple partitions from one relation map to one partition from the
+ * other relation. Partition-wise join does not handle this case right
+ * now, since it requires ganging multiple partitions together (into
+ * one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+
+ return merged_index;
+}
+
+/*
+ * generate_matching_part_pairs
+ *
+ * partmaps1 map each partition from either side of the join to a merged
+ * partition resp. E.g. partmaps1[i].to gives the merged partition to which ith
+ * partition of first relation maps. Similarly for partmap2. If
+ * partmaps1[i].to == partmaps2[j].to, i and j form the matching pair of
+ * partitions.
+ *
+ * Given these maps this function produces the list pairs of partitions which
+ * when joined produce the merged partitions in the order of merged partition
+ * indexes.
+ *
+ * nparts1 and nparts2 are the number of partitions of the joining relations
+ * resp.
+ *
+ * nparts is the number of merged partitions.
+ *
+ * If successful, the pairs of partitions are returned as two separate lists,
+ * parts1 and parts2 resp., one for each side. Otherwise, those lists will be
+ * set to NIL.
+ */
+static void
+generate_matching_part_pairs(PartitionMap *partmaps1, PartitionMap *partmaps2,
+ int nparts1, int nparts2,
+ JoinType jointype, int nparts,
+ List **matched_parts1, List **matched_parts2)
+{
+ bool merged = true;
+ int *matching1,
+ *matching2;
+ int i;
+ int max_nparts;
+
+ *matched_parts1 = NIL;
+ *matched_parts2 = NIL;
+
+ matching1 = (int *) palloc(sizeof(int) * nparts),
+ matching2 = (int *) palloc(sizeof(int) * nparts);
+ for (i = 0; i < nparts; i++)
+ matching1[i] = matching2[i] = -1;
+
+ /* Set pairs of matching partitions. */
+ max_nparts = Max(nparts1, nparts2);
+ for (i = 0; i < max_nparts; i++)
+ {
+ if (i < nparts1)
+ {
+ PartitionMap outer_map = partmaps1[i];
+
+ if (outer_map.to >= 0)
+ {
+ Assert(outer_map.to < nparts);
+ matching1[outer_map.to] = i;
+ }
+ }
+
+ if (i < nparts2)
+ {
+ PartitionMap inner_map = partmaps2[i];
+
+ if (inner_map.to >= 0)
+ {
+ Assert(inner_map.to < nparts);
+ matching2[inner_map.to] = i;
+ }
+ }
+ }
+
+ /*
+ * If we have a partition missing on an inner side, we need to add a dummy
+ * relation which joins with the outer partition. If the inner relation
+ * happens to be a base relation, it will require adding a dummy child
+ * base relation during join processing. Right now, we freeze the base
+ * relation arrays like PlannerInfo::simple_rte_array after planning for
+ * base relations. Adding a new (dummy) base relation would require some
+ * changes to that. So, right now, we do not implement partition-wise join
+ * in such cases.
+ */
+ for (i = 0; i < nparts; i++)
+ {
+ int part1 = matching1[i];
+ int part2 = matching2[i];
+
+ /* At least one of the partitions should exist. */
+ Assert(part1 >= 0 || part2 >= 0);
+
+ switch (jointype)
+ {
+ case JOIN_INNER:
+ case JOIN_SEMI:
+
+ /*
+ * An inner or semi join can not return any row when the
+ * matching partition on either side is missing. We should
+ * have eliminated all such cases while merging the bounds.
+ */
+ Assert(part1 >= 0 && part2 >= 0);
+ break;
+
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ Assert(part1 >= 0);
+ if (part2 < 0)
+ merged = false;
+ break;
+
+ case JOIN_FULL:
+ if (part1 < 0 || part2 < 0)
+ merged = false;
+ break;
+
+ default:
+ elog(ERROR, "unrecognized join type: %d", (int) jointype);
+ }
+
+ if (!merged)
+ break;
+
+ *matched_parts1 = lappend_int(*matched_parts1, part1);
+ *matched_parts2 = lappend_int(*matched_parts2, part2);
+ }
+
+ pfree(matching1);
+ pfree(matching2);
+
+ if (!merged)
+ {
+ list_free(*matched_parts1);
+ list_free(*matched_parts2);
+ *matched_parts1 = NIL;
+ *matched_parts2 = NIL;
+ }
+}
+
+static PartitionBoundInfo
+build_merged_partition_bounds(char strategy, List *merged_datums,
+ List *merged_indexes, List *merged_kinds,
+ int null_index, int default_index)
+{
+ int cnt;
+ PartitionBoundInfo merged_bounds;
+ ListCell *lc;
+
+ /* We expect the same number of elements in datums and indexes lists. */
+ Assert(list_length(merged_datums) == list_length(merged_indexes));
+
+ merged_bounds = (PartitionBoundInfo) palloc(sizeof(PartitionBoundInfoData));
+ merged_bounds->strategy = strategy;
+ merged_bounds->ndatums = list_length(merged_datums);
+
+ if (strategy == PARTITION_STRATEGY_RANGE)
+ {
+ Assert(list_length(merged_datums) == list_length(merged_kinds));
+ merged_bounds->kind =
+ (PartitionRangeDatumKind **) palloc(sizeof(PartitionRangeDatumKind *) *
+ list_length(merged_kinds));
+ cnt = 0;
+ foreach(lc, merged_kinds)
+ merged_bounds->kind[cnt++] = lfirst(lc);
+
+ /* There are ndatums+1 indexes in case of range partitions */
+ merged_indexes = lappend_int(merged_indexes, -1);
+ }
+ else
+ merged_bounds->kind = NULL;
+
+ cnt = 0;
+ merged_bounds->datums = (Datum **) palloc(sizeof(Datum *) *
+ list_length(merged_datums));
+ foreach(lc, merged_datums)
+ merged_bounds->datums[cnt++] = lfirst(lc);
+
+ merged_bounds->indexes = (int *) palloc(sizeof(int) *
+ list_length(merged_indexes));
+ cnt = 0;
+ foreach(lc, merged_indexes)
+ merged_bounds->indexes[cnt++] = lfirst_int(lc);
+
+ merged_bounds->null_index = null_index;
+ merged_bounds->default_index = default_index;
+
+ return merged_bounds;
+}
+
+/*
+ * Merge default partitions from both sides, if any, and assign the default
+ * partition for the join result, if necessary.
+ *
+ * If both the relations have default partitions, try mapping those to each
+ * other. If the mapping succeeds corresponding merged partition will act as
+ * the default partition of the join result.
+ *
+ * If inner side of the join has default but not the outer side, rows in it
+ * won't appear in the join result. So don't create a default partition. If
+ * outer side of the join has default but not the inner side, rows in it will
+ * appear in the join result, so create a default merged partition.
+ */
+static bool
+merge_default_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps, PartitionMap *inner_maps,
+ JoinType jointype, int *next_index, int *default_index)
+{
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool merged = true;
+ PartitionMap *outer_default_map = NULL;
+ PartitionMap *inner_default_map = NULL;
+
+ if (outer_has_default)
+ outer_default_map = &outer_maps[outer_default];
+
+ if (inner_has_default)
+ inner_default_map = &inner_maps[inner_default];
+
+ if (!outer_has_default && !inner_has_default)
+ Assert(*default_index < 0);
+ else if (outer_default_map != NULL && inner_default_map == NULL)
+ {
+ if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (outer_default_map->to < 0)
+ {
+ outer_default_map->to = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = outer_default_map->to;
+ }
+ else
+ Assert(*default_index == outer_default_map->to);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else if (outer_default_map == NULL && inner_default_map != NULL)
+ {
+ if (jointype == JOIN_FULL)
+ {
+ if (inner_default_map->to < 0)
+ {
+ inner_default_map->to = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = inner_default_map->to;
+ }
+ else
+ Assert(*default_index == inner_default_map->to);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else
+ {
+ Assert(outer_has_default && inner_has_default);
+
+ *default_index = map_and_merge_partitions(outer_maps, inner_maps,
+ outer_default, inner_default,
+ next_index);
+
+ if (*default_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
+
+/*
+ * merge_null_partitions
+ *
+ * Merge NULL partitions, i.e. a partition that can hold NULL values for a list
+ * partitioned table, if any. Find the index of merged partition to which the
+ * NULL values would belong in the join result. If one joining relation has a
+ * NULL partition but not the other, try matching it with the default partition
+ * from the other relation since the default partition may have rows with NULL
+ * partition key. We can eliminate a NULL partition when it appears only on the
+ * inner side of the join and the outer side doesn't have a default partition.
+ *
+ * When the equality operator used for join is strict, two NULL values will not
+ * be considered as equal, and thus a NULL partition can be eliminated for an
+ * inner join. But we don't check the strictness operator here.
+ */
+static bool
+merge_null_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps, PartitionMap *inner_maps,
+ JoinType jointype, int *next_index,
+ int *null_index, int *default_index)
+{
+ bool outer_has_null = partition_bound_accepts_nulls(outer_bi);
+ bool inner_has_null = partition_bound_accepts_nulls(inner_bi);
+ int outer_ni = outer_bi->null_index;
+ int inner_ni = inner_bi->null_index;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool merged = true;
+
+ if (!outer_has_null && !inner_has_null)
+ Assert(*null_index < 0);
+ else if (outer_has_null && !inner_has_null)
+ {
+ int merged_index = -1;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+
+ merged = handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ outer_ni,
+ missing_side_outer,
+ missing_side_inner, next_index,
+ default_index, &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join to which the outer null partition maps
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = outer_maps[outer_ni].to;
+ }
+ else if (!outer_has_null && inner_has_null)
+ {
+ int merged_index = -1;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as OUTER
+ * relation. For INNER and SEMI join OUTER and INNER differentiation is
+ * immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+ merged = handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ inner_ni,
+ missing_side_outer,
+ missing_side_inner,
+ next_index, default_index,
+ &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join, to which the outer side null partition maps,
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = inner_maps[inner_ni].to;
+ }
+ else
+ {
+ /* Both the relations have NULL partitions, try merging them. */
+ *null_index = map_and_merge_partitions(outer_maps,
+ inner_maps,
+ outer_ni,
+ inner_ni,
+ next_index);
+ if (*null_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
diff --git a/src/include/partitioning/partbounds.h b/src/include/partitioning/partbounds.h
index b1ae39ad63..fb2dc1cbb1 100644
--- a/src/include/partitioning/partbounds.h
+++ b/src/include/partitioning/partbounds.h
@@ -16,6 +16,7 @@
#include "nodes/pg_list.h"
#include "partitioning/partdefs.h"
#include "utils/relcache.h"
+struct RelOptInfo; /* avoid including pathnodes.h here */
/*
@@ -107,5 +108,11 @@ extern int partition_range_datum_bsearch(FmgrInfo *partsupfunc,
int nvalues, Datum *values, bool *is_equal);
extern int partition_hash_bsearch(PartitionBoundInfo boundinfo,
int modulus, int remainder);
+extern PartitionBoundInfo partition_bounds_merge(int partnatts,
+ FmgrInfo *partsupfunc, Oid *partcollation,
+ struct RelOptInfo *outer_rel,
+ struct RelOptInfo *inner_rel,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts);
#endif /* PARTBOUNDS_H */
--
2.18.0
[application/octet-stream] 0001-Hash-partition-bound-equality-refactoring-v20.patch (5.1K, ../../CAAJ_b94RqnFw3zJN2njaCTfGWYDtpdhPBu6_-vMn1xDLctL5+w@mail.gmail.com/4-0001-Hash-partition-bound-equality-refactoring-v20.patch)
download | inline diff:
From 8740ccc8ebd92d2d2ae9dfee7e171df15a95faa6 Mon Sep 17 00:00:00 2001
From: Etsuro Fujita <efujita@postgresql.org>
Date: Thu, 31 Jan 2019 19:18:18 +0900
Subject: [PATCH 1/3] Hash partition bound equality refactoring.
Separate the code to check whether two given hash bounds are equal into a
separate function, so that it can be called from multiple places. Right now
it's only caller is partition_bounds_equal() but later we will use it for
merging partition bounds.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/partitioning/partbounds.c | 95 +++++++++++++++++----------
1 file changed, 61 insertions(+), 34 deletions(-)
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index e71eb3793b..637e05e5ca 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -106,6 +106,9 @@ static void get_range_key_properties(PartitionKey key, int keynum,
Expr **keyCol,
Const **lower_val, Const **upper_val);
static List *get_range_nulltest(PartitionKey key);
+static bool partition_hbounds_equal(PartitionBoundInfo b1,
+ PartitionBoundInfo b2);
+
/*
* get_qual_from_partbound
@@ -654,6 +657,63 @@ create_range_bounds(PartitionBoundSpec **boundspecs, int nparts,
return boundinfo;
}
+/*
+ * Are two hash partition bound collections logically equal?
+ *
+ * Hash partition bounds store modulus and remainder in datums array which are
+ * always integers irrespective of the number of partition keys and their data
+ * types. Hence we can compare the hash bound collection without any partition
+ * key specific information. Separating this logic in a function which does not
+ * require partition key specific information allows it be called from places
+ * where the partition key specific information is not completely available.
+ */
+static bool
+partition_hbounds_equal(PartitionBoundInfo b1, PartitionBoundInfo b2)
+{
+ int greatest_modulus = get_hash_partition_greatest_modulus(b1);
+ int i;
+
+ Assert(b1->strategy == PARTITION_STRATEGY_HASH &&
+ b2->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * If two hash partitioned tables have different greatest moduli,
+ * their partition schemes don't match. For hash partitioned table,
+ * the greatest modulus is given by the last datum and number of
+ * partitions is given by ndatums.
+ */
+ if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ return false;
+
+ /*
+ * We arrange the partitions in the ascending order of their modulus and
+ * remainders. Also every modulus is factor of next larger modulus.
+ * Therefore we can safely store index of a given partition in indexes
+ * array at remainder of that partition. Also entries at (remainder + N *
+ * modulus) positions in indexes array are all same for (modulus,
+ * remainder) specification for any partition. Thus datums array from both
+ * the given bounds are same, if and only if their indexes array will be
+ * same. So, it suffices to compare indexes array.
+ */
+ for (i = 0; i < greatest_modulus; i++)
+ if (b1->indexes[i] != b2->indexes[i])
+ return false;
+
+#ifdef USE_ASSERT_CHECKING
+
+ /*
+ * Nonetheless make sure that the bounds are indeed same when the indexes
+ * match. Hash partition bound stores modulus and remainder at
+ * b1->datums[i][0] and b1->datums[i][1] position respectively.
+ */
+ for (i = 0; i < b1->ndatums; i++)
+ Assert((b1->datums[i][0] == b2->datums[i][0] &&
+ b1->datums[i][1] == b2->datums[i][1]));
+#endif
+
+ return true;
+}
+
/*
* Are two partition bound collections logically equal?
*
@@ -682,41 +742,8 @@ partition_bounds_equal(int partnatts, int16 *parttyplen, bool *parttypbyval,
if (b1->strategy == PARTITION_STRATEGY_HASH)
{
- int greatest_modulus = get_hash_partition_greatest_modulus(b1);
-
- /*
- * If two hash partitioned tables have different greatest moduli,
- * their partition schemes don't match.
- */
- if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ if (!partition_hbounds_equal(b1, b2))
return false;
-
- /*
- * We arrange the partitions in the ascending order of their moduli
- * and remainders. Also every modulus is factor of next larger
- * modulus. Therefore we can safely store index of a given partition
- * in indexes array at remainder of that partition. Also entries at
- * (remainder + N * modulus) positions in indexes array are all same
- * for (modulus, remainder) specification for any partition. Thus
- * datums array from both the given bounds are same, if and only if
- * their indexes array will be same. So, it suffices to compare
- * indexes array.
- */
- for (i = 0; i < greatest_modulus; i++)
- if (b1->indexes[i] != b2->indexes[i])
- return false;
-
-#ifdef USE_ASSERT_CHECKING
-
- /*
- * Nonetheless make sure that the bounds are indeed same when the
- * indexes match. Hash partition bound stores modulus and remainder
- * at b1->datums[i][0] and b1->datums[i][1] position respectively.
- */
- for (i = 0; i < b1->ndatums; i++)
- Assert((b1->datums[i][0] == b2->datums[i][0] &&
- b1->datums[i][1] == b2->datums[i][1]));
-#endif
}
else
{
--
2.18.0
[application/octet-stream] 0003-Tests-for-0-1-1-1-and-1-0-partition-matching-v20.patch (213.3K, ../../CAAJ_b94RqnFw3zJN2njaCTfGWYDtpdhPBu6_-vMn1xDLctL5+w@mail.gmail.com/5-0003-Tests-for-0-1-1-1-and-1-0-partition-matching-v20.patch)
download | inline diff:
From 6fe0f54b27749fdf6dfa1f0a548977d6899653bb Mon Sep 17 00:00:00 2001
From: Amul Sul <amul.sul@enterprisedb.com>
Date: Tue, 5 Mar 2019 00:40:55 -0500
Subject: [PATCH 3/3] Tests for 0:1, 1:1 and 1:0 partition matching
Rajkumar Raghuvanshi and Ashutosh Bapat.
---
src/test/regress/expected/partition_join.out | 3955 +++++++++++++++---
src/test/regress/sql/partition_join.sql | 427 +-
2 files changed, 3767 insertions(+), 615 deletions(-)
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index bbdc373782..7954ba2c91 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -8,59 +8,86 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(21 rows)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
-(4 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+(7 rows)
-- left outer join, with whole-row reference; partitionwise join does not apply
EXPLAIN (COSTS OFF)
@@ -72,35 +99,50 @@ SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(22 rows)
SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- t1 | t2
---------------+--------------
- (0,0,0000) | (0,0,0000)
- (50,0,0050) |
- (100,0,0100) |
- (150,0,0150) | (0,150,0150)
- (200,0,0200) |
- (250,0,0250) |
- (300,0,0300) | (0,300,0300)
- (350,0,0350) |
- (400,0,0400) |
- (450,0,0450) | (0,450,0450)
- (500,0,0500) |
- (550,0,0550) |
-(12 rows)
+ t1 | t2
+----------------+----------------
+ (-250,0,-0250) |
+ (-200,0,-0200) |
+ (-150,0,-0150) | (0,-150,-0150)
+ (-100,0,-0100) |
+ (-50,0,-0050) |
+ (0,0,0000) | (0,0,0000)
+ (50,0,0050) |
+ (100,0,0100) |
+ (150,0,0150) | (0,150,0150)
+ (200,0,0200) |
+ (250,0,0250) |
+ (300,0,0300) | (0,300,0300)
+ (350,0,0350) |
+ (400,0,0400) |
+ (450,0,0450) | (0,450,0450)
+ (500,0,0500) |
+ (550,0,0550) |
+ (600,0,0600) | (0,600,0600)
+ (650,0,0650) |
+ (700,0,0700) |
+ (750,0,0750) | (0,750,0750)
+(21 rows)
-- right outer join
EXPLAIN (COSTS OFF)
@@ -112,35 +154,53 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHE
-> Append
-> Hash Right Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Right Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Hash Right Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-> Nested Loop Left Join
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p3 t2_3
Filter: (a = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t2_2.b)
-(20 rows)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
- | | 75 | 0075
- | | 225 | 0225
- | | 375 | 0375
- | | 525 | 0525
-(8 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+ | | -225 | -0225
+ | | -75 | -0075
+ | | 75 | 0075
+ | | 225 | 0225
+ | | 375 | 0375
+ | | 525 | 0525
+ | | 675 | 0675
+(14 rows)
-- full outer join, with placeholder vars
EXPLAIN (COSTS OFF)
@@ -148,8 +208,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
QUERY PLAN
------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b
+ Sort Key: prt1_p0.a, prt2_p0.b
-> Append
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ Filter: (((50) = prt1_p0.a) OR ((75) = prt2_p0.b))
+ -> Seq Scan on prt1_p0
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p1.a = prt2_p1.b)
Filter: (((50) = prt1_p1.a) OR ((75) = prt2_p1.b))
@@ -174,7 +242,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
-> Hash
-> Seq Scan on prt2_p3
Filter: (a = 0)
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ Filter: (((50) = prt1_p4.a) OR ((75) = prt2_p4.b))
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) WHERE t1.phv = t1.a OR t2.phv = t2.b ORDER BY t1.a, t2.b;
a | c | b | c
@@ -211,8 +287,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Hash Left Join
+ Hash Cond: (prt1_p0.a = b)
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Hash
+ -> Result
+ One-Time Filter: false
-> Hash Left Join
Hash Cond: (prt1_p1.a = b)
-> Seq Scan on prt1_p1
@@ -227,29 +310,42 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
-> Hash
-> Seq Scan on prt1_p2
Filter: ((a < 450) AND (b = 0))
-(17 rows)
+(24 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
-(9 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+(14 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
QUERY PLAN
------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = b)
+ Filter: ((prt1_p0.b = 0) OR (a = 0))
+ -> Seq Scan on prt1_p0
+ Filter: (a < 450)
+ -> Hash
+ -> Result
+ One-Time Filter: false
-> Hash Full Join
Hash Cond: (prt1_p1.a = b)
Filter: ((prt1_p1.b = 0) OR (a = 0))
@@ -274,64 +370,153 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JO
-> Hash
-> Result
One-Time Filter: false
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt2_p4.b = a)
+ Filter: ((b = 0) OR (prt2_p4.a = 0))
+ -> Seq Scan on prt2_p4
+ Filter: (b > 250)
+ -> Hash
+ -> Result
+ One-Time Filter: false
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
- | | 375 | 0375
- | | 450 | 0450
- | | 525 | 0525
-(12 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ | | 375 | 0375
+ | | 450 | 0450
+ | | 525 | 0525
+ | | 600 | 0600
+ | | 675 | 0675
+ | | 750 | 0750
+(20 rows)
-- Semi-join
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Semi Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Semi Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Nested Loop Semi Join
- Join Filter: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Materialize
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-(24 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(39 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p0 t2
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_2.b = t2_2.a)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p2 t2_2
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: (t1_3.b = t2_3.a)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt1_p3 t2_3
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.b = t2_4.a)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p4 t2_4
+ Filter: (b = 0)
+(37 rows)
+
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
@@ -342,27 +527,82 @@ SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS
-> Append
-> Hash Anti Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash Anti Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash Anti Join
Hash Cond: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p3 t2_2
-(17 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash Anti Join
+ Hash Cond: (t1_3.a = t2_3.b)
+ -> Seq Scan on prt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_3
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(27 rows)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
- sum | avg | sum | avg
--------+----------------------+------+---------------------
- 60000 | 300.0000000000000000 | 2400 | 12.0000000000000000
+ sum | avg | sum | avg
+-------+----------------------+------+--------------------
+ 95550 | 273.0000000000000000 | 2200 | 6.2857142857142857
(1 row)
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ QUERY PLAN
+--------------------------------------------------------------
+ Append
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Hash Anti Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(27 rows)
+
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ b | c
+------+-------
+ -225 | -0225
+ -75 | -0075
+ 75 | 0075
+ 225 | 0225
+ 375 | 0375
+ 525 | 0525
+ 675 | 0675
+(7 rows)
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -374,49 +614,74 @@ SELECT * FROM prt1 t1 LEFT JOIN LATERAL
Sort Key: t1.a
-> Append
-> Nested Loop Left Join
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p1_a on prt1_p1 t2
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
Index Cond: (a = t1.a)
- -> Index Scan using iprt2_p1_b on prt2_p1 t3
+ -> Index Scan using iprt2_p0_b on prt2_p0 t3
Index Cond: (b = t2.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_1
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
Index Cond: (a = t1_1.a)
- -> Index Scan using iprt2_p2_b on prt2_p2 t3_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t3_1
Index Cond: (b = t2_1.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_2
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
Index Cond: (a = t1_2.a)
- -> Index Scan using iprt2_p3_b on prt2_p3 t3_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t3_2
Index Cond: (b = t2_2.a)
-(27 rows)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.a)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t3_3
+ Index Cond: (b = t2_3.a)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.a)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t3_4
+ Index Cond: (b = t2_4.a)
+(43 rows)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, least(t1.a,t2.a,t3.b) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.a = ss.t2a WHERE t1.b = 0 ORDER BY t1.a;
- a | b | c | t2a | t3a | least
------+---+------+-----+-----+-------
- 0 | 0 | 0000 | 0 | 0 | 0
- 50 | 0 | 0050 | | |
- 100 | 0 | 0100 | | |
- 150 | 0 | 0150 | 150 | 0 | 150
- 200 | 0 | 0200 | | |
- 250 | 0 | 0250 | | |
- 300 | 0 | 0300 | 300 | 0 | 300
- 350 | 0 | 0350 | | |
- 400 | 0 | 0400 | | |
- 450 | 0 | 0450 | 450 | 0 | 450
- 500 | 0 | 0500 | | |
- 550 | 0 | 0550 | | |
-(12 rows)
+ a | b | c | t2a | t3a | least
+------+---+-------+------+-----+-------
+ -250 | 0 | -0250 | | |
+ -200 | 0 | -0200 | | |
+ -150 | 0 | -0150 | -150 | 0 | -150
+ -100 | 0 | -0100 | | |
+ -50 | 0 | -0050 | | |
+ 0 | 0 | 0000 | 0 | 0 | 0
+ 50 | 0 | 0050 | | |
+ 100 | 0 | 0100 | | |
+ 150 | 0 | 0150 | 150 | 0 | 150
+ 200 | 0 | 0200 | | |
+ 250 | 0 | 0250 | | |
+ 300 | 0 | 0300 | 300 | 0 | 300
+ 350 | 0 | 0350 | | |
+ 400 | 0 | 0400 | | |
+ 450 | 0 | 0450 | 450 | 0 | 450
+ 500 | 0 | 0500 | | |
+ 550 | 0 | 0550 | | |
+ 600 | 0 | 0600 | 600 | 0 | 600
+ 650 | 0 | 0650 | | |
+ 700 | 0 | 0700 | | |
+ 750 | 0 | 0750 | 750 | 0 | 750
+(21 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
@@ -430,64 +695,95 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
Hash Cond: ((t1.c)::text = (t2.c)::text)
Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Hash Join
Hash Cond: (t2.a = t3.b)
- -> Seq Scan on prt1_p1 t2
+ -> Seq Scan on prt1_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t3
+ -> Seq Scan on prt2_p0 t3
-> Hash Join
Hash Cond: (t2_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t2_1
+ -> Seq Scan on prt1_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p1 t3_1
-> Hash Join
Hash Cond: (t2_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p2 t2_2
-> Hash
- -> Seq Scan on prt2_p3 t3_2
-(26 rows)
+ -> Seq Scan on prt2_p2 t3_2
+ -> Hash Join
+ Hash Cond: (t2_3.a = t3_3.b)
+ -> Seq Scan on prt1_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t3_3
+ -> Hash Join
+ Hash Cond: (t2_4.a = t3_4.b)
+ -> Seq Scan on prt1_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t3_4
+(38 rows)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, t2.b t2b, t2.c t2c, least(t1.a,t2.a,t3.a) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.c = ss.t2c WHERE (t1.b + coalesce(ss.t2b, 0)) = 0 ORDER BY t1.a;
- a | t2a | t2c
------+-----+------
- 0 | 0 | 0000
- 50 | |
- 100 | |
- 150 | 150 | 0150
- 200 | |
- 250 | |
- 300 | 300 | 0300
- 350 | |
- 400 | |
- 450 | 450 | 0450
- 500 | |
- 550 | |
-(12 rows)
+ a | t2a | t2c
+------+------+-------
+ -250 | |
+ -200 | |
+ -150 | -150 | -0150
+ -100 | |
+ -50 | |
+ 0 | 0 | 0000
+ 50 | |
+ 100 | |
+ 150 | 150 | 0150
+ 200 | |
+ 250 | |
+ 300 | 300 | 0300
+ 350 | |
+ 400 | |
+ 450 | 450 | 0450
+ 500 | |
+ 550 | |
+ 600 | 600 | 0600
+ 650 | |
+ 700 | |
+ 750 | 750 | 0750
+(21 rows)
--
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
@@ -498,32 +794,49 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 =
-> Append
-> Hash Join
Hash Cond: (((t2.b + t2.a) / 2) = ((t1.a + t1.b) / 2))
- -> Seq Scan on prt2_e_p1 t2
+ -> Seq Scan on prt2_e_p0 t2
-> Hash
- -> Seq Scan on prt1_e_p1 t1
+ -> Seq Scan on prt1_e_p0 t1
Filter: (c = 0)
-> Hash Join
- Hash Cond: (((t2_1.b + t2_1.a) / 2) = ((t1_1.a + t1_1.b) / 2))
- -> Seq Scan on prt2_e_p2 t2_1
+ Hash Cond: (((t1_1.a + t1_1.b) / 2) = ((t2_1.b + t2_1.a) / 2))
+ -> Seq Scan on prt1_e_p1 t1_1
+ Filter: (c = 0)
-> Hash
- -> Seq Scan on prt1_e_p2 t1_1
- Filter: (c = 0)
+ -> Seq Scan on prt2_e_p1 t2_1
-> Hash Join
Hash Cond: (((t2_2.b + t2_2.a) / 2) = ((t1_2.a + t1_2.b) / 2))
- -> Seq Scan on prt2_e_p3 t2_2
+ -> Seq Scan on prt2_e_p2 t2_2
-> Hash
- -> Seq Scan on prt1_e_p3 t1_2
+ -> Seq Scan on prt1_e_p2 t1_2
Filter: (c = 0)
-(21 rows)
+ -> Hash Join
+ Hash Cond: (((t2_3.b + t2_3.a) / 2) = ((t1_3.a + t1_3.b) / 2))
+ -> Seq Scan on prt2_e_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t1_3
+ Filter: (c = 0)
+ -> Hash Join
+ Hash Cond: (((t2_4.b + t2_4.a) / 2) = ((t1_4.a + t1_4.b) / 2))
+ -> Seq Scan on prt2_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_4
+ Filter: (c = 0)
+(33 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 150 | 0 | 150 | 0
- 300 | 0 | 300 | 0
- 450 | 0 | 450 | 0
-(4 rows)
+ a | c | b | c
+------+---+------+---
+ -250 | 0 | -250 | 0
+ -100 | 0 | -100 | 0
+ 0 | 0 | 0 | 0
+ 0 | 0 | 0 | 0
+ 150 | 0 | 150 | 0
+ 300 | 0 | 300 | 0
+ 450 | 0 | 450 | 0
+ 600 | 0 | 600 | 0
+ 750 | 0 | 750 | 0
+(9 rows)
--
-- N-way join
@@ -536,154 +849,232 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = ((t3.a + t3.b) / 2))
+ Join Filter: (t1.a = t2.b)
-> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p1_ab2 on prt1_e_p1 t3
- Index Cond: (((a + b) / 2) = t2.b)
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
+ Index Cond: (b = ((t3.a + t3.b) / 2))
-> Nested Loop
Join Filter: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_1
+ -> Index Scan using iprt1_e_p4_ab2 on prt1_e_p1 t3_1
Index Cond: (((a + b) / 2) = t2_1.b)
-> Nested Loop
Join Filter: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_2
Index Cond: (((a + b) / 2) = t2_2.b)
-(33 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = ((t3_3.a + t3_3.b) / 2))
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (((a + b) / 2) = t2_3.b)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t2_4.b)
+ -> Hash Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (b = ((t3_4.a + t3_4.b) / 2))
+(52 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t3 WHERE t1.a = t2.b AND t1.a = (t3.a + t3.b)/2 AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
-(4 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(8 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
---------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Hash Right Join
Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_1.a + t3_1.b) / 2) = t1_1.a)
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
-> Hash
-> Hash Right Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_2.a + t3_2.b) / 2) = t1_2.a)
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
-> Hash
-> Hash Right Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(33 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (((a + b) / 2) = t1_3.a)
+ -> Hash Right Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(51 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
--------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1.a = ((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
Index Cond: (b = t1.a)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t2_1
Index Cond: (b = t1_1.a)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t2_2
Index Cond: (b = t1_2.a)
-(30 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t3_3.a + t3_3.b) / 2))
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Nested Loop Left Join
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = ((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (b = t1_4.a)
+(47 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- Cases with non-nullable expressions in subquery results;
-- make sure these go to null as expected
@@ -692,21 +1083,34 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
QUERY PLAN
----------------------------------------------------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b, ((prt1_e_p1.a + prt1_e_p1.b))
+ Sort Key: prt1_p0.a, prt2_p0.b, ((prt1_e_p0.a + prt1_e_p0.b))
-> Append
-> Hash Full Join
- Hash Cond: (prt1_p1.a = ((prt1_e_p1.a + prt1_e_p1.b) / 2))
- Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ Hash Cond: (prt1_p0.a = ((prt1_e_p0.a + prt1_e_p0.b) / 2))
+ Filter: ((prt1_p0.a = (50)) OR (prt2_p0.b = (75)) OR (((prt1_e_p0.a + prt1_e_p0.b) / 2) = (50)))
-> Hash Full Join
- Hash Cond: (prt1_p1.a = prt2_p1.b)
- -> Seq Scan on prt1_p1
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ -> Seq Scan on prt1_p0
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1
+ -> Seq Scan on prt2_p0
Filter: (a = 0)
-> Hash
- -> Seq Scan on prt1_e_p1
+ -> Seq Scan on prt1_e_p0
Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: (((prt1_e_p1.a + prt1_e_p1.b) / 2) = prt1_p1.a)
+ Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ -> Seq Scan on prt1_e_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Hash Full Join
+ Hash Cond: (prt1_p1.a = prt2_p1.b)
+ -> Seq Scan on prt1_p1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p2.a = ((prt1_e_p2.a + prt1_e_p2.b) / 2))
Filter: ((prt1_p2.a = (50)) OR (prt2_p2.b = (75)) OR (((prt1_e_p2.a + prt1_e_p2.b) / 2) = (50)))
@@ -733,7 +1137,20 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
-> Hash
-> Seq Scan on prt1_e_p3
Filter: (c = 0)
-(42 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = ((prt1_e_p4.a + prt1_e_p4.b) / 2))
+ Filter: ((prt1_p4.a = (50)) OR (prt2_p4.b = (75)) OR (((prt1_e_p4.a + prt1_e_p4.b) / 2) = (50)))
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_e_p4
+ Filter: (c = 0)
+(68 rows)
SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b)) FULL JOIN (SELECT 50 phv, * FROM prt1_e WHERE prt1_e.c = 0) t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.a = t1.phv OR t2.b = t2.phv OR (t3.a + t3.b)/2 = t3.phv ORDER BY t1.a, t2.b, t3.a + t3.b;
a | phv | b | phv | ?column? | phv
@@ -751,172 +1168,260 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHER
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = t1_3.b)
+ Join Filter: (t1.a = t1_5.b)
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Join
- Hash Cond: (((t2.a + t2.b) / 2) = t1_3.b)
- -> Seq Scan on prt1_e_p1 t2
+ Hash Cond: (((t2.a + t2.b) / 2) = t1_5.b)
+ -> Seq Scan on prt1_e_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t1_3
+ -> Seq Scan on prt2_p0 t1_5
Filter: (a = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
Index Cond: (a = ((t2.a + t2.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_1.a = t1_4.b)
+ Join Filter: (t1_1.a = t1_6.b)
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Join
- Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_4.b)
- -> Seq Scan on prt1_e_p2 t2_1
+ Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_6.b)
+ -> Seq Scan on prt1_e_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t1_4
+ -> Seq Scan on prt2_p1 t1_6
Filter: (a = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
Index Cond: (a = ((t2_1.a + t2_1.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_2.a = t1_5.b)
+ Join Filter: (t1_2.a = t1_7.b)
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Nested Loop
- -> Seq Scan on prt2_p3 t1_5
+ -> Seq Scan on prt2_p2 t1_7
Filter: (a = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_2
- Index Cond: (((a + b) / 2) = t1_5.b)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t2_2
+ Index Cond: (((a + b) / 2) = t1_7.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
Index Cond: (a = ((t2_2.a + t2_2.b) / 2))
Filter: (b = 0)
-(41 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = t1_8.b)
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t1_8
+ Filter: (a = 0)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_3
+ Index Cond: (((a + b) / 2) = t1_8.b)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t2_3.a + t2_3.b) / 2))
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t1_9.b)
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Join
+ Hash Cond: (((t2_4.a + t2_4.b) / 2) = t1_9.b)
+ -> Seq Scan on prt1_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t1_9
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = ((t2_4.a + t2_4.b) / 2))
+ Filter: (b = 0)
+(66 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHERE t1.a = 0 AND t1.b = (t2.a + t2.b)/2) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
--------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Nested Loop
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Semi Join
- Hash Cond: (t1_3.b = ((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt2_p1 t1_3
+ Hash Cond: (t1_5.b = ((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt2_p0 t1_5
-> Hash
- -> Seq Scan on prt1_e_p1 t1_6
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
- Index Cond: (a = t1_3.b)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t1_5.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Semi Join
- Hash Cond: (t1_4.b = ((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt2_p2 t1_4
+ Hash Cond: (t1_6.b = ((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt2_p1 t1_6
-> Hash
- -> Seq Scan on prt1_e_p2 t1_7
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
- Index Cond: (a = t1_4.b)
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
+ Index Cond: (a = t1_6.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Hash Semi Join
- Hash Cond: (t1_5.b = ((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt2_p3 t1_5
+ Hash Cond: (t1_7.b = ((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt2_p2 t1_7
-> Hash
- -> Seq Scan on prt1_e_p3 t1_8
+ -> Seq Scan on prt1_e_p2 t1_12
Filter: (c = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t1_5.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t1_7.b)
Filter: (b = 0)
-(39 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Hash Semi Join
+ Hash Cond: (t1_8.b = ((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt2_p3 t1_8
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t1_13
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t1_8.b)
+ Filter: (b = 0)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Semi Join
+ Hash Cond: (t1_9.b = ((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt2_p4 t1_9
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = t1_9.b)
+ Filter: (b = 0)
+(63 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
-- test merge joins
SET enable_hashjoin TO off;
SET enable_nestloop TO off;
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
-----------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------
Merge Append
Sort Key: t1.a
-> Merge Semi Join
- Merge Cond: (t1.a = t1_3.b)
+ Merge Cond: (t1.a = t1_5.b)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_3.b = (((t1_6.a + t1_6.b) / 2)))
+ Merge Cond: (t1_5.b = (((t1_10.a + t1_10.b) / 2)))
-> Sort
- Sort Key: t1_3.b
- -> Seq Scan on prt2_p1 t1_3
+ Sort Key: t1_5.b
+ -> Seq Scan on prt2_p0 t1_5
-> Sort
- Sort Key: (((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt1_e_p1 t1_6
+ Sort Key: (((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_1.a = t1_4.b)
+ Merge Cond: (t1_1.a = t1_6.b)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_4.b = (((t1_7.a + t1_7.b) / 2)))
+ Merge Cond: (t1_6.b = (((t1_11.a + t1_11.b) / 2)))
-> Sort
- Sort Key: t1_4.b
- -> Seq Scan on prt2_p2 t1_4
+ Sort Key: t1_6.b
+ -> Seq Scan on prt2_p1 t1_6
-> Sort
- Sort Key: (((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt1_e_p2 t1_7
+ Sort Key: (((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_2.a = t1_5.b)
+ Merge Cond: (t1_2.a = t1_7.b)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_5.b = (((t1_8.a + t1_8.b) / 2)))
+ Merge Cond: (t1_7.b = (((t1_12.a + t1_12.b) / 2)))
-> Sort
- Sort Key: t1_5.b
- -> Seq Scan on prt2_p3 t1_5
+ Sort Key: t1_7.b
+ -> Seq Scan on prt2_p2 t1_7
-> Sort
- Sort Key: (((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt1_e_p3 t1_8
+ Sort Key: (((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt1_e_p2 t1_12
Filter: (c = 0)
-(47 rows)
+ -> Merge Semi Join
+ Merge Cond: (t1_3.a = t1_8.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_8.b = (((t1_13.a + t1_13.b) / 2)))
+ -> Sort
+ Sort Key: t1_8.b
+ -> Seq Scan on prt2_p3 t1_8
+ -> Sort
+ Sort Key: (((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt1_e_p3 t1_13
+ Filter: (c = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_4.a = t1_9.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_9.b = (((t1_14.a + t1_14.b) / 2)))
+ -> Sort
+ Sort Key: t1_9.b
+ -> Seq Scan on prt2_p4 t1_9
+ -> Sort
+ Sort Key: (((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+(77 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
@@ -933,14 +1438,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3.a + t3.b) / 2)) = t1.a)
-> Sort
Sort Key: (((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Sort
Sort Key: t2.b
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Merge Left Join
Merge Cond: (t1_1.a = t2_1.b)
-> Sort
@@ -949,14 +1454,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_1.a + t3_1.b) / 2)) = t1_1.a)
-> Sort
Sort Key: (((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Sort
Sort Key: t2_1.b
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Merge Left Join
Merge Cond: (t1_2.a = t2_2.b)
-> Sort
@@ -965,32 +1470,74 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_2.a + t3_2.b) / 2)) = t1_2.a)
-> Sort
Sort Key: (((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Sort
Sort Key: t2_2.b
- -> Seq Scan on prt2_p3 t2_2
-(51 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Merge Left Join
+ Merge Cond: (t1_3.a = t2_3.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_3.a + t3_3.b) / 2)) = t1_3.a)
+ -> Sort
+ Sort Key: (((t3_3.a + t3_3.b) / 2))
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ -> Sort
+ Sort Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ -> Merge Left Join
+ Merge Cond: (t1_4.a = t2_4.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_4.a + t3_4.b) / 2)) = t1_4.a)
+ -> Sort
+ Sort Key: (((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ -> Sort
+ Sort Key: t2_4.b
+ -> Seq Scan on prt2_p4 t2_4
+(83 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- MergeAppend on nullable column
EXPLAIN (COSTS OFF)
@@ -998,8 +1545,18 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, b
+ Sort Key: prt1_p0.a, b
-> Append
+ -> Merge Left Join
+ Merge Cond: (prt1_p0.a = b)
+ -> Sort
+ Sort Key: prt1_p0.a
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
+ -> Sort
+ Sort Key: b
+ -> Result
+ One-Time Filter: false
-> Merge Left Join
Merge Cond: (prt1_p1.a = b)
-> Sort
@@ -1020,21 +1577,26 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
Sort Key: prt2_p2.b
-> Seq Scan on prt2_p2
Filter: (b > 250)
-(23 rows)
+(33 rows)
SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | b
------+-----
- 0 |
- 50 |
- 100 |
- 150 |
- 200 |
- 250 |
- 300 | 300
- 350 |
- 400 |
-(9 rows)
+ a | b
+------+-----
+ -250 |
+ -200 |
+ -150 |
+ -100 |
+ -50 |
+ 0 |
+ 50 |
+ 100 |
+ 150 |
+ 200 |
+ 250 |
+ 300 | 300
+ 350 |
+ 400 |
+(14 rows)
-- merge join when expression with whole-row reference needs to be sorted;
-- partitionwise join does not apply
@@ -1048,30 +1610,797 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
Sort Key: t1.a, ((((t1.*)::prt1))::text)
-> Result
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Sort
Sort Key: t2.b, ((((t2.*)::prt2))::text)
-> Result
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
-(16 rows)
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+(20 rows)
SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.b ORDER BY t1.a;
- a | b
-----+----
- 0 | 0
- 6 | 6
- 12 | 12
- 18 | 18
- 24 | 24
-(5 rows)
+ a | b
+-----+-----
+ -24 | -24
+ -18 | -18
+ -12 | -12
+ -6 | -6
+ 0 | 0
+ 6 | 6
+ 12 | 12
+ 18 | 18
+ 24 | 24
+(9 rows)
RESET enable_hashjoin;
RESET enable_nestloop;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+ -> Seq Scan on prt2_p3 t2_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_4
+ Filter: (b = 0)
+(22 rows)
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p1 t2
+ -> Hash
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p2 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p3 t1_2
+ Filter: (b = 0)
+(21 rows)
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -150 | -0150 | 0 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 0 | 0150
+ 300 | 0300 | 0 | 0300
+ 450 | 0450 | 0 | 0450
+ 600 | 0600 | 0 | 0600
+ 750 | 0750 | 0 | 0750
+(7 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | 0 | -0150
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | 0 | 0000
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | 0 | 0150
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 0 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ 450 | 0450 | 0 | 0450
+ 500 | 0500 | |
+ 550 | 0550 | |
+ 600 | 0600 | 0 | 0600
+ 650 | 0650 | |
+ 700 | 0700 | |
+ 750 | 0750 | 0 | 0750
+(21 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Semi Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Append
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
+ Index Cond: (a = t1_1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(28 rows)
+
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Anti Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Anti Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -250 | 0 | -0250
+ -200 | 0 | -0200
+ -100 | 0 | -0100
+ -50 | 0 | -0050
+ 50 | 0 | 0050
+ 100 | 0 | 0100
+ 200 | 0 | 0200
+ 250 | 0 | 0250
+ 350 | 0 | 0350
+ 400 | 0 | 0400
+ 500 | 0 | 0500
+ 550 | 0 | 0550
+ 650 | 0 | 0650
+ 700 | 0 | 0700
+(14 rows)
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ QUERY PLAN
+---------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t3.c
+ -> Append
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t3
+ Index Cond: (a = t2.b)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t2.b)
+ -> Hash Right Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t3_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t3_2
+ Index Cond: (a = t2_2.b)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t2_2.b)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t3_3
+ Index Cond: (a = t2_3.b)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(47 rows)
+
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ a | a | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.b
+ -> Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(24 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: (t1.a = t2.b)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.a, 0)) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------
+ Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(22 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Join
+ Hash Cond: (t1.a = t2.b)
+ Join Filter: ((t1.b + t2.a) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
--
-- partitioned by multiple columns
--
@@ -1141,82 +2470,1552 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1
--
-- tests for list partitioned tables.
--
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 470 | 0 | 0011
+(1 row)
+
--
-- list partitioned by expression
--
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
ANALYZE plt1_e;
-- test partition matching with N-way join
EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- QUERY PLAN
---------------------------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------------------------------------
GroupAggregate
Group Key: t1.c, t2.c, t3.c
-> Sort
Sort Key: t1.c, t3.c
-> Append
-> Hash Join
- Hash Cond: (t1.c = ltrim(t3.c, 'A'::text))
+ Hash Cond: ((t1.c)::text = ltrim(t3.c, 'A'::text))
-> Hash Join
- Hash Cond: ((t1.b = t2.b) AND (t1.c = t2.c))
- -> Seq Scan on plt1_p1 t1
+ Hash Cond: ((t2.b = t1.b) AND ((t2.c)::text = (t1.c)::text))
+ -> Seq Scan on plt2_p4 t2
-> Hash
- -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt1_p4 t1
-> Hash
- -> Seq Scan on plt1_e_p1 t3
+ -> Seq Scan on plt1_e_p4 t3
-> Hash Join
- Hash Cond: (t1_1.c = ltrim(t3_1.c, 'A'::text))
+ Hash Cond: ((t1_1.c)::text = ltrim(t3_1.c, 'A'::text))
-> Hash Join
- Hash Cond: ((t1_1.b = t2_1.b) AND (t1_1.c = t2_1.c))
- -> Seq Scan on plt1_p2 t1_1
+ Hash Cond: ((t1_1.b = t2_1.b) AND ((t1_1.c)::text = (t2_1.c)::text))
+ -> Seq Scan on plt1_p1 t1_1
-> Hash
- -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p1 t2_1
-> Hash
- -> Seq Scan on plt1_e_p2 t3_1
+ -> Seq Scan on plt1_e_p1 t3_1
-> Hash Join
- Hash Cond: (t1_2.c = ltrim(t3_2.c, 'A'::text))
+ Hash Cond: ((t1_2.c)::text = ltrim(t3_2.c, 'A'::text))
-> Hash Join
- Hash Cond: ((t1_2.b = t2_2.b) AND (t1_2.c = t2_2.c))
- -> Seq Scan on plt1_p3 t1_2
+ Hash Cond: ((t1_2.b = t2_2.b) AND ((t1_2.c)::text = (t2_2.c)::text))
+ -> Seq Scan on plt1_p2 t1_2
-> Hash
- -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p2 t2_2
-> Hash
- -> Seq Scan on plt1_e_p3 t3_2
-(32 rows)
+ -> Seq Scan on plt1_e_p2 t3_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = ltrim(t3_3.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t2_3.b = t1_3.b) AND ((t2_3.c)::text = (t1_3.c)::text))
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt1_e_p3 t3_3
+(41 rows)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- avg | avg | avg | c | c | c
-----------------------+----------------------+-----------------------+------+------+-------
- 24.0000000000000000 | 24.0000000000000000 | 48.0000000000000000 | 0000 | 0000 | A0000
- 75.0000000000000000 | 75.0000000000000000 | 148.0000000000000000 | 0001 | 0001 | A0001
- 123.0000000000000000 | 123.0000000000000000 | 248.0000000000000000 | 0002 | 0002 | A0002
- 174.0000000000000000 | 174.0000000000000000 | 348.0000000000000000 | 0003 | 0003 | A0003
- 225.0000000000000000 | 225.0000000000000000 | 448.0000000000000000 | 0004 | 0004 | A0004
- 273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
- 324.0000000000000000 | 324.0000000000000000 | 648.0000000000000000 | 0006 | 0006 | A0006
- 375.0000000000000000 | 375.0000000000000000 | 748.0000000000000000 | 0007 | 0007 | A0007
- 423.0000000000000000 | 423.0000000000000000 | 848.0000000000000000 | 0008 | 0008 | A0008
- 474.0000000000000000 | 474.0000000000000000 | 948.0000000000000000 | 0009 | 0009 | A0009
- 525.0000000000000000 | 525.0000000000000000 | 1048.0000000000000000 | 0010 | 0010 | A0010
- 573.0000000000000000 | 573.0000000000000000 | 1148.0000000000000000 | 0011 | 0011 | A0011
-(12 rows)
+ avg | avg | avg | c | c | c
+----------------------+---------------------+----------------------+------+------+------
+ 246.5000000000000000 | 22.4666666666666667 | 268.9666666666666667 | 0000 | 0000 | 0000
+ 248.5000000000000000 | 21.3333333333333333 | 269.8333333333333333 | 0002 | 0002 | 0002
+ 249.5000000000000000 | 22.3333333333333333 | 271.8333333333333333 | 0003 | 0003 | 0003
+ 250.5000000000000000 | 23.3333333333333333 | 273.8333333333333333 | 0004 | 0004 | 0004
+ 251.5000000000000000 | 22.7666666666666667 | 274.2666666666666667 | 0005 | 0005 | 0005
+ 252.5000000000000000 | 22.2000000000000000 | 274.7000000000000000 | 0006 | 0006 | 0006
+ 246.0000000000000000 | 23.9655172413793103 | 269.9655172413793103 | 0008 | 0008 | 0008
+ 247.0000000000000000 | 23.3448275862068966 | 270.3448275862068966 | 0009 | 0009 | 0009
+(8 rows)
+
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 470 | 0011
+ | | 235 | 0014
+(8 rows)
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 235 | 0014
+ | | 470 | 0011
+(10 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 47 | 0 | 0013
+ 235 | 0 | 0014
+ 470 | 0 | 0011
+(3 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+----------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Materialize
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(20 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Materialize
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+---
+ 470 | 0 |
+(1 row)
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(22 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(22 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(19 rows)
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
@@ -1241,22 +4040,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
--------------------------------------------------
Hash Left Join
Hash Cond: (t2.b = a)
- -> Append
- -> Hash Join
- Hash Cond: (t3.a = t2.b)
- -> Seq Scan on prt1_p1 t3
- -> Hash
- -> Seq Scan on prt2_p1 t2
- -> Hash Join
- Hash Cond: (t3_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t3_1
- -> Hash
- -> Seq Scan on prt2_p2 t2_1
- -> Hash Join
- Hash Cond: (t3_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t3_2
- -> Hash
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash Join
+ Hash Cond: (t3.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t3
+ -> Seq Scan on prt1_p1 t3_1
+ -> Seq Scan on prt1_p2 t3_2
+ -> Seq Scan on prt1_p3 t3_3
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Result
One-Time Filter: false
@@ -1271,16 +4070,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
-> Hash Left Join
Hash Cond: (t2.b = a)
-> Append
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
Filter: (a = 0)
-> Hash
-> Result
One-Time Filter: false
-(14 rows)
+(20 rows)
--
-- tests for hash partitioned tables.
@@ -1356,41 +4161,9 @@ SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, ph
273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
(6 rows)
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
- Sort
- Sort Key: t1.a
- -> Append
- -> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
- -> Hash
- -> Seq Scan on prt1_p1 t1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
- -> Hash
- -> Seq Scan on prt1_p2 t1_1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
- -> Hash
- -> Seq Scan on prt1_p3 t1_2
- Filter: (b = 0)
-(21 rows)
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
@@ -1405,26 +4178,24 @@ SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c
Sort Key: t1.c
-> HashAggregate
Group Key: t1.c, t2.c
- -> Append
- -> Hash Join
- Hash Cond: (t2.c = t1.c)
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_p1 t1
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_1.c = t1_1.c)
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p1 t1_1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_2.c = t1_2.c)
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p2 t1_2
Filter: ((a % 25) = 0)
-(23 rows)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: ((a % 25) = 0)
+(21 rows)
--
-- multiple levels of partitioning
@@ -1826,64 +4597,70 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2 WHERE t1.a = t2.a;
Hash Join
Hash Cond: (t1.a = t2.a)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Seq Scan on prt4_n_p1 t2
-> Seq Scan on prt4_n_p2 t2_1
-> Seq Scan on prt4_n_p3 t2_2
-(11 rows)
+(13 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2, prt2 t3 WHERE t1.a = t2.a and t1.a = t3.b;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------
Hash Join
- Hash Cond: (t2.a = t1.a)
+ Hash Cond: (t3.b = t1.a)
-> Append
- -> Seq Scan on prt4_n_p1 t2
- -> Seq Scan on prt4_n_p2 t2_1
- -> Seq Scan on prt4_n_p3 t2_2
+ -> Seq Scan on prt2_p0 t3
+ -> Seq Scan on prt2_p1 t3_1
+ -> Seq Scan on prt2_p2 t3_2
+ -> Seq Scan on prt2_p3 t3_3
+ -> Seq Scan on prt2_p4 t3_4
+ -> Seq Scan on prt2_p5 t3_5
-> Hash
- -> Append
- -> Hash Join
- Hash Cond: (t1.a = t3.b)
- -> Seq Scan on prt1_p1 t1
- -> Hash
- -> Seq Scan on prt2_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t1_1
- -> Hash
- -> Seq Scan on prt2_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t1_2
- -> Hash
- -> Seq Scan on prt2_p3 t3_2
+ -> Hash Join
+ Hash Cond: (t1.a = t2.a)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt4_n_p1 t2
+ -> Seq Scan on prt4_n_p2 t2_1
+ -> Seq Scan on prt4_n_p3 t2_2
(23 rows)
-- partitionwise join can not be applied if there are no equi-join conditions
-- between partition keys
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON (t1.a < t2.b);
- QUERY PLAN
----------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------
Nested Loop Left Join
+ Join Filter: (t1.a < t2.b)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
- -> Append
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
- Index Cond: (b > t1.a)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
- Index Cond: (b > t1.a)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
- Index Cond: (b > t1.a)
-(12 rows)
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Materialize
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(16 rows)
-- equi-join with join condition on partial keys does not qualify for
-- partitionwise join
@@ -1969,16 +4746,17 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 JOIN prt2_n t2 ON (t1.c = t2.c) JOI
-> Seq Scan on prt2_n_p2 t2_1
-> Hash
-> Hash Join
- Hash Cond: (t3.c = (t1.c)::text)
+ Hash Cond: ((t3.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on plt1_p1 t3
- -> Seq Scan on plt1_p2 t3_1
- -> Seq Scan on plt1_p3 t3_2
+ -> Seq Scan on plt1_p4 t3
+ -> Seq Scan on plt1_p1 t3_1
+ -> Seq Scan on plt1_p2 t3_2
+ -> Seq Scan on plt1_p3 t3_3
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(16 rows)
+(17 rows)
-- partitionwise join can not be applied for a join between list and range
-- partitioned table
@@ -1989,14 +4767,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 FULL JOIN prt1 t2 ON (t1.c = t2.c);
Hash Full Join
Hash Cond: ((t2.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on prt1_p1 t2
- -> Seq Scan on prt1_p2 t2_1
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(10 rows)
+(12 rows)
-- partitionwise join can not be applied if only one of joining table has
-- default partition
@@ -2012,16 +4792,23 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b =
-> Hash Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
diff --git a/src/test/regress/sql/partition_join.sql b/src/test/regress/sql/partition_join.sql
index c1c9859651..0e884835fb 100644
--- a/src/test/regress/sql/partition_join.sql
+++ b/src/test/regress/sql/partition_join.sql
@@ -10,25 +10,39 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
@@ -67,11 +81,19 @@ EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -93,20 +115,30 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
@@ -169,6 +201,128 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
RESET enable_hashjoin;
RESET enable_nestloop;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
--
-- partitioned by multiple columns
--
@@ -193,28 +347,79 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1
--
-- tests for list partitioned tables.
--
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
--
-- list partitioned by expression
--
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
ANALYZE plt1_e;
-- test partition matching with N-way join
@@ -222,6 +427,175 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.a = 1 AND t1.a = 2;
@@ -267,27 +641,18 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
ALTER TABLE plt2 DETACH PARTITION plt2_p3;
ALTER TABLE plt2 ATTACH PARTITION plt2_p3 DEFAULT;
ANALYZE plt2;
-
EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.a % 25 = 0 GROUP BY t1.c, t2.c ORDER BY t1.c, t2.c;
+
--
-- multiple levels of partitioning
--
--
2.18.0
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
@ 2019-03-08 08:42 ` Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
1 sibling, 0 replies; 154+ messages in thread
From: Rajkumar Raghuwanshi @ 2019-03-08 08:42 UTC (permalink / raw)
To: amul sul <sulamul@gmail.com>; +Cc: Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers; ashutosh.bapat.oss@gmail.com
On Thu, Mar 7, 2019 at 8:20 PM amul sul <sulamul@gmail.com> wrote:
>
>
> On Thu, Mar 7, 2019 at 1:02 PM amul sul <sulamul@gmail.com> wrote:
>
>> Thanks Rajkumar,
>>
>> I am looking into this.
>>
>>
> The crash happens when none of the if-else branch of
> handle_missing_partition()
> evaluates and returns merged_index unassigned.
>
> Let me explain, in Rajkumar 's test case, the join type is JOIN_INNER.
> When
> only outer rel has null partition, merge_null_partitions() function calls
> handle_missing_partition() with missing_side_inner = false and
> missing_side_outer = false argument value which fails to set merged_index.
>
> In the attached patch, I tried to fix this case by setting merged_index
> explicitly which fixes the reported crash.
>
Thanks Amul, with v20 patches, crash is fixed.
>
> Regards,
> Amul
>
>
>
>> On Thu, Mar 7, 2019 at 11:54 AM Rajkumar Raghuwanshi <
>> rajkumar.raghuwanshi@enterprisedb.com> wrote:
>>
>>>
>>>
>>> On Tue, Mar 5, 2019 at 3:45 PM amul sul <sulamul@gmail.com> wrote:
>>>
>>>> Attached is the rebased atop of the latest master head(35bc0ec7c8).
>>>>
>>> thanks Amul, patches applied cleanly on PG head.
>>>
>>> While testing this I got a server crash with below test case.
>>>
>>> CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
>>> CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN
>>> ('0001','0002','0003');
>>> CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN
>>> ('0004','0005','0006');
>>> CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN
>>> (NULL,'0008','0009');
>>> CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
>>> INSERT INTO plt1 SELECT i, i % 47, to_char(i % 17, 'FM0000') FROM
>>> generate_series(0, 500) i WHERE i % 17 NOT IN (7, 11, 12, 13, 14, 15,16);
>>> INSERT INTO plt1 SELECT i, i % 47, case when i % 17 = 7 then NULL else
>>> to_char(i % 17, 'FM0000') end FROM generate_series(0, 500) i WHERE i % 17
>>> IN (7,8,9);
>>> ANALYSE plt1;
>>>
>>> CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
>>> CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
>>> CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN
>>> ('0004','0005','0006');
>>> CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN
>>> ('0007','0008','0009');
>>> CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN
>>> ('0000',NULL,'0012');
>>> INSERT INTO plt2 SELECT i, i % 47, to_char(i % 17, 'FM0000') FROM
>>> generate_series(0, 500) i WHERE i % 17 NOT IN (1, 10, 11, 13, 14, 15, 16);
>>> INSERT INTO plt2 SELECT i, i % 47, case when i % 17 = 11 then NULL else
>>> to_char(i % 17, 'FM0000') end FROM generate_series(0, 500) i WHERE i % 17
>>> IN (0,11,12);
>>> ANALYZE plt2;
>>>
>>> CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c,
>>> 'A'));
>>> CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002',
>>> '0003');
>>> CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004',
>>> '0005', '0006');
>>> CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008',
>>> '0009');
>>> CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
>>> INSERT INTO plt1_e SELECT i, i % 47, to_char(i % 17, 'FM0000') FROM
>>> generate_series(0, 500) i WHERE i % 17 NOT IN (1, 7, 10, 11, 12, 13, 14,
>>> 15, 16);
>>> ANALYZE plt1_e;
>>>
>>> EXPLAIN (COSTS OFF)
>>> SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM
>>> plt1 t1, plt2 t2, plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') =
>>> t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
>>> server closed the connection unexpectedly
>>> This probably means the server terminated abnormally
>>> before or while processing the request.
>>> The connection to the server was lost. Attempting reset: Failed.
>>>
>>> below is stack trace, looks like some indexes got corrupted, please
>>> take a look.
>>>
>>> Core was generated by `postgres: edb postgres [local]
>>> EXPLAIN '.
>>> Program terminated with signal 11, Segmentation fault.
>>> #0 0x0000000000821aee in map_and_merge_partitions (partmaps1=0x2c1c8a8,
>>> partmaps2=0x2c1c8e0, index1=45540240, index2=0, next_index=0x7ffeebd43d3c)
>>> at partbounds.c:4162
>>> 4162 if (partmap1->from < 0 && partmap2->from < 0)
>>> Missing separate debuginfos, use: debuginfo-install
>>> keyutils-libs-1.4-5.el6.x86_64 krb5-libs-1.10.3-65.el6.x86_64
>>> libcom_err-1.41.12-24.el6.x86_64 libselinux-2.0.94-7.el6.x86_64
>>> openssl-1.0.1e-57.el6.x86_64 zlib-1.2.3-29.el6.x86_64
>>> (gdb) bt
>>> #0 0x0000000000821aee in map_and_merge_partitions (partmaps1=0x2c1c8a8,
>>> partmaps2=0x2c1c8e0, *index1=45540240*, index2=0,
>>> next_index=0x7ffeebd43d3c) at partbounds.c:4162
>>> #1 0x00000000008226c3 in merge_null_partitions (outer_bi=0x2b6e338,
>>> inner_bi=0x2bf90b0, outer_maps=0x2c1c8a8, inner_maps=0x2c1c8e0,
>>> jointype=JOIN_INNER,
>>> next_index=0x7ffeebd43d3c, null_index=0x7ffeebd43d38,
>>> default_index=0x7ffeebd43d34) at partbounds.c:4610
>>> #2 0x0000000000821726 in partition_list_bounds_merge
>>> (partsupfunc=0x2ba3548, partcollation=0x2ba34e8, outer_rel=0x2b6ce40,
>>> inner_rel=0x2bf8d28, outer_parts=0x7ffeebd43ed8,
>>> inner_parts=0x7ffeebd43ed0, jointype=JOIN_INNER) at partbounds.c:4031
>>> #3 0x000000000081ff5d in partition_bounds_merge (partnatts=1,
>>> partsupfunc=0x2ba3548, partcollation=0x2ba34e8, outer_rel=0x2b6ce40,
>>> inner_rel=0x2bf8d28, jointype=JOIN_INNER,
>>> outer_parts=0x7ffeebd43ed8, inner_parts=0x7ffeebd43ed0) at
>>> partbounds.c:3053
>>> #4 0x00000000007c610f in try_partitionwise_join (root=0x2be2a28,
>>> rel1=0x2b6ce40, rel2=0x2bf8d28, joinrel=0x2c1b0f0,
>>> parent_sjinfo=0x7ffeebd44010,
>>> parent_restrictlist=0x2c1c070) at joinrels.c:1370
>>> #5 0x00000000007c5521 in populate_joinrel_with_paths (root=0x2be2a28,
>>> rel1=0x2b6ce40, rel2=0x2bf8d28, joinrel=0x2c1b0f0, sjinfo=0x7ffeebd44010,
>>> restrictlist=0x2c1c070)
>>> at joinrels.c:914
>>> #6 0x00000000007c4f48 in make_join_rel (root=0x2be2a28, rel1=0x2b6ce40,
>>> rel2=0x2bf8d28) at joinrels.c:748
>>> #7 0x00000000007c4514 in make_rels_by_clause_joins (root=0x2be2a28,
>>> old_rel=0x2b6ce40, other_rels=0x2bae4d8) at joinrels.c:294
>>> #8 0x00000000007c41c8 in join_search_one_level (root=0x2be2a28,
>>> level=3) at joinrels.c:116
>>> #9 0x00000000007abe59 in standard_join_search (root=0x2be2a28,
>>> levels_needed=3, initial_rels=0x2bae500) at allpaths.c:2716
>>> #10 0x00000000007abdca in make_rel_from_joinlist (root=0x2be2a28,
>>> joinlist=0x2bfbae8) at allpaths.c:2647
>>> #11 0x00000000007a86b0 in make_one_rel (root=0x2be2a28,
>>> joinlist=0x2bfbae8) at allpaths.c:227
>>> #12 0x00000000007dada1 in query_planner (root=0x2be2a28,
>>> tlist=0x2ba01c8, qp_callback=0x7e0b25 <standard_qp_callback>,
>>> qp_extra=0x7ffeebd44390) at planmain.c:265
>>> #13 0x00000000007ddf83 in grouping_planner (root=0x2be2a28,
>>> inheritance_update=false, tuple_fraction=0) at planner.c:1929
>>> #14 0x00000000007dc5f5 in subquery_planner (glob=0x2be2990,
>>> parse=0x2c0e8c8, parent_root=0x0, hasRecursion=false, tuple_fraction=0) at
>>> planner.c:997
>>> #15 0x00000000007db1b6 in standard_planner (parse=0x2c0e8c8,
>>> cursorOptions=256, boundParams=0x0) at planner.c:416
>>> #16 0x00000000007daef7 in planner (parse=0x2c0e8c8, cursorOptions=256,
>>> boundParams=0x0) at planner.c:276
>>> #17 0x00000000008e15c5 in pg_plan_query (querytree=0x2c0e8c8,
>>> cursorOptions=256, boundParams=0x0) at postgres.c:878
>>> #18 0x00000000006562cc in ExplainOneQuery (query=0x2c0e8c8,
>>> cursorOptions=256, into=0x0, es=0x2c0e0a0,
>>> queryString=0x2aa24d8 "EXPLAIN (COSTS OFF)\nSELECT avg(t1.a),
>>> avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM\nplt1 t1, plt2 t2,
>>> plt1_e t3 WHERE t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c,
>>> t2.c, t3.c ORDER BY t1"..., params=0x0, queryEnv=0x0) at explain.c:364
>>>
>>> Thanks & Regards,
>>> Rajkumar Raghuwanshi
>>> QMG, EnterpriseDB.
>>>
>>>
>>>> Regards,
>>>> Amul Sul
>>>>
>>>> On Mon, Feb 4, 2019 at 11:05 AM amul sul <sulamul@gmail.com> wrote:
>>>>
>>>>> There are few whitespaces in 0002 patch that I have fixed in the
>>>>> attached version.
>>>>> Rest of the patches are untouched.
>>>>>
>>>>> Ill continue my review and testing.
>>>>>
>>>>> Regards,
>>>>> Amul
>>>>>
>>>>> On Thu, Jan 31, 2019 at 5:26 PM Etsuro Fujita <
>>>>> fujita.etsuro@lab.ntt.co.jp> wrote:
>>>>>
>>>>>> (2019/01/22 21:38), Etsuro Fujita wrote:
>>>>>> > Will continue to review.
>>>>>>
>>>>>> I rebased the patch set against the latest HEAD. Attached is a new
>>>>>> version. I'll move this to the next CF, and continue to review it.
>>>>>>
>>>>>> Best regards,
>>>>>> Etsuro Fujita
>>>>>>
>>>>>
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
@ 2019-03-11 02:58 ` Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-03-11 05:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
1 sibling, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2019-03-11 02:58 UTC (permalink / raw)
To: amul sul <sulamul@gmail.com>; +Cc: Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers
On Thu, Mar 7, 2019 at 8:20 PM amul sul <sulamul@gmail.com> wrote:
>
>
> On Thu, Mar 7, 2019 at 1:02 PM amul sul <sulamul@gmail.com> wrote:
>
>> Thanks Rajkumar,
>>
>> I am looking into this.
>>
>>
> The crash happens when none of the if-else branch of
> handle_missing_partition()
> evaluates and returns merged_index unassigned.
>
> Let me explain, in Rajkumar 's test case, the join type is JOIN_INNER.
> When
> only outer rel has null partition, merge_null_partitions() function calls
> handle_missing_partition() with missing_side_inner = false and
> missing_side_outer = false
>
Both missing_side_ variables being false when the NULL partition is missing
on the inner side looks suspicious. I guess from the variable names that
the missing_side_inner should be true in this case.
> argument value which fails to set merged_index.
>
> In the attached patch, I tried to fix this case by setting merged_index
> explicitly which fixes the reported crash.
>
I expect handle_missing_partition() to set the merged_index always. In your
patches, I don't see that function in your patches is setting it
explicitly. If we are setting merged_index explicitly somewhere else, other
places may miss that explicit assignment. So it's better to move it inside
this function.
--
Best Wishes,
Ashutosh Bapat
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 02:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
@ 2019-03-11 05:09 ` amul sul <sulamul@gmail.com>
2019-03-11 16:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: amul sul @ 2019-03-11 05:09 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>; +Cc: Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers
On Mon, Mar 11, 2019 at 8:29 AM Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
wrote:
> On Thu, Mar 7, 2019 at 8:20 PM amul sul <sulamul@gmail.com> wrote:
>
>>
>>
>> On Thu, Mar 7, 2019 at 1:02 PM amul sul <sulamul@gmail.com> wrote:
>>
>>> Thanks Rajkumar,
>>>
>>> I am looking into this.
>>>
>>>
>> The crash happens when none of the if-else branch of
>> handle_missing_partition()
>> evaluates and returns merged_index unassigned.
>>
>> Let me explain, in Rajkumar 's test case, the join type is JOIN_INNER.
>> When
>> only outer rel has null partition, merge_null_partitions() function calls
>> handle_missing_partition() with missing_side_inner = false and
>> missing_side_outer = false
>>
>
> Both missing_side_ variables being false when the NULL partition is
> missing on the inner side looks suspicious. I guess from the variable names
> that the missing_side_inner should be true in this case.
>
>
All the places from where this handle_missing_partition() get called
have the following code to decide the value for missing_side_outer/_inner
which
I yet to understand. Do you think this has some flaw?
/*
* For a FULL join, inner relation acts as both OUTER and INNER
* relation. For LEFT and ANTI join the inner relation acts as
* INNER relation. For INNER and SEMI join OUTER and INNER
* differentiation is immaterial.
*/
missing_side_inner = (jointype == JOIN_FULL ||
jointype == JOIN_LEFT ||
jointype == JOIN_ANTI);
missing_side_outer = (jointype == JOIN_FULL);
> argument value which fails to set merged_index.
>>
>> In the attached patch, I tried to fix this case by setting merged_index
>> explicitly which fixes the reported crash.
>>
>
> I expect handle_missing_partition() to set the merged_index always. In
> your patches, I don't see that function in your patches is setting it
> explicitly. If we are setting merged_index explicitly somewhere else, other
> places may miss that explicit assignment. So it's better to move it inside
> this function.
>
>
Ok, that can be fixed.
Similarly, I think merge_null_partitions should set null_index instead of
asserting when null partitions missing from both the side, make sense?
Regards,
Amul
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 02:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-03-11 05:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
@ 2019-03-11 16:43 ` Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-04-24 11:26 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Ashutosh Bapat @ 2019-03-11 16:43 UTC (permalink / raw)
To: amul sul <sulamul@gmail.com>; +Cc: Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers
On Mon, Mar 11, 2019 at 10:40 AM amul sul <sulamul@gmail.com> wrote:
>
> All the places from where this handle_missing_partition() get called
> have the following code to decide the value for missing_side_outer/_inner
> which
> I yet to understand. Do you think this has some flaw?
>
> /*
> * For a FULL join, inner relation acts as both OUTER and INNER
> * relation. For LEFT and ANTI join the inner relation acts as
> * INNER relation. For INNER and SEMI join OUTER and INNER
> * differentiation is immaterial.
> */
> missing_side_inner = (jointype == JOIN_FULL ||
> jointype == JOIN_LEFT ||
> jointype == JOIN_ANTI);
> missing_side_outer = (jointype == JOIN_FULL);
>
I was wrong, sorry. The comment says it all.
>
>
>
>> argument value which fails to set merged_index.
>>>
>>> In the attached patch, I tried to fix this case by setting merged_index
>>> explicitly which fixes the reported crash.
>>>
>>
>> I expect handle_missing_partition() to set the merged_index always. In
>> your patches, I don't see that function in your patches is setting it
>> explicitly. If we are setting merged_index explicitly somewhere else, other
>> places may miss that explicit assignment. So it's better to move it inside
>> this function.
>>
>>
>
> Ok, that can be fixed.
>
> Similarly, I think merge_null_partitions should set null_index instead of
> asserting when null partitions missing from both the side, make sense?
>
I think not. null_index, once set shouldn't change and hence does not
change with each pair of partitions being matched. So, it makes sense to
make sure that null_index remains invalid if none of the tables have null
partition.
--
Best Wishes,
Ashutosh Bapat
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 02:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-03-11 05:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 16:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
@ 2019-04-24 11:26 ` amul sul <sulamul@gmail.com>
2019-04-26 10:29 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-05-14 04:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
0 siblings, 2 replies; 154+ messages in thread
From: amul sul @ 2019-04-24 11:26 UTC (permalink / raw)
To: Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>; +Cc: Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers
Attached version is rebase atop of the latest master head(fdc7efcc30), also
incorporates the Ashutosh's suggestion, thanks.
Regards,
Amul
On Mon, Mar 11, 2019 at 10:14 PM Ashutosh Bapat <
ashutosh.bapat.oss@gmail.com> wrote:
>
>
> On Mon, Mar 11, 2019 at 10:40 AM amul sul <sulamul@gmail.com> wrote:
>
>>
>> All the places from where this handle_missing_partition() get called
>> have the following code to decide the value for missing_side_outer/_inner
>> which
>> I yet to understand. Do you think this has some flaw?
>>
>> /*
>> * For a FULL join, inner relation acts as both OUTER and INNER
>> * relation. For LEFT and ANTI join the inner relation acts as
>> * INNER relation. For INNER and SEMI join OUTER and INNER
>> * differentiation is immaterial.
>> */
>> missing_side_inner = (jointype == JOIN_FULL ||
>> jointype == JOIN_LEFT ||
>> jointype == JOIN_ANTI);
>> missing_side_outer = (jointype == JOIN_FULL);
>>
>
> I was wrong, sorry. The comment says it all.
>
>
>>
>>
>>
>>> argument value which fails to set merged_index.
>>>>
>>>> In the attached patch, I tried to fix this case by setting merged_index
>>>> explicitly which fixes the reported crash.
>>>>
>>>
>>> I expect handle_missing_partition() to set the merged_index always. In
>>> your patches, I don't see that function in your patches is setting it
>>> explicitly. If we are setting merged_index explicitly somewhere else, other
>>> places may miss that explicit assignment. So it's better to move it inside
>>> this function.
>>>
>>>
>>
>> Ok, that can be fixed.
>>
>> Similarly, I think merge_null_partitions should set null_index instead of
>> asserting when null partitions missing from both the side, make sense?
>>
>
> I think not. null_index, once set shouldn't change and hence does not
> change with each pair of partitions being matched. So, it makes sense to
> make sure that null_index remains invalid if none of the tables have null
> partition.
>
> --
> Best Wishes,
> Ashutosh Bapat
>
Attachments:
[application/octet-stream] 0002-Partition-wise-join-for-1-1-1-0-0-1-partition-matchi-v21.patch (70.3K, ../../CAAJ_b94cHo4GE45ysV73A+gdoLnMnTivzkMeKX3U3=RoDyFoDQ@mail.gmail.com/3-0002-Partition-wise-join-for-1-1-1-0-0-1-partition-matchi-v21.patch)
download | inline diff:
From 496cb36ab294044c4d545af7a53e31709e9d9a6a Mon Sep 17 00:00:00 2001
From: Amul Sul <amul.sul@enterprisedb.com>
Date: Thu, 18 Apr 2019 04:54:29 -0400
Subject: [PATCH 2/3] Partition-wise join for 1:1, 1:0, 0:1 partition matching.
Earlier version of partition-wise join implementation allowed
partition-wise join between two relations with exactly same partition
bounds. This commit allows partition-wise join to be applied under
following conditions
1. the partition bounds of joining relations are such that rows from
given partition on one side join can join with rows from maximum one
partition on the other side i.e. bounds of a given partition on one
side match/overlap with those of maximum one partition on the other
side. If the mapping happens to be m:n where m > 1 or n > 1, we have
to gang multiple partition relations together into a single relation.
This means that we have to add simple relations during join
processing, something which is not supported right now. ALso, in such
a case, different pairs of joining relations can produce different
partition bounds for the same join relation, which again is not
supported right now.
2. For every partition on outer side that can contribute to the result
of an OUTER join, there exists at least one (taken along with item 1,
it means exactly one) matching partition on the inner side. To
support partition-wise join when the inner matching partition doesn't
exist, we have to add a dummy base relation corresponding to the
non-existent inner partition. We don't have support to add base
relations during join processing.
3. For hash partitioned tables however, we support partition-wise join
only when the bounds exactly match. For hash partitioning it's unusual
to have missing partitions and hence generic partition matching is not
required.
With advanced partition matching, we won't be able to apply
partition-wise join when there are missing matching partitions. So for
a given N-way join, some sub-joins may not be partitioned, while the
overall N-way join is partitioned. We can not try partition-wise join
when one or both of the joining relations are not partitioned in one
of the pairs of joining relation. Skip partition-wise join for that
pair.
An example is A IJ B LJ C where B has an extra partition compared to A
and C. Join B LJ C requires dummy relation to join the extra partition
from B to a missing partition from C, and hence can not use
partition-wise join right now and hence BC is not partitioned. The
extra partition in B gets eliminated in A IJ B and thus it can use
partition-wise join and is partitioned. Hence (AB)C can use
partition-wise join but not A(BC).
Not every pair of joining relation (including the one presented to
build_joinrel_partition_info()) for the same joinrel can use
partition-wise join or has both the relations partitioned. Hence we
calculate the partition bounds for the join relation in
try_partition_wise_join() instead of doing it here.
The partition bounds produced for the first pair that can use
partition-wise are saved in the RelOptInfo of the joinrel. Partition
bounds produced for subsequent pairs should match that produced by the
first pair.
Support for default partition in list partitioned tables
========================================================
When a list value is present in one of the joining relations and not
the other, and the other relation has default partition, match (join)
the partition containing that list value with the default partition.
If there are multiple matches, we can not proceed with the
partition-wise join similar to the case of matching non-default
partition. If the default partition happens to be on the outer side of
the join, the resulting join partition acts as a default partition as
it will contain all the values from the default partition. If
the partition containing the list value happens to be on the outer
side of the join, the resulting join partition is associated with the
list value, since no other partition key value from the default
partition makes it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a partition from the inner side,
if inner side has a list value that is not present in the outer side.
But if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Support for matching default partition in range partitioned tables
==================================================================
When a range is present in one of the joining relations and not the
other, and the other relation has default partition, match (join) the
partition corresponding range with the default partition. If two
ranges overlap but their ranges don't match exactly, the
non-overlapping portion from one range may join the previous
(non-overlapping portion near the lower bound, if exists), next
(non-overlapping portion near the upper bound, if exists) ranges from
the other relation or default partition from the other relation. This
causes multiple partitions on the other side to be joined with a
single partition on the first side; a case we don't support. Any range
from one side which doesn't overlap with any range on the other side,
may find its join partner in the default partition and the
corresponding range partition will need to be joined with the default
partition. If the default partition happens to be on the outer side
of the join, the resulting join partition acts as a default partition
as it will contain all the values from the default partition. If the
non-partition corresponding to the range happens to be on the outer
side of the join, the resulting join partition is associated with that
range, since partition key values from the default partition outside
that range won't make it to the join result.
If both the relations have default partition, match (join) the default
partition with each other and deem the resulting join partition as
default partition. If one of the relations has default partition but
not the other, and the default partition happens to be on the outer
side of the join, all its rows will make it to the join. Such a
default partition may get joined to a non-default partition from the
inner side, if inner side has a range missing in the outer side. But
if such a join partner does not exist, we won't be able to use
partition-wise join since there is no (dummy) relation on the inner
side to join to.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/optimizer/path/joinrels.c | 103 +-
src/backend/optimizer/util/relnode.c | 33 +-
src/backend/partitioning/partbounds.c | 1682 ++++++++++++++++++++++++-
src/include/partitioning/partbounds.h | 7 +
4 files changed, 1775 insertions(+), 50 deletions(-)
diff --git a/src/backend/optimizer/path/joinrels.c b/src/backend/optimizer/path/joinrels.c
index 46623c33c6..5c433f495a 100644
--- a/src/backend/optimizer/path/joinrels.c
+++ b/src/backend/optimizer/path/joinrels.c
@@ -1339,25 +1339,31 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
{
bool rel1_is_simple = IS_SIMPLE_REL(rel1);
bool rel2_is_simple = IS_SIMPLE_REL(rel2);
- int nparts;
+ PartitionScheme part_scheme;
+ PartitionBoundInfo join_boundinfo;
+ List *parts1;
+ List *parts2;
+ ListCell *lc1;
+ ListCell *lc2;
int cnt_parts;
/* Guard against stack overflow due to overly deep partition hierarchy. */
check_stack_depth();
/* Nothing to do, if the join relation is not partitioned. */
- if (!IS_PARTITIONED_REL(joinrel))
+ if (joinrel->part_scheme == NULL)
return;
/* The join relation should have consider_partitionwise_join set. */
Assert(joinrel->consider_partitionwise_join);
/*
- * Since this join relation is partitioned, all the base relations
- * participating in this join must be partitioned and so are all the
- * intermediate join relations.
+ * We can not perform partition-wise join if either of the joining
+ * relations is not partitioned.
*/
- Assert(IS_PARTITIONED_REL(rel1) && IS_PARTITIONED_REL(rel2));
+ if (!IS_PARTITIONED_REL(rel1) || !IS_PARTITIONED_REL(rel2))
+ return;
+
Assert(REL_HAS_ALL_PART_PROPS(rel1) && REL_HAS_ALL_PART_PROPS(rel2));
/* The joining relations should have consider_partitionwise_join set. */
@@ -1370,36 +1376,65 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
*/
Assert(joinrel->part_scheme == rel1->part_scheme &&
joinrel->part_scheme == rel2->part_scheme);
+ part_scheme = joinrel->part_scheme;
/*
- * 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.
+ * Get the list of matching partitions to be joined along with the
+ * partition bounds of the join relation. Because of the restrictions
+ * imposed by partition matching algorithm, not every pair of joining
+ * relations for this join will be able to use partition-wise join. But all
+ * those pairs which can use partition-wise join will produce the same
+ * partition bounds for the join relation.
*/
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel1->boundinfo));
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel2->boundinfo));
+ join_boundinfo = partition_bounds_merge(part_scheme->partnatts,
+ part_scheme->partsupfunc,
+ part_scheme->partcollation,
+ rel1, rel2,
+ parent_sjinfo->jointype,
+ &parts1, &parts2);
+
+ if (join_boundinfo == NULL)
+ return;
- nparts = joinrel->nparts;
+ if (joinrel->boundinfo == NULL)
+ {
+ Assert(joinrel->nparts == 0 && joinrel->part_rels == NULL);
+ joinrel->boundinfo = join_boundinfo;
+ joinrel->nparts = list_length(parts1);
+ Assert(joinrel->nparts == list_length(parts2));
+ joinrel->part_rels =
+ (RelOptInfo **) palloc0(sizeof(RelOptInfo *) *
+ joinrel->nparts);
+ }
+ else
+ {
+ Assert(partition_bounds_equal(part_scheme->partnatts,
+ part_scheme->parttyplen,
+ part_scheme->parttypbyval,
+ join_boundinfo, joinrel->boundinfo));
+ /*
+ * Every pair of joining relations should result in the same number
+ * of child-joins.
+ */
+ Assert(joinrel->nparts == list_length(parts1));
+ Assert(joinrel->nparts == list_length(parts2));
+ Assert(joinrel->part_rels);
+ }
/*
* Create child-join relations for this partitioned join, if those don't
* exist. Add paths to child-joins for a pair of child relations
* corresponding to the given pair of parent relations.
*/
- for (cnt_parts = 0; cnt_parts < nparts; cnt_parts++)
+ cnt_parts = -1;
+ forboth(lc1, parts1, lc2, parts2)
{
- RelOptInfo *child_rel1 = rel1->part_rels[cnt_parts];
- RelOptInfo *child_rel2 = rel2->part_rels[cnt_parts];
- bool rel1_empty = (child_rel1 == NULL ||
- IS_DUMMY_REL(child_rel1));
- bool rel2_empty = (child_rel2 == NULL ||
- IS_DUMMY_REL(child_rel2));
+ int part1 = lfirst_int(lc1);
+ int part2 = lfirst_int(lc2);
+ RelOptInfo *child_rel1;
+ RelOptInfo *child_rel2;
+ bool rel1_empty;
+ bool rel2_empty;
SpecialJoinInfo *child_sjinfo;
List *child_restrictlist;
RelOptInfo *child_joinrel;
@@ -1407,6 +1442,13 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
AppendRelInfo **appinfos;
int nappinfos;
+ Assert(part1 >= 0 && part2 >= 0);
+ child_rel1 = rel1->part_rels[part1];
+ child_rel2 = rel2->part_rels[part2];
+ rel1_empty = (child_rel1 == NULL || IS_DUMMY_REL(child_rel1));
+ rel2_empty = (child_rel2 == NULL || IS_DUMMY_REL(child_rel2));
+ cnt_parts++;
+
/*
* Check for cases where we can prove that this segment of the join
* returns no rows, due to one or both inputs being empty (including
@@ -1506,12 +1548,23 @@ try_partitionwise_join(PlannerInfo *root, RelOptInfo *rel1, RelOptInfo *rel2,
joinrel->part_rels[cnt_parts] = child_joinrel;
}
+ /*
+ * For every pair of joining relations, the set of matching partitions
+ * would change. However, the base relation partitions constituting
+ * the given child should remain same for all the joining pairs. Since
+ * the order in which children are stored in the array of child-joins,
+ * depends upon partition bounds of the join, which are same for all
+ * the joining pairs, every joining pair yields the child-joins in the
+ * same order.
+ */
Assert(bms_equal(child_joinrel->relids, child_joinrelids));
populate_joinrel_with_paths(root, child_rel1, child_rel2,
child_joinrel, child_sjinfo,
child_restrictlist);
}
+
+ Assert(cnt_parts == (joinrel->nparts - 1));
}
/*
diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c
index 272e2eb10a..af33511aab 100644
--- a/src/backend/optimizer/util/relnode.c
+++ b/src/backend/optimizer/util/relnode.c
@@ -1623,7 +1623,7 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
* of the way the query planner deduces implied equalities and reorders
* the joins. Please see optimizer/README for details.
*/
- if (!IS_PARTITIONED_REL(outer_rel) || !IS_PARTITIONED_REL(inner_rel) ||
+ if (outer_rel->part_scheme == NULL || inner_rel->part_scheme == NULL ||
!outer_rel->consider_partitionwise_join ||
!inner_rel->consider_partitionwise_join ||
outer_rel->part_scheme != inner_rel->part_scheme ||
@@ -1636,24 +1636,6 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
part_scheme = outer_rel->part_scheme;
- Assert(REL_HAS_ALL_PART_PROPS(outer_rel) &&
- REL_HAS_ALL_PART_PROPS(inner_rel));
-
- /*
- * For now, our partition matching algorithm can match partitions only
- * when the partition bounds of the joining relations are exactly same.
- * So, bail out otherwise.
- */
- if (outer_rel->nparts != inner_rel->nparts ||
- !partition_bounds_equal(part_scheme->partnatts,
- part_scheme->parttyplen,
- part_scheme->parttypbyval,
- outer_rel->boundinfo, inner_rel->boundinfo))
- {
- Assert(!IS_PARTITIONED_REL(joinrel));
- return;
- }
-
/*
* This function will be called only once for each joinrel, hence it
* should not have partition scheme, partition bounds, partition key
@@ -1665,17 +1647,20 @@ build_joinrel_partition_info(RelOptInfo *joinrel, RelOptInfo *outer_rel,
/*
* Join relation is partitioned using the same partitioning scheme as the
- * joining relations and has same bounds.
+ * joining relations.
+ *
+ * Because of restrictions in partition_bounds_merge(), not every pair of
+ * joining relations (including the one presented to this function) for the
+ * same joinrel can use partition-wise join or has both the relations
+ * partitioned. Hence we calculate the partition bounds, number of
+ * partitions and child-join relations of the join relation when and if we
+ * find a suitable pair in try_partition_wise_join().
*/
joinrel->part_scheme = part_scheme;
- joinrel->boundinfo = outer_rel->boundinfo;
partnatts = joinrel->part_scheme->partnatts;
joinrel->partexprs = (List **) palloc0(sizeof(List *) * partnatts);
joinrel->nullable_partexprs =
(List **) palloc0(sizeof(List *) * partnatts);
- joinrel->nparts = outer_rel->nparts;
- joinrel->part_rels =
- (RelOptInfo **) palloc0(sizeof(RelOptInfo *) * joinrel->nparts);
/*
* Set the consider_partitionwise_join flag.
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index 35c03f611a..2086db720e 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -25,6 +25,7 @@
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
+#include "nodes/pathnodes.h"
#include "parser/parse_coerce.h"
#include "partitioning/partbounds.h"
#include "partitioning/partdesc.h"
@@ -69,6 +70,12 @@ typedef struct PartitionRangeBound
bool lower; /* this is the lower (vs upper) bound */
} PartitionRangeBound;
+typedef struct PartitionMap
+{
+ int from;
+ int to;
+} PartitionMap;
+
static int32 qsort_partition_hbound_cmp(const void *a, const void *b);
static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
void *arg);
@@ -110,7 +117,58 @@ static void get_range_key_properties(PartitionKey key, int keynum,
static List *get_range_nulltest(PartitionKey key);
static bool partition_hbounds_equal(PartitionBoundInfo b1,
PartitionBoundInfo b2);
-
+static PartitionBoundInfo partition_range_bounds_merge(
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype, int partnatts,
+ FmgrInfo *supfuncs, Oid *collations);
+static PartitionBoundInfo partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *collations,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype);
+static PartitionBoundInfo partition_hash_bounds_merge(RelOptInfo *outer_rel,
+ RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype);
+static void generate_matching_part_pairs(PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ int nparts1, int nparts2,
+ JoinType jointype, int nparts,
+ List **parts1, List **parts2);
+static PartitionBoundInfo build_merged_partition_bounds(char strategy,
+ List *merged_datums, List *merged_indexes,
+ List *merged_contents, int null_index,
+ int default_index);
+static int map_and_merge_partitions(PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ int index1, int index2, int *next_index);
+static int32 partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *collations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2);
+static bool partition_range_cmp(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval);
+static bool partition_range_merge_next_lb(int partnatts, FmgrInfo *supfuncs,
+ Oid *collations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes);
+static bool merge_default_partitions(PartitionBoundInfo outer_bi,
+ PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ JoinType jointype,
+ int *next_index, int *default_index);
+static bool merge_null_partitions(PartitionBoundInfo outer_bi,
+ PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps,
+ PartitionMap *inner_maps,
+ JoinType jointype,
+ int *next_index, int *null_index,
+ int *default_index);
/*
* get_qual_from_partbound
@@ -3007,3 +3065,1625 @@ satisfies_hash_partition(PG_FUNCTION_ARGS)
PG_RETURN_BOOL(rowHash % modulus == remainder);
}
+
+/*
+ * partition_bounds_merge
+ *
+ * The function produces the partition bounds for a join between two relations
+ * whose partition bounds are given. The function also returns two lists of
+ * partition indexes one for each of the joining relations. Both the lists
+ * contain the same number of elements. The partition indexes at the same
+ * positions in the lists indicate the pair partitions, one from each side, to
+ * be joined and the position itself corresponds to the index of partition
+ * produced by that child-join in the partitioned join.
+ *
+ * The function returns NULL if we can not find the matching pair of
+ * partitions. This happens if 1. multiple partitions on one side match with
+ * one partition on the other side. 2. a given partition on the outer side
+ * doesn't have a matching partition on the inner side. We can not support the
+ * first case since we don't have a way to represent multiple partitions as a
+ * single relation (RelOptInfo) and then perform join using the ganged
+ * relation. We can not support the second case since the missing inner
+ * partition needs to be represented as an empty relation and we don't have a
+ * way to introduce empty relation during join planning after creating paths
+ * for all the base relations.
+ */
+extern PartitionBoundInfo
+partition_bounds_merge(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts)
+{
+ PartitionBoundInfo merged_bounds;
+ PartitionBoundInfo outer_binfo = outer_rel->boundinfo,
+ inner_binfo = inner_rel->boundinfo;
+ char strategy = outer_binfo->strategy;
+
+ /* Bail out if partitioning strategies are different. */
+ if (outer_binfo->strategy != inner_binfo->strategy)
+ return NULL;
+
+ if (jointype != JOIN_LEFT && jointype != JOIN_INNER &&
+ jointype != JOIN_SEMI && jointype != JOIN_ANTI &&
+ jointype != JOIN_FULL)
+ elog(ERROR, "unexpected join type %d", jointype);
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+ switch (strategy)
+ {
+ case PARTITION_STRATEGY_LIST:
+ merged_bounds = partition_list_bounds_merge(partsupfunc,
+ partcollation,
+ outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype);
+ break;
+
+ case PARTITION_STRATEGY_RANGE:
+ merged_bounds = partition_range_bounds_merge(outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype, partnatts,
+ partsupfunc,
+ partcollation);
+ break;
+
+ case PARTITION_STRATEGY_HASH:
+ merged_bounds = partition_hash_bounds_merge(outer_rel, inner_rel,
+ outer_parts, inner_parts,
+ jointype);
+ break;
+
+ default:
+ elog(ERROR, "unexpected partition strategy: %d", strategy);
+ }
+
+ Assert(merged_bounds || (*outer_parts == NIL && *inner_parts == NIL));
+
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+
+ Assert((*outer_parts == NIL || *inner_parts != NIL) &&
+ (*inner_parts == NIL || *outer_parts != NIL));
+
+ return merged_bounds;
+}
+
+/*
+ * partition_get_range_bounds
+ *
+ * Given the index of lower bound in datums array, return lower and upper
+ * bounds and the index of the partition with that lower bound.
+ */
+static int
+partition_get_range_bounds(PartitionBoundInfo bi, int lb_index,
+ PartitionRangeBound *lower,
+ PartitionRangeBound *upper)
+{
+ int part_index;
+
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The lower bound should correspond to a valid partition. */
+ part_index = bi->indexes[lb_index + 1];
+ Assert(part_index >= 0);
+
+ lower->kind = bi->kind[lb_index];
+ lower->datums = bi->datums[lb_index];
+ lower->lower = true;
+ upper->kind = bi->kind[lb_index + 1];
+ upper->datums = bi->datums[lb_index + 1];
+ upper->lower = false;
+
+ return part_index;
+}
+
+/*
+ * partition_range_get_next_lb_index
+ *
+ * Given the index of lower bound in datums array return the
+ * index of lower bound of the next partition. When the given index corresponds
+ * to the last partition, return number of datums (ndatums).
+ */
+static int
+partition_range_get_next_lb_index(PartitionBoundInfo bi, int lb_index)
+{
+ /* A lower bound should have at least one more bound after it. */
+ Assert(lb_index < bi->ndatums - 1);
+
+ /* The partition index corresponding to the upper bound should be valid. */
+ Assert(bi->indexes[lb_index + 1] >= 0);
+
+ /*
+ * If there are no bounds left beyond the upper bound, we have reached the
+ * last partition.
+ */
+ if (lb_index + 2 < bi->ndatums)
+ {
+ /*
+ * If the bound next to the upper bound corresponds to no partition,
+ * that's the next lower bound of the next partition. Otherwise, the
+ * current upper bound is the lower bound of the next partition.
+ */
+ if (bi->indexes[lb_index + 2] < 0)
+ return lb_index + 2;
+ else
+ return lb_index + 1;
+ }
+ else
+ return bi->ndatums;
+}
+
+static int32
+partition_range_bound_cmp(int partnatts, FmgrInfo *partsupfunc,
+ Oid *partcollations, PartitionRangeBound *bound1,
+ PartitionRangeBound *bound2)
+{
+ return partition_rbound_cmp(partnatts, partsupfunc, partcollations,
+ bound1->datums, bound1->kind, bound1->lower,
+ bound2);
+}
+
+/*
+ * partition_range_cmp
+ *
+ * Compare the bounds of two range partitions. Set ub_cmpval <, = or > 0, if the
+ * first partition's upper bound is lower than, equal to or higher than the
+ * second partition's upper bound resp. Similarly set lb_cmpval <, = or > 0,
+ * if the first partition's lower bound is lower than, equal to or higher than
+ * the second partition's lower bound resp.
+ *
+ * Return true, if the ranges overlap, otherwise return false.
+ */
+static bool
+partition_range_cmp(int partnatts, FmgrInfo *partsupfuncs, Oid *partcollations,
+ PartitionRangeBound *lower_bound1,
+ PartitionRangeBound *upper_bound1,
+ PartitionRangeBound *lower_bound2,
+ PartitionRangeBound *upper_bound2, int *ub_cmpval,
+ int *lb_cmpval)
+{
+ bool overlap;
+
+ /*
+ * Compare upper bound of the first partition with the lower bound of the
+ * second and vice-versa. If lower bound is higher than the upper bound,
+ * the partitions are not overlapping. All other cases indicate overlapping
+ * partitions.
+ */
+ if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound1, upper_bound2) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = 1;
+ *lb_cmpval = 1;
+ }
+ else if (partition_range_bound_cmp(partnatts, partsupfuncs, partcollations,
+ lower_bound2, upper_bound1) > 0)
+ {
+ overlap = false;
+ *ub_cmpval = -1;
+ *lb_cmpval = -1;
+ }
+ else
+ {
+ overlap = true;
+ *ub_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, upper_bound1,
+ upper_bound2);
+ *lb_cmpval = partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, lower_bound1,
+ lower_bound2);
+ }
+
+ return overlap;
+}
+
+/*
+ * partition_range_merge
+ *
+ * Merge the partition bounds of given two partitions such that the join
+ * between the given two partitions fits merged bounds.
+ *
+ * "merged_upper" will be set to one of the given upper bounds and
+ * "merged_lower" will be set to one of the given lower bounds.
+ */
+static void
+partition_range_merge(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, JoinType jointype,
+ PartitionRangeBound *left_lb,
+ PartitionRangeBound *left_ub,
+ PartitionRangeBound *right_lb,
+ PartitionRangeBound *right_ub,
+ PartitionRangeBound **merged_lb,
+ PartitionRangeBound **merged_ub)
+{
+ /*
+ * An outer join will have all the rows from the outer side, so merged
+ * bounds will be same as the outer bounds. An inner join will have rows
+ * that fit both the bounds, thus lower merged bound will be higher of two
+ * lower bounds and upper merged bound will be lower of the two upper
+ * bounds.
+ */
+ switch (jointype)
+ {
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ *merged_ub = left_ub;
+ *merged_lb = left_lb;
+ break;
+
+ case JOIN_INNER:
+ case JOIN_SEMI:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) < 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) > 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ case JOIN_FULL:
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_ub,
+ right_ub) > 0)
+ *merged_ub = left_ub;
+ else
+ *merged_ub = right_ub;
+
+ if (partition_range_bound_cmp(partnatts, partsupfuncs,
+ partcollations, left_lb,
+ right_lb) < 0)
+ *merged_lb = left_lb;
+ else
+ *merged_lb = right_lb;
+ break;
+
+ default:
+ elog(ERROR, "unexpected join type %d", jointype);
+ }
+
+ return;
+}
+
+/*
+ * Add the lower bound of the next range to the list of bounds, if the lower
+ * bound is higher or equal to the previous upper bound. If successful return
+ * true, otherwise false.
+ */
+static bool
+partition_range_merge_next_lb(int partnatts, FmgrInfo *partsupfuncs,
+ Oid *partcollations, Datum *next_lb_datums,
+ PartitionRangeDatumKind *next_lb_kind,
+ List **merged_datums, List **merged_kinds,
+ List **merged_indexes)
+{
+ int cmpval;
+
+ if (!*merged_datums)
+ {
+ Assert(!*merged_kinds && !*merged_indexes);
+ cmpval = 1;
+ }
+ else
+ {
+ PartitionRangeBound prev_ub;
+
+ prev_ub.datums = llast(*merged_datums);
+ prev_ub.kind = llast(*merged_kinds);
+ prev_ub.lower = false;
+
+ cmpval = partition_rbound_cmp(partnatts, partsupfuncs, partcollations,
+ next_lb_datums, next_lb_kind, false,
+ &prev_ub);
+ }
+
+ /*
+ * The lower bound is lower than the last upper bound, thus does not fit
+ * the bounds created so far and hence can not be merged with the existing
+ * bounds.
+ */
+ if (cmpval < 0)
+ return false;
+
+ /*
+ * Add bounds of the new merged partition. If the next lower bound is
+ * higher than the last upper bound, add new range with index
+ * corresponding to the lower bound as -1. If the merged lower bound
+ * is same as the last merged upper bound, the last upper bound will be
+ * reused as the lower bound of the next range.
+ */
+ if (cmpval > 0)
+ {
+ *merged_datums = lappend(*merged_datums, next_lb_datums);
+ *merged_kinds = lappend(*merged_kinds, next_lb_kind);
+ *merged_indexes = lappend_int(*merged_indexes, -1);
+ }
+
+ return true;
+}
+
+/*
+ * handle_missing_partition
+ *
+ * If a range appears in one of the joining relations but not the other, a row
+ * in the corresponding partition will not have any join partner in the other
+ * relation, unless the other relation has a default partition. If a given list
+ * value is present in one joining relation but not the other, the default
+ * partition on the other side may contain that value.
+ *
+ * In both these cases, such an extra partition forms a joining pair with the
+ * default partition, if any, on the other side.
+ *
+ * If the default partition happens to be on the outer side of the join, the
+ * resultant partition will act as the default partition of the join relation.
+ * Otherwise the resultant partition will be associated with the range.
+ *
+ * When the default partition is not present in the other relation, the rows in
+ * the extra partition will be included in the bounds of the join result, if it
+ * appears on the outer side of the join, since all rows from the outer side
+ * are included in the join result.
+ *
+ * This function handles all these cases.
+ *
+ * maps_with_missing and missing_side_default are the partition maps (See
+ * partition_range/list_bounds_merge() for details) and the index of default
+ * partition respectively corresponding the side with missing partition.
+ *
+ * maps_with_extra and extra_part are the partition maps (See
+ * partition_range/list_bounds_merge() for details) and the index of extra
+ * partition respectively corresponding to the side with the extra partition.
+ *
+ * It returns true if the matching succeeds, otherwise returns false.
+ */
+static bool
+handle_missing_partition(PartitionMap *maps_with_missing,
+ PartitionMap *maps_with_extra,
+ int missing_side_default,
+ int extra_part,
+ bool missing_side_outer,
+ bool missing_side_inner,
+ int *next_index, int *default_index,
+ int *merged_index)
+{
+ bool missing_has_default = (missing_side_default != -1);
+
+ if (missing_has_default)
+ {
+ *merged_index = map_and_merge_partitions(maps_with_missing,
+ maps_with_extra,
+ missing_side_default,
+ extra_part,
+ next_index);
+ if (*merged_index < 0)
+ return false;
+
+ if (missing_side_outer)
+ {
+ /*
+ * Default partition on the outer side forms the default
+ * partition of the join result.
+ */
+ if (*default_index < 0)
+ *default_index = *merged_index;
+ else if(*default_index != *merged_index)
+ {
+ /*
+ * Ended up with default partition on the outer side
+ * being joined with multiple partitions on the inner
+ * side. We don't support this case.
+ */
+ return false;
+ }
+
+ /*
+ * Since the merged partition acts as a default partition, it
+ * doesn't need a separate index.
+ */
+ *merged_index = -1;
+ }
+ }
+ else if (missing_side_inner)
+ {
+ /*
+ * If this partition has already been mapped (say because we
+ * found an overlapping range earlier), we know where does it
+ * fit in the join result. Nothing to do in that case. Else
+ * create a new merged partition.
+ */
+ PartitionMap *extra_map = &maps_with_extra[extra_part];
+ if (extra_map->to < 0)
+ {
+ extra_map->to = *next_index;
+ *next_index = *next_index + 1;
+ *merged_index = extra_map->to;
+ }
+ }
+ else
+ *merged_index = -1;
+
+ return true;
+}
+
+static PartitionMap*
+init_partition_map(RelOptInfo *rel)
+{
+ int i, nparts = rel->nparts;
+ PartitionMap *map;
+
+ map = (PartitionMap *) palloc(sizeof(PartitionMap) * nparts);
+
+ for (i = 0; i < nparts; i++)
+ {
+ map[i].from = -1;
+ map[i].to = -1;
+ }
+
+ return map;
+}
+
+/*
+ * Allocate and initialize partition maps. We maintain four maps, two maps
+ * for each joining relation. pmap[i] gives the partition from the other
+ * relation which would join with ith partition of the given relation.
+ * Partition i from the given relation will join with partition pmap[i]
+ * from the other relation to produce partition mmap[i] of the join (merged
+ * partition).
+ *
+ * pmap[i] = -1 indicates that ith partition of a given relation does not
+ * have a matching partition from the other relation.
+ *
+ * mmap[i] = -1 indicates that ith partition of a given relation does not
+ * contribute to the join result. That can happen only when the given
+ * relation is the inner relation and it doesn't have a matching partition
+ * from the outer relation, hence pmap[i] should be -1.
+ *
+ * In case of an outer join, every partition of the outer join will appear
+ * in the join result, and thus has mmap[i] set for all i. But it's not
+ * necessary that every partition on the outer side will have a matching
+ * partition on the inner side. In such a case, we end up with pmap[i] = -1
+ * and mmap[i] != -1.
+ */
+
+/*
+ * partition_range_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for range partitioned tables.
+ */
+static PartitionBoundInfo
+partition_range_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype, int partnatts,
+ FmgrInfo *partsupfuncs, Oid *partcollations)
+
+{
+ PartitionMap *outer_maps = NULL;
+ PartitionMap *inner_maps = NULL;
+ int outer_part = 0;
+ int inner_part = 0;
+ PartitionBoundInfo merged_bounds = NULL;
+ int outer_lb_index;
+ int inner_lb_index;
+ int next_index;
+ int default_index = -1;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ List *merged_kinds = NIL;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int inner_default = inner_bi->default_index;
+ int outer_default = outer_bi->default_index;
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_RANGE);
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ outer_maps = init_partition_map(outer_rel);
+ inner_maps = init_partition_map(inner_rel);
+
+ /*
+ * Merge the ranges (partitions) from both sides. Every iteration compares
+ * a pair of ranges, one from each side, advancing to the next range from
+ * the side with smaller upper range bound. If upper bounds of ranges from
+ * both sides match exactly, both the sides are advanced. For a given pair
+ * of ranges, we decide whether the corresponding partition match or not.
+ * lb_index, for inner or outer side, keeps track of the index of lower bound
+ * datum in PartitionBoundInfo::datums of that side.
+ */
+ outer_lb_index = 0;
+ inner_lb_index = 0;
+ next_index = 0;
+ while (outer_lb_index < outer_bi->ndatums ||
+ inner_lb_index < inner_bi->ndatums)
+ {
+ PartitionRangeBound outer_lb, outer_ub,
+ inner_lb, inner_ub,
+ *merged_lb = NULL,
+ *merged_ub = NULL;
+
+ int merged_index = -1;
+ bool overlap;
+ bool finished_outer = false;
+ bool finished_inner = false;
+
+ /* Result of bounds comparison per partition_rbound_cmp(). */
+ int ub_cmpval; /* Upper bounds comparison result. */
+ int lb_cmpval; /* Lower bounds comparison result. */
+
+ /* Get the range bounds of the next pair of partitions. */
+ if (outer_lb_index < outer_bi->ndatums)
+ outer_part = partition_get_range_bounds(outer_bi, outer_lb_index,
+ &outer_lb, &outer_ub);
+ else
+ finished_outer = true;
+
+ if (inner_lb_index < inner_bi->ndatums)
+ inner_part = partition_get_range_bounds(inner_bi, inner_lb_index,
+ &inner_lb, &inner_ub);
+ else
+ finished_inner = true;
+
+ Assert(!finished_outer || !finished_inner);
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining partitions on the side
+ * which finishes later. For that we set the comparison parameters
+ * overlap, ub_cmpval and lb_cmpval in such a way that it appears as if
+ * the side which finishes earlier has an extra partition with lower
+ * and upper bounds higher than any other partition of the unfinished
+ * side. That way we advance the partitions on that side till all of
+ * them are exhausted.
+ */
+ if (finished_outer)
+ {
+ overlap = false;
+ ub_cmpval = 1;
+ lb_cmpval = 1;
+ }
+ else if (finished_inner)
+ {
+ overlap = false;
+ ub_cmpval = -1;
+ lb_cmpval = -1;
+ }
+ else
+ overlap = partition_range_cmp(partnatts, partsupfuncs, partcollations,
+ &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &ub_cmpval, &lb_cmpval);
+
+ if (overlap)
+ {
+ /*
+ * The rows from overlapping portion of ranges on both sides may
+ * join, hence the corresponding pair of partitions form a joining
+ * pair. Match them and produce the bounds of the joint partition
+ * and its index by merging the bounds according to the type of
+ * join.
+ */
+ partition_range_merge(partnatts, partsupfuncs, partcollations,
+ jointype, &outer_lb, &outer_ub, &inner_lb,
+ &inner_ub, &merged_lb, &merged_ub);
+
+ merged_index = map_and_merge_partitions(outer_maps, inner_maps,
+ outer_part, inner_part,
+ &next_index);
+
+ if (merged_index < 0)
+ {
+ /* Failed to match the partitions. */
+ return NULL;
+ }
+
+ /*
+ * If the ranges overlap but don't exactly match, a row from
+ * non-overlapping portion of the range from one side of join may
+ * find its join partner in the previous or next overlapping
+ * partition or default partition on the other side , if such a
+ * partition exists. All those cases, if true, will cause one
+ * partition from that side to match at least two partitions on the
+ * other side; a case that we do not support now. Previous
+ * partition has been delt with in the previous iteration of this
+ * loop, next partition will be delt in the next iteration. We will
+ * deal with the default partition here.
+ */
+ if ((lb_cmpval < 0 && inner_has_default) ||
+ /* Non-overlapping range on the lower side of outer range. */
+ (lb_cmpval > 0 && outer_has_default) ||
+ /* Non-overlapping range on the lower side of inner range. */
+ (ub_cmpval < 0 && outer_has_default) ||
+ /* Non-overlapping range on the upper side of inner range. */
+ (ub_cmpval > 0 && inner_has_default))
+ /* Non-overlapping range on the upper side of outer range. */
+ return NULL;
+ }
+
+ if (ub_cmpval == 0)
+ {
+ /* Upper bounds of both the ranges match. */
+ Assert(overlap);
+
+ /* Move to the next pair of partitions. */
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+ else if (ub_cmpval < 0)
+ {
+ /* Upper bound of inner range higher than that of the outer. */
+
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the inner side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &outer_lb;
+ merged_ub = &outer_ub;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+ if (!handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ outer_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+ }
+
+ /* Move to the next partition on the outer side. */
+ Assert(!finished_outer);
+ outer_lb_index = partition_range_get_next_lb_index(outer_bi,
+ outer_lb_index);
+ }
+ else
+ {
+ Assert(ub_cmpval > 0);
+
+ /* Upper bound of outer range higher than that of the inner. */
+ if (overlap)
+ {
+ /* We have already dealt with overlapping ranges. */
+ }
+ else
+ {
+ /* A range missing from the outer side. */
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ merged_lb = &inner_lb;
+ merged_ub = &inner_ub;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ inner_part,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+ }
+
+ /* Move to the next partition on the inner side. */
+ Assert (!finished_inner);
+ inner_lb_index = partition_range_get_next_lb_index(inner_bi,
+ inner_lb_index);
+ }
+
+ if (merged_index < 0)
+ {
+ /* We didn't find a new merged partition. */
+ continue;
+ }
+
+ /*
+ * We have a valid partition index for the next partition of join. The
+ * partition should have valid range.
+ */
+ Assert(merged_lb && merged_ub);
+
+ /* Try merging new lower bound with the last upper bound. */
+ if (!partition_range_merge_next_lb(partnatts, partsupfuncs,
+ partcollations,
+ merged_lb->datums,
+ merged_lb->kind, &merged_datums,
+ &merged_kinds, &merged_indexes))
+ return NULL;
+
+ /* Add upper bound with the merged partition index. */
+ merged_datums = lappend(merged_datums, merged_ub->datums);
+ merged_kinds = lappend(merged_kinds, merged_ub->kind);
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ }
+
+ if (!merge_default_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index,
+ &default_index))
+ return NULL;
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_maps, inner_maps,
+ outer_nparts, inner_nparts,
+ jointype, next_index,
+ outer_parts, inner_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes,
+ merged_kinds,
+ -1, default_index);
+ }
+
+ /* Free any memory we used in this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+ list_free(merged_kinds);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_list_bounds_merge
+ *
+ * partition_bounds_merge()'s arm for list partitioned tables.
+ *
+ */
+static PartitionBoundInfo
+partition_list_bounds_merge(FmgrInfo *partsupfunc, Oid *partcollation,
+ RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype)
+{
+ PartitionMap *outer_maps = NULL;
+ PartitionMap *inner_maps = NULL;
+ int cnto;
+ int cnti;
+ List *merged_datums = NIL;
+ List *merged_indexes = NIL;
+ int next_index = 0;
+ int null_index = -1;
+ int default_index = -1;
+ PartitionBoundInfo merged_bounds = NULL;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int *outer_indexes = outer_bi->indexes;
+ int *inner_indexes = inner_bi->indexes;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_LIST);
+
+ /* List partitions do not require unbounded ranges. */
+ Assert(!outer_bi->kind && !inner_bi->kind);
+
+ outer_maps = init_partition_map(outer_rel);
+ inner_maps = init_partition_map(inner_rel);
+
+ /*
+ * Merge the list value datums from both sides. Every iteration compares a
+ * pair of datums, one from each side, advancing to the next datum from the
+ * side with smaller datum. If datums from both sides match exactly, both
+ * the sides are advanced. For a given pair of datums, we decide whether
+ * the corresponding partition match or not.
+ */
+ cnto = cnti = 0;
+ while (cnto < outer_bi->ndatums || cnti < inner_bi->ndatums)
+ {
+ Datum *odatums;
+ Datum *idatums;
+ int o_index;
+ int i_index;
+ int cmpval;
+ int merged_index = -1;
+ Datum *merged_datum;
+ bool finished_inner;
+ bool finished_outer;
+
+ /*
+ * We run this loop till both the sides finish. This allows to avoid
+ * duplicating code to handle the remaining datums on the side which
+ * finishes later. For that we set the comparison parameter cmpval in
+ * such a way that it appears as if the side which finishes earlier has
+ * an extra datum higher than any other datum on the unfinished side.
+ * That way we advance the datums on the unfinished side till all of
+ * its datums are exhausted.
+ */
+ if (cnto >= outer_bi->ndatums)
+ {
+ finished_outer = true;
+ odatums = NULL;
+ o_index = -1;
+ }
+ else
+ {
+ finished_outer = false;
+ odatums = outer_bi->datums[cnto];
+ o_index = outer_indexes[cnto];
+ }
+
+ if (cnti >= inner_bi->ndatums)
+ {
+ finished_inner = true;
+ idatums = NULL;
+ i_index = -1;
+ }
+ else
+ {
+ finished_inner = false;
+ idatums = inner_bi->datums[cnti];
+ i_index = inner_indexes[cnti];
+ }
+
+ /* If we exhausted both the sides, we won't enter the loop. */
+ Assert(!finished_inner || !finished_outer);
+
+ if (finished_outer)
+ cmpval = 1;
+ else if (finished_inner)
+ cmpval = -1;
+ else
+ {
+ /* Every list datum should map to a valid partition index. */
+ Assert(o_index >= 0 && i_index >= 0 &&
+ odatums != NULL && idatums != NULL);
+
+ cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
+ partcollation[0],
+ odatums[0], idatums[0]));
+ }
+
+ if (cmpval == 0)
+ {
+ /*
+ * Datums match. Rows on either side with these datums as partition
+ * key value will join and will be part of the partition of the
+ * join result produced by joining the corresponding partitions.
+ * Match the corresponding partitions and if successful, add the
+ * datum to the list of merged datums with index of merged
+ * partition containing it.
+ */
+ merged_datum = odatums;
+ merged_index = map_and_merge_partitions(outer_maps, inner_maps,
+ o_index, i_index,
+ &next_index);
+
+ if (merged_index < 0)
+ return NULL;
+
+ /* Move to the next pair of bounds. */
+ cnto++;
+ cnti++;
+ }
+ else if (cmpval < 0)
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /* A datum missing from the inner side. */
+ merged_index = -1;
+ merged_datum = odatums;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ o_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+
+ /* Move to the next datum on the outer side. */
+ Assert(!finished_outer);
+ cnto++;
+ }
+ else
+ {
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ Assert(cmpval > 0);
+
+ /* A datum missing from the outer side. */
+ merged_index = -1;
+ merged_datum = idatums;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as
+ * OUTER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+
+ if (!handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ i_index,
+ missing_side_outer,
+ missing_side_inner,
+ &next_index,
+ &default_index,
+ &merged_index))
+ return NULL;
+
+ /* Move to the next datum on the right side. */
+ Assert(!finished_inner);
+ cnti++;
+ }
+
+ /*
+ * Add the list value with appropriate index in the list of datums, if
+ * we have associated a partition with this list value.
+ */
+ if (merged_index >= 0)
+ {
+ merged_indexes = lappend_int(merged_indexes, merged_index);
+ merged_datums = lappend(merged_datums, merged_datum);
+ }
+ }
+
+ if (!merge_null_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index, &null_index,
+ &default_index))
+ return NULL;
+
+ if (!merge_default_partitions(outer_bi, inner_bi,
+ outer_maps, inner_maps,
+ jointype, &next_index,
+ &default_index))
+ return NULL;
+
+ /* Use maps to match partition from the joining relations. */
+ generate_matching_part_pairs(outer_maps, inner_maps,
+ outer_nparts, inner_nparts,
+ jointype, next_index,
+ outer_parts, inner_parts);
+
+ /* Craft a PartitionBoundInfo to return. */
+ if (*outer_parts && *inner_parts)
+ {
+ Assert(list_length(*outer_parts) == list_length(*inner_parts));
+ Assert(list_length(*outer_parts) == next_index);
+ merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
+ merged_datums,
+ merged_indexes, NIL,
+ null_index, default_index);
+ }
+
+ /* Free up all extra memory before returning from this function. */
+ list_free(merged_datums);
+ list_free(merged_indexes);
+
+ return merged_bounds;
+}
+
+/*
+ * partition_bounds_merge()'s arm for hash partitioned tables.
+ *
+ * If the given two hash bounds are same, the function returns the first one
+ * without any change, alongwith the lists of matching partitions. Otherwise it
+ * returns NULL.
+ *
+ * We could try merging the bounds when both the bounds have same greatest
+ * modulii. But there seems to be hardly any requirement for the same.
+ */
+static PartitionBoundInfo
+partition_hash_bounds_merge(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
+ List **outer_parts, List **inner_parts,
+ JoinType jointype)
+{
+ int nparts;
+ int cnt;
+ PartitionBoundInfo outer_bi = outer_rel->boundinfo,
+ inner_bi = inner_rel->boundinfo;
+ int outer_nparts = outer_rel->nparts,
+ inner_nparts = inner_rel->nparts;
+
+ Assert(*outer_parts == NIL);
+ Assert(*inner_parts == NIL);
+
+ Assert(outer_bi->strategy == inner_bi->strategy &&
+ outer_bi->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * Hash partitioned table does not have explicit NULL accepting partition
+ * and also does not have a default partition.
+ */
+ Assert(!partition_bound_has_default(outer_bi) &&
+ !partition_bound_has_default(inner_bi));
+ Assert(!partition_bound_accepts_nulls(outer_bi) &&
+ !partition_bound_accepts_nulls(inner_bi));
+
+ *outer_parts = NIL;
+ *inner_parts = NIL;
+
+ if (outer_nparts != inner_nparts)
+ return NULL;
+ nparts = outer_nparts;
+
+ if (outer_bi->ndatums != inner_bi->ndatums ||
+ !partition_hbounds_equal(outer_bi, inner_bi))
+ return NULL;
+
+ /*
+ * Cook up list of matching partitions. Since bounds are exactly same the
+ * partitions at the same position from both the relations match.
+ */
+ for (cnt = 0; cnt < nparts; cnt++)
+ {
+ *outer_parts = lappend_int(*outer_parts, cnt);
+ *inner_parts = lappend_int(*inner_parts, cnt);
+ }
+
+ return outer_bi;
+}
+
+/*
+ * map_and_merge_partitions
+ *
+ * If the two given partitions (given by index1 and index2 resp.) are
+ * already mapped to each other return the index of corresponding partition in
+ * the merged set of partitions. If they do not have a merged partition
+ * associated with them, assign a new merged partition index. If the
+ * partitions are already mapped and their mapped partitions are different from
+ * each other, they can not be merged, so return -1.
+ *
+ * partmaps1[i] gives the mapping of partitions for both relations. It
+ * describes which partition of relation 2 matches ith partition of relation 1,
+ * and which partition in the merged set matches ith partition of relation 1
+ * maps to. Similarly for partmap2.
+ *
+ * index1 and index2 are the indexes of matching partition from respective
+ * relations.
+ *
+ * *next_index is used and incremented when the given partitions require a new
+ * merged partition.
+ */
+
+static int
+map_and_merge_partitions(PartitionMap *partmaps1, PartitionMap *partmaps2,
+ int index1, int index2, int *next_index)
+{
+ PartitionMap *partmap1 = &partmaps1[index1];
+ PartitionMap *partmap2 = &partmaps2[index2];
+ int merged_index;
+
+ /*
+ * If both the partitions are not mapped to each other, update the
+ * maps.
+ */
+ if (partmap1->from < 0 && partmap2->from < 0)
+ {
+ partmap1->from = index2;
+ partmap2->from = index1;
+ }
+
+ /*
+ * If the given to partitions map to each other, find the corresponding
+ * merged partition index .
+ */
+ if (partmap1->from == index2 && partmap2->from == index1)
+ {
+ /*
+ * If both the partitions are mapped to the same merged partition, get
+ * the index of merged partition.
+ */
+ if (partmap1->to == partmap2->to)
+ {
+ merged_index = partmap1->to;
+
+ /*
+ * If the given two partitions do not have a merged partition
+ * associated with them, allocate a new merged partition.
+ */
+ if (merged_index < 0)
+ {
+ merged_index = *next_index;
+ *next_index = *next_index + 1;
+ partmap1->to = merged_index;
+ partmap2->to = merged_index;
+ }
+ }
+
+ /*
+ * If partition from one relation was mapped to a merged partition but
+ * not the partition from the other relation, map the same merged
+ * partition to the partition from other relation, since matching
+ * partitions map to the same merged partition.
+ */
+ else if (partmap1->to >= 0 && partmap2->to < 0)
+ {
+ partmap2->to = partmap1->to;
+ merged_index = partmap1->to;
+ }
+ else if (partmap1->to < 0 && partmap2->to >= 0)
+ {
+ partmap1->to = partmap2->to;
+ merged_index = partmap2->to;
+ }
+ else
+ {
+ Assert(partmap1->to != partmap2->to &&
+ partmap1->to >= 0 && partmap2->to >= 0);
+
+ /*
+ * Both the partitions map to different merged partitions. This
+ * means that multiple partitions from one relation matches to one
+ * partition from the other relation. Partition-wise join does not
+ * handle this case right now, since it requires ganging multiple
+ * partitions together (into one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+ }
+ else
+ {
+ /*
+ * Multiple partitions from one relation map to one partition from the
+ * other relation. Partition-wise join does not handle this case right
+ * now, since it requires ganging multiple partitions together (into
+ * one RelOptInfo).
+ */
+ merged_index = -1;
+ }
+
+ return merged_index;
+}
+
+/*
+ * generate_matching_part_pairs
+ *
+ * partmaps1 map each partition from either side of the join to a merged
+ * partition resp. E.g. partmaps1[i].to gives the merged partition to which ith
+ * partition of first relation maps. Similarly for partmap2. If
+ * partmaps1[i].to == partmaps2[j].to, i and j form the matching pair of
+ * partitions.
+ *
+ * Given these maps this function produces the list pairs of partitions which
+ * when joined produce the merged partitions in the order of merged partition
+ * indexes.
+ *
+ * nparts1 and nparts2 are the number of partitions of the joining relations
+ * resp.
+ *
+ * nparts is the number of merged partitions.
+ *
+ * If successful, the pairs of partitions are returned as two separate lists,
+ * parts1 and parts2 resp., one for each side. Otherwise, those lists will be
+ * set to NIL.
+ */
+static void
+generate_matching_part_pairs(PartitionMap *partmaps1, PartitionMap *partmaps2,
+ int nparts1, int nparts2,
+ JoinType jointype, int nparts,
+ List **matched_parts1, List **matched_parts2)
+{
+ bool merged = true;
+ int *matching1,
+ *matching2;
+ int i;
+ int max_nparts;
+
+ *matched_parts1 = NIL;
+ *matched_parts2 = NIL;
+
+ matching1 = (int *) palloc(sizeof(int) * nparts),
+ matching2 = (int *) palloc(sizeof(int) * nparts);
+ for (i = 0; i < nparts; i++)
+ matching1[i] = matching2[i] = -1;
+
+ /* Set pairs of matching partitions. */
+ max_nparts = Max(nparts1, nparts2);
+ for (i = 0; i < max_nparts; i++)
+ {
+ if (i < nparts1)
+ {
+ PartitionMap outer_map = partmaps1[i];
+
+ if (outer_map.to >= 0)
+ {
+ Assert(outer_map.to < nparts);
+ matching1[outer_map.to] = i;
+ }
+ }
+
+ if (i < nparts2)
+ {
+ PartitionMap inner_map = partmaps2[i];
+
+ if (inner_map.to >= 0)
+ {
+ Assert(inner_map.to < nparts);
+ matching2[inner_map.to] = i;
+ }
+ }
+ }
+
+ /*
+ * If we have a partition missing on an inner side, we need to add a dummy
+ * relation which joins with the outer partition. If the inner relation
+ * happens to be a base relation, it will require adding a dummy child
+ * base relation during join processing. Right now, we freeze the base
+ * relation arrays like PlannerInfo::simple_rte_array after planning for
+ * base relations. Adding a new (dummy) base relation would require some
+ * changes to that. So, right now, we do not implement partition-wise join
+ * in such cases.
+ */
+ for (i = 0; i < nparts; i++)
+ {
+ int part1 = matching1[i];
+ int part2 = matching2[i];
+
+ /* At least one of the partitions should exist. */
+ Assert(part1 >= 0 || part2 >= 0);
+
+ switch (jointype)
+ {
+ case JOIN_INNER:
+ case JOIN_SEMI:
+
+ /*
+ * An inner or semi join can not return any row when the
+ * matching partition on either side is missing. We should
+ * have eliminated all such cases while merging the bounds.
+ */
+ Assert(part1 >= 0 && part2 >= 0);
+ break;
+
+ case JOIN_LEFT:
+ case JOIN_ANTI:
+ Assert(part1 >= 0);
+ if (part2 < 0)
+ merged = false;
+ break;
+
+ case JOIN_FULL:
+ if (part1 < 0 || part2 < 0)
+ merged = false;
+ break;
+
+ default:
+ elog(ERROR, "unrecognized join type: %d", (int) jointype);
+ }
+
+ if (!merged)
+ break;
+
+ *matched_parts1 = lappend_int(*matched_parts1, part1);
+ *matched_parts2 = lappend_int(*matched_parts2, part2);
+ }
+
+ pfree(matching1);
+ pfree(matching2);
+
+ if (!merged)
+ {
+ list_free(*matched_parts1);
+ list_free(*matched_parts2);
+ *matched_parts1 = NIL;
+ *matched_parts2 = NIL;
+ }
+}
+
+static PartitionBoundInfo
+build_merged_partition_bounds(char strategy, List *merged_datums,
+ List *merged_indexes, List *merged_kinds,
+ int null_index, int default_index)
+{
+ int cnt;
+ PartitionBoundInfo merged_bounds;
+ ListCell *lc;
+
+ /* We expect the same number of elements in datums and indexes lists. */
+ Assert(list_length(merged_datums) == list_length(merged_indexes));
+
+ merged_bounds = (PartitionBoundInfo) palloc(sizeof(PartitionBoundInfoData));
+ merged_bounds->strategy = strategy;
+ merged_bounds->ndatums = list_length(merged_datums);
+
+ if (strategy == PARTITION_STRATEGY_RANGE)
+ {
+ Assert(list_length(merged_datums) == list_length(merged_kinds));
+ merged_bounds->kind =
+ (PartitionRangeDatumKind **) palloc(sizeof(PartitionRangeDatumKind *) *
+ list_length(merged_kinds));
+ cnt = 0;
+ foreach(lc, merged_kinds)
+ merged_bounds->kind[cnt++] = lfirst(lc);
+
+ /* There are ndatums+1 indexes in case of range partitions */
+ merged_indexes = lappend_int(merged_indexes, -1);
+ }
+ else
+ merged_bounds->kind = NULL;
+
+ cnt = 0;
+ merged_bounds->datums = (Datum **) palloc(sizeof(Datum *) *
+ list_length(merged_datums));
+ foreach(lc, merged_datums)
+ merged_bounds->datums[cnt++] = lfirst(lc);
+
+ merged_bounds->indexes = (int *) palloc(sizeof(int) *
+ list_length(merged_indexes));
+ cnt = 0;
+ foreach(lc, merged_indexes)
+ merged_bounds->indexes[cnt++] = lfirst_int(lc);
+
+ merged_bounds->null_index = null_index;
+ merged_bounds->default_index = default_index;
+
+ return merged_bounds;
+}
+
+/*
+ * Merge default partitions from both sides, if any, and assign the default
+ * partition for the join result, if necessary.
+ *
+ * If both the relations have default partitions, try mapping those to each
+ * other. If the mapping succeeds corresponding merged partition will act as
+ * the default partition of the join result.
+ *
+ * If inner side of the join has default but not the outer side, rows in it
+ * won't appear in the join result. So don't create a default partition. If
+ * outer side of the join has default but not the inner side, rows in it will
+ * appear in the join result, so create a default merged partition.
+ */
+static bool
+merge_default_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps, PartitionMap *inner_maps,
+ JoinType jointype, int *next_index, int *default_index)
+{
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool outer_has_default = partition_bound_has_default(outer_bi);
+ bool inner_has_default = partition_bound_has_default(inner_bi);
+ bool merged = true;
+ PartitionMap *outer_default_map = NULL;
+ PartitionMap *inner_default_map = NULL;
+
+ if (outer_has_default)
+ outer_default_map = &outer_maps[outer_default];
+
+ if (inner_has_default)
+ inner_default_map = &inner_maps[inner_default];
+
+ if (!outer_has_default && !inner_has_default)
+ Assert(*default_index < 0);
+ else if (outer_default_map != NULL && inner_default_map == NULL)
+ {
+ if (jointype == JOIN_LEFT || jointype == JOIN_FULL ||
+ jointype == JOIN_ANTI)
+ {
+ if (outer_default_map->to < 0)
+ {
+ outer_default_map->to = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = outer_default_map->to;
+ }
+ else
+ Assert(*default_index == outer_default_map->to);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else if (outer_default_map == NULL && inner_default_map != NULL)
+ {
+ if (jointype == JOIN_FULL)
+ {
+ if (inner_default_map->to < 0)
+ {
+ inner_default_map->to = *next_index;
+ *next_index = *next_index + 1;
+ Assert(*default_index < 0);
+ *default_index = inner_default_map->to;
+ }
+ else
+ Assert(*default_index == inner_default_map->to);
+ }
+ else
+ Assert(*default_index < 0);
+ }
+ else
+ {
+ Assert(outer_has_default && inner_has_default);
+
+ *default_index = map_and_merge_partitions(outer_maps, inner_maps,
+ outer_default, inner_default,
+ next_index);
+
+ if (*default_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
+
+/*
+ * merge_null_partitions
+ *
+ * Merge NULL partitions, i.e. a partition that can hold NULL values for a list
+ * partitioned table, if any. Find the index of merged partition to which the
+ * NULL values would belong in the join result. If one joining relation has a
+ * NULL partition but not the other, try matching it with the default partition
+ * from the other relation since the default partition may have rows with NULL
+ * partition key. We can eliminate a NULL partition when it appears only on the
+ * inner side of the join and the outer side doesn't have a default partition.
+ *
+ * When the equality operator used for join is strict, two NULL values will not
+ * be considered as equal, and thus a NULL partition can be eliminated for an
+ * inner join. But we don't check the strictness operator here.
+ */
+static bool
+merge_null_partitions(PartitionBoundInfo outer_bi, PartitionBoundInfo inner_bi,
+ PartitionMap *outer_maps, PartitionMap *inner_maps,
+ JoinType jointype, int *next_index,
+ int *null_index, int *default_index)
+{
+ bool outer_has_null = partition_bound_accepts_nulls(outer_bi);
+ bool inner_has_null = partition_bound_accepts_nulls(inner_bi);
+ int outer_ni = outer_bi->null_index;
+ int inner_ni = inner_bi->null_index;
+ int outer_default = outer_bi->default_index;
+ int inner_default = inner_bi->default_index;
+ bool merged = true;
+
+ if (!outer_has_null && !inner_has_null)
+ Assert(*null_index < 0);
+ else if (outer_has_null && !inner_has_null)
+ {
+ int merged_index = -1;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, inner relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the inner relation acts as
+ * INNER relation. For INNER and SEMI join OUTER and INNER
+ * differentiation is immaterial.
+ */
+ missing_side_inner = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_outer = (jointype == JOIN_FULL);
+
+ merged = handle_missing_partition(inner_maps,
+ outer_maps,
+ inner_default,
+ outer_ni,
+ missing_side_outer,
+ missing_side_inner, next_index,
+ default_index, &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join to which the outer null partition maps
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = outer_maps[outer_ni].to;
+ }
+ else if (!outer_has_null && inner_has_null)
+ {
+ int merged_index = -1;
+ bool missing_side_outer;
+ bool missing_side_inner;
+
+ /*
+ * For a FULL join, outer relation acts as both OUTER and INNER
+ * relation. For LEFT and ANTI join the outer relation acts as OUTER
+ * relation. For INNER and SEMI join OUTER and INNER differentiation is
+ * immaterial.
+ */
+ missing_side_outer = (jointype == JOIN_FULL ||
+ jointype == JOIN_LEFT ||
+ jointype == JOIN_ANTI);
+ missing_side_inner = (jointype == JOIN_FULL);
+ merged = handle_missing_partition(outer_maps,
+ inner_maps,
+ outer_default,
+ inner_ni,
+ missing_side_outer,
+ missing_side_inner,
+ next_index, default_index,
+ &merged_index);
+ *null_index = merged_index;
+
+ /*
+ * If the NULL partition was missing from the inner side of the join,
+ * the partition of the join, to which the outer side null partition maps,
+ * will contain the NULL values and thus becomes the NULL partition of
+ * the join.
+ */
+ if (missing_side_inner)
+ *null_index = inner_maps[inner_ni].to;
+ }
+ else
+ {
+ /* Both the relations have NULL partitions, try merging them. */
+ *null_index = map_and_merge_partitions(outer_maps,
+ inner_maps,
+ outer_ni,
+ inner_ni,
+ next_index);
+ if (*null_index < 0)
+ merged = false;
+ }
+
+ return merged;
+}
diff --git a/src/include/partitioning/partbounds.h b/src/include/partitioning/partbounds.h
index c954965e4e..3823ad4cab 100644
--- a/src/include/partitioning/partbounds.h
+++ b/src/include/partitioning/partbounds.h
@@ -16,6 +16,7 @@
#include "nodes/pg_list.h"
#include "partitioning/partdefs.h"
#include "utils/relcache.h"
+struct RelOptInfo; /* avoid including pathnodes.h here */
/*
@@ -109,5 +110,11 @@ extern int partition_range_datum_bsearch(FmgrInfo *partsupfunc,
int nvalues, Datum *values, bool *is_equal);
extern int partition_hash_bsearch(PartitionBoundInfo boundinfo,
int modulus, int remainder);
+extern PartitionBoundInfo partition_bounds_merge(int partnatts,
+ FmgrInfo *partsupfunc, Oid *partcollation,
+ struct RelOptInfo *outer_rel,
+ struct RelOptInfo *inner_rel,
+ JoinType jointype, List **outer_parts,
+ List **inner_parts);
#endif /* PARTBOUNDS_H */
--
2.18.0
[application/octet-stream] 0001-Hash-partition-bound-equality-refactoring-v21.patch (5.1K, ../../CAAJ_b94cHo4GE45ysV73A+gdoLnMnTivzkMeKX3U3=RoDyFoDQ@mail.gmail.com/4-0001-Hash-partition-bound-equality-refactoring-v21.patch)
download | inline diff:
From df87e688e0a9ac1f0b4820a3e5b920a08fe3196b Mon Sep 17 00:00:00 2001
From: Etsuro Fujita <efujita@postgresql.org>
Date: Thu, 31 Jan 2019 19:18:18 +0900
Subject: [PATCH 1/3] Hash partition bound equality refactoring.
Separate the code to check whether two given hash bounds are equal into a
separate function, so that it can be called from multiple places. Right now
it's only caller is partition_bounds_equal() but later we will use it for
merging partition bounds.
Ashutosh Bapat, reviewed by Dmitry Dolgov
---
src/backend/partitioning/partbounds.c | 95 +++++++++++++++++----------
1 file changed, 61 insertions(+), 34 deletions(-)
diff --git a/src/backend/partitioning/partbounds.c b/src/backend/partitioning/partbounds.c
index 0e33a370c6..35c03f611a 100644
--- a/src/backend/partitioning/partbounds.c
+++ b/src/backend/partitioning/partbounds.c
@@ -108,6 +108,9 @@ static void get_range_key_properties(PartitionKey key, int keynum,
Expr **keyCol,
Const **lower_val, Const **upper_val);
static List *get_range_nulltest(PartitionKey key);
+static bool partition_hbounds_equal(PartitionBoundInfo b1,
+ PartitionBoundInfo b2);
+
/*
* get_qual_from_partbound
@@ -656,6 +659,63 @@ create_range_bounds(PartitionBoundSpec **boundspecs, int nparts,
return boundinfo;
}
+/*
+ * Are two hash partition bound collections logically equal?
+ *
+ * Hash partition bounds store modulus and remainder in datums array which are
+ * always integers irrespective of the number of partition keys and their data
+ * types. Hence we can compare the hash bound collection without any partition
+ * key specific information. Separating this logic in a function which does not
+ * require partition key specific information allows it be called from places
+ * where the partition key specific information is not completely available.
+ */
+static bool
+partition_hbounds_equal(PartitionBoundInfo b1, PartitionBoundInfo b2)
+{
+ int greatest_modulus = get_hash_partition_greatest_modulus(b1);
+ int i;
+
+ Assert(b1->strategy == PARTITION_STRATEGY_HASH &&
+ b2->strategy == PARTITION_STRATEGY_HASH);
+
+ /*
+ * If two hash partitioned tables have different greatest moduli,
+ * their partition schemes don't match. For hash partitioned table,
+ * the greatest modulus is given by the last datum and number of
+ * partitions is given by ndatums.
+ */
+ if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ return false;
+
+ /*
+ * We arrange the partitions in the ascending order of their modulus and
+ * remainders. Also every modulus is factor of next larger modulus.
+ * Therefore we can safely store index of a given partition in indexes
+ * array at remainder of that partition. Also entries at (remainder + N *
+ * modulus) positions in indexes array are all same for (modulus,
+ * remainder) specification for any partition. Thus datums array from both
+ * the given bounds are same, if and only if their indexes array will be
+ * same. So, it suffices to compare indexes array.
+ */
+ for (i = 0; i < greatest_modulus; i++)
+ if (b1->indexes[i] != b2->indexes[i])
+ return false;
+
+#ifdef USE_ASSERT_CHECKING
+
+ /*
+ * Nonetheless make sure that the bounds are indeed same when the indexes
+ * match. Hash partition bound stores modulus and remainder at
+ * b1->datums[i][0] and b1->datums[i][1] position respectively.
+ */
+ for (i = 0; i < b1->ndatums; i++)
+ Assert((b1->datums[i][0] == b2->datums[i][0] &&
+ b1->datums[i][1] == b2->datums[i][1]));
+#endif
+
+ return true;
+}
+
/*
* Are two partition bound collections logically equal?
*
@@ -684,41 +744,8 @@ partition_bounds_equal(int partnatts, int16 *parttyplen, bool *parttypbyval,
if (b1->strategy == PARTITION_STRATEGY_HASH)
{
- int greatest_modulus = get_hash_partition_greatest_modulus(b1);
-
- /*
- * If two hash partitioned tables have different greatest moduli,
- * their partition schemes don't match.
- */
- if (greatest_modulus != get_hash_partition_greatest_modulus(b2))
+ if (!partition_hbounds_equal(b1, b2))
return false;
-
- /*
- * We arrange the partitions in the ascending order of their moduli
- * and remainders. Also every modulus is factor of next larger
- * modulus. Therefore we can safely store index of a given partition
- * in indexes array at remainder of that partition. Also entries at
- * (remainder + N * modulus) positions in indexes array are all same
- * for (modulus, remainder) specification for any partition. Thus
- * datums array from both the given bounds are same, if and only if
- * their indexes array will be same. So, it suffices to compare
- * indexes array.
- */
- for (i = 0; i < greatest_modulus; i++)
- if (b1->indexes[i] != b2->indexes[i])
- return false;
-
-#ifdef USE_ASSERT_CHECKING
-
- /*
- * Nonetheless make sure that the bounds are indeed same when the
- * indexes match. Hash partition bound stores modulus and remainder
- * at b1->datums[i][0] and b1->datums[i][1] position respectively.
- */
- for (i = 0; i < b1->ndatums; i++)
- Assert((b1->datums[i][0] == b2->datums[i][0] &&
- b1->datums[i][1] == b2->datums[i][1]));
-#endif
}
else
{
--
2.18.0
[application/octet-stream] 0003-Tests-for-0-1-1-1-and-1-0-partition-matching-v21.patch (213.4K, ../../CAAJ_b94cHo4GE45ysV73A+gdoLnMnTivzkMeKX3U3=RoDyFoDQ@mail.gmail.com/5-0003-Tests-for-0-1-1-1-and-1-0-partition-matching-v21.patch)
download | inline diff:
From 512ae6f3ec4788d7453f2df56f8b8fd437d928ee Mon Sep 17 00:00:00 2001
From: Amul Sul <amul.sul@enterprisedb.com>
Date: Wed, 24 Apr 2019 05:28:25 -0400
Subject: [PATCH 3/3] Tests for 0:1, 1:1 and 1:0 partition matching
Rajkumar Raghuvanshi and Ashutosh Bapat.
---
src/test/regress/expected/partition_join.out | 3944 +++++++++++++++---
src/test/regress/sql/partition_join.sql | 427 +-
2 files changed, 3751 insertions(+), 620 deletions(-)
diff --git a/src/test/regress/expected/partition_join.out b/src/test/regress/expected/partition_join.out
index 1296edcdae..d26be918aa 100644
--- a/src/test/regress/expected/partition_join.out
+++ b/src/test/regress/expected/partition_join.out
@@ -8,59 +8,86 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(21 rows)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
-(4 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+(7 rows)
-- left outer join, with whole-row reference; partitionwise join does not apply
EXPLAIN (COSTS OFF)
@@ -72,35 +99,50 @@ SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(22 rows)
SELECT t1, t2 FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- t1 | t2
---------------+--------------
- (0,0,0000) | (0,0,0000)
- (50,0,0050) |
- (100,0,0100) |
- (150,0,0150) | (0,150,0150)
- (200,0,0200) |
- (250,0,0250) |
- (300,0,0300) | (0,300,0300)
- (350,0,0350) |
- (400,0,0400) |
- (450,0,0450) | (0,450,0450)
- (500,0,0500) |
- (550,0,0550) |
-(12 rows)
+ t1 | t2
+----------------+----------------
+ (-250,0,-0250) |
+ (-200,0,-0200) |
+ (-150,0,-0150) | (0,-150,-0150)
+ (-100,0,-0100) |
+ (-50,0,-0050) |
+ (0,0,0000) | (0,0,0000)
+ (50,0,0050) |
+ (100,0,0100) |
+ (150,0,0150) | (0,150,0150)
+ (200,0,0200) |
+ (250,0,0250) |
+ (300,0,0300) | (0,300,0300)
+ (350,0,0350) |
+ (400,0,0400) |
+ (450,0,0450) | (0,450,0450)
+ (500,0,0500) |
+ (550,0,0550) |
+ (600,0,0600) | (0,600,0600)
+ (650,0,0650) |
+ (700,0,0700) |
+ (750,0,0750) | (0,750,0750)
+(21 rows)
-- right outer join
EXPLAIN (COSTS OFF)
@@ -112,35 +154,53 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHE
-> Append
-> Hash Right Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Right Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Hash Right Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-> Nested Loop Left Join
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p3 t2_3
Filter: (a = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t2_2.b)
-(20 rows)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(32 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | 0 | 0000
- 150 | 0150 | 150 | 0150
- 300 | 0300 | 300 | 0300
- 450 | 0450 | 450 | 0450
- | | 75 | 0075
- | | 225 | 0225
- | | 375 | 0375
- | | 525 | 0525
-(8 rows)
+ a | c | b | c
+------+-------+------+-------
+ -150 | -0150 | -150 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 150 | 0150
+ 300 | 0300 | 300 | 0300
+ 450 | 0450 | 450 | 0450
+ 600 | 0600 | 600 | 0600
+ 750 | 0750 | 750 | 0750
+ | | -225 | -0225
+ | | -75 | -0075
+ | | 75 | 0075
+ | | 225 | 0225
+ | | 375 | 0375
+ | | 525 | 0525
+ | | 675 | 0675
+(14 rows)
-- full outer join, with placeholder vars
EXPLAIN (COSTS OFF)
@@ -148,8 +208,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
QUERY PLAN
------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b
+ Sort Key: prt1_p0.a, prt2_p0.b
-> Append
+ -> Hash Full Join
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ Filter: (((50) = prt1_p0.a) OR ((75) = prt2_p0.b))
+ -> Seq Scan on prt1_p0
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p1.a = prt2_p1.b)
Filter: (((50) = prt1_p1.a) OR ((75) = prt2_p1.b))
@@ -174,7 +242,15 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0)
-> Hash
-> Seq Scan on prt2_p3
Filter: (a = 0)
-(27 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ Filter: (((50) = prt1_p4.a) OR ((75) = prt2_p4.b))
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+(43 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b) WHERE t1.phv = t1.a OR t2.phv = t2.b ORDER BY t1.a, t2.b;
a | c | b | c
@@ -211,35 +287,44 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JO
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p2.b
+ Sort Key: prt1_p0.a, prt2_p2.b
-> Hash Right Join
- Hash Cond: (prt2_p2.b = prt1_p1.a)
+ Hash Cond: (prt2_p2.b = prt1_p0.a)
-> Append
-> Seq Scan on prt2_p2
Filter: (b > 250)
-> Seq Scan on prt2_p3
Filter: (b > 250)
+ -> Seq Scan on prt2_p4
+ Filter: (b > 250)
-> Hash
-> Append
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
-> Seq Scan on prt1_p1
Filter: ((a < 450) AND (b = 0))
-> Seq Scan on prt1_p2
Filter: ((a < 450) AND (b = 0))
-(15 rows)
+(19 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
-(9 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+(14 rows)
-- Currently we can't do partitioned join if nullable-side partitions are pruned
EXPLAIN (COSTS OFF)
@@ -247,11 +332,13 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JO
QUERY PLAN
------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p2.b
+ Sort Key: prt1_p0.a, prt2_p2.b
-> Hash Full Join
- Hash Cond: (prt1_p1.a = prt2_p2.b)
- Filter: ((prt1_p1.b = 0) OR (prt2_p2.a = 0))
+ Hash Cond: (prt1_p0.a = prt2_p2.b)
+ Filter: ((prt1_p0.b = 0) OR (prt2_p2.a = 0))
-> Append
+ -> Seq Scan on prt1_p0
+ Filter: (a < 450)
-> Seq Scan on prt1_p1
Filter: (a < 450)
-> Seq Scan on prt1_p2
@@ -262,64 +349,147 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JO
Filter: (b > 250)
-> Seq Scan on prt2_p3
Filter: (b > 250)
-(16 rows)
+ -> Seq Scan on prt2_p4
+ Filter: (b > 250)
+(20 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a < 450) t1 FULL JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 OR t2.a = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+------+-----+------
- 0 | 0000 | |
- 50 | 0050 | |
- 100 | 0100 | |
- 150 | 0150 | |
- 200 | 0200 | |
- 250 | 0250 | |
- 300 | 0300 | 300 | 0300
- 350 | 0350 | |
- 400 | 0400 | |
- | | 375 | 0375
- | | 450 | 0450
- | | 525 | 0525
-(12 rows)
+ a | c | b | c
+------+-------+-----+------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | |
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | |
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | |
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 300 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ | | 375 | 0375
+ | | 450 | 0450
+ | | 525 | 0525
+ | | 600 | 0600
+ | | 675 | 0675
+ | | 750 | 0750
+(20 rows)
-- Semi-join
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
---------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Hash Semi Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
-> Hash Semi Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Nested Loop Semi Join
- Join Filter: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Materialize
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
Filter: (a = 0)
-(24 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(39 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p0 t2
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_2.b = t2_2.a)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p2 t2_2
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: (t1_3.b = t2_3.a)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt1_p3 t2_3
+ Filter: (b = 0)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.b = t2_4.a)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p4 t2_4
+ Filter: (b = 0)
+(37 rows)
+
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
@@ -330,27 +500,82 @@ SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS
-> Append
-> Hash Anti Join
Hash Cond: (t1.a = t2.b)
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash Anti Join
Hash Cond: (t1_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash Anti Join
Hash Cond: (t1_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt2_p3 t2_2
-(17 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash Anti Join
+ Hash Cond: (t1_3.a = t2_3.b)
+ -> Seq Scan on prt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t2_3
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(27 rows)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
- sum | avg | sum | avg
--------+----------------------+------+---------------------
- 60000 | 300.0000000000000000 | 2400 | 12.0000000000000000
+ sum | avg | sum | avg
+-------+----------------------+------+--------------------
+ 95550 | 273.0000000000000000 | 2200 | 6.2857142857142857
(1 row)
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ QUERY PLAN
+--------------------------------------------------------------
+ Append
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Hash Anti Join
+ Hash Cond: (t1_1.b = t2_1.a)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_p1 t2_1
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(27 rows)
+
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+ b | c
+------+-------
+ -225 | -0225
+ -75 | -0075
+ 75 | 0075
+ 225 | 0225
+ 375 | 0375
+ 525 | 0525
+ 675 | 0675
+(7 rows)
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -362,49 +587,74 @@ SELECT * FROM prt1 t1 LEFT JOIN LATERAL
Sort Key: t1.a
-> Append
-> Nested Loop Left Join
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p1_a on prt1_p1 t2
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
Index Cond: (a = t1.a)
- -> Index Scan using iprt2_p1_b on prt2_p1 t3
+ -> Index Scan using iprt2_p0_b on prt2_p0 t3
Index Cond: (b = t2.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_1
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
Index Cond: (a = t1_1.a)
- -> Index Scan using iprt2_p2_b on prt2_p2 t3_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t3_1
Index Cond: (b = t2_1.a)
-> Nested Loop Left Join
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Nested Loop
- -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_2
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
Index Cond: (a = t1_2.a)
- -> Index Scan using iprt2_p3_b on prt2_p3 t3_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t3_2
Index Cond: (b = t2_2.a)
-(27 rows)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.a)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t3_3
+ Index Cond: (b = t2_3.a)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.a)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t3_4
+ Index Cond: (b = t2_4.a)
+(43 rows)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, least(t1.a,t2.a,t3.b) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.a = ss.t2a WHERE t1.b = 0 ORDER BY t1.a;
- a | b | c | t2a | t3a | least
------+---+------+-----+-----+-------
- 0 | 0 | 0000 | 0 | 0 | 0
- 50 | 0 | 0050 | | |
- 100 | 0 | 0100 | | |
- 150 | 0 | 0150 | 150 | 0 | 150
- 200 | 0 | 0200 | | |
- 250 | 0 | 0250 | | |
- 300 | 0 | 0300 | 300 | 0 | 300
- 350 | 0 | 0350 | | |
- 400 | 0 | 0400 | | |
- 450 | 0 | 0450 | 450 | 0 | 450
- 500 | 0 | 0500 | | |
- 550 | 0 | 0550 | | |
-(12 rows)
+ a | b | c | t2a | t3a | least
+------+---+-------+------+-----+-------
+ -250 | 0 | -0250 | | |
+ -200 | 0 | -0200 | | |
+ -150 | 0 | -0150 | -150 | 0 | -150
+ -100 | 0 | -0100 | | |
+ -50 | 0 | -0050 | | |
+ 0 | 0 | 0000 | 0 | 0 | 0
+ 50 | 0 | 0050 | | |
+ 100 | 0 | 0100 | | |
+ 150 | 0 | 0150 | 150 | 0 | 150
+ 200 | 0 | 0200 | | |
+ 250 | 0 | 0250 | | |
+ 300 | 0 | 0300 | 300 | 0 | 300
+ 350 | 0 | 0350 | | |
+ 400 | 0 | 0400 | | |
+ 450 | 0 | 0450 | 450 | 0 | 450
+ 500 | 0 | 0500 | | |
+ 550 | 0 | 0550 | | |
+ 600 | 0 | 0600 | 600 | 0 | 600
+ 650 | 0 | 0650 | | |
+ 700 | 0 | 0700 | | |
+ 750 | 0 | 0750 | 750 | 0 | 750
+(21 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
@@ -418,64 +668,95 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
Hash Cond: ((t1.c)::text = (t2.c)::text)
Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Hash Join
Hash Cond: (t2.a = t3.b)
- -> Seq Scan on prt1_p1 t2
+ -> Seq Scan on prt1_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t3
+ -> Seq Scan on prt2_p0 t3
-> Hash Join
Hash Cond: (t2_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t2_1
+ -> Seq Scan on prt1_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t3_1
+ -> Seq Scan on prt2_p1 t3_1
-> Hash Join
Hash Cond: (t2_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p2 t2_2
-> Hash
- -> Seq Scan on prt2_p3 t3_2
-(26 rows)
+ -> Seq Scan on prt2_p2 t3_2
+ -> Hash Join
+ Hash Cond: (t2_3.a = t3_3.b)
+ -> Seq Scan on prt1_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt2_p3 t3_3
+ -> Hash Join
+ Hash Cond: (t2_4.a = t3_4.b)
+ -> Seq Scan on prt1_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t3_4
+(38 rows)
SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
(SELECT t2.a AS t2a, t3.a AS t3a, t2.b t2b, t2.c t2c, least(t1.a,t2.a,t3.a) FROM prt1 t2 JOIN prt2 t3 ON (t2.a = t3.b)) ss
ON t1.c = ss.t2c WHERE (t1.b + coalesce(ss.t2b, 0)) = 0 ORDER BY t1.a;
- a | t2a | t2c
------+-----+------
- 0 | 0 | 0000
- 50 | |
- 100 | |
- 150 | 150 | 0150
- 200 | |
- 250 | |
- 300 | 300 | 0300
- 350 | |
- 400 | |
- 450 | 450 | 0450
- 500 | |
- 550 | |
-(12 rows)
+ a | t2a | t2c
+------+------+-------
+ -250 | |
+ -200 | |
+ -150 | -150 | -0150
+ -100 | |
+ -50 | |
+ 0 | 0 | 0000
+ 50 | |
+ 100 | |
+ 150 | 150 | 0150
+ 200 | |
+ 250 | |
+ 300 | 300 | 0300
+ 350 | |
+ 400 | |
+ 450 | 450 | 0450
+ 500 | |
+ 550 | |
+ 600 | 600 | 0600
+ 650 | |
+ 700 | |
+ 750 | 750 | 0750
+(21 rows)
--
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
@@ -486,32 +767,49 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 =
-> Append
-> Hash Join
Hash Cond: (((t2.b + t2.a) / 2) = ((t1.a + t1.b) / 2))
- -> Seq Scan on prt2_e_p1 t2
+ -> Seq Scan on prt2_e_p0 t2
-> Hash
- -> Seq Scan on prt1_e_p1 t1
+ -> Seq Scan on prt1_e_p0 t1
Filter: (c = 0)
-> Hash Join
- Hash Cond: (((t2_1.b + t2_1.a) / 2) = ((t1_1.a + t1_1.b) / 2))
- -> Seq Scan on prt2_e_p2 t2_1
+ Hash Cond: (((t1_1.a + t1_1.b) / 2) = ((t2_1.b + t2_1.a) / 2))
+ -> Seq Scan on prt1_e_p1 t1_1
+ Filter: (c = 0)
-> Hash
- -> Seq Scan on prt1_e_p2 t1_1
- Filter: (c = 0)
+ -> Seq Scan on prt2_e_p1 t2_1
-> Hash Join
Hash Cond: (((t2_2.b + t2_2.a) / 2) = ((t1_2.a + t1_2.b) / 2))
- -> Seq Scan on prt2_e_p3 t2_2
+ -> Seq Scan on prt2_e_p2 t2_2
-> Hash
- -> Seq Scan on prt1_e_p3 t1_2
+ -> Seq Scan on prt1_e_p2 t1_2
Filter: (c = 0)
-(21 rows)
+ -> Hash Join
+ Hash Cond: (((t2_3.b + t2_3.a) / 2) = ((t1_3.a + t1_3.b) / 2))
+ -> Seq Scan on prt2_e_p3 t2_3
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t1_3
+ Filter: (c = 0)
+ -> Hash Join
+ Hash Cond: (((t2_4.b + t2_4.a) / 2) = ((t1_4.a + t1_4.b) / 2))
+ -> Seq Scan on prt2_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_4
+ Filter: (c = 0)
+(33 rows)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_e t1, prt2_e t2 WHERE (t1.a + t1.b)/2 = (t2.b + t2.a)/2 AND t1.c = 0 ORDER BY t1.a, t2.b;
- a | c | b | c
------+---+-----+---
- 0 | 0 | 0 | 0
- 150 | 0 | 150 | 0
- 300 | 0 | 300 | 0
- 450 | 0 | 450 | 0
-(4 rows)
+ a | c | b | c
+------+---+------+---
+ -250 | 0 | -250 | 0
+ -100 | 0 | -100 | 0
+ 0 | 0 | 0 | 0
+ 0 | 0 | 0 | 0
+ 150 | 0 | 150 | 0
+ 300 | 0 | 300 | 0
+ 450 | 0 | 450 | 0
+ 600 | 0 | 600 | 0
+ 750 | 0 | 750 | 0
+(9 rows)
--
-- N-way join
@@ -524,154 +822,232 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = ((t3.a + t3.b) / 2))
+ Join Filter: (t1.a = t2.b)
-> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p1_ab2 on prt1_e_p1 t3
- Index Cond: (((a + b) / 2) = t2.b)
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
+ Index Cond: (b = ((t3.a + t3.b) / 2))
-> Nested Loop
Join Filter: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
-> Hash Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_1
+ -> Index Scan using iprt1_e_p4_ab2 on prt1_e_p1 t3_1
Index Cond: (((a + b) / 2) = t2_1.b)
-> Nested Loop
Join Filter: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
-> Hash Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t3_2
Index Cond: (((a + b) / 2) = t2_2.b)
-(33 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = ((t3_3.a + t3_3.b) / 2))
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (((a + b) / 2) = t2_3.b)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t2_4.b)
+ -> Hash Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (b = ((t3_4.a + t3_4.b) / 2))
+(52 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM prt1 t1, prt2 t2, prt1_e t3 WHERE t1.a = t2.b AND t1.a = (t3.a + t3.b)/2 AND t1.b = 0 ORDER BY t1.a, t2.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
-(4 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(8 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
---------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Hash Right Join
Hash Cond: (((t3.a + t3.b) / 2) = t1.a)
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
-> Hash
-> Hash Right Join
Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Hash
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_1.a + t3_1.b) / 2) = t1_1.a)
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
-> Hash
-> Hash Right Join
Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Hash
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Hash Right Join
Hash Cond: (((t3_2.a + t3_2.b) / 2) = t1_2.a)
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
-> Hash
-> Hash Right Join
Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
-> Hash
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(33 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t3_3
+ Index Cond: (((a + b) / 2) = t1_3.a)
+ -> Hash Right Join
+ Hash Cond: (((t3_4.a + t3_4.b) / 2) = t1_4.a)
+ -> Seq Scan on prt1_e_p4 t3_4
+ -> Hash
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(51 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) LEFT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.b = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- QUERY PLAN
--------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------
Sort
Sort Key: t1.a, t2.b, ((t3.a + t3.b))
-> Append
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1.a = ((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Hash
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
+ -> Index Scan using iprt2_p0_b on prt2_p0 t2
Index Cond: (b = t1.a)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_1.a = ((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Hash
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
+ -> Index Scan using iprt2_p1_b on prt2_p1 t2_1
Index Cond: (b = t1_1.a)
-> Nested Loop Left Join
-> Hash Right Join
Hash Cond: (t1_2.a = ((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Hash
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
+ -> Index Scan using iprt2_p2_b on prt2_p2 t2_2
Index Cond: (b = t1_2.a)
-(30 rows)
+ -> Nested Loop Left Join
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t3_3.a + t3_3.b) / 2))
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Nested Loop Left Join
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = ((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Index Scan using iprt2_p4_b on prt2_p4 t2_4
+ Index Cond: (b = t1_4.a)
+(47 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- Cases with non-nullable expressions in subquery results;
-- make sure these go to null as expected
@@ -680,21 +1056,34 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
QUERY PLAN
----------------------------------------------------------------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p1.b, ((prt1_e_p1.a + prt1_e_p1.b))
+ Sort Key: prt1_p0.a, prt2_p0.b, ((prt1_e_p0.a + prt1_e_p0.b))
-> Append
-> Hash Full Join
- Hash Cond: (prt1_p1.a = ((prt1_e_p1.a + prt1_e_p1.b) / 2))
- Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ Hash Cond: (prt1_p0.a = ((prt1_e_p0.a + prt1_e_p0.b) / 2))
+ Filter: ((prt1_p0.a = (50)) OR (prt2_p0.b = (75)) OR (((prt1_e_p0.a + prt1_e_p0.b) / 2) = (50)))
-> Hash Full Join
- Hash Cond: (prt1_p1.a = prt2_p1.b)
- -> Seq Scan on prt1_p1
+ Hash Cond: (prt1_p0.a = prt2_p0.b)
+ -> Seq Scan on prt1_p0
Filter: (b = 0)
-> Hash
- -> Seq Scan on prt2_p1
+ -> Seq Scan on prt2_p0
Filter: (a = 0)
-> Hash
- -> Seq Scan on prt1_e_p1
+ -> Seq Scan on prt1_e_p0
Filter: (c = 0)
+ -> Hash Full Join
+ Hash Cond: (((prt1_e_p1.a + prt1_e_p1.b) / 2) = prt1_p1.a)
+ Filter: ((prt1_p1.a = (50)) OR (prt2_p1.b = (75)) OR (((prt1_e_p1.a + prt1_e_p1.b) / 2) = (50)))
+ -> Seq Scan on prt1_e_p1
+ Filter: (c = 0)
+ -> Hash
+ -> Hash Full Join
+ Hash Cond: (prt1_p1.a = prt2_p1.b)
+ -> Seq Scan on prt1_p1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1
+ Filter: (a = 0)
-> Hash Full Join
Hash Cond: (prt1_p2.a = ((prt1_e_p2.a + prt1_e_p2.b) / 2))
Filter: ((prt1_p2.a = (50)) OR (prt2_p2.b = (75)) OR (((prt1_e_p2.a + prt1_e_p2.b) / 2) = (50)))
@@ -721,7 +1110,20 @@ SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * F
-> Hash
-> Seq Scan on prt1_e_p3
Filter: (c = 0)
-(42 rows)
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = ((prt1_e_p4.a + prt1_e_p4.b) / 2))
+ Filter: ((prt1_p4.a = (50)) OR (prt2_p4.b = (75)) OR (((prt1_e_p4.a + prt1_e_p4.b) / 2) = (50)))
+ -> Hash Full Join
+ Hash Cond: (prt1_p4.a = prt2_p4.b)
+ -> Seq Scan on prt1_p4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4
+ Filter: (a = 0)
+ -> Hash
+ -> Seq Scan on prt1_e_p4
+ Filter: (c = 0)
+(68 rows)
SELECT t1.a, t1.phv, t2.b, t2.phv, t3.a + t3.b, t3.phv FROM ((SELECT 50 phv, * FROM prt1 WHERE prt1.b = 0) t1 FULL JOIN (SELECT 75 phv, * FROM prt2 WHERE prt2.a = 0) t2 ON (t1.a = t2.b)) FULL JOIN (SELECT 50 phv, * FROM prt1_e WHERE prt1_e.c = 0) t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t1.a = t1.phv OR t2.b = t2.phv OR (t3.a + t3.b)/2 = t3.phv ORDER BY t1.a, t2.b, t3.a + t3.b;
a | phv | b | phv | ?column? | phv
@@ -739,172 +1141,260 @@ SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHER
Sort Key: t1.a
-> Append
-> Nested Loop
- Join Filter: (t1.a = t1_3.b)
+ Join Filter: (t1.a = t1_5.b)
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Join
- Hash Cond: (((t2.a + t2.b) / 2) = t1_3.b)
- -> Seq Scan on prt1_e_p1 t2
+ Hash Cond: (((t2.a + t2.b) / 2) = t1_5.b)
+ -> Seq Scan on prt1_e_p0 t2
-> Hash
- -> Seq Scan on prt2_p1 t1_3
+ -> Seq Scan on prt2_p0 t1_5
Filter: (a = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
Index Cond: (a = ((t2.a + t2.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_1.a = t1_4.b)
+ Join Filter: (t1_1.a = t1_6.b)
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Join
- Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_4.b)
- -> Seq Scan on prt1_e_p2 t2_1
+ Hash Cond: (((t2_1.a + t2_1.b) / 2) = t1_6.b)
+ -> Seq Scan on prt1_e_p1 t2_1
-> Hash
- -> Seq Scan on prt2_p2 t1_4
+ -> Seq Scan on prt2_p1 t1_6
Filter: (a = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
Index Cond: (a = ((t2_1.a + t2_1.b) / 2))
Filter: (b = 0)
-> Nested Loop
- Join Filter: (t1_2.a = t1_5.b)
+ Join Filter: (t1_2.a = t1_7.b)
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Nested Loop
- -> Seq Scan on prt2_p3 t1_5
+ -> Seq Scan on prt2_p2 t1_7
Filter: (a = 0)
- -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_2
- Index Cond: (((a + b) / 2) = t1_5.b)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
+ -> Index Scan using iprt1_e_p2_ab2 on prt1_e_p2 t2_2
+ Index Cond: (((a + b) / 2) = t1_7.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
Index Cond: (a = ((t2_2.a + t2_2.b) / 2))
Filter: (b = 0)
-(41 rows)
+ -> Nested Loop
+ Join Filter: (t1_3.a = t1_8.b)
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t1_8
+ Filter: (a = 0)
+ -> Index Scan using iprt1_e_p3_ab2 on prt1_e_p3 t2_3
+ Index Cond: (((a + b) / 2) = t1_8.b)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = ((t2_3.a + t2_3.b) / 2))
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: (t1_4.a = t1_9.b)
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Join
+ Hash Cond: (((t2_4.a + t2_4.b) / 2) = t1_9.b)
+ -> Seq Scan on prt1_e_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t1_9
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = ((t2_4.a + t2_4.b) / 2))
+ Filter: (b = 0)
+(66 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1, prt1_e t2 WHERE t1.a = 0 AND t1.b = (t2.a + t2.b)/2) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
--------------------------------------------------------------------------
+ QUERY PLAN
+---------------------------------------------------------------------------
Sort
Sort Key: t1.a
-> Append
-> Nested Loop
-> HashAggregate
- Group Key: t1_3.b
+ Group Key: t1_5.b
-> Hash Semi Join
- Hash Cond: (t1_3.b = ((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt2_p1 t1_3
+ Hash Cond: (t1_5.b = ((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt2_p0 t1_5
-> Hash
- -> Seq Scan on prt1_e_p1 t1_6
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
- -> Index Scan using iprt1_p1_a on prt1_p1 t1
- Index Cond: (a = t1_3.b)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t1_5.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_4.b
+ Group Key: t1_6.b
-> Hash Semi Join
- Hash Cond: (t1_4.b = ((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt2_p2 t1_4
+ Hash Cond: (t1_6.b = ((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt2_p1 t1_6
-> Hash
- -> Seq Scan on prt1_e_p2 t1_7
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
- -> Index Scan using iprt1_p2_a on prt1_p2 t1_1
- Index Cond: (a = t1_4.b)
+ -> Index Scan using iprt1_p1_a on prt1_p1 t1_1
+ Index Cond: (a = t1_6.b)
Filter: (b = 0)
-> Nested Loop
-> HashAggregate
- Group Key: t1_5.b
+ Group Key: t1_7.b
-> Hash Semi Join
- Hash Cond: (t1_5.b = ((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt2_p3 t1_5
+ Hash Cond: (t1_7.b = ((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt2_p2 t1_7
-> Hash
- -> Seq Scan on prt1_e_p3 t1_8
+ -> Seq Scan on prt1_e_p2 t1_12
Filter: (c = 0)
- -> Index Scan using iprt1_p3_a on prt1_p3 t1_2
- Index Cond: (a = t1_5.b)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t1_7.b)
Filter: (b = 0)
-(39 rows)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_8.b
+ -> Hash Semi Join
+ Hash Cond: (t1_8.b = ((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt2_p3 t1_8
+ -> Hash
+ -> Seq Scan on prt1_e_p3 t1_13
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t1_8.b)
+ Filter: (b = 0)
+ -> Nested Loop
+ -> HashAggregate
+ Group Key: t1_9.b
+ -> Hash Semi Join
+ Hash Cond: (t1_9.b = ((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt2_p4 t1_9
+ -> Hash
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+ -> Index Scan using iprt1_p4_a on prt1_p4 t1_4
+ Index Cond: (a = t1_9.b)
+ Filter: (b = 0)
+(63 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
-- test merge joins
SET enable_hashjoin TO off;
SET enable_nestloop TO off;
EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- QUERY PLAN
-----------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------
Merge Append
Sort Key: t1.a
-> Merge Semi Join
- Merge Cond: (t1.a = t1_3.b)
+ Merge Cond: (t1.a = t1_5.b)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_3.b = (((t1_6.a + t1_6.b) / 2)))
+ Merge Cond: (t1_5.b = (((t1_10.a + t1_10.b) / 2)))
-> Sort
- Sort Key: t1_3.b
- -> Seq Scan on prt2_p1 t1_3
+ Sort Key: t1_5.b
+ -> Seq Scan on prt2_p0 t1_5
-> Sort
- Sort Key: (((t1_6.a + t1_6.b) / 2))
- -> Seq Scan on prt1_e_p1 t1_6
+ Sort Key: (((t1_10.a + t1_10.b) / 2))
+ -> Seq Scan on prt1_e_p0 t1_10
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_1.a = t1_4.b)
+ Merge Cond: (t1_1.a = t1_6.b)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_4.b = (((t1_7.a + t1_7.b) / 2)))
+ Merge Cond: (t1_6.b = (((t1_11.a + t1_11.b) / 2)))
-> Sort
- Sort Key: t1_4.b
- -> Seq Scan on prt2_p2 t1_4
+ Sort Key: t1_6.b
+ -> Seq Scan on prt2_p1 t1_6
-> Sort
- Sort Key: (((t1_7.a + t1_7.b) / 2))
- -> Seq Scan on prt1_e_p2 t1_7
+ Sort Key: (((t1_11.a + t1_11.b) / 2))
+ -> Seq Scan on prt1_e_p1 t1_11
Filter: (c = 0)
-> Merge Semi Join
- Merge Cond: (t1_2.a = t1_5.b)
+ Merge Cond: (t1_2.a = t1_7.b)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-> Merge Semi Join
- Merge Cond: (t1_5.b = (((t1_8.a + t1_8.b) / 2)))
+ Merge Cond: (t1_7.b = (((t1_12.a + t1_12.b) / 2)))
-> Sort
- Sort Key: t1_5.b
- -> Seq Scan on prt2_p3 t1_5
+ Sort Key: t1_7.b
+ -> Seq Scan on prt2_p2 t1_7
-> Sort
- Sort Key: (((t1_8.a + t1_8.b) / 2))
- -> Seq Scan on prt1_e_p3 t1_8
+ Sort Key: (((t1_12.a + t1_12.b) / 2))
+ -> Seq Scan on prt1_e_p2 t1_12
Filter: (c = 0)
-(47 rows)
+ -> Merge Semi Join
+ Merge Cond: (t1_3.a = t1_8.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_8.b = (((t1_13.a + t1_13.b) / 2)))
+ -> Sort
+ Sort Key: t1_8.b
+ -> Seq Scan on prt2_p3 t1_8
+ -> Sort
+ Sort Key: (((t1_13.a + t1_13.b) / 2))
+ -> Seq Scan on prt1_e_p3 t1_13
+ Filter: (c = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_4.a = t1_9.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Merge Semi Join
+ Merge Cond: (t1_9.b = (((t1_14.a + t1_14.b) / 2)))
+ -> Sort
+ Sort Key: t1_9.b
+ -> Seq Scan on prt2_p4 t1_9
+ -> Sort
+ Sort Key: (((t1_14.a + t1_14.b) / 2))
+ -> Seq Scan on prt1_e_p4 t1_14
+ Filter: (c = 0)
+(77 rows)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t1.b FROM prt2 t1 WHERE t1.b IN (SELECT (t1.a + t1.b)/2 FROM prt1_e t1 WHERE t1.c = 0)) AND t1.b = 0 ORDER BY t1.a;
- a | b | c
------+---+------
- 0 | 0 | 0000
- 150 | 0 | 0150
- 300 | 0 | 0300
- 450 | 0 | 0450
-(4 rows)
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
@@ -921,14 +1411,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3.a + t3.b) / 2)) = t1.a)
-> Sort
Sort Key: (((t3.a + t3.b) / 2))
- -> Seq Scan on prt1_e_p1 t3
+ -> Seq Scan on prt1_e_p0 t3
Filter: (c = 0)
-> Sort
Sort Key: t1.a
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
-> Sort
Sort Key: t2.b
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
-> Merge Left Join
Merge Cond: (t1_1.a = t2_1.b)
-> Sort
@@ -937,14 +1427,14 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_1.a + t3_1.b) / 2)) = t1_1.a)
-> Sort
Sort Key: (((t3_1.a + t3_1.b) / 2))
- -> Seq Scan on prt1_e_p2 t3_1
+ -> Seq Scan on prt1_e_p1 t3_1
Filter: (c = 0)
-> Sort
Sort Key: t1_1.a
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
-> Sort
Sort Key: t2_1.b
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
-> Merge Left Join
Merge Cond: (t1_2.a = t2_2.b)
-> Sort
@@ -953,32 +1443,74 @@ SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2
Merge Cond: ((((t3_2.a + t3_2.b) / 2)) = t1_2.a)
-> Sort
Sort Key: (((t3_2.a + t3_2.b) / 2))
- -> Seq Scan on prt1_e_p3 t3_2
+ -> Seq Scan on prt1_e_p2 t3_2
Filter: (c = 0)
-> Sort
Sort Key: t1_2.a
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
-> Sort
Sort Key: t2_2.b
- -> Seq Scan on prt2_p3 t2_2
-(51 rows)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Merge Left Join
+ Merge Cond: (t1_3.a = t2_3.b)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_3.a + t3_3.b) / 2)) = t1_3.a)
+ -> Sort
+ Sort Key: (((t3_3.a + t3_3.b) / 2))
+ -> Seq Scan on prt1_e_p3 t3_3
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_3.a
+ -> Seq Scan on prt1_p3 t1_3
+ -> Sort
+ Sort Key: t2_3.b
+ -> Seq Scan on prt2_p3 t2_3
+ -> Merge Left Join
+ Merge Cond: (t1_4.a = t2_4.b)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Merge Left Join
+ Merge Cond: ((((t3_4.a + t3_4.b) / 2)) = t1_4.a)
+ -> Sort
+ Sort Key: (((t3_4.a + t3_4.b) / 2))
+ -> Seq Scan on prt1_e_p4 t3_4
+ Filter: (c = 0)
+ -> Sort
+ Sort Key: t1_4.a
+ -> Seq Scan on prt1_p4 t1_4
+ -> Sort
+ Sort Key: t2_4.b
+ -> Seq Scan on prt2_p4 t2_4
+(83 rows)
SELECT t1.a, t1.c, t2.b, t2.c, t3.a + t3.b, t3.c FROM (prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b) RIGHT JOIN prt1_e t3 ON (t1.a = (t3.a + t3.b)/2) WHERE t3.c = 0 ORDER BY t1.a, t2.b, t3.a + t3.b;
- a | c | b | c | ?column? | c
------+------+-----+------+----------+---
- 0 | 0000 | 0 | 0000 | 0 | 0
- 50 | 0050 | | | 100 | 0
- 100 | 0100 | | | 200 | 0
- 150 | 0150 | 150 | 0150 | 300 | 0
- 200 | 0200 | | | 400 | 0
- 250 | 0250 | | | 500 | 0
- 300 | 0300 | 300 | 0300 | 600 | 0
- 350 | 0350 | | | 700 | 0
- 400 | 0400 | | | 800 | 0
- 450 | 0450 | 450 | 0450 | 900 | 0
- 500 | 0500 | | | 1000 | 0
- 550 | 0550 | | | 1100 | 0
-(12 rows)
+ a | c | b | c | ?column? | c
+------+-------+------+-------+----------+---
+ -250 | -0250 | | | -500 | 0
+ -200 | -0200 | | | -400 | 0
+ -150 | -0150 | -150 | -0150 | -300 | 0
+ -100 | -0100 | | | -200 | 0
+ -50 | -0050 | | | -100 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 0 | 0000 | 0 | 0000 | 0 | 0
+ 50 | 0050 | | | 100 | 0
+ 100 | 0100 | | | 200 | 0
+ 150 | 0150 | 150 | 0150 | 300 | 0
+ 200 | 0200 | | | 400 | 0
+ 250 | 0250 | | | 500 | 0
+ 300 | 0300 | 300 | 0300 | 600 | 0
+ 350 | 0350 | | | 700 | 0
+ 400 | 0400 | | | 800 | 0
+ 450 | 0450 | 450 | 0450 | 900 | 0
+ 500 | 0500 | | | 1000 | 0
+ 550 | 0550 | | | 1100 | 0
+ 600 | 0600 | 600 | 0600 | 1200 | 0
+ 650 | 0650 | | | 1300 | 0
+ 700 | 0700 | | | 1400 | 0
+ 750 | 0750 | 750 | 0750 | 1500 | 0
+(22 rows)
-- MergeAppend on nullable column
-- This should generate a partitionwise join, but currently fails to
@@ -987,12 +1519,14 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
QUERY PLAN
-----------------------------------------------------------
Sort
- Sort Key: prt1_p1.a, prt2_p2.b
+ Sort Key: prt1_p0.a, prt2_p2.b
-> Merge Left Join
- Merge Cond: (prt1_p1.a = prt2_p2.b)
+ Merge Cond: (prt1_p0.a = prt2_p2.b)
-> Sort
- Sort Key: prt1_p1.a
+ Sort Key: prt1_p0.a
-> Append
+ -> Seq Scan on prt1_p0
+ Filter: ((a < 450) AND (b = 0))
-> Seq Scan on prt1_p1
Filter: ((a < 450) AND (b = 0))
-> Seq Scan on prt1_p2
@@ -1004,21 +1538,28 @@ SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT *
Filter: (b > 250)
-> Seq Scan on prt2_p3
Filter: (b > 250)
-(18 rows)
+ -> Seq Scan on prt2_p4
+ Filter: (b > 250)
+(22 rows)
SELECT t1.a, t2.b FROM (SELECT * FROM prt1 WHERE a < 450) t1 LEFT JOIN (SELECT * FROM prt2 WHERE b > 250) t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a, t2.b;
- a | b
------+-----
- 0 |
- 50 |
- 100 |
- 150 |
- 200 |
- 250 |
- 300 | 300
- 350 |
- 400 |
-(9 rows)
+ a | b
+------+-----
+ -250 |
+ -200 |
+ -150 |
+ -100 |
+ -50 |
+ 0 |
+ 50 |
+ 100 |
+ 150 |
+ 200 |
+ 250 |
+ 300 | 300
+ 350 |
+ 400 |
+(14 rows)
-- merge join when expression with whole-row reference needs to be sorted;
-- partitionwise join does not apply
@@ -1032,30 +1573,797 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
Sort Key: t1.a, ((((t1.*)::prt1))::text)
-> Result
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Sort
Sort Key: t2.b, ((((t2.*)::prt2))::text)
-> Result
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
-(16 rows)
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+(20 rows)
SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.b ORDER BY t1.a;
- a | b
-----+----
- 0 | 0
- 6 | 6
- 12 | 12
- 18 | 18
- 24 | 24
-(5 rows)
+ a | b
+-----+-----
+ -24 | -24
+ -18 | -18
+ -12 | -12
+ -6 | -6
+ 0 | 0
+ 6 | 6
+ 12 | 12
+ 18 | 18
+ 24 | 24
+(9 rows)
RESET enable_hashjoin;
RESET enable_nestloop;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p4 t2_3
+ -> Seq Scan on prt2_p3 t2_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_4
+ Filter: (b = 0)
+(22 rows)
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p1 t2
+ -> Hash
+ -> Seq Scan on prt1_p1 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p2 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p3 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p3 t1_2
+ Filter: (b = 0)
+(21 rows)
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -150 | -0150 | 0 | -0150
+ 0 | 0000 | 0 | 0000
+ 150 | 0150 | 0 | 0150
+ 300 | 0300 | 0 | 0300
+ 450 | 0450 | 0 | 0450
+ 600 | 0600 | 0 | 0600
+ 750 | 0750 | 0 | 0750
+(7 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Seq Scan on prt2_p0 t2
+ -> Hash
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_1.b = t1_1.a)
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash Right Join
+ Hash Cond: (t2_2.b = t1_2.a)
+ -> Seq Scan on prt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Nested Loop Left Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Right Join
+ Hash Cond: (t2_4.b = t1_4.a)
+ -> Seq Scan on prt2_p4 t2_4
+ -> Hash
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(32 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ a | c | a | c
+------+-------+---+-------
+ -250 | -0250 | |
+ -200 | -0200 | |
+ -150 | -0150 | 0 | -0150
+ -100 | -0100 | |
+ -50 | -0050 | |
+ 0 | 0000 | 0 | 0000
+ 50 | 0050 | |
+ 100 | 0100 | |
+ 150 | 0150 | 0 | 0150
+ 200 | 0200 | |
+ 250 | 0250 | |
+ 300 | 0300 | 0 | 0300
+ 350 | 0350 | |
+ 400 | 0400 | |
+ 450 | 0450 | 0 | 0450
+ 500 | 0500 | |
+ 550 | 0550 | |
+ 600 | 0600 | 0 | 0600
+ 650 | 0650 | |
+ 700 | 0700 | |
+ 750 | 0750 | 0 | 0750
+(21 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Semi Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Semi Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Semi Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Append
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t2
+ Index Cond: (a = t1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p1_a on prt1_p1 t2_1
+ Index Cond: (a = t1_1.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t2_2
+ Index Cond: (a = t1_2.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t2_3
+ Index Cond: (a = t1_3.b)
+ -> Nested Loop Semi Join
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Index Only Scan using iprt1_p4_a on prt1_p4 t2_4
+ Index Cond: (a = t1_4.b)
+(28 rows)
+
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+---+------+-------
+ 0 | -150 | -0150
+ 0 | 0 | 0000
+ 0 | 150 | 0150
+ 0 | 300 | 0300
+ 0 | 450 | 0450
+ 0 | 600 | 0600
+ 0 | 750 | 0750
+(7 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p0 t2
+ -> Hash Anti Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ -> Hash Anti Join
+ Hash Cond: (t1_2.a = t2_2.b)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p2 t2_2
+ -> Nested Loop Anti Join
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Index Only Scan using iprt2_p3_b on prt2_p3 t2_3
+ Index Cond: (b = t1_3.a)
+ -> Hash Anti Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+(32 rows)
+
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+------+---+-------
+ -250 | 0 | -0250
+ -200 | 0 | -0200
+ -100 | 0 | -0100
+ -50 | 0 | -0050
+ 50 | 0 | 0050
+ 100 | 0 | 0100
+ 200 | 0 | 0200
+ 250 | 0 | 0250
+ 350 | 0 | 0350
+ 400 | 0 | 0400
+ 500 | 0 | 0500
+ 550 | 0 | 0550
+ 650 | 0 | 0650
+ 700 | 0 | 0700
+(14 rows)
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ QUERY PLAN
+---------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t3.c
+ -> Append
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p0_a on prt1_p0 t3
+ Index Cond: (a = t2.b)
+ -> Index Only Scan using iprt1_p0_a on prt1_p0 t1
+ Index Cond: (a = t2.b)
+ -> Hash Right Join
+ Hash Cond: (t1_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t1_1
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_1.a = t2_1.b)
+ -> Seq Scan on prt1_p1 t3_1
+ -> Hash
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p2_a on prt1_p2 t3_2
+ Index Cond: (a = t2_2.b)
+ -> Index Only Scan using iprt1_p2_a on prt1_p2 t1_2
+ Index Cond: (a = t2_2.b)
+ -> Nested Loop Left Join
+ -> Nested Loop
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Index Scan using iprt1_p3_a on prt1_p3 t3_3
+ Index Cond: (a = t2_3.b)
+ -> Index Only Scan using iprt1_p3_a on prt1_p3 t1_3
+ Index Cond: (a = t2_3.b)
+ -> Hash Right Join
+ Hash Cond: (t1_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Hash Join
+ Hash Cond: (t3_4.a = t2_4.b)
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+(47 rows)
+
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+ a | a | c
+------+---+-------
+ -150 | 0 | -0150
+ 0 | 0 | 0000
+ 150 | 0 | 0150
+ 300 | 0 | 0300
+ 450 | 0 | 0450
+ 600 | 0 | 0600
+ 750 | 0 | 0750
+(7 rows)
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.b
+ -> Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(24 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: (t1.a = t2.b)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.a, 0)) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: (t2.b = t1.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------
+ Hash Right Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t2_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
+ Filter: (a = 0)
+(22 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Join
+ Hash Cond: (t1.a = t2.b)
+ Join Filter: ((t1.b + t2.a) = 0)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(19 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Semi Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.b, t1.c
+ -> Hash Anti Join
+ Hash Cond: (t1.b = t2.a)
+ -> Append
+ -> Seq Scan on prt2_p0 t1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p1 t1_1
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p2 t1_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t1_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t1_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t1_5
+ Filter: (a = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
+(24 rows)
+
--
-- partitioned by multiple columns
--
@@ -1125,82 +2433,1552 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1
--
-- tests for list partitioned tables.
--
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 | 0011
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 470 | 0 | 0011
+(1 row)
+
--
-- list partitioned by expression
--
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
ANALYZE plt1_e;
-- test partition matching with N-way join
EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- QUERY PLAN
---------------------------------------------------------------------------------
+ QUERY PLAN
+------------------------------------------------------------------------------------------------
GroupAggregate
Group Key: t1.c, t2.c, t3.c
-> Sort
Sort Key: t1.c, t3.c
-> Append
-> Hash Join
- Hash Cond: (t1.c = ltrim(t3.c, 'A'::text))
+ Hash Cond: ((t1.c)::text = ltrim(t3.c, 'A'::text))
-> Hash Join
- Hash Cond: ((t1.b = t2.b) AND (t1.c = t2.c))
- -> Seq Scan on plt1_p1 t1
+ Hash Cond: ((t2.b = t1.b) AND ((t2.c)::text = (t1.c)::text))
+ -> Seq Scan on plt2_p4 t2
-> Hash
- -> Seq Scan on plt2_p1 t2
+ -> Seq Scan on plt1_p4 t1
-> Hash
- -> Seq Scan on plt1_e_p1 t3
+ -> Seq Scan on plt1_e_p4 t3
-> Hash Join
- Hash Cond: (t1_1.c = ltrim(t3_1.c, 'A'::text))
+ Hash Cond: ((t1_1.c)::text = ltrim(t3_1.c, 'A'::text))
-> Hash Join
- Hash Cond: ((t1_1.b = t2_1.b) AND (t1_1.c = t2_1.c))
- -> Seq Scan on plt1_p2 t1_1
+ Hash Cond: ((t1_1.b = t2_1.b) AND ((t1_1.c)::text = (t2_1.c)::text))
+ -> Seq Scan on plt1_p1 t1_1
-> Hash
- -> Seq Scan on plt2_p2 t2_1
+ -> Seq Scan on plt2_p1 t2_1
-> Hash
- -> Seq Scan on plt1_e_p2 t3_1
+ -> Seq Scan on plt1_e_p1 t3_1
-> Hash Join
- Hash Cond: (t1_2.c = ltrim(t3_2.c, 'A'::text))
+ Hash Cond: ((t1_2.c)::text = ltrim(t3_2.c, 'A'::text))
-> Hash Join
- Hash Cond: ((t1_2.b = t2_2.b) AND (t1_2.c = t2_2.c))
- -> Seq Scan on plt1_p3 t1_2
+ Hash Cond: ((t1_2.b = t2_2.b) AND ((t1_2.c)::text = (t2_2.c)::text))
+ -> Seq Scan on plt1_p2 t1_2
-> Hash
- -> Seq Scan on plt2_p3 t2_2
+ -> Seq Scan on plt2_p2 t2_2
-> Hash
- -> Seq Scan on plt1_e_p3 t3_2
-(32 rows)
+ -> Seq Scan on plt1_e_p2 t3_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = ltrim(t3_3.c, 'A'::text))
+ -> Hash Join
+ Hash Cond: ((t2_3.b = t1_3.b) AND ((t2_3.c)::text = (t1_3.c)::text))
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt1_e_p3 t3_3
+(41 rows)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
- avg | avg | avg | c | c | c
-----------------------+----------------------+-----------------------+------+------+-------
- 24.0000000000000000 | 24.0000000000000000 | 48.0000000000000000 | 0000 | 0000 | A0000
- 75.0000000000000000 | 75.0000000000000000 | 148.0000000000000000 | 0001 | 0001 | A0001
- 123.0000000000000000 | 123.0000000000000000 | 248.0000000000000000 | 0002 | 0002 | A0002
- 174.0000000000000000 | 174.0000000000000000 | 348.0000000000000000 | 0003 | 0003 | A0003
- 225.0000000000000000 | 225.0000000000000000 | 448.0000000000000000 | 0004 | 0004 | A0004
- 273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
- 324.0000000000000000 | 324.0000000000000000 | 648.0000000000000000 | 0006 | 0006 | A0006
- 375.0000000000000000 | 375.0000000000000000 | 748.0000000000000000 | 0007 | 0007 | A0007
- 423.0000000000000000 | 423.0000000000000000 | 848.0000000000000000 | 0008 | 0008 | A0008
- 474.0000000000000000 | 474.0000000000000000 | 948.0000000000000000 | 0009 | 0009 | A0009
- 525.0000000000000000 | 525.0000000000000000 | 1048.0000000000000000 | 0010 | 0010 | A0010
- 573.0000000000000000 | 573.0000000000000000 | 1148.0000000000000000 | 0011 | 0011 | A0011
-(12 rows)
+ avg | avg | avg | c | c | c
+----------------------+---------------------+----------------------+------+------+------
+ 246.5000000000000000 | 22.4666666666666667 | 268.9666666666666667 | 0000 | 0000 | 0000
+ 248.5000000000000000 | 21.3333333333333333 | 269.8333333333333333 | 0002 | 0002 | 0002
+ 249.5000000000000000 | 22.3333333333333333 | 271.8333333333333333 | 0003 | 0003 | 0003
+ 250.5000000000000000 | 23.3333333333333333 | 273.8333333333333333 | 0004 | 0004 | 0004
+ 251.5000000000000000 | 22.7666666666666667 | 274.2666666666666667 | 0005 | 0005 | 0005
+ 252.5000000000000000 | 22.2000000000000000 | 274.7000000000000000 | 0006 | 0006 | 0006
+ 246.0000000000000000 | 23.9655172413793103 | 269.9655172413793103 | 0008 | 0008 | 0008
+ 247.0000000000000000 | 23.3448275862068966 | 270.3448275862068966 | 0009 | 0009 | 0009
+(8 rows)
+
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt1_p4 t1
+ -> Hash
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 470 | 0011
+ | | 235 | 0014
+(8 rows)
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Seq Scan on plt2_p5 t2_4
+(17 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 47 | 0013
+ | | 235 | 0014
+ | | 470 | 0011
+(10 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 47 | 0 | 0013
+ 235 | 0 | 0014
+ 470 | 0 | 0011
+(3 rows)
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Left Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Right Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(17 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(23 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+----------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Materialize
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p5 t2_1
+ -> Seq Scan on plt2_p1 t2_2
+ -> Seq Scan on plt2_p2 t2_3
+ -> Seq Scan on plt2_p3 t2_4
+(20 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p5 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_4
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(21 rows)
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Join Filter: ((t1_1.b + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Join Filter: ((t1_2.b + t2_2.b) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Join Filter: ((t1_3.b + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(5 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Append
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Right Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((t1_1.b + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((t1_2.b + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Left Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((t1_3.b + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+(7 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+------------------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Append
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Left Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + t2_1.b) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Left Join
+ Hash Cond: ((t2_2.c)::text = (t1_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + t2_2.b) = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash Right Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + t2_3.b) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(6 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+-------------------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Append
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash
+ -> Seq Scan on plt1_p4 t1
+ -> Hash Full Join
+ Hash Cond: ((t2_1.c)::text = (t1_1.c)::text)
+ Filter: ((COALESCE(t1_1.b, 0) + COALESCE(t2_1.b, 0)) = 0)
+ -> Seq Scan on plt2_p1 t2_1
+ -> Hash
+ -> Seq Scan on plt1_p1 t1_1
+ -> Hash Full Join
+ Hash Cond: ((t1_2.c)::text = (t2_2.c)::text)
+ Filter: ((COALESCE(t1_2.b, 0) + COALESCE(t2_2.b, 0)) = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ -> Hash
+ -> Seq Scan on plt2_p2 t2_2
+ -> Hash Full Join
+ Hash Cond: ((t1_3.c)::text = (t2_3.c)::text)
+ Filter: ((COALESCE(t1_3.b, 0) + COALESCE(t2_3.b, 0)) = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ -> Hash
+ -> Seq Scan on plt2_p3 t2_3
+(27 rows)
+
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ a | c | a | c
+-----+------+-----+------
+ 0 | 0000 | 0 | 0000
+ 94 | 0009 | 94 | 0009
+ 141 | 0005 | 141 | 0005
+ 188 | 0001 | |
+ 282 | 0010 | |
+ 329 | 0006 | 329 | 0006
+ 376 | 0002 | 376 | 0002
+ | | 470 |
+(8 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt2_p4 t2
+ -> Materialize
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> HashAggregate
+ Group Key: (t2_1.c)::text
+ -> Seq Scan on plt2_p1 t2_1
+ -> Materialize
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(29 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Seq Scan on plt1_p4 t2
+ -> Materialize
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Semi Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(26 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 0 | 0 | 0000
+ 94 | 0 | 0009
+ 141 | 0 | 0005
+ 329 | 0 | 0006
+ 376 | 0 | 0002
+(5 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Nested Loop Anti Join
+ Join Filter: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p4 t2
+ -> Hash Anti Join
+ Hash Cond: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt2_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+------
+ 188 | 0 | 0001
+ 282 | 0 | 0010
+(2 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Append
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Hash
+ -> Seq Scan on plt1_p4 t2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_1.c)::text = (t2_1.c)::text)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t2_1
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_2.c)::text = (t2_2.c)::text)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t2_2
+ -> Nested Loop Anti Join
+ Join Filter: ((t1_3.c)::text = (t2_3.c)::text)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t2_3
+(24 rows)
+
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ a | b | c
+-----+---+---
+ 470 | 0 |
+(1 row)
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Join Filter: ((t1.b + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a
+ -> Hash Right Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((t1.b + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t2.a
+ -> Hash Left Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + t2.b) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+ QUERY PLAN
+---------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t2.a
+ -> Hash Full Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ Filter: ((COALESCE(t1.b, 0) + COALESCE(t2.b, 0)) = 0)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ -> Seq Scan on plt1_p1 t1_1
+ -> Seq Scan on plt1_p2 t1_2
+ -> Seq Scan on plt1_p3 t1_3
+(16 rows)
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(22 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> HashAggregate
+ Group Key: (t2.c)::text
+ -> Result
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(22 rows)
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt1_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+(19 rows)
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+ QUERY PLAN
+--------------------------------------------------
+ Sort
+ Sort Key: t1.a, t1.c
+ -> Hash Anti Join
+ Hash Cond: ((t1.c)::text = (t2.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p1 t1_1
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p2 t1_2
+ Filter: (b = 0)
+ -> Seq Scan on plt2_p3 t1_3
+ Filter: (b = 0)
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t2
+ -> Seq Scan on plt1_p1 t2_1
+ -> Seq Scan on plt1_p2 t2_2
+ -> Seq Scan on plt1_p3 t2_3
+(19 rows)
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
@@ -1225,22 +4003,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
--------------------------------------------------
Hash Left Join
Hash Cond: (t2.b = a)
- -> Append
- -> Hash Join
- Hash Cond: (t3.a = t2.b)
- -> Seq Scan on prt1_p1 t3
- -> Hash
- -> Seq Scan on prt2_p1 t2
- -> Hash Join
- Hash Cond: (t3_1.a = t2_1.b)
- -> Seq Scan on prt1_p2 t3_1
- -> Hash
- -> Seq Scan on prt2_p2 t2_1
- -> Hash Join
- Hash Cond: (t3_2.a = t2_2.b)
- -> Seq Scan on prt1_p3 t3_2
- -> Hash
- -> Seq Scan on prt2_p3 t2_2
+ -> Hash Join
+ Hash Cond: (t3.a = t2.b)
+ -> Append
+ -> Seq Scan on prt1_p0 t3
+ -> Seq Scan on prt1_p1 t3_1
+ -> Seq Scan on prt1_p2 t3_2
+ -> Seq Scan on prt1_p3 t3_3
+ -> Seq Scan on prt1_p4 t3_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Result
One-Time Filter: false
@@ -1255,16 +4033,22 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1 WHERE a = 1 AND a = 2) t1
-> Hash Left Join
Hash Cond: (t2.b = a)
-> Append
- -> Seq Scan on prt2_p1 t2
+ -> Seq Scan on prt2_p0 t2
Filter: (a = 0)
- -> Seq Scan on prt2_p2 t2_1
+ -> Seq Scan on prt2_p1 t2_1
Filter: (a = 0)
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p2 t2_2
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p3 t2_3
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p4 t2_4
+ Filter: (a = 0)
+ -> Seq Scan on prt2_p5 t2_5
Filter: (a = 0)
-> Hash
-> Result
One-Time Filter: false
-(14 rows)
+(20 rows)
--
-- tests for hash partitioned tables.
@@ -1340,41 +4124,9 @@ SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, ph
273.0000000000000000 | 273.0000000000000000 | 548.0000000000000000 | 0005 | 0005 | A0005
(6 rows)
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
- QUERY PLAN
---------------------------------------------------
- Sort
- Sort Key: t1.a
- -> Append
- -> Hash Join
- Hash Cond: (t2.b = t1.a)
- -> Seq Scan on prt2_p1 t2
- -> Hash
- -> Seq Scan on prt1_p1 t1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_1.b = t1_1.a)
- -> Seq Scan on prt2_p2 t2_1
- -> Hash
- -> Seq Scan on prt1_p2 t1_1
- Filter: (b = 0)
- -> Hash Join
- Hash Cond: (t2_2.b = t1_2.a)
- -> Seq Scan on prt2_p3 t2_2
- -> Hash
- -> Seq Scan on prt1_p3 t1_2
- Filter: (b = 0)
-(21 rows)
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
@@ -1389,26 +4141,24 @@ SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c
Sort Key: t1.c
-> HashAggregate
Group Key: t1.c, t2.c
- -> Append
- -> Hash Join
- Hash Cond: (t2.c = t1.c)
- -> Seq Scan on plt2_p1 t2
- -> Hash
- -> Seq Scan on plt1_p1 t1
+ -> Hash Join
+ Hash Cond: ((t2.c)::text = (t1.c)::text)
+ -> Append
+ -> Seq Scan on plt2_p4 t2
+ -> Seq Scan on plt2_p1 t2_1
+ -> Seq Scan on plt2_p2 t2_2
+ -> Seq Scan on plt2_p3 t2_3
+ -> Hash
+ -> Append
+ -> Seq Scan on plt1_p4 t1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_1.c = t1_1.c)
- -> Seq Scan on plt2_p2 t2_1
- -> Hash
- -> Seq Scan on plt1_p2 t1_1
+ -> Seq Scan on plt1_p1 t1_1
Filter: ((a % 25) = 0)
- -> Hash Join
- Hash Cond: (t2_2.c = t1_2.c)
- -> Seq Scan on plt2_p3 t2_2
- -> Hash
- -> Seq Scan on plt1_p3 t1_2
+ -> Seq Scan on plt1_p2 t1_2
Filter: ((a % 25) = 0)
-(23 rows)
+ -> Seq Scan on plt1_p3 t1_3
+ Filter: ((a % 25) = 0)
+(21 rows)
--
-- multiple levels of partitioning
@@ -1804,64 +4554,70 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2 WHERE t1.a = t2.a;
Hash Join
Hash Cond: (t1.a = t2.a)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
-> Hash
-> Append
-> Seq Scan on prt4_n_p1 t2
-> Seq Scan on prt4_n_p2 t2_1
-> Seq Scan on prt4_n_p3 t2_2
-(11 rows)
+(13 rows)
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt4_n t2, prt2 t3 WHERE t1.a = t2.a and t1.a = t3.b;
- QUERY PLAN
---------------------------------------------------------
+ QUERY PLAN
+----------------------------------------------------------
Hash Join
- Hash Cond: (t2.a = t1.a)
+ Hash Cond: (t3.b = t1.a)
-> Append
- -> Seq Scan on prt4_n_p1 t2
- -> Seq Scan on prt4_n_p2 t2_1
- -> Seq Scan on prt4_n_p3 t2_2
+ -> Seq Scan on prt2_p0 t3
+ -> Seq Scan on prt2_p1 t3_1
+ -> Seq Scan on prt2_p2 t3_2
+ -> Seq Scan on prt2_p3 t3_3
+ -> Seq Scan on prt2_p4 t3_4
+ -> Seq Scan on prt2_p5 t3_5
-> Hash
- -> Append
- -> Hash Join
- Hash Cond: (t1.a = t3.b)
- -> Seq Scan on prt1_p1 t1
- -> Hash
- -> Seq Scan on prt2_p1 t3
- -> Hash Join
- Hash Cond: (t1_1.a = t3_1.b)
- -> Seq Scan on prt1_p2 t1_1
- -> Hash
- -> Seq Scan on prt2_p2 t3_1
- -> Hash Join
- Hash Cond: (t1_2.a = t3_2.b)
- -> Seq Scan on prt1_p3 t1_2
- -> Hash
- -> Seq Scan on prt2_p3 t3_2
+ -> Hash Join
+ Hash Cond: (t1.a = t2.a)
+ -> Append
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Hash
+ -> Append
+ -> Seq Scan on prt4_n_p1 t2
+ -> Seq Scan on prt4_n_p2 t2_1
+ -> Seq Scan on prt4_n_p3 t2_2
(23 rows)
-- partitionwise join can not be applied if there are no equi-join conditions
-- between partition keys
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON (t1.a < t2.b);
- QUERY PLAN
----------------------------------------------------------
+ QUERY PLAN
+--------------------------------------------
Nested Loop Left Join
+ Join Filter: (t1.a < t2.b)
-> Append
- -> Seq Scan on prt1_p1 t1
- -> Seq Scan on prt1_p2 t1_1
- -> Seq Scan on prt1_p3 t1_2
- -> Append
- -> Index Scan using iprt2_p1_b on prt2_p1 t2
- Index Cond: (b > t1.a)
- -> Index Scan using iprt2_p2_b on prt2_p2 t2_1
- Index Cond: (b > t1.a)
- -> Index Scan using iprt2_p3_b on prt2_p3 t2_2
- Index Cond: (b > t1.a)
-(12 rows)
+ -> Seq Scan on prt1_p0 t1
+ -> Seq Scan on prt1_p1 t1_1
+ -> Seq Scan on prt1_p2 t1_2
+ -> Seq Scan on prt1_p3 t1_3
+ -> Seq Scan on prt1_p4 t1_4
+ -> Materialize
+ -> Append
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
+(16 rows)
-- equi-join with join condition on partial keys does not qualify for
-- partitionwise join
@@ -1947,16 +4703,17 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 JOIN prt2_n t2 ON (t1.c = t2.c) JOI
-> Seq Scan on prt2_n_p2 t2_1
-> Hash
-> Hash Join
- Hash Cond: (t3.c = (t1.c)::text)
+ Hash Cond: ((t3.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on plt1_p1 t3
- -> Seq Scan on plt1_p2 t3_1
- -> Seq Scan on plt1_p3 t3_2
+ -> Seq Scan on plt1_p4 t3
+ -> Seq Scan on plt1_p1 t3_1
+ -> Seq Scan on plt1_p2 t3_2
+ -> Seq Scan on plt1_p3 t3_3
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(16 rows)
+(17 rows)
-- partitionwise join can not be applied for a join between list and range
-- partitioned table
@@ -1967,14 +4724,16 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1_n t1 FULL JOIN prt1 t2 ON (t1.c = t2.c);
Hash Full Join
Hash Cond: ((t2.c)::text = (t1.c)::text)
-> Append
- -> Seq Scan on prt1_p1 t2
- -> Seq Scan on prt1_p2 t2_1
- -> Seq Scan on prt1_p3 t2_2
+ -> Seq Scan on prt1_p0 t2
+ -> Seq Scan on prt1_p1 t2_1
+ -> Seq Scan on prt1_p2 t2_2
+ -> Seq Scan on prt1_p3 t2_3
+ -> Seq Scan on prt1_p4 t2_4
-> Hash
-> Append
-> Seq Scan on prt1_n_p1 t1
-> Seq Scan on prt1_n_p2 t1_1
-(10 rows)
+(12 rows)
-- partitionwise join can not be applied if only one of joining table has
-- default partition
@@ -1990,16 +4749,23 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b =
-> Hash Join
Hash Cond: (t2.b = t1.a)
-> Append
- -> Seq Scan on prt2_p1 t2
- -> Seq Scan on prt2_p2 t2_1
- -> Seq Scan on prt2_p3 t2_2
+ -> Seq Scan on prt2_p0 t2
+ -> Seq Scan on prt2_p1 t2_1
+ -> Seq Scan on prt2_p2 t2_2
+ -> Seq Scan on prt2_p3 t2_3
+ -> Seq Scan on prt2_p4 t2_4
+ -> Seq Scan on prt2_p5 t2_5
-> Hash
-> Append
- -> Seq Scan on prt1_p1 t1
+ -> Seq Scan on prt1_p0 t1
Filter: (b = 0)
- -> Seq Scan on prt1_p2 t1_1
+ -> Seq Scan on prt1_p1 t1_1
Filter: (b = 0)
- -> Seq Scan on prt1_p3 t1_2
+ -> Seq Scan on prt1_p2 t1_2
Filter: (b = 0)
-(16 rows)
+ -> Seq Scan on prt1_p3 t1_3
+ Filter: (b = 0)
+ -> Seq Scan on prt1_p4 t1_4
+ Filter: (b = 0)
+(23 rows)
diff --git a/src/test/regress/sql/partition_join.sql b/src/test/regress/sql/partition_join.sql
index db9a6b4a96..7597b069fa 100644
--- a/src/test/regress/sql/partition_join.sql
+++ b/src/test/regress/sql/partition_join.sql
@@ -10,25 +10,39 @@ SET enable_partitionwise_join to true;
-- partitioned by a single column
--
CREATE TABLE prt1 (a int, b int, c varchar) PARTITION BY RANGE(a);
+CREATE TABLE prt1_p0 PARTITION OF prt1 FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_p1 PARTITION OF prt1 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_p3 PARTITION OF prt1 FOR VALUES FROM (500) TO (600);
CREATE TABLE prt1_p2 PARTITION OF prt1 FOR VALUES FROM (250) TO (500);
-INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 2 = 0;
+CREATE TABLE prt1_p4 PARTITION OF prt1 FOR VALUES FROM (600) TO (800);
+INSERT INTO prt1 SELECT i, i % 25, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 2 = 0;
+CREATE INDEX iprt1_p0_a on prt1_p0(a);
CREATE INDEX iprt1_p1_a on prt1_p1(a);
CREATE INDEX iprt1_p2_a on prt1_p2(a);
CREATE INDEX iprt1_p3_a on prt1_p3(a);
+CREATE INDEX iprt1_p4_a on prt1_p4(a);
ANALYZE prt1;
+-- prt2 have missing starting MINVALUE to -250 range and
+-- extra bounds from 800 to MAXVALUE
CREATE TABLE prt2 (a int, b int, c varchar) PARTITION BY RANGE(b);
+CREATE TABLE prt2_p0 PARTITION OF prt2 FOR VALUES FROM (-250) TO (0);
CREATE TABLE prt2_p1 PARTITION OF prt2 FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_p2 PARTITION OF prt2 FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_p3 PARTITION OF prt2 FOR VALUES FROM (500) TO (600);
-INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(0, 599) i WHERE i % 3 = 0;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (MAXVALUE);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(-250, 799) i WHERE i % 3 = 0;
+CREATE INDEX iprt2_p0_b on prt2_p0(b);
CREATE INDEX iprt2_p1_b on prt2_p1(b);
CREATE INDEX iprt2_p2_b on prt2_p2(b);
CREATE INDEX iprt2_p3_b on prt2_p3(b);
+CREATE INDEX iprt2_p4_b on prt2_p4(b);
ANALYZE prt2;
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
+
-- inner join
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
@@ -69,11 +83,19 @@ EXPLAIN (COSTS OFF)
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
SELECT t1.* FROM prt1 t1 WHERE t1.a IN (SELECT t2.b FROM prt2 t2 WHERE t2.a = 0) AND t1.b = 0 ORDER BY t1.a;
+EXPLAIN (COSTS OFF)
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+SELECT t1.* FROM prt2 t1 WHERE t1.b IN (SELECT t2.a FROM prt1 t2 WHERE t2.b = 0) AND t1.a = 0 ORDER BY t1.b;
+
-- Anti-join with aggregates
EXPLAIN (COSTS OFF)
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
SELECT sum(t1.a), avg(t1.a), sum(t1.b), avg(t1.b) FROM prt1 t1 WHERE NOT EXISTS (SELECT 1 FROM prt2 t2 WHERE t1.a = t2.b);
+EXPLAIN (COSTS OFF)
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+SELECT t1.b, t1.c FROM prt2 t1 WHERE NOT EXISTS (SELECT 1 FROM prt1 t2 WHERE t1.b = t2.a) and t1.a = 0;
+
-- lateral reference
EXPLAIN (COSTS OFF)
SELECT * FROM prt1 t1 LEFT JOIN LATERAL
@@ -95,20 +117,30 @@ SELECT t1.a, ss.t2a, ss.t2c FROM prt1 t1 LEFT JOIN LATERAL
-- partitioned by expression
--
CREATE TABLE prt1_e (a int, b int, c int) PARTITION BY RANGE(((a + b)/2));
+CREATE TABLE prt1_e_p0 PARTITION OF prt1_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt1_e_p1 PARTITION OF prt1_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt1_e_p2 PARTITION OF prt1_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt1_e_p3 PARTITION OF prt1_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt1_e_p4 PARTITION OF prt1_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(0, 599, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 2) i;
+INSERT INTO prt1_e SELECT i, i, i % 25 FROM generate_series(600, 799, 2) i;
+CREATE INDEX iprt1_e_p0_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p1_ab2 on prt1_e_p1(((a+b)/2));
CREATE INDEX iprt1_e_p2_ab2 on prt1_e_p2(((a+b)/2));
CREATE INDEX iprt1_e_p3_ab2 on prt1_e_p3(((a+b)/2));
+CREATE INDEX iprt1_e_p4_ab2 on prt1_e_p1(((a+b)/2));
ANALYZE prt1_e;
CREATE TABLE prt2_e (a int, b int, c int) PARTITION BY RANGE(((b + a)/2));
+CREATE TABLE prt2_e_p0 PARTITION OF prt2_e FOR VALUES FROM (MINVALUE) TO (0);
CREATE TABLE prt2_e_p1 PARTITION OF prt2_e FOR VALUES FROM (0) TO (250);
CREATE TABLE prt2_e_p2 PARTITION OF prt2_e FOR VALUES FROM (250) TO (500);
CREATE TABLE prt2_e_p3 PARTITION OF prt2_e FOR VALUES FROM (500) TO (600);
+CREATE TABLE prt2_e_p4 PARTITION OF prt2_e FOR VALUES FROM (600) TO (MAXVALUE);
INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(0, 599, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(-250, 0, 3) i;
+INSERT INTO prt2_e SELECT i, i, i % 25 FROM generate_series(600, 799, 3) i;
ANALYZE prt2_e;
EXPLAIN (COSTS OFF)
@@ -172,6 +204,128 @@ SELECT t1.a, t2.b FROM prt1 t1, prt2 t2 WHERE t1::text = t2::text AND t1.a = t2.
RESET enable_hashjoin;
RESET enable_nestloop;
+-- test default partition behavior for range, partition-wise join is not
+-- possible since more than one partition on one side matches default partition
+-- on the other side. Default partition from prt1 matches default partition and
+-- prt2_p4 from prt2 and default partition from prt2 matches default partition
+-- and prt1_p0 from prt1
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- partition-wise join should be possible when we drop the first and last
+-- partitions from both sides
+ALTER TABLE prt1 DETACH PARTITION prt1_p0;
+ALTER TABLE prt1 DETACH PARTITION prt1_p4;
+ANALYZE prt1;
+ALTER TABLE prt2 DETACH PARTITION prt2_p0;
+ALTER TABLE prt2 DETACH PARTITION prt2_p4;
+ANALYZE prt2;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
+
+-- restore the partitioned tables for rest of the tests
+ALTER TABLE prt1 ATTACH PARTITION prt1_p0 FOR VALUES FROM (MINVALUE) TO (0);
+ALTER TABLE prt1 ATTACH PARTITION prt1_p4 FOR VALUES FROM (600) TO (800);
+ALTER TABLE prt1 DETACH PARTITION prt1_p3;
+ALTER TABLE prt1 ATTACH PARTITION prt1_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt1;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p0 FOR VALUES FROM (-250) TO (0);
+ALTER TABLE prt2 ATTACH PARTITION prt2_p4 FOR VALUES FROM (600) TO (MAXVALUE);
+ALTER TABLE prt2 DETACH PARTITION prt2_p3;
+ALTER TABLE prt2 ATTACH PARTITION prt2_p3 FOR VALUES FROM (500) TO (600);
+ANALYZE prt2;
+
+-- Add an extra partition to prt2 , Partition-wise join is possible with
+-- extra partitions on inner side are allowed
+DROP TABLE prt2_p4;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (800);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (800) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999) i WHERE i % 3 = 0;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- 3-way join when not every pair of joining relation can use partition-wise
+-- join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+SELECT t1.a, t2.a, t3.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON (t1.a = t2.b) INNER JOIN prt1 t3 ON (t2.b = t3.a) WHERE t2.a = 0 ORDER BY t1.a, t2.a, t3.c;
+
+-- partition-wise join can not handle missing partition on the inner side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.b;
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE coalesce(t1.b, 0) + coalesce(t2.a, 0) = 0 ORDER BY t1.a, t2.a;
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE prt2_p4;
+DROP TABLE prt2_p5;
+CREATE TABLE prt2_p4 PARTITION OF prt2 FOR VALUES FROM (600) TO (700);
+CREATE TABLE prt2_p5 PARTITION OF prt2 FOR VALUES FROM (700) TO (1000);
+INSERT INTO prt2 SELECT i % 25, i, to_char(i, 'FM0000') FROM generate_series(600, 999, 3) i;
+ANALYZE prt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 INNER JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 LEFT JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 RIGHT JOIN prt2 t2 ON t1.a = t2.b WHERE t2.a = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM prt1 t1 FULL JOIN prt2 t2 ON t1.a = t2.b WHERE t1.b + t2.a = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt1 t1 where not exists (select 1 from prt2 t2 WHERE t1.a = t2.b) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from prt2 t1 where not exists (select 1 from prt1 t2 WHERE t1.b = t2.a) and t1.a = 0 order by t1.a, t1.b, t1.c;
+
--
-- partitioned by multiple columns
--
@@ -196,28 +350,79 @@ SELECT t1.a, t1.c, t2.b, t2.c FROM (SELECT * FROM prt1_m WHERE prt1_m.c = 0) t1
--
-- tests for list partitioned tables.
--
-CREATE TABLE plt1 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
-ANALYZE plt1;
+\set part_mod 17
+\set cond_mod 47
+\set num_rows 500
+
+CREATE TABLE plt1 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt1_p1 PARTITION OF plt1 FOR VALUES IN ('0001','0002','0003');
+CREATE TABLE plt1_p2 PARTITION OF plt1 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN ('0008','0009');
+CREATE TABLE plt1_p4 PARTITION OF plt1 FOR VALUES IN ('0000','0010');
+INSERT INTO plt1 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (7, 11, 12, 13, 14, 15, 16);
+ANALYSE plt1;
+
+-- plt2 have missing starting 0001, additional 0007, missing ending 0010
+-- and additional 0011 and 0012 bounds
+CREATE TABLE plt2 (a int, b int, c varchar) PARTITION BY LIST(c);
+CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0002','0003');
+CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0004','0005','0006');
+CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0007','0008','0009');
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000','0011','0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 10, 13, 14, 15, 16);
+ANALYSE plt2;
+
+-- Partition-wise-join is possible with some partition bounds overlap
+-- with each other completely and some partialy for inner,left,right,
+-- full, semi and anti joins
-CREATE TABLE plt2 (a int, b int, c text) PARTITION BY LIST(c);
-CREATE TABLE plt2_p1 PARTITION OF plt2 FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt2_p2 PARTITION OF plt2 FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt2_p3 PARTITION OF plt2 FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt2 SELECT i, i, to_char(i/50, 'FM0000') FROM generate_series(0, 599, 3) i;
-ANALYZE plt2;
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
--
-- list partitioned by expression
--
CREATE TABLE plt1_e (a int, b int, c text) PARTITION BY LIST(ltrim(c, 'A'));
-CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0000', '0003', '0004', '0010');
-CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0001', '0005', '0002', '0009');
-CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0006', '0007', '0008', '0011');
-INSERT INTO plt1_e SELECT i, i, 'A' || to_char(i/50, 'FM0000') FROM generate_series(0, 599, 2) i;
+CREATE TABLE plt1_e_p1 PARTITION OF plt1_e FOR VALUES IN ('0002', '0003');
+CREATE TABLE plt1_e_p2 PARTITION OF plt1_e FOR VALUES IN ('0004', '0005', '0006');
+CREATE TABLE plt1_e_p3 PARTITION OF plt1_e FOR VALUES IN ('0008', '0009');
+CREATE TABLE plt1_e_p4 PARTITION OF plt1_e FOR VALUES IN ('0000');
+INSERT INTO plt1_e SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod NOT IN (1, 7, 10, 11, 12, 13, 14, 15, 16);
ANALYZE plt1_e;
-- test partition matching with N-way join
@@ -225,6 +430,175 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM plt1 t1, plt2 t2, plt1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
+-- Add an extra partition to plt2 , Partition-wise join is possible with
+-- partitions on inner side are allowed
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join, partition-wise join can not handle extra partition on the outer
+-- side
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt2_p5;
+CREATE TABLE plt2_p5 PARTITION OF plt2 FOR VALUES IN ('0001','0013','0014');
+INSERT INTO plt2 SELECT i, i % :cond_mod, to_char(i % :part_mod, 'FM0000') FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (1, 13, 14);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on one side, Partition-wise join is possible with
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- in this case NULL will be treated as addition partition bounds.
+DROP TABLE plt2_p5;
+DROP TABLE plt2_p4;
+CREATE TABLE plt2_p4 PARTITION OF plt2 FOR VALUES IN ('0000',NULL,'0012');
+INSERT INTO plt2 SELECT i, i % :cond_mod, case when i % :part_mod = 11 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (0,11,12);
+ANALYZE plt2;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t1.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- partition have a NULL on both side with different partition bounds w.r.t other side
+-- NULL when NULL comparision is not strict i.e. NULL=NULL allowed
+-- Partition-wise join can not handle the case when one partition from one side
+-- matches with multiple partitions on the other side
+DROP TABLE plt1_p3;
+CREATE TABLE plt1_p3 PARTITION OF plt1 FOR VALUES IN (NULL,'0008','0009');
+INSERT INTO plt1 SELECT i, i % :cond_mod, case when i % :part_mod = 7 then NULL else to_char(i % :part_mod, 'FM0000') end FROM generate_series(0, :num_rows) i WHERE i % :part_mod IN (7,8,9);
+ANALYZE plt1;
+
+-- inner join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 INNER JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + t2.b = 0 ORDER BY t1.a;
+
+-- left join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 LEFT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.b + coalesce(t2.b, 0) = 0 ORDER BY t1.a;
+
+-- right join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + t2.b = 0 ORDER BY t2.a;
+
+-- full join
+EXPLAIN (COSTS OFF)
+SELECT t1.a, t1.c, t2.a, t2.c FROM plt1 t1 FULL JOIN plt2 t2 ON t1.c = t2.c WHERE coalesce(t1.b, 0) + coalesce(t2.b, 0) = 0 ORDER BY t1.a, t2.a;
+
+-- semi join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+-- anti join
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt1 t1 where not exists (select 1 from plt2 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
+EXPLAIN (COSTS OFF)
+select t1.a, t1.b, t1.c from plt2 t1 where not exists (select 1 from plt1 t2 WHERE t1.c = t2.c) and t1.b = 0 order by t1.a, t1.b, t1.c;
+
-- joins where one of the relations is proven empty
EXPLAIN (COSTS OFF)
SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.a = 1 AND t1.a = 2;
@@ -270,27 +644,18 @@ EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
SELECT avg(t1.a), avg(t2.b), avg(t3.a + t3.b), t1.c, t2.c, t3.c FROM pht1 t1, pht2 t2, pht1_e t3 WHERE t1.b = t2.b AND t1.c = t2.c AND ltrim(t3.c, 'A') = t1.c GROUP BY t1.c, t2.c, t3.c ORDER BY t1.c, t2.c, t3.c;
--- test default partition behavior for range
-ALTER TABLE prt1 DETACH PARTITION prt1_p3;
-ALTER TABLE prt1 ATTACH PARTITION prt1_p3 DEFAULT;
-ANALYZE prt1;
-ALTER TABLE prt2 DETACH PARTITION prt2_p3;
-ALTER TABLE prt2 ATTACH PARTITION prt2_p3 DEFAULT;
-ANALYZE prt2;
-
-EXPLAIN (COSTS OFF)
-SELECT t1.a, t1.c, t2.b, t2.c FROM prt1 t1, prt2 t2 WHERE t1.a = t2.b AND t1.b = 0 ORDER BY t1.a, t2.b;
-
--- test default partition behavior for list
+-- test default partition behavior for list, should not use partition-wise join
+-- since default partition from one side matches multiple partitions on the
+-- other
ALTER TABLE plt1 DETACH PARTITION plt1_p3;
ALTER TABLE plt1 ATTACH PARTITION plt1_p3 DEFAULT;
ANALYZE plt1;
ALTER TABLE plt2 DETACH PARTITION plt2_p3;
ALTER TABLE plt2 ATTACH PARTITION plt2_p3 DEFAULT;
ANALYZE plt2;
-
EXPLAIN (COSTS OFF)
SELECT avg(t1.a), avg(t2.b), t1.c, t2.c FROM plt1 t1 RIGHT JOIN plt2 t2 ON t1.c = t2.c WHERE t1.a % 25 = 0 GROUP BY t1.c, t2.c ORDER BY t1.c, t2.c;
+
--
-- multiple levels of partitioning
--
--
2.18.0
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 02:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-03-11 05:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 16:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-04-24 11:26 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
@ 2019-04-26 10:29 ` Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
1 sibling, 0 replies; 154+ messages in thread
From: Rajkumar Raghuwanshi @ 2019-04-26 10:29 UTC (permalink / raw)
To: amul sul <sulamul@gmail.com>; +Cc: Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>; Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers
On Wed, Apr 24, 2019 at 4:56 PM amul sul <sulamul@gmail.com> wrote:
> Attached version is rebase atop of the latest master head(fdc7efcc30), also
> incorporates the Ashutosh's suggestion, thanks.
>
Thanks for rebase patch, patches applied cleanly on PG head.
I did some crash testing with extra test case [0006 patch] [1] and found no
more issue.
Thanks & Regards,
Rajkumar Raghuwanshi
QMG, EnterpriseDB.
[1]
https://www.postgresql.org/message-id/CAFjFpReKuV_4LRRfdy80BqX8oZfwbo%2BHWLQNv3CsJ5iGPSyTfA%40mail.g...
<https://www.postgresql.org/message-id/CA%2Bq6zcU3X4%3DBfqnWXAUPBFtKK7vy0HO7-%2BmAW6KB2Zy_EPtC_Q%40ma...;
>
> Regards,
> Amul
>
> On Mon, Mar 11, 2019 at 10:14 PM Ashutosh Bapat <
> ashutosh.bapat.oss@gmail.com> wrote:
>
>>
>>
>> On Mon, Mar 11, 2019 at 10:40 AM amul sul <sulamul@gmail.com> wrote:
>>
>>>
>>> All the places from where this handle_missing_partition() get called
>>> have the following code to decide the value for
>>> missing_side_outer/_inner which
>>> I yet to understand. Do you think this has some flaw?
>>>
>>> /*
>>> * For a FULL join, inner relation acts as both OUTER and INNER
>>> * relation. For LEFT and ANTI join the inner relation acts as
>>> * INNER relation. For INNER and SEMI join OUTER and INNER
>>> * differentiation is immaterial.
>>> */
>>> missing_side_inner = (jointype == JOIN_FULL ||
>>> jointype == JOIN_LEFT ||
>>> jointype == JOIN_ANTI);
>>> missing_side_outer = (jointype == JOIN_FULL);
>>>
>>
>> I was wrong, sorry. The comment says it all.
>>
>>
>>>
>>>
>>>
>>>> argument value which fails to set merged_index.
>>>>>
>>>>> In the attached patch, I tried to fix this case by setting
>>>>> merged_index
>>>>> explicitly which fixes the reported crash.
>>>>>
>>>>
>>>> I expect handle_missing_partition() to set the merged_index always. In
>>>> your patches, I don't see that function in your patches is setting it
>>>> explicitly. If we are setting merged_index explicitly somewhere else, other
>>>> places may miss that explicit assignment. So it's better to move it inside
>>>> this function.
>>>>
>>>>
>>>
>>> Ok, that can be fixed.
>>>
>>> Similarly, I think merge_null_partitions should set null_index instead
>>> of
>>> asserting when null partitions missing from both the side, make sense?
>>>
>>
>> I think not. null_index, once set shouldn't change and hence does not
>> change with each pair of partitions being matched. So, it makes sense to
>> make sure that null_index remains invalid if none of the tables have null
>> partition.
>>
>> --
>> Best Wishes,
>> Ashutosh Bapat
>>
>
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 02:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-03-11 05:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 16:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-04-24 11:26 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
@ 2019-05-14 04:23 ` Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2019-05-14 04:29 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2019-05-17 12:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
1 sibling, 2 replies; 154+ messages in thread
From: Amit Langote @ 2019-05-14 04:23 UTC (permalink / raw)
To: amul sul <sulamul@gmail.com>; Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>; +Cc: Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers
Hi Amul, Ashutosh,
On 2019/04/24 20:26, amul sul wrote:
> Attached version is rebase atop of the latest master head(fdc7efcc30), also
> incorporates the Ashutosh's suggestion, thanks.
Reading the commit message of 0002 and after testing to confirm, I
understand that the patch doesn't handle OUTER joins where the nullable
side is missing some partitions. The reason given is that join planning
would have to add base relations corresponding to missing partitions on
the nullable side, which we can't do. While working on partition pruning
refactoring recently (committed as 428b260f87e), we faced a similar
situation in that pruned partitions are like missing partitions, because
they're not added to the PlannerInfo anymore, whereas before that commit,
they'd be added and marked dummy afterwards. Earlier versions of my patch
had code to add dummy base relations for such pruned partitions, because
partitionwise join expected pairs of matched partitions to be valid base
relations, because that's how things were when partitionwise joins feature
was committed. Join path generated in this case would have a
constant-false Result path (an empty relation) for the nullable side. Tom
strongly objected to that idea saying that such join paths are kind of
silly [1], even outside the context of partitionwise join. He suggested
that we abandon partitionwise join in such cases, because having to build
a dummy base relation for pruned partitions only to generate silly-looking
paths would be an ugly kludge. I guess the same argument applies to the
case where the nullable side is missing some partitions, so the right way
to support partitionwise join case in that case wouldn't be to figure out
how joinrels.c could add dummy base relations.
He did mention that cases where the nullable side is provably empty can be
handled by simply returning the path of the non-nullable side with
suitable projection path added on top to emit NULLs for the columns of the
nullable-side. If we teach populate_joinrel_with_paths() and underlings
about that, then we can allow partitionwise join even in the case where
the nullable side has some partitions missing.
Thanks,
Amit
[1] https://www.postgresql.org/message-id/25035.1553905052%40sss.pgh.pa.us
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 02:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-03-11 05:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 16:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-04-24 11:26 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-05-14 04:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
@ 2019-05-14 04:29 ` Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2019-05-14 14:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
1 sibling, 1 reply; 154+ messages in thread
From: Amit Langote @ 2019-05-14 04:29 UTC (permalink / raw)
To: amul sul <sulamul@gmail.com>; Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>; +Cc: Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers
On 2019/05/14 13:23, Amit Langote wrote:
> Tom
> strongly objected to that idea saying that such join paths are kind of
> silly [1], even outside the context of partitionwise join. He suggested
> that we abandon partitionwise join in such cases, because having to build
> a dummy base relation for pruned partitions only to generate silly-looking
> paths would be an ugly kludge.
I forgot to mention that he even committed a patch to disable
partitionwise joins in such cases, which was also applied to v11 branch.
https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=d70c147fa217c4bae32ac1afb86ab42d9...
Note that there were also other reasons for committing, beside what I
described in my previous email.
Thanks,
Amit
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 02:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-03-11 05:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 16:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-04-24 11:26 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-05-14 04:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2019-05-14 04:29 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
@ 2019-05-14 14:11 ` Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
0 siblings, 0 replies; 154+ messages in thread
From: Ashutosh Bapat @ 2019-05-14 14:11 UTC (permalink / raw)
To: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; +Cc: amul sul <sulamul@gmail.com>; Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Antonin Houska <ah@cybertec.at>; Robert Haas <robertmhaas@gmail.com>; pgsql-hackers
On Tue, May 14, 2019 at 10:00 AM Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
wrote:
> On 2019/05/14 13:23, Amit Langote wrote:
> > Tom
> > strongly objected to that idea saying that such join paths are kind of
> > silly [1], even outside the context of partitionwise join. He suggested
> > that we abandon partitionwise join in such cases, because having to build
> > a dummy base relation for pruned partitions only to generate
> silly-looking
> > paths would be an ugly kludge.
>
> I forgot to mention that he even committed a patch to disable
> partitionwise joins in such cases, which was also applied to v11 branch.
>
>
> https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=d70c147fa217c4bae32ac1afb86ab42d9...
>
> Note that there were also other reasons for committing, beside what I
> described in my previous email.
>
>
I haven't seen the actual commit, but we could use these patches to enable
partition-wise join when partitions are pruned. For that the partition
descriptor of the pruned partition table should be arranged as if those
partitions are missing in the table itself. However, we will still need
code to handle the cases when the partitions are missing on the nullable
side. Tom mentioned the idea of using just projection to produce join
tuples with rows on the outer side appended with null columns from the
nullable side. If we can implement that, we can remove the restrictions in
this patch.
--
Best Wishes,
Ashutosh Bapat
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 02:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-03-11 05:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 16:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-04-24 11:26 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-05-14 04:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
@ 2019-05-17 12:20 ` Robert Haas <robertmhaas@gmail.com>
2019-07-01 09:49 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@gmail.com>
1 sibling, 1 reply; 154+ messages in thread
From: Robert Haas @ 2019-05-17 12:20 UTC (permalink / raw)
To: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; +Cc: amul sul <sulamul@gmail.com>; Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>; Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Tue, May 14, 2019 at 12:24 AM Amit Langote
<Langote_Amit_f8@lab.ntt.co.jp> wrote:
> He did mention that cases where the nullable side is provably empty can be
> handled by simply returning the path of the non-nullable side with
> suitable projection path added on top to emit NULLs for the columns of the
> nullable-side. If we teach populate_joinrel_with_paths() and underlings
> about that, then we can allow partitionwise join even in the case where
> the nullable side has some partitions missing.
Yes, I think that would be a good approach to pursue.
--
Robert Haas
EnterpriseDB: http://www.enterprisedb.com
The Enterprise PostgreSQL Company
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 02:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-03-11 05:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 16:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-04-24 11:26 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-05-14 04:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2019-05-17 12:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
@ 2019-07-01 09:49 ` Thomas Munro <thomas.munro@gmail.com>
2019-07-01 11:16 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Thomas Munro @ 2019-07-01 09:49 UTC (permalink / raw)
To: Robert Haas <robertmhaas@gmail.com>; +Cc: Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; amul sul <sulamul@gmail.com>; Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>; Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Sat, May 18, 2019 at 12:20 AM Robert Haas <robertmhaas@gmail.com> wrote:
> On Tue, May 14, 2019 at 12:24 AM Amit Langote
> <Langote_Amit_f8@lab.ntt.co.jp> wrote:
> > He did mention that cases where the nullable side is provably empty can be
> > handled by simply returning the path of the non-nullable side with
> > suitable projection path added on top to emit NULLs for the columns of the
> > nullable-side. If we teach populate_joinrel_with_paths() and underlings
> > about that, then we can allow partitionwise join even in the case where
> > the nullable side has some partitions missing.
>
> Yes, I think that would be a good approach to pursue.
Hi Ashutosh, Amul, Fujita-san,
Could we please have a fresh rebase for the new Commitfest?
Thanks,
--
Thomas Munro
https://enterprisedb.com
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 02:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-03-11 05:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 16:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-04-24 11:26 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-05-14 04:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2019-05-17 12:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2019-07-01 09:49 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@gmail.com>
@ 2019-07-01 11:16 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-02 04:47 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Etsuro Fujita @ 2019-07-01 11:16 UTC (permalink / raw)
To: Thomas Munro <thomas.munro@gmail.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; amul sul <sulamul@gmail.com>; Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>; Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Mon, Jul 1, 2019 at 6:50 PM Thomas Munro <thomas.munro@gmail.com> wrote:
> On Sat, May 18, 2019 at 12:20 AM Robert Haas <robertmhaas@gmail.com> wrote:
> > On Tue, May 14, 2019 at 12:24 AM Amit Langote
> > <Langote_Amit_f8@lab.ntt.co.jp> wrote:
> > > He did mention that cases where the nullable side is provably empty can be
> > > handled by simply returning the path of the non-nullable side with
> > > suitable projection path added on top to emit NULLs for the columns of the
> > > nullable-side. If we teach populate_joinrel_with_paths() and underlings
> > > about that, then we can allow partitionwise join even in the case where
> > > the nullable side has some partitions missing.
> >
> > Yes, I think that would be a good approach to pursue.
>
> Hi Ashutosh, Amul, Fujita-san,
>
> Could we please have a fresh rebase for the new Commitfest?
Will do unless Ashutosh, Amul, or anyone wants to.
Thanks!
Best regards,
Etsuro Fujita
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 02:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-03-11 05:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 16:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-04-24 11:26 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-05-14 04:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2019-05-17 12:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2019-07-01 09:49 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@gmail.com>
2019-07-01 11:16 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-02 04:47 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
@ 2019-07-03 06:44 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-08 11:33 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Etsuro Fujita @ 2019-07-03 06:44 UTC (permalink / raw)
To: amul sul <sulamul@gmail.com>; +Cc: Thomas Munro <thomas.munro@gmail.com>; Robert Haas <robertmhaas@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>; Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Tue, Jul 2, 2019 at 1:47 PM amul sul <sulamul@gmail.com> wrote:
> Attached version is rebase atop of the latest master head(c74d49d41c), thanks.
Thanks! Will review.
Best regards,
Etsuro Fujita
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 02:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-03-11 05:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 16:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-04-24 11:26 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-05-14 04:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2019-05-17 12:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2019-07-01 09:49 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@gmail.com>
2019-07-01 11:16 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-02 04:47 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-07-03 06:44 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-08 11:33 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
@ 2019-07-18 06:55 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-19 13:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
1 sibling, 1 reply; 154+ messages in thread
From: Etsuro Fujita @ 2019-07-18 06:55 UTC (permalink / raw)
To: amul sul <sulamul@gmail.com>; +Cc: Thomas Munro <thomas.munro@gmail.com>; Robert Haas <robertmhaas@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>; Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Mon, Jul 8, 2019 at 8:33 PM Etsuro Fujita <etsuro.fujita@gmail.com> wrote:
> I'll review the remaining parts (ie,
> "0002-Partition-wise-join-for-1-1-1-0-0-1-partition-matchi-v22.patch"
> and "0003-Tests-for-0-1-1-1-and-1-0-partition-matching-v22.patch")
> closely next.
I've been reviewing the main patch
"0002-Partition-wise-join-for-1-1-1-0-0-1-partition-matchi-v22.patch",
but it's pretty large and complicated, so I'm still at the first pass,
and so maybe I'm missing something, but let me comment a few things on
the patch. First of all, I think the patch's problem setting, which
is stated in the commit message, is reasonable:
Earlier version of partition-wise join implementation allowed
partition-wise join between two relations with exactly same partition
bounds. This commit allows partition-wise join to be applied under
following conditions
1. the partition bounds of joining relations are such that rows from
given partition on one side join can join with rows from maximum one
partition on the other side i.e. bounds of a given partition on one
side match/overlap with those of maximum one partition on the other
side.
And I agree with the patch's approach to this that tries to find such
a partition mapping between two input partitioned relations for a join
relation, by trying to match their partition bounds, which is
implemented in a new function partition_bounds_merge(), in general.
But one thing that I'm concerned about most at this point is this in
try_partitionwise_join():
/*
- * 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.
+ * Get the list of matching partitions to be joined along with the
+ * partition bounds of the join relation. Because of the restrictions
+ * imposed by partition matching algorithm, not every pair of joining
+ * relations for this join will be able to use partition-wise join. But all
+ * those pairs which can use partition-wise join will produce the same
+ * partition bounds for the join relation.
*/
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel1->boundinfo));
- Assert(partition_bounds_equal(joinrel->part_scheme->partnatts,
- joinrel->part_scheme->parttyplen,
- joinrel->part_scheme->parttypbyval,
- joinrel->boundinfo, rel2->boundinfo));
+ join_boundinfo = partition_bounds_merge(part_scheme->partnatts,
+ part_scheme->partsupfunc,
+ part_scheme->partcollation,
+ rel1, rel2,
+ parent_sjinfo->jointype,
+ &parts1, &parts2);
+
+ if (join_boundinfo == NULL)
+ return;
I.e., partition_bounds_merge() is performed for each pair of input
partitioned relations for a join relation in try_partitionwise_join().
Since partition_bounds_merge() would need a lot of CPU cycles, I don't
think this is acceptable; ISTM that some redesign is needed to avoid
this. I'm wondering that once we successfully merged partition bounds
from a pair of input partitioned relations for the join relation, by
using the merged partition bounds, we could get the lists of matching
to-be-joined partitions for subsequent pairs of input partitioned
relations for the join relation in a more efficient way than by
performing partition_bounds_merge() as proposed in the patch.
Best regards,
Etsuro Fujita
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 02:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-03-11 05:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 16:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-04-24 11:26 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-05-14 04:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2019-05-17 12:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2019-07-01 09:49 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@gmail.com>
2019-07-01 11:16 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-02 04:47 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-07-03 06:44 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-08 11:33 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-18 06:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
@ 2019-07-19 13:43 ` Robert Haas <robertmhaas@gmail.com>
2019-07-30 09:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Robert Haas @ 2019-07-19 13:43 UTC (permalink / raw)
To: Etsuro Fujita <etsuro.fujita@gmail.com>; +Cc: amul sul <sulamul@gmail.com>; Thomas Munro <thomas.munro@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>; Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Thu, Jul 18, 2019 at 2:55 AM Etsuro Fujita <etsuro.fujita@gmail.com> wrote:
> I.e., partition_bounds_merge() is performed for each pair of input
> partitioned relations for a join relation in try_partitionwise_join().
> Since partition_bounds_merge() would need a lot of CPU cycles, I don't
> think this is acceptable; ISTM that some redesign is needed to avoid
> this. I'm wondering that once we successfully merged partition bounds
> from a pair of input partitioned relations for the join relation, by
> using the merged partition bounds, we could get the lists of matching
> to-be-joined partitions for subsequent pairs of input partitioned
> relations for the join relation in a more efficient way than by
> performing partition_bounds_merge() as proposed in the patch.
I don't know whether partition_bounds_merge() is well-implemented; I
haven't looked. But in general I don't see an alternative to doing
some kind of merging on each pair of input relations. That's just how
planning works, and I don't see why it should need to be prohibitively
expensive. I might be missing something, though; do you have an idea?
--
Robert Haas
EnterpriseDB: http://www.enterprisedb.com
The Enterprise PostgreSQL Company
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 02:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-03-11 05:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 16:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-04-24 11:26 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-05-14 04:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2019-05-17 12:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2019-07-01 09:49 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@gmail.com>
2019-07-01 11:16 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-02 04:47 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-07-03 06:44 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-08 11:33 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-18 06:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-19 13:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
@ 2019-07-30 09:00 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-31 05:47 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <amitlangote09@gmail.com>
2019-08-16 13:25 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
0 siblings, 2 replies; 154+ messages in thread
From: Etsuro Fujita @ 2019-07-30 09:00 UTC (permalink / raw)
To: Robert Haas <robertmhaas@gmail.com>; +Cc: amul sul <sulamul@gmail.com>; Thomas Munro <thomas.munro@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>; Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Fri, Jul 19, 2019 at 10:44 PM Robert Haas <robertmhaas@gmail.com> wrote:
> On Thu, Jul 18, 2019 at 2:55 AM Etsuro Fujita <etsuro.fujita@gmail.com> wrote:
> > I.e., partition_bounds_merge() is performed for each pair of input
> > partitioned relations for a join relation in try_partitionwise_join().
> > Since partition_bounds_merge() would need a lot of CPU cycles, I don't
> > think this is acceptable; ISTM that some redesign is needed to avoid
> > this. I'm wondering that once we successfully merged partition bounds
> > from a pair of input partitioned relations for the join relation, by
> > using the merged partition bounds, we could get the lists of matching
> > to-be-joined partitions for subsequent pairs of input partitioned
> > relations for the join relation in a more efficient way than by
> > performing partition_bounds_merge() as proposed in the patch.
>
> I don't know whether partition_bounds_merge() is well-implemented; I
> haven't looked.
My concern about that is list partitioning. In that case that
function calls partition_list_bounds_merge(), which generates the
partition bounds for a join relation between two given input
relations, by performing merge join for a pair of the datums arrays
from both the input relations. Since the datums arrays contain all
non-null list values across all partitions, if the numbers of the list
values (ie, ndatums') are large, the merge join would require not a
few cycles, so it would be much expensive to perform the merge join
for each such pair when considering large N-way partitionwise joins of
list-partitioned tables with large ndatums. To see that, I did simple
tests using a list-partitioned table pt created with the attached,
which has 10 partitions, each with 1000 list values, so ndatums is
10000. (The tests below are performed with
enable_partitionwise_join=on.)
* 2-way self-join of pt: explain analyze select * from pt t0, pt t1
where t0.a = t1.a;
- HEAD:
Planning Time: 1.731 ms
Execution Time: 15.159 ms
- Patched:
Planning Time: 1.884 ms
Execution Time: 15.127 ms
* 4-way self-join of pt: explain analyze select * from pt t0, pt t1,
pt t2, pt t3 where t0.a = t1.a and t1.a = t2.a and t2.a = t3.a;
- HEAD:
Planning Time: 28.787 ms
Execution Time: 34.313 ms
- Patched:
Planning Time: 40.263 ms
Execution Time: 35.019 ms
* 8-way self-join of pt: explain analyze select * from pt t0, pt t1,
pt t2, pt t3, pt t4, pt t5, pt t6, pt t7 where t0.a = t1.a and t1.a =
t2.a and t2.a = t3.a and t3.a = t4.a and t4.a = t5.a and t5.a = t6.a
and t6.a = t7.a;
- HEAD:
Planning Time: 2279.653 ms
Execution Time: 63.303 ms
- Patched:
Planning Time: 3834.751 ms
Execution Time: 62.949 ms
Actually, these joins would not need the partition-matching algorithm
the patch adds; we could probably avoid this regression by modifying
the patch to plan these joins the same way as before, but ISTM that
these results imply that the cost of performing the merge join for
each such pair would not be negligible when considering large N-way
partitionwise joins mentioned above. Maybe I'm missing something,
though.
> But in general I don't see an alternative to doing
> some kind of merging on each pair of input relations. That's just how
> planning works, and I don't see why it should need to be prohibitively
> expensive. I might be missing something, though; do you have an idea?
Yes, I do; but I think I should think a little more about that.
Sorry for the delay.
Best regards,
Etsuro Fujita
Attachments:
[application/octet-stream] list_parted2.sql (79.7K, ../../CAPmGK16wDqJiUof8+e4HuGmrAqqoFzb=iQX4V+xicsJ5_BvJ=g@mail.gmail.com/2-list_parted2.sql)
download
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 02:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-03-11 05:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 16:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-04-24 11:26 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-05-14 04:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2019-05-17 12:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2019-07-01 09:49 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@gmail.com>
2019-07-01 11:16 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-02 04:47 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-07-03 06:44 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-08 11:33 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-18 06:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-19 13:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2019-07-30 09:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
@ 2019-07-31 05:47 ` Amit Langote <amitlangote09@gmail.com>
2019-08-01 10:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
1 sibling, 1 reply; 154+ messages in thread
From: Amit Langote @ 2019-07-31 05:47 UTC (permalink / raw)
To: Etsuro Fujita <etsuro.fujita@gmail.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; amul sul <sulamul@gmail.com>; Thomas Munro <thomas.munro@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>; Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
On Tue, Jul 30, 2019 at 6:00 PM Etsuro Fujita <etsuro.fujita@gmail.com> wrote:
> On Fri, Jul 19, 2019 at 10:44 PM Robert Haas <robertmhaas@gmail.com> wrote:
> > On Thu, Jul 18, 2019 at 2:55 AM Etsuro Fujita <etsuro.fujita@gmail.com> wrote:
> > > I.e., partition_bounds_merge() is performed for each pair of input
> > > partitioned relations for a join relation in try_partitionwise_join().
> > > Since partition_bounds_merge() would need a lot of CPU cycles, I don't
> > > think this is acceptable; ISTM that some redesign is needed to avoid
> > > this. I'm wondering that once we successfully merged partition bounds
> > > from a pair of input partitioned relations for the join relation, by
> > > using the merged partition bounds, we could get the lists of matching
> > > to-be-joined partitions for subsequent pairs of input partitioned
> > > relations for the join relation in a more efficient way than by
> > > performing partition_bounds_merge() as proposed in the patch.
> >
> > I don't know whether partition_bounds_merge() is well-implemented; I
> > haven't looked.
>
> My concern about that is list partitioning. In that case that
> function calls partition_list_bounds_merge(), which generates the
> partition bounds for a join relation between two given input
> relations, by performing merge join for a pair of the datums arrays
> from both the input relations.
I had similar thoughts upon seeing that partition_bounds_merge() will
be replacing the current way of determining if partition-wise join can
occur; that it will make the handling of currently supported cases
more expensive.
The current way is to compare the PartitionBoundInfos of joining
relations using partition_bounds_equal(), and if equal, simply join
the pairs of matching partitions if the join quals permit doing so.
There's no need to do anything extra to determine which partitions to
join with each other, because it's already established. Likewise,
partition_bounds_merge() shouldn't to have to anything extra in that
case. That is, for the cases that are already supported, we should
find a way to make partition_bounds_merge() only as expensive as just
performing partition_bounds_equals(), or maybe just slightly more.
Thanks,
Amit
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 02:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-03-11 05:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 16:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-04-24 11:26 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-05-14 04:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2019-05-17 12:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2019-07-01 09:49 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@gmail.com>
2019-07-01 11:16 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-02 04:47 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-07-03 06:44 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-08 11:33 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-18 06:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-19 13:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2019-07-30 09:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-31 05:47 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <amitlangote09@gmail.com>
@ 2019-08-01 10:36 ` Etsuro Fujita <etsuro.fujita@gmail.com>
0 siblings, 0 replies; 154+ messages in thread
From: Etsuro Fujita @ 2019-08-01 10:36 UTC (permalink / raw)
To: Amit Langote <amitlangote09@gmail.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; amul sul <sulamul@gmail.com>; Thomas Munro <thomas.munro@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>; Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
Amit-san,
On Wed, Jul 31, 2019 at 2:47 PM Amit Langote <amitlangote09@gmail.com> wrote:
> On Tue, Jul 30, 2019 at 6:00 PM Etsuro Fujita <etsuro.fujita@gmail.com> wrote:
> > On Fri, Jul 19, 2019 at 10:44 PM Robert Haas <robertmhaas@gmail.com> wrote:
> > > I don't know whether partition_bounds_merge() is well-implemented; I
> > > haven't looked.
> >
> > My concern about that is list partitioning. In that case that
> > function calls partition_list_bounds_merge(), which generates the
> > partition bounds for a join relation between two given input
> > relations, by performing merge join for a pair of the datums arrays
> > from both the input relations.
>
> I had similar thoughts upon seeing that partition_bounds_merge() will
> be replacing the current way of determining if partition-wise join can
> occur; that it will make the handling of currently supported cases
> more expensive.
>
> The current way is to compare the PartitionBoundInfos of joining
> relations using partition_bounds_equal(), and if equal, simply join
> the pairs of matching partitions if the join quals permit doing so.
> There's no need to do anything extra to determine which partitions to
> join with each other, because it's already established. Likewise,
> partition_bounds_merge() shouldn't to have to anything extra in that
> case. That is, for the cases that are already supported, we should
> find a way to make partition_bounds_merge() only as expensive as just
> performing partition_bounds_equals(), or maybe just slightly more.
I 100% agree on that point.
One thing that was unexpected to me is this:
I wrote:
> To see that, I did simple
> tests using a list-partitioned table pt created with the attached,
> which has 10 partitions, each with 1000 list values, so ndatums is
> 10000. (The tests below are performed with
> enable_partitionwise_join=on.)
>
> * 2-way self-join of pt: explain analyze select * from pt t0, pt t1
> where t0.a = t1.a;
> - HEAD:
> Planning Time: 1.731 ms
> Execution Time: 15.159 ms
> - Patched:
> Planning Time: 1.884 ms
> Execution Time: 15.127 ms
IIUC, in this test, I think partition_bounds_equals() and
partition_bounds_merge() have been performed only once in HEAD and the
patched version respectively to plan the partitionwise join, so this
might imply that the cost of the latter is just slightly more
expensive than that of the former. I'm missing something, though.
Anyway I'll continue to review this patch, so I'll move this to the
next CF with the same status (Needs review).
Best regards,
Etsuro Fujita
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 02:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-03-11 05:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 16:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-04-24 11:26 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-05-14 04:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2019-05-17 12:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2019-07-01 09:49 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@gmail.com>
2019-07-01 11:16 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-02 04:47 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-07-03 06:44 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-08 11:33 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-18 06:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-19 13:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2019-07-30 09:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-08-16 13:25 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-08-28 10:22 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
@ 2019-08-28 10:26 ` amul sul <sulamul@gmail.com>
2 siblings, 0 replies; 154+ messages in thread
From: amul sul @ 2019-08-28 10:26 UTC (permalink / raw)
To: Etsuro Fujita <etsuro.fujita@gmail.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; Thomas Munro <thomas.munro@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>; Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
Thank you Fujita San for the enhancement, will have a look.
Regards,
Amul
On Wed, Aug 28, 2019 at 3:52 PM Etsuro Fujita <etsuro.fujita@gmail.com>
wrote:
> On Fri, Aug 16, 2019 at 10:25 PM Etsuro Fujita <etsuro.fujita@gmail.com>
> wrote:
> > It seems that I performed the above tests on an assertion-enabled
> > build. :( So I executed the tests one more time. Here are the
> > results.
> >
> > * 2-way self-join of pt: explain analyze select * from pt t0, pt t1
> > where t0.a = t1.a;
> > - HEAD:
> > Planning Time: 0.969 ms
> > Execution Time: 13.843 ms
> > - with patch:
> > Planning Time: 1.720 ms
> > Execution Time: 14.393 ms
> > - with patch plus attached:
> > Planning Time: 1.630 ms
> > Execution Time: 14.002 ms
> >
> > * 4-way self-join of pt: explain analyze select * from pt t0, pt t1,
> > pt t2, pt t3 where t0.a = t1.a
> >
> > and t1.a = t2.a and t2.a = t3.a;
> > - HEAD:
> > Planning Time: 12.203 ms
> > Execution Time: 31.784 ms
> > - with patch:
> > Planning Time: 32.102 ms
> > Execution Time: 32.504 ms
> > - with patch plus attached:
> > Planning Time: 19.471 ms
> > Execution Time: 32.582 ms
> >
> > * 8-way self-join of pt: explain analyze select * from pt t0, pt t1,
> > pt t2, pt t3, pt t4, pt t5, pt t6, pt t7 where t0.a = t1.a and t1.a =
> > t2.a and t2.a = t3.a and t3.a = t4.a and t4.a = t5.a and t5.a = t6.a
> > and t6.a = t7.a;
> > - HEAD:
> > Planning Time: 948.131 ms
> > Execution Time: 55.645 ms
> > - with patch:
> > Planning Time: 2939.813 ms
> > Execution Time: 56.760 ms
> > - with patch plus attached:
> > Planning Time: 1108.076 ms
> > Execution Time: 55.750 ms
> >
> > Note: the attached patch still uses the proposed partition matching
> > algorithm for these queries. As I said before, these queries don't
> > need that algorithm, so we could eliminate the planning overhead
> > compared to HEAD, by planning these queries as before, perhaps, but I
> > haven't modified the patch as such yet.
>
> I modified the patch further as such. Attached is an updated version
> of the patch created on top of the patch in [1]. I did the tests
> again using the updated version of the patch. Here are the results:
>
> * 2-way self-join of pt:
> Planning Time: 1.043 ms
> Execution Time: 13.931 ms
>
> * 4-way self-join of pt:
> Planning Time: 12.499 ms
> Execution Time: 32.392 ms
>
> * 8-way self-join of pt:
> Planning Time: 968.412 ms
> Execution Time: 56.328 ms
>
> The planning time for each test case still increased slightly, but IMO
> I think that would be acceptable. To see the efficiency of the
> attached, I did another testing with test cases that really need the
> new partition-matching algorithm:
>
> * explain analyze select * from pt6 t6, pt7 t7 where t6.a = t7.a;
> - base patch in [1]
> Planning Time: 1.758 ms
> Execution Time: 13.977 ms
> - with attached
> Planning Time: 1.777 ms
> Execution Time: 13.959 ms
>
> * explain analyze select * from pt4 t4, pt5 t5, pt6 t6, pt7 t7 where
> t4.a = t5.a and t5.a = t6.a and t6.a = t7.a;
> - base patch in [1]
> Planning Time: 33.201 ms
> Execution Time: 32.480 ms
> - with attached
> Planning Time: 21.019 ms
> Execution Time: 32.777 ms
>
> * explain analyze select * from pt0 t0, pt1 t1, pt2 t2, pt3 t3, pt4
> t4, pt5 t5, pt6 t6, pt7 t7 where t0.a = t1.a and t1.a = t2.a and t2.a
> = t3.a and t3.a = t4.a and t4.a = t5.a and t5.a = t6.a and t6.a =
> t7.a;
> - base patch in [1]
> Planning Time: 3060.000 ms
> Execution Time: 55.553 ms
> - with attached
> Planning Time: 1144.996 ms
> Execution Time: 56.233 ms
>
> where pt0, pt1, pt2, pt3, pt4, pt5, pt6 and pt7 are list partitioned
> tables that have slighly different list values. (The structure and
> list values of ptN are almost the same as that of pt used above, but
> ptN's N-th partition ptNpN has an extra list value that pt's N-th
> partition ptpN doesn't have.) If anyone is interested in this
> testing, I'll send a script file for producing these list partitioned
> tables.
>
> About the attached:
>
> * The attached patch modified try_partitionwise_join() so that we call
> partition_bounds_equal() then partition_bounds_merge() (if necessary)
> to create the partition bounds for the join rel. We don't support for
> merging the partition bounds for the hash-partitioning case, so this
> makes code to handle the hash-partitioning case in
> partition_bounds_merge() completely unnecessary, so I removed that
> entirely.
>
> * I removed this assertion in partition_bounds_merge(), because I
> think this is covered by two assertions above this.
>
> + Assert((*outer_parts == NIL || *inner_parts != NIL) &&
> + (*inner_parts == NIL || *outer_parts != NIL));
>
> * (I forgot to mention this in a previous email, but) I removed this
> bit of generate_matching_part_pairs(), because we already have the
> same check in try_partitionwise_join(), so this bit would be redundant
> IIUC.
>
> + switch (jointype)
> + {
> + case JOIN_INNER:
> + case JOIN_SEMI:
> +
> + /*
> + * An inner or semi join can not return any row when the
> + * matching partition on either side is missing. We should
> + * have eliminated all such cases while merging the bounds.
> + */
> + Assert(part1 >= 0 && part2 >= 0);
> + break;
> +
> + case JOIN_LEFT:
> + case JOIN_ANTI:
> + Assert(part1 >= 0);
> + if (part2 < 0)
> + merged = false;
> + break;
> +
> + case JOIN_FULL:
> + if (part1 < 0 || part2 < 0)
> + merged = false;
> + break;
> +
> + default:
> + elog(ERROR, "unrecognized join type: %d", (int) jointype);
> + }
>
> * I added more comments.
>
> If there are no objections, I'll merge the attached with the base patch in
> [1].
>
> Best regards,
> Etsuro Fujita
>
> [1]
> https://www.postgresql.org/message-id/CAPmGK177W%2BjNgpM5f_m-vdDKbEBu_%3D3CyPzFjkT_1nzf1Vqn%2BA%40ma...
>
^ permalink raw reply [nested|flat] 154+ messages in thread
* Re: [HACKERS] advanced partition matching algorithm for partition-wise join
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Re: advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-07 14:04 ` Re: advanced partition matching algorithm for partition-wise join Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Re: advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Re: advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:27 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-17 09:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 02:58 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-03-11 05:09 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-03-11 16:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-04-24 11:26 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-05-14 04:23 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2019-05-17 12:20 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2019-07-01 09:49 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Thomas Munro <thomas.munro@gmail.com>
2019-07-01 11:16 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-02 04:47 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-07-03 06:44 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-08 11:33 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-18 06:55 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-19 13:43 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Robert Haas <robertmhaas@gmail.com>
2019-07-30 09:00 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-08-16 13:25 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-08-28 10:22 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-09-02 05:08 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
2019-09-24 15:59 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-10-16 12:50 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
2019-10-25 09:59 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join amul sul <sulamul@gmail.com>
@ 2019-10-29 10:29 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-10-31 09:49 ` Re: [HACKERS] advanced partition matching algorithm for partition-wise join Etsuro Fujita <etsuro.fujita@gmail.com>
0 siblings, 1 reply; 154+ messages in thread
From: Etsuro Fujita @ 2019-10-29 10:29 UTC (permalink / raw)
To: amul sul <sulamul@gmail.com>; +Cc: Robert Haas <robertmhaas@gmail.com>; Thomas Munro <thomas.munro@gmail.com>; Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>; Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>; Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>; Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>; Dmitry Dolgov <9erthalion6@gmail.com>; Thomas Munro <thomas.munro@enterprisedb.com>; Antonin Houska <ah@cybertec.at>; pgsql-hackers
Hi Amul,
On Fri, Oct 25, 2019 at 6:59 PM amul sul <sulamul@gmail.com> wrote:
> On Wed, Oct 16, 2019 at 6:20 PM Etsuro Fujita <etsuro.fujita@gmail.com> wrote:
>> So I'd like to propose to introduce separate functions like
>> process_outer_partition() and process_inner_partition() in the
>> attached, instead of handle_missing_partition(). (I added a fast path
>> to these functions that if both outer/inner sides have the default
>> partitions, give up on merging partitions. Also, I modified the
>> caller sites of proposed functions so that they call these if
>> necessary.)
> Agree -- process_outer_partition() & process_inner_partition() approach looks
> much cleaner than before.
>
> Here are the few comments:
Thanks for the review!
> Note that LHS numbers are the line numbers in your previously posted patch[1].
>
> 455 + if (inner_has_default ||
> 456 + jointype == JOIN_LEFT ||
> 457 + jointype == JOIN_ANTI ||
> 458 + jointype == JOIN_FULL)
> 459 + {
> 460 + if (!process_outer_partition(&outer_map,
>
> 512 + if (outer_has_default || jointype == JOIN_FULL)
> 513 + {
> 514 + if (!process_inner_partition(&outer_map,
>
> How about adding these conditions to the else block of process_outer_partition()
> & process_inner_partition() function respectively so that these functions can be
> called unconditionally? Thoughts/Comments?
I'm not sure that's a good idea; these functions might be called many
times, so I just thought it would be better to call these functions
conditionally, to avoid useless function call overhead.
> 456 + jointype == JOIN_LEFT ||
> 457 + jointype == JOIN_ANTI ||
> 458 + jointype == JOIN_FULL)
>
> Also, how about using IS_OUTER_JOIN() instead. But we need an assertion to
> restrict JOIN_RIGHT or something.
Seems like a good idea.
> For the convenience, I did both aforesaid changes in the attached delta patch that
> can be applied atop of your previously posted patch[1]. Kindly have a look & share
> your thoughts, thanks.
Thanks for the patch!
> 1273 + * *next_index is incremented when creating a new merged partition associated
> 1274 + * with the given outer partition.
> 1275 + */
>
> Correction: s/outer/inner
> ---
>
> 1338 + * In range partitioning, if the given outer partition is already
> 1339 + * merged (eg, because we found an overlapping range earlier), we know
> 1340 + * where it fits in the join result; nothing to do in that case. Else
> 1341 + * create a new merged partition.
>
> Correction: s/outer/inner.
> ---
>
> 1712 /*
> 1713 * If the NULL partition was missing from the inner side of the join,
>
> s/inner side/outer side
> --
Good catch! Will fix.
Best regards,
Etsuro Fujita
^ permalink raw reply [nested|flat] 154+ messages in thread
68 further messages in this thread omitted from this page (render size limit).
Use the per-message pages, or the t.mbox.gz byte stream, for the complete thread.
end of thread, other threads:[~2020-04-16 09:20 UTC | newest]
Thread overview: 154+ messages (download: mbox mbox.gz follow: Atom feed)
-- links below jump to the message on this page --
2017-08-21 07:13 advanced partition matching algorithm for partition-wise join Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-08-28 07:14 ` Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-01 19:12 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-04 12:30 ` Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-05 11:04 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-09-05 11:55 ` Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2017-09-07 14:04 ` Antonin Houska <ah@cybertec.at>
2017-09-11 08:08 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-11 11:08 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-10-12 16:16 ` Robert Haas <robertmhaas@gmail.com>
2017-10-13 02:29 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2017-12-03 11:23 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-07 04:51 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-08 02:55 ` Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-08 05:11 ` Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 05:31 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-09 05:56 ` Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-09 06:05 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-09 05:27 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-15 09:11 ` Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-02-16 05:14 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-02-23 14:05 ` Robert Haas <robertmhaas@gmail.com>
2018-02-26 10:03 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-11 19:34 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-12 05:00 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-21 23:02 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-22 13:18 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-03-28 21:23 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-03-30 14:06 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-04-03 13:34 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-05-06 19:36 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-05-14 11:14 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-26 08:57 ` Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-26 09:02 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-27 06:58 ` Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-06-27 13:21 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-06-28 05:53 ` Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2018-07-15 17:43 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-16 15:01 ` Robert Haas <robertmhaas@gmail.com>
2018-07-17 09:58 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-19 19:04 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-19 21:43 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-23 08:38 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-26 15:07 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-07-27 07:17 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-07-27 18:13 ` Robert Haas <robertmhaas@gmail.com>
2018-08-23 10:31 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-29 07:32 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-08-30 08:53 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-08-31 06:23 ` Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>
2018-09-12 20:14 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-09-17 09:20 ` Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2018-10-25 21:19 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 20:04 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-25 21:06 ` Thomas Munro <thomas.munro@enterprisedb.com>
2018-11-26 12:41 ` Dmitry Dolgov <9erthalion6@gmail.com>
2018-11-26 16:03 ` Dmitry Dolgov <9erthalion6@gmail.com>
2019-01-21 11:56 ` amul sul <sulamul@gmail.com>
2019-01-21 12:09 ` Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-22 12:38 ` Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-01-31 11:53 ` Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>
2019-02-04 05:35 ` amul sul <sulamul@gmail.com>
2019-03-05 10:14 ` amul sul <sulamul@gmail.com>
2019-03-07 06:24 ` Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-07 07:32 ` amul sul <sulamul@gmail.com>
2019-03-07 14:50 ` amul sul <sulamul@gmail.com>
2019-03-08 08:42 ` Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-03-11 02:58 ` Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-03-11 05:09 ` amul sul <sulamul@gmail.com>
2019-03-11 16:43 ` Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-04-24 11:26 ` amul sul <sulamul@gmail.com>
2019-04-26 10:29 ` Rajkumar Raghuwanshi <rajkumar.raghuwanshi@enterprisedb.com>
2019-05-14 04:23 ` Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2019-05-14 04:29 ` Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>
2019-05-14 14:11 ` Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2019-05-17 12:20 ` Robert Haas <robertmhaas@gmail.com>
2019-07-01 09:49 ` Thomas Munro <thomas.munro@gmail.com>
2019-07-01 11:16 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-02 04:47 ` amul sul <sulamul@gmail.com>
2019-07-03 06:44 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-08 11:33 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-18 06:55 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-19 13:43 ` Robert Haas <robertmhaas@gmail.com>
2019-07-30 09:00 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-31 05:47 ` Amit Langote <amitlangote09@gmail.com>
2019-08-01 10:36 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-08-16 13:25 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-08-28 10:22 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-08-28 10:26 ` amul sul <sulamul@gmail.com>
2019-09-02 05:08 ` amul sul <sulamul@gmail.com>
2019-09-24 15:59 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-10-16 12:50 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-10-25 09:59 ` amul sul <sulamul@gmail.com>
2019-10-29 10:29 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-10-31 09:49 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-11-01 10:28 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-11-05 13:14 ` amul sul <sulamul@gmail.com>
2019-11-06 06:11 ` amul sul <sulamul@gmail.com>
2019-11-13 04:16 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-11-15 05:20 ` amul sul <sulamul@gmail.com>
2019-11-15 09:10 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-11-22 13:08 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-11-29 03:45 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-12-09 09:38 ` amul sul <sulamul@gmail.com>
2019-12-10 06:49 ` amul sul <sulamul@gmail.com>
2019-12-10 10:30 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2020-01-15 14:41 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2020-01-28 04:39 ` Mark Dilger <mark.dilger@enterprisedb.com>
2020-01-29 12:15 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2020-02-05 12:51 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2020-02-05 17:03 ` Mark Dilger <mark.dilger@enterprisedb.com>
2020-02-07 12:53 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2020-02-05 18:55 ` Mark Dilger <mark.dilger@enterprisedb.com>
2020-02-07 12:57 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2020-02-10 11:46 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2020-03-03 16:48 ` Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2020-03-17 08:14 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2020-03-23 13:41 ` Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2020-03-24 18:03 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2020-03-25 19:05 ` Tomas Vondra <tomas.vondra@2ndquadrant.com>
2020-03-26 00:17 ` Tomas Vondra <tomas.vondra@2ndquadrant.com>
2020-04-01 16:51 ` Ashutosh Bapat <ashutosh.bapat@2ndquadrant.com>
2020-04-02 03:08 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2020-04-01 17:12 ` Ashutosh Bapat <ashutosh.bapat@2ndquadrant.com>
2020-04-03 15:15 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2020-04-06 08:28 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2020-04-06 11:45 ` Ashutosh Bapat <ashutosh.bapat@2ndquadrant.com>
2020-04-07 15:15 ` Tomas Vondra <tomas.vondra@2ndquadrant.com>
2020-04-07 17:24 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2020-04-08 01:36 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2020-04-08 05:09 ` Ashutosh Bapat <ashutosh.bapat@2ndquadrant.com>
2020-04-08 07:30 ` Kuntal Ghosh <kuntalghosh.2007@gmail.com>
2020-04-08 10:12 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2020-04-08 10:18 ` Ashutosh Bapat <ashutosh.bapat@2ndquadrant.com>
2020-04-08 15:06 ` Kuntal Ghosh <kuntalghosh.2007@gmail.com>
2020-04-09 04:59 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2020-04-09 05:36 ` Tom Lane <tgl@sss.pgh.pa.us>
2020-04-09 06:33 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2020-04-09 14:04 ` Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2020-04-09 14:41 ` Tomas Vondra <tomas.vondra@2ndquadrant.com>
2020-04-10 15:14 ` Jeff Janes <jeff.janes@gmail.com>
2020-04-10 15:20 ` Ashutosh Bapat <ashutosh.bapat@2ndquadrant.com>
2020-04-10 15:44 ` Tom Lane <tgl@sss.pgh.pa.us>
2020-04-10 15:51 ` Ashutosh Bapat <ashutosh.bapat.oss@gmail.com>
2020-04-10 15:59 ` Tom Lane <tgl@sss.pgh.pa.us>
2020-04-11 04:02 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2020-04-08 10:14 ` Ashutosh Bapat <ashutosh.bapat@2ndquadrant.com>
2020-04-06 11:43 ` Ashutosh Bapat <ashutosh.bapat@2ndquadrant.com>
2020-04-16 09:20 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-09-03 21:10 ` Alvaro Herrera <alvherre@2ndquadrant.com>
2019-09-05 04:23 ` amul sul <sulamul@gmail.com>
2019-09-05 07:10 ` Etsuro Fujita <etsuro.fujita@gmail.com>
2019-07-19 11:09 ` amul sul <sulamul@gmail.com>
2019-07-30 07:57 ` Etsuro Fujita <etsuro.fujita@gmail.com>
This inbox is served by agora; see mirroring instructions
for how to clone and mirror all data and code used for this inbox