Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * partbounds.c
4 : * Support routines for manipulating partition bounds
5 : *
6 : * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
7 : * Portions Copyright (c) 1994, Regents of the University of California
8 : *
9 : * IDENTIFICATION
10 : * src/backend/partitioning/partbounds.c
11 : *
12 : *-------------------------------------------------------------------------
13 : */
14 :
15 : #include "postgres.h"
16 :
17 : #include "access/relation.h"
18 : #include "access/table.h"
19 : #include "access/tableam.h"
20 : #include "catalog/partition.h"
21 : #include "catalog/pg_inherits.h"
22 : #include "catalog/pg_type.h"
23 : #include "commands/tablecmds.h"
24 : #include "common/hashfn.h"
25 : #include "executor/executor.h"
26 : #include "miscadmin.h"
27 : #include "nodes/makefuncs.h"
28 : #include "nodes/nodeFuncs.h"
29 : #include "nodes/pathnodes.h"
30 : #include "parser/parse_coerce.h"
31 : #include "partitioning/partbounds.h"
32 : #include "partitioning/partdesc.h"
33 : #include "partitioning/partprune.h"
34 : #include "utils/builtins.h"
35 : #include "utils/datum.h"
36 : #include "utils/fmgroids.h"
37 : #include "utils/lsyscache.h"
38 : #include "utils/partcache.h"
39 : #include "utils/ruleutils.h"
40 : #include "utils/snapmgr.h"
41 : #include "utils/syscache.h"
42 :
43 : /*
44 : * When qsort'ing partition bounds after reading from the catalog, each bound
45 : * is represented with one of the following structs.
46 : */
47 :
48 : /* One bound of a hash partition */
49 : typedef struct PartitionHashBound
50 : {
51 : int modulus;
52 : int remainder;
53 : int index;
54 : } PartitionHashBound;
55 :
56 : /* One value coming from some (index'th) list partition */
57 : typedef struct PartitionListValue
58 : {
59 : int index;
60 : Datum value;
61 : } PartitionListValue;
62 :
63 : /* One bound of a range partition */
64 : typedef struct PartitionRangeBound
65 : {
66 : int index;
67 : Datum *datums; /* range bound datums */
68 : PartitionRangeDatumKind *kind; /* the kind of each datum */
69 : bool lower; /* this is the lower (vs upper) bound */
70 : } PartitionRangeBound;
71 :
72 : /*
73 : * Mapping from partitions of a joining relation to partitions of a join
74 : * relation being computed (a.k.a merged partitions)
75 : */
76 : typedef struct PartitionMap
77 : {
78 : int nparts; /* number of partitions */
79 : int *merged_indexes; /* indexes of merged partitions */
80 : bool *merged; /* flags to indicate whether partitions are
81 : * merged with non-dummy partitions */
82 : bool did_remapping; /* did we re-map partitions? */
83 : int *old_indexes; /* old indexes of merged partitions if
84 : * did_remapping */
85 : } PartitionMap;
86 :
87 : /* Macro for comparing two range bounds */
88 : #define compare_range_bounds(partnatts, partsupfunc, partcollations, \
89 : bound1, bound2) \
90 : (partition_rbound_cmp(partnatts, partsupfunc, partcollations, \
91 : (bound1)->datums, (bound1)->kind, (bound1)->lower, \
92 : bound2))
93 :
94 : static int32 qsort_partition_hbound_cmp(const void *a, const void *b);
95 : static int32 qsort_partition_list_value_cmp(const void *a, const void *b,
96 : void *arg);
97 : static int32 qsort_partition_rbound_cmp(const void *a, const void *b,
98 : void *arg);
99 : static PartitionBoundInfo create_hash_bounds(PartitionBoundSpec **boundspecs,
100 : int nparts, PartitionKey key, int **mapping);
101 : static PartitionBoundInfo create_list_bounds(PartitionBoundSpec **boundspecs,
102 : int nparts, PartitionKey key, int **mapping);
103 : static PartitionBoundInfo create_range_bounds(PartitionBoundSpec **boundspecs,
104 : int nparts, PartitionKey key, int **mapping);
105 : static PartitionBoundInfo merge_list_bounds(FmgrInfo *partsupfunc,
106 : Oid *collations,
107 : RelOptInfo *outer_rel,
108 : RelOptInfo *inner_rel,
109 : JoinType jointype,
110 : List **outer_parts,
111 : List **inner_parts);
112 : static PartitionBoundInfo merge_range_bounds(int partnatts,
113 : FmgrInfo *partsupfuncs,
114 : Oid *partcollations,
115 : RelOptInfo *outer_rel,
116 : RelOptInfo *inner_rel,
117 : JoinType jointype,
118 : List **outer_parts,
119 : List **inner_parts);
120 : static void init_partition_map(RelOptInfo *rel, PartitionMap *map);
121 : static void free_partition_map(PartitionMap *map);
122 : static bool is_dummy_partition(RelOptInfo *rel, int part_index);
123 : static int merge_matching_partitions(PartitionMap *outer_map,
124 : PartitionMap *inner_map,
125 : int outer_part,
126 : int inner_part,
127 : int *next_index);
128 : static int process_outer_partition(PartitionMap *outer_map,
129 : PartitionMap *inner_map,
130 : bool outer_has_default,
131 : bool inner_has_default,
132 : int outer_index,
133 : int inner_default,
134 : JoinType jointype,
135 : int *next_index,
136 : int *default_index);
137 : static int process_inner_partition(PartitionMap *outer_map,
138 : PartitionMap *inner_map,
139 : bool outer_has_default,
140 : bool inner_has_default,
141 : int inner_index,
142 : int outer_default,
143 : JoinType jointype,
144 : int *next_index,
145 : int *default_index);
146 : static void merge_null_partitions(PartitionMap *outer_map,
147 : PartitionMap *inner_map,
148 : bool outer_has_null,
149 : bool inner_has_null,
150 : int outer_null,
151 : int inner_null,
152 : JoinType jointype,
153 : int *next_index,
154 : int *null_index);
155 : static void merge_default_partitions(PartitionMap *outer_map,
156 : PartitionMap *inner_map,
157 : bool outer_has_default,
158 : bool inner_has_default,
159 : int outer_default,
160 : int inner_default,
161 : JoinType jointype,
162 : int *next_index,
163 : int *default_index);
164 : static int merge_partition_with_dummy(PartitionMap *map, int index,
165 : int *next_index);
166 : static void fix_merged_indexes(PartitionMap *outer_map,
167 : PartitionMap *inner_map,
168 : int nmerged, List *merged_indexes);
169 : static void generate_matching_part_pairs(RelOptInfo *outer_rel,
170 : RelOptInfo *inner_rel,
171 : PartitionMap *outer_map,
172 : PartitionMap *inner_map,
173 : int nmerged,
174 : List **outer_parts,
175 : List **inner_parts);
176 : static PartitionBoundInfo build_merged_partition_bounds(char strategy,
177 : List *merged_datums,
178 : List *merged_kinds,
179 : List *merged_indexes,
180 : int null_index,
181 : int default_index);
182 : static int get_range_partition(RelOptInfo *rel,
183 : PartitionBoundInfo bi,
184 : int *lb_pos,
185 : PartitionRangeBound *lb,
186 : PartitionRangeBound *ub);
187 : static int get_range_partition_internal(PartitionBoundInfo bi,
188 : int *lb_pos,
189 : PartitionRangeBound *lb,
190 : PartitionRangeBound *ub);
191 : static bool compare_range_partitions(int partnatts, FmgrInfo *partsupfuncs,
192 : Oid *partcollations,
193 : PartitionRangeBound *outer_lb,
194 : PartitionRangeBound *outer_ub,
195 : PartitionRangeBound *inner_lb,
196 : PartitionRangeBound *inner_ub,
197 : int *lb_cmpval, int *ub_cmpval);
198 : static void get_merged_range_bounds(int partnatts, FmgrInfo *partsupfuncs,
199 : Oid *partcollations, JoinType jointype,
200 : PartitionRangeBound *outer_lb,
201 : PartitionRangeBound *outer_ub,
202 : PartitionRangeBound *inner_lb,
203 : PartitionRangeBound *inner_ub,
204 : int lb_cmpval, int ub_cmpval,
205 : PartitionRangeBound *merged_lb,
206 : PartitionRangeBound *merged_ub);
207 : static void add_merged_range_bounds(int partnatts, FmgrInfo *partsupfuncs,
208 : Oid *partcollations,
209 : PartitionRangeBound *merged_lb,
210 : PartitionRangeBound *merged_ub,
211 : int merged_index,
212 : List **merged_datums,
213 : List **merged_kinds,
214 : List **merged_indexes);
215 : static PartitionRangeBound *make_one_partition_rbound(PartitionKey key, int index,
216 : List *datums, bool lower);
217 : static int32 partition_hbound_cmp(int modulus1, int remainder1, int modulus2,
218 : int remainder2);
219 : static int32 partition_rbound_cmp(int partnatts, FmgrInfo *partsupfunc,
220 : Oid *partcollation, Datum *datums1,
221 : PartitionRangeDatumKind *kind1, bool lower1,
222 : PartitionRangeBound *b2);
223 : static int partition_range_bsearch(int partnatts, FmgrInfo *partsupfunc,
224 : Oid *partcollation,
225 : PartitionBoundInfo boundinfo,
226 : PartitionRangeBound *probe, int32 *cmpval);
227 : static Expr *make_partition_op_expr(PartitionKey key, int keynum,
228 : uint16 strategy, Expr *arg1, Expr *arg2);
229 : static Oid get_partition_operator(PartitionKey key, int col,
230 : StrategyNumber strategy, bool *need_relabel);
231 : static List *get_qual_for_hash(Relation parent, PartitionBoundSpec *spec);
232 : static List *get_qual_for_list(Relation parent, PartitionBoundSpec *spec);
233 : static List *get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
234 : bool for_default);
235 : static void get_range_key_properties(PartitionKey key, int keynum,
236 : PartitionRangeDatum *ldatum,
237 : PartitionRangeDatum *udatum,
238 : ListCell **partexprs_item,
239 : Expr **keyCol,
240 : Const **lower_val, Const **upper_val);
241 : static List *get_range_nulltest(PartitionKey key);
242 :
243 : /*
244 : * get_qual_from_partbound
245 : * Given a parser node for partition bound, return the list of executable
246 : * expressions as partition constraint
247 : */
248 : List *
249 4780 : get_qual_from_partbound(Relation parent, PartitionBoundSpec *spec)
250 : {
251 4780 : PartitionKey key = RelationGetPartitionKey(parent);
252 4780 : List *my_qual = NIL;
253 :
254 : Assert(key != NULL);
255 :
256 4780 : switch (key->strategy)
257 : {
258 116 : case PARTITION_STRATEGY_HASH:
259 : Assert(spec->strategy == PARTITION_STRATEGY_HASH);
260 116 : my_qual = get_qual_for_hash(parent, spec);
261 116 : break;
262 :
263 2202 : case PARTITION_STRATEGY_LIST:
264 : Assert(spec->strategy == PARTITION_STRATEGY_LIST);
265 2202 : my_qual = get_qual_for_list(parent, spec);
266 2202 : break;
267 :
268 2462 : case PARTITION_STRATEGY_RANGE:
269 : Assert(spec->strategy == PARTITION_STRATEGY_RANGE);
270 2462 : my_qual = get_qual_for_range(parent, spec, false);
271 2462 : break;
272 :
273 0 : default:
274 0 : elog(ERROR, "unexpected partition strategy: %d",
275 : (int) key->strategy);
276 : }
277 :
278 4780 : return my_qual;
279 : }
280 :
281 : /*
282 : * partition_bounds_create
283 : * Build a PartitionBoundInfo struct from a list of PartitionBoundSpec
284 : * nodes
285 : *
286 : * This function creates a PartitionBoundInfo and fills the values of its
287 : * various members based on the input list. Importantly, 'datums' array will
288 : * contain Datum representation of individual bounds (possibly after
289 : * de-duplication as in case of range bounds), sorted in a canonical order
290 : * defined by qsort_partition_* functions of respective partitioning methods.
291 : * 'indexes' array will contain as many elements as there are bounds (specific
292 : * exceptions to this rule are listed in the function body), which represent
293 : * the 0-based canonical positions of partitions.
294 : *
295 : * Upon return from this function, *mapping is set to an array of
296 : * list_length(boundspecs) elements, each of which maps the original index of
297 : * a partition to its canonical index.
298 : *
299 : * Note: The objects returned by this function are wholly allocated in the
300 : * current memory context.
301 : */
302 : PartitionBoundInfo
303 13830 : partition_bounds_create(PartitionBoundSpec **boundspecs, int nparts,
304 : PartitionKey key, int **mapping)
305 : {
306 : int i;
307 :
308 : Assert(nparts > 0);
309 :
310 : /*
311 : * For each partitioning method, we first convert the partition bounds
312 : * from their parser node representation to the internal representation,
313 : * along with any additional preprocessing (such as de-duplicating range
314 : * bounds). Resulting bound datums are then added to the 'datums' array
315 : * in PartitionBoundInfo. For each datum added, an integer indicating the
316 : * canonical partition index is added to the 'indexes' array.
317 : *
318 : * For each bound, we remember its partition's position (0-based) in the
319 : * original list to later map it to the canonical index.
320 : */
321 :
322 : /*
323 : * Initialize mapping array with invalid values, this is filled within
324 : * each sub-routine below depending on the bound type.
325 : */
326 13830 : *mapping = (int *) palloc(sizeof(int) * nparts);
327 41728 : for (i = 0; i < nparts; i++)
328 27898 : (*mapping)[i] = -1;
329 :
330 13830 : switch (key->strategy)
331 : {
332 538 : case PARTITION_STRATEGY_HASH:
333 538 : return create_hash_bounds(boundspecs, nparts, key, mapping);
334 :
335 7148 : case PARTITION_STRATEGY_LIST:
336 7148 : return create_list_bounds(boundspecs, nparts, key, mapping);
337 :
338 6144 : case PARTITION_STRATEGY_RANGE:
339 6144 : return create_range_bounds(boundspecs, nparts, key, mapping);
340 :
341 0 : default:
342 0 : elog(ERROR, "unexpected partition strategy: %d",
343 : (int) key->strategy);
344 : break;
345 : }
346 :
347 : Assert(false);
348 : return NULL; /* keep compiler quiet */
349 : }
350 :
351 : /*
352 : * create_hash_bounds
353 : * Create a PartitionBoundInfo for a hash partitioned table
354 : */
355 : static PartitionBoundInfo
356 538 : create_hash_bounds(PartitionBoundSpec **boundspecs, int nparts,
357 : PartitionKey key, int **mapping)
358 : {
359 : PartitionBoundInfo boundinfo;
360 : PartitionHashBound *hbounds;
361 : int i;
362 : int greatest_modulus;
363 : Datum *boundDatums;
364 :
365 : boundinfo = (PartitionBoundInfoData *)
366 538 : palloc0(sizeof(PartitionBoundInfoData));
367 538 : boundinfo->strategy = key->strategy;
368 : /* No special hash partitions. */
369 538 : boundinfo->null_index = -1;
370 538 : boundinfo->default_index = -1;
371 :
372 : hbounds = (PartitionHashBound *)
373 538 : palloc(nparts * sizeof(PartitionHashBound));
374 :
375 : /* Convert from node to the internal representation */
376 1596 : for (i = 0; i < nparts; i++)
377 : {
378 1058 : PartitionBoundSpec *spec = boundspecs[i];
379 :
380 1058 : if (spec->strategy != PARTITION_STRATEGY_HASH)
381 0 : elog(ERROR, "invalid strategy in partition bound spec");
382 :
383 1058 : hbounds[i].modulus = spec->modulus;
384 1058 : hbounds[i].remainder = spec->remainder;
385 1058 : hbounds[i].index = i;
386 : }
387 :
388 : /* Sort all the bounds in ascending order */
389 538 : qsort(hbounds, nparts, sizeof(PartitionHashBound),
390 : qsort_partition_hbound_cmp);
391 :
392 : /* After sorting, moduli are now stored in ascending order. */
393 538 : greatest_modulus = hbounds[nparts - 1].modulus;
394 :
395 538 : boundinfo->ndatums = nparts;
396 538 : boundinfo->datums = (Datum **) palloc0(nparts * sizeof(Datum *));
397 538 : boundinfo->kind = NULL;
398 538 : boundinfo->interleaved_parts = NULL;
399 538 : boundinfo->nindexes = greatest_modulus;
400 538 : boundinfo->indexes = (int *) palloc(greatest_modulus * sizeof(int));
401 4920 : for (i = 0; i < greatest_modulus; i++)
402 4382 : boundinfo->indexes[i] = -1;
403 :
404 : /*
405 : * In the loop below, to save from allocating a series of small datum
406 : * arrays, here we just allocate a single array and below we'll just
407 : * assign a portion of this array per partition.
408 : */
409 538 : boundDatums = (Datum *) palloc(nparts * 2 * sizeof(Datum));
410 :
411 : /*
412 : * For hash partitioning, there are as many datums (modulus and remainder
413 : * pairs) as there are partitions. Indexes are simply values ranging from
414 : * 0 to (nparts - 1).
415 : */
416 1596 : for (i = 0; i < nparts; i++)
417 : {
418 1058 : int modulus = hbounds[i].modulus;
419 1058 : int remainder = hbounds[i].remainder;
420 :
421 1058 : boundinfo->datums[i] = &boundDatums[i * 2];
422 1058 : boundinfo->datums[i][0] = Int32GetDatum(modulus);
423 1058 : boundinfo->datums[i][1] = Int32GetDatum(remainder);
424 :
425 2590 : while (remainder < greatest_modulus)
426 : {
427 : /* overlap? */
428 : Assert(boundinfo->indexes[remainder] == -1);
429 1532 : boundinfo->indexes[remainder] = i;
430 1532 : remainder += modulus;
431 : }
432 :
433 1058 : (*mapping)[hbounds[i].index] = i;
434 : }
435 538 : pfree(hbounds);
436 :
437 538 : return boundinfo;
438 : }
439 :
440 : /*
441 : * get_non_null_list_datum_count
442 : * Counts the number of non-null Datums in each partition.
443 : */
444 : static int
445 7148 : get_non_null_list_datum_count(PartitionBoundSpec **boundspecs, int nparts)
446 : {
447 : int i;
448 7148 : int count = 0;
449 :
450 21214 : for (i = 0; i < nparts; i++)
451 : {
452 : ListCell *lc;
453 :
454 34238 : foreach(lc, boundspecs[i]->listdatums)
455 : {
456 20172 : Const *val = lfirst_node(Const, lc);
457 :
458 20172 : if (!val->constisnull)
459 19638 : count++;
460 : }
461 : }
462 :
463 7148 : return count;
464 : }
465 :
466 : /*
467 : * create_list_bounds
468 : * Create a PartitionBoundInfo for a list partitioned table
469 : */
470 : static PartitionBoundInfo
471 7148 : create_list_bounds(PartitionBoundSpec **boundspecs, int nparts,
472 : PartitionKey key, int **mapping)
473 : {
474 : PartitionBoundInfo boundinfo;
475 : PartitionListValue *all_values;
476 : int i;
477 : int j;
478 : int ndatums;
479 7148 : int next_index = 0;
480 7148 : int default_index = -1;
481 7148 : int null_index = -1;
482 : Datum *boundDatums;
483 :
484 : boundinfo = (PartitionBoundInfoData *)
485 7148 : palloc0(sizeof(PartitionBoundInfoData));
486 7148 : boundinfo->strategy = key->strategy;
487 : /* Will be set correctly below. */
488 7148 : boundinfo->null_index = -1;
489 7148 : boundinfo->default_index = -1;
490 :
491 7148 : ndatums = get_non_null_list_datum_count(boundspecs, nparts);
492 : all_values = (PartitionListValue *)
493 7148 : palloc(ndatums * sizeof(PartitionListValue));
494 :
495 : /* Create a unified list of non-null values across all partitions. */
496 21214 : for (j = 0, i = 0; i < nparts; i++)
497 : {
498 14066 : PartitionBoundSpec *spec = boundspecs[i];
499 : ListCell *c;
500 :
501 14066 : if (spec->strategy != PARTITION_STRATEGY_LIST)
502 0 : elog(ERROR, "invalid strategy in partition bound spec");
503 :
504 : /*
505 : * Note the index of the partition bound spec for the default
506 : * partition. There's no datum to add to the list on non-null datums
507 : * for this partition.
508 : */
509 14066 : if (spec->is_default)
510 : {
511 828 : default_index = i;
512 828 : continue;
513 : }
514 :
515 33410 : foreach(c, spec->listdatums)
516 : {
517 20172 : Const *val = lfirst_node(Const, c);
518 :
519 20172 : if (!val->constisnull)
520 : {
521 19638 : all_values[j].index = i;
522 19638 : all_values[j].value = val->constvalue;
523 19638 : j++;
524 : }
525 : else
526 : {
527 : /*
528 : * Never put a null into the values array; save the index of
529 : * the partition that stores nulls, instead.
530 : */
531 534 : if (null_index != -1)
532 0 : elog(ERROR, "found null more than once");
533 534 : null_index = i;
534 : }
535 : }
536 : }
537 :
538 : /* ensure we found a Datum for every slot in the all_values array */
539 : Assert(j == ndatums);
540 :
541 7148 : qsort_arg(all_values, ndatums, sizeof(PartitionListValue),
542 : qsort_partition_list_value_cmp, (void *) key);
543 :
544 7148 : boundinfo->ndatums = ndatums;
545 7148 : boundinfo->datums = (Datum **) palloc0(ndatums * sizeof(Datum *));
546 7148 : boundinfo->kind = NULL;
547 7148 : boundinfo->interleaved_parts = NULL;
548 7148 : boundinfo->nindexes = ndatums;
549 7148 : boundinfo->indexes = (int *) palloc(ndatums * sizeof(int));
550 :
551 : /*
552 : * In the loop below, to save from allocating a series of small datum
553 : * arrays, here we just allocate a single array and below we'll just
554 : * assign a portion of this array per datum.
555 : */
556 7148 : boundDatums = (Datum *) palloc(ndatums * sizeof(Datum));
557 :
558 : /*
559 : * Copy values. Canonical indexes are values ranging from 0 to (nparts -
560 : * 1) assigned to each partition such that all datums of a given partition
561 : * receive the same value. The value for a given partition is the index of
562 : * that partition's smallest datum in the all_values[] array.
563 : */
564 26786 : for (i = 0; i < ndatums; i++)
565 : {
566 19638 : int orig_index = all_values[i].index;
567 :
568 19638 : boundinfo->datums[i] = &boundDatums[i];
569 39276 : boundinfo->datums[i][0] = datumCopy(all_values[i].value,
570 19638 : key->parttypbyval[0],
571 19638 : key->parttyplen[0]);
572 :
573 : /* If the old index has no mapping, assign one */
574 19638 : if ((*mapping)[orig_index] == -1)
575 13046 : (*mapping)[orig_index] = next_index++;
576 :
577 19638 : boundinfo->indexes[i] = (*mapping)[orig_index];
578 : }
579 :
580 7148 : pfree(all_values);
581 :
582 : /*
583 : * Set the canonical value for null_index, if any.
584 : *
585 : * It is possible that the null-accepting partition has not been assigned
586 : * an index yet, which could happen if such partition accepts only null
587 : * and hence not handled in the above loop which only looked at non-null
588 : * values.
589 : */
590 7148 : if (null_index != -1)
591 : {
592 : Assert(null_index >= 0);
593 534 : if ((*mapping)[null_index] == -1)
594 192 : (*mapping)[null_index] = next_index++;
595 534 : boundinfo->null_index = (*mapping)[null_index];
596 : }
597 :
598 : /* Set the canonical value for default_index, if any. */
599 7148 : if (default_index != -1)
600 : {
601 : /*
602 : * The default partition accepts any value not specified in the lists
603 : * of other partitions, hence it should not get mapped index while
604 : * assigning those for non-null datums.
605 : */
606 : Assert(default_index >= 0);
607 : Assert((*mapping)[default_index] == -1);
608 828 : (*mapping)[default_index] = next_index++;
609 828 : boundinfo->default_index = (*mapping)[default_index];
610 : }
611 :
612 : /*
613 : * Calculate interleaved partitions. Here we look for partitions which
614 : * might be interleaved with other partitions and set a bit in
615 : * interleaved_parts for any partitions which may be interleaved with
616 : * another partition.
617 : */
618 :
619 : /*
620 : * There must be multiple partitions to have any interleaved partitions,
621 : * otherwise there's nothing to interleave with.
622 : */
623 7148 : if (nparts > 1)
624 : {
625 : /*
626 : * Short-circuit check to see if only 1 Datum is allowed per
627 : * partition. When this is true there's no need to do the more
628 : * expensive checks to look for interleaved values.
629 : */
630 4298 : if (boundinfo->ndatums +
631 4298 : partition_bound_accepts_nulls(boundinfo) +
632 4298 : partition_bound_has_default(boundinfo) != nparts)
633 : {
634 1694 : int last_index = -1;
635 :
636 : /*
637 : * Since the indexes array is sorted in Datum order, if any
638 : * partitions are interleaved then it will show up by the
639 : * partition indexes not being in ascending order. Here we check
640 : * for that and record all partitions that are out of order.
641 : */
642 11884 : for (i = 0; i < boundinfo->nindexes; i++)
643 : {
644 10190 : int index = boundinfo->indexes[i];
645 :
646 10190 : if (index < last_index)
647 610 : boundinfo->interleaved_parts = bms_add_member(boundinfo->interleaved_parts,
648 : index);
649 :
650 : /*
651 : * Otherwise, if the null_index exists in the indexes array,
652 : * then the NULL partition must also allow some other Datum,
653 : * therefore it's "interleaved".
654 : */
655 9580 : else if (partition_bound_accepts_nulls(boundinfo) &&
656 2838 : index == boundinfo->null_index)
657 756 : boundinfo->interleaved_parts = bms_add_member(boundinfo->interleaved_parts,
658 : index);
659 :
660 10190 : last_index = index;
661 : }
662 : }
663 :
664 : /*
665 : * The DEFAULT partition is the "catch-all" partition that can contain
666 : * anything that does not belong to any other partition. If there are
667 : * any other partitions then the DEFAULT partition must be marked as
668 : * interleaved.
669 : */
670 4298 : if (partition_bound_has_default(boundinfo))
671 718 : boundinfo->interleaved_parts = bms_add_member(boundinfo->interleaved_parts,
672 : boundinfo->default_index);
673 : }
674 :
675 :
676 : /* All partitions must now have been assigned canonical indexes. */
677 : Assert(next_index == nparts);
678 7148 : return boundinfo;
679 : }
680 :
681 : /*
682 : * create_range_bounds
683 : * Create a PartitionBoundInfo for a range partitioned table
684 : */
685 : static PartitionBoundInfo
686 6144 : create_range_bounds(PartitionBoundSpec **boundspecs, int nparts,
687 : PartitionKey key, int **mapping)
688 : {
689 : PartitionBoundInfo boundinfo;
690 6144 : PartitionRangeBound **rbounds = NULL;
691 : PartitionRangeBound **all_bounds,
692 : *prev;
693 : int i,
694 : k,
695 : partnatts;
696 6144 : int ndatums = 0;
697 6144 : int default_index = -1;
698 6144 : int next_index = 0;
699 : Datum *boundDatums;
700 : PartitionRangeDatumKind *boundKinds;
701 :
702 : boundinfo = (PartitionBoundInfoData *)
703 6144 : palloc0(sizeof(PartitionBoundInfoData));
704 6144 : boundinfo->strategy = key->strategy;
705 : /* There is no special null-accepting range partition. */
706 6144 : boundinfo->null_index = -1;
707 : /* Will be set correctly below. */
708 6144 : boundinfo->default_index = -1;
709 :
710 : all_bounds = (PartitionRangeBound **)
711 6144 : palloc0(2 * nparts * sizeof(PartitionRangeBound *));
712 :
713 : /* Create a unified list of range bounds across all the partitions. */
714 6144 : ndatums = 0;
715 18918 : for (i = 0; i < nparts; i++)
716 : {
717 12774 : PartitionBoundSpec *spec = boundspecs[i];
718 : PartitionRangeBound *lower,
719 : *upper;
720 :
721 12774 : if (spec->strategy != PARTITION_STRATEGY_RANGE)
722 0 : elog(ERROR, "invalid strategy in partition bound spec");
723 :
724 : /*
725 : * Note the index of the partition bound spec for the default
726 : * partition. There's no datum to add to the all_bounds array for
727 : * this partition.
728 : */
729 12774 : if (spec->is_default)
730 : {
731 754 : default_index = i;
732 754 : continue;
733 : }
734 :
735 12020 : lower = make_one_partition_rbound(key, i, spec->lowerdatums, true);
736 12020 : upper = make_one_partition_rbound(key, i, spec->upperdatums, false);
737 12020 : all_bounds[ndatums++] = lower;
738 12020 : all_bounds[ndatums++] = upper;
739 : }
740 :
741 : Assert(ndatums == nparts * 2 ||
742 : (default_index != -1 && ndatums == (nparts - 1) * 2));
743 :
744 : /* Sort all the bounds in ascending order */
745 6144 : qsort_arg(all_bounds, ndatums,
746 : sizeof(PartitionRangeBound *),
747 : qsort_partition_rbound_cmp,
748 : (void *) key);
749 :
750 : /* Save distinct bounds from all_bounds into rbounds. */
751 : rbounds = (PartitionRangeBound **)
752 6144 : palloc(ndatums * sizeof(PartitionRangeBound *));
753 6144 : k = 0;
754 6144 : prev = NULL;
755 30184 : for (i = 0; i < ndatums; i++)
756 : {
757 24040 : PartitionRangeBound *cur = all_bounds[i];
758 24040 : bool is_distinct = false;
759 : int j;
760 :
761 : /* Is the current bound distinct from the previous one? */
762 32846 : for (j = 0; j < key->partnatts; j++)
763 : {
764 : Datum cmpval;
765 :
766 27788 : if (prev == NULL || cur->kind[j] != prev->kind[j])
767 : {
768 7440 : is_distinct = true;
769 7440 : break;
770 : }
771 :
772 : /*
773 : * If the bounds are both MINVALUE or MAXVALUE, stop now and treat
774 : * them as equal, since any values after this point must be
775 : * ignored.
776 : */
777 20348 : if (cur->kind[j] != PARTITION_RANGE_DATUM_VALUE)
778 186 : break;
779 :
780 20162 : cmpval = FunctionCall2Coll(&key->partsupfunc[j],
781 20162 : key->partcollation[j],
782 20162 : cur->datums[j],
783 20162 : prev->datums[j]);
784 20162 : if (DatumGetInt32(cmpval) != 0)
785 : {
786 11356 : is_distinct = true;
787 11356 : break;
788 : }
789 : }
790 :
791 : /*
792 : * Only if the bound is distinct save it into a temporary array, i.e,
793 : * rbounds which is later copied into boundinfo datums array.
794 : */
795 24040 : if (is_distinct)
796 18796 : rbounds[k++] = all_bounds[i];
797 :
798 24040 : prev = cur;
799 : }
800 :
801 6144 : pfree(all_bounds);
802 :
803 : /* Update ndatums to hold the count of distinct datums. */
804 6144 : ndatums = k;
805 :
806 : /*
807 : * Add datums to boundinfo. Canonical indexes are values ranging from 0
808 : * to nparts - 1, assigned in that order to each partition's upper bound.
809 : * For 'datums' elements that are lower bounds, there is -1 in the
810 : * 'indexes' array to signify that no partition exists for the values less
811 : * than such a bound and greater than or equal to the previous upper
812 : * bound.
813 : */
814 6144 : boundinfo->ndatums = ndatums;
815 6144 : boundinfo->datums = (Datum **) palloc0(ndatums * sizeof(Datum *));
816 6144 : boundinfo->kind = (PartitionRangeDatumKind **)
817 6144 : palloc(ndatums *
818 : sizeof(PartitionRangeDatumKind *));
819 6144 : boundinfo->interleaved_parts = NULL;
820 :
821 : /*
822 : * For range partitioning, an additional value of -1 is stored as the last
823 : * element of the indexes[] array.
824 : */
825 6144 : boundinfo->nindexes = ndatums + 1;
826 6144 : boundinfo->indexes = (int *) palloc((ndatums + 1) * sizeof(int));
827 :
828 : /*
829 : * In the loop below, to save from allocating a series of small arrays,
830 : * here we just allocate a single array for Datums and another for
831 : * PartitionRangeDatumKinds, below we'll just assign a portion of these
832 : * arrays in each loop.
833 : */
834 6144 : partnatts = key->partnatts;
835 6144 : boundDatums = (Datum *) palloc(ndatums * partnatts * sizeof(Datum));
836 6144 : boundKinds = (PartitionRangeDatumKind *) palloc(ndatums * partnatts *
837 : sizeof(PartitionRangeDatumKind));
838 :
839 24940 : for (i = 0; i < ndatums; i++)
840 : {
841 : int j;
842 :
843 18796 : boundinfo->datums[i] = &boundDatums[i * partnatts];
844 18796 : boundinfo->kind[i] = &boundKinds[i * partnatts];
845 43120 : for (j = 0; j < partnatts; j++)
846 : {
847 24324 : if (rbounds[i]->kind[j] == PARTITION_RANGE_DATUM_VALUE)
848 21842 : boundinfo->datums[i][j] =
849 21842 : datumCopy(rbounds[i]->datums[j],
850 21842 : key->parttypbyval[j],
851 21842 : key->parttyplen[j]);
852 24324 : boundinfo->kind[i][j] = rbounds[i]->kind[j];
853 : }
854 :
855 : /*
856 : * There is no mapping for invalid indexes.
857 : *
858 : * Any lower bounds in the rbounds array have invalid indexes
859 : * assigned, because the values between the previous bound (if there
860 : * is one) and this (lower) bound are not part of the range of any
861 : * existing partition.
862 : */
863 18796 : if (rbounds[i]->lower)
864 6776 : boundinfo->indexes[i] = -1;
865 : else
866 : {
867 12020 : int orig_index = rbounds[i]->index;
868 :
869 : /* If the old index has no mapping, assign one */
870 12020 : if ((*mapping)[orig_index] == -1)
871 12020 : (*mapping)[orig_index] = next_index++;
872 :
873 12020 : boundinfo->indexes[i] = (*mapping)[orig_index];
874 : }
875 : }
876 :
877 6144 : pfree(rbounds);
878 :
879 : /* Set the canonical value for default_index, if any. */
880 6144 : if (default_index != -1)
881 : {
882 : Assert(default_index >= 0 && (*mapping)[default_index] == -1);
883 754 : (*mapping)[default_index] = next_index++;
884 754 : boundinfo->default_index = (*mapping)[default_index];
885 : }
886 :
887 : /* The extra -1 element. */
888 : Assert(i == ndatums);
889 6144 : boundinfo->indexes[i] = -1;
890 :
891 : /* All partitions must now have been assigned canonical indexes. */
892 : Assert(next_index == nparts);
893 6144 : return boundinfo;
894 : }
895 :
896 : /*
897 : * Are two partition bound collections logically equal?
898 : *
899 : * Used in the keep logic of relcache.c (ie, in RelationClearRelation()).
900 : * This is also useful when b1 and b2 are bound collections of two separate
901 : * relations, respectively, because PartitionBoundInfo is a canonical
902 : * representation of partition bounds.
903 : */
904 : bool
905 1446 : partition_bounds_equal(int partnatts, int16 *parttyplen, bool *parttypbyval,
906 : PartitionBoundInfo b1, PartitionBoundInfo b2)
907 : {
908 : int i;
909 :
910 1446 : if (b1->strategy != b2->strategy)
911 0 : return false;
912 :
913 1446 : if (b1->ndatums != b2->ndatums)
914 222 : return false;
915 :
916 1224 : if (b1->nindexes != b2->nindexes)
917 0 : return false;
918 :
919 1224 : if (b1->null_index != b2->null_index)
920 72 : return false;
921 :
922 1152 : if (b1->default_index != b2->default_index)
923 0 : return false;
924 :
925 : /* For all partition strategies, the indexes[] arrays have to match */
926 6944 : for (i = 0; i < b1->nindexes; i++)
927 : {
928 5840 : if (b1->indexes[i] != b2->indexes[i])
929 48 : return false;
930 : }
931 :
932 : /* Finally, compare the datums[] arrays */
933 1104 : if (b1->strategy == PARTITION_STRATEGY_HASH)
934 : {
935 : /*
936 : * We arrange the partitions in the ascending order of their moduli
937 : * and remainders. Also every modulus is factor of next larger
938 : * modulus. Therefore we can safely store index of a given partition
939 : * in indexes array at remainder of that partition. Also entries at
940 : * (remainder + N * modulus) positions in indexes array are all same
941 : * for (modulus, remainder) specification for any partition. Thus the
942 : * datums arrays from the given bounds are the same, if and only if
943 : * their indexes arrays are the same. So, it suffices to compare the
944 : * indexes arrays.
945 : *
946 : * Nonetheless make sure that the bounds are indeed the same when the
947 : * indexes match. Hash partition bound stores modulus and remainder
948 : * at b1->datums[i][0] and b1->datums[i][1] position respectively.
949 : */
950 : #ifdef USE_ASSERT_CHECKING
951 : for (i = 0; i < b1->ndatums; i++)
952 : Assert((b1->datums[i][0] == b2->datums[i][0] &&
953 : b1->datums[i][1] == b2->datums[i][1]));
954 : #endif
955 : }
956 : else
957 : {
958 4940 : for (i = 0; i < b1->ndatums; i++)
959 : {
960 : int j;
961 :
962 8002 : for (j = 0; j < partnatts; j++)
963 : {
964 : /* For range partitions, the bounds might not be finite. */
965 4118 : if (b1->kind != NULL)
966 : {
967 : /* The different kinds of bound all differ from each other */
968 3044 : if (b1->kind[i][j] != b2->kind[i][j])
969 0 : return false;
970 :
971 : /*
972 : * Non-finite bounds are equal without further
973 : * examination.
974 : */
975 3044 : if (b1->kind[i][j] != PARTITION_RANGE_DATUM_VALUE)
976 0 : continue;
977 : }
978 :
979 : /*
980 : * Compare the actual values. Note that it would be both
981 : * incorrect and unsafe to invoke the comparison operator
982 : * derived from the partitioning specification here. It would
983 : * be incorrect because we want the relcache entry to be
984 : * updated for ANY change to the partition bounds, not just
985 : * those that the partitioning operator thinks are
986 : * significant. It would be unsafe because we might reach
987 : * this code in the context of an aborted transaction, and an
988 : * arbitrary partitioning operator might not be safe in that
989 : * context. datumIsEqual() should be simple enough to be
990 : * safe.
991 : */
992 4118 : if (!datumIsEqual(b1->datums[i][j], b2->datums[i][j],
993 4118 : parttypbyval[j], parttyplen[j]))
994 186 : return false;
995 : }
996 : }
997 : }
998 918 : return true;
999 : }
1000 :
1001 : /*
1002 : * Return a copy of given PartitionBoundInfo structure. The data types of bounds
1003 : * are described by given partition key specification.
1004 : *
1005 : * Note: it's important that this function and its callees not do any catalog
1006 : * access, nor anything else that would result in allocating memory other than
1007 : * the returned data structure. Since this is called in a long-lived context,
1008 : * that would result in unwanted memory leaks.
1009 : */
1010 : PartitionBoundInfo
1011 13830 : partition_bounds_copy(PartitionBoundInfo src,
1012 : PartitionKey key)
1013 : {
1014 : PartitionBoundInfo dest;
1015 : int i;
1016 : int ndatums;
1017 : int nindexes;
1018 : int partnatts;
1019 : bool hash_part;
1020 : int natts;
1021 : Datum *boundDatums;
1022 :
1023 13830 : dest = (PartitionBoundInfo) palloc(sizeof(PartitionBoundInfoData));
1024 :
1025 13830 : dest->strategy = src->strategy;
1026 13830 : ndatums = dest->ndatums = src->ndatums;
1027 13830 : nindexes = dest->nindexes = src->nindexes;
1028 13830 : partnatts = key->partnatts;
1029 :
1030 : /* List partitioned tables have only a single partition key. */
1031 : Assert(key->strategy != PARTITION_STRATEGY_LIST || partnatts == 1);
1032 :
1033 13830 : dest->datums = (Datum **) palloc(sizeof(Datum *) * ndatums);
1034 :
1035 13830 : if (src->kind != NULL)
1036 : {
1037 : PartitionRangeDatumKind *boundKinds;
1038 :
1039 : /* only RANGE partition should have a non-NULL kind */
1040 : Assert(key->strategy == PARTITION_STRATEGY_RANGE);
1041 :
1042 6144 : dest->kind = (PartitionRangeDatumKind **) palloc(ndatums *
1043 : sizeof(PartitionRangeDatumKind *));
1044 :
1045 : /*
1046 : * In the loop below, to save from allocating a series of small arrays
1047 : * for storing the PartitionRangeDatumKind, we allocate a single chunk
1048 : * here and use a smaller portion of it for each datum.
1049 : */
1050 6144 : boundKinds = (PartitionRangeDatumKind *) palloc(ndatums * partnatts *
1051 : sizeof(PartitionRangeDatumKind));
1052 :
1053 24940 : for (i = 0; i < ndatums; i++)
1054 : {
1055 18796 : dest->kind[i] = &boundKinds[i * partnatts];
1056 18796 : memcpy(dest->kind[i], src->kind[i],
1057 : sizeof(PartitionRangeDatumKind) * partnatts);
1058 : }
1059 : }
1060 : else
1061 7686 : dest->kind = NULL;
1062 :
1063 : /* copy interleaved partitions for LIST partitioned tables */
1064 13830 : dest->interleaved_parts = bms_copy(src->interleaved_parts);
1065 :
1066 : /*
1067 : * For hash partitioning, datums array will have two elements - modulus
1068 : * and remainder.
1069 : */
1070 13830 : hash_part = (key->strategy == PARTITION_STRATEGY_HASH);
1071 13830 : natts = hash_part ? 2 : partnatts;
1072 13830 : boundDatums = palloc(ndatums * natts * sizeof(Datum));
1073 :
1074 53322 : for (i = 0; i < ndatums; i++)
1075 : {
1076 : int j;
1077 :
1078 39492 : dest->datums[i] = &boundDatums[i * natts];
1079 :
1080 85570 : for (j = 0; j < natts; j++)
1081 : {
1082 : bool byval;
1083 : int typlen;
1084 :
1085 46078 : if (hash_part)
1086 : {
1087 2116 : typlen = sizeof(int32); /* Always int4 */
1088 2116 : byval = true; /* int4 is pass-by-value */
1089 : }
1090 : else
1091 : {
1092 43962 : byval = key->parttypbyval[j];
1093 43962 : typlen = key->parttyplen[j];
1094 : }
1095 :
1096 46078 : if (dest->kind == NULL ||
1097 24324 : dest->kind[i][j] == PARTITION_RANGE_DATUM_VALUE)
1098 43596 : dest->datums[i][j] = datumCopy(src->datums[i][j],
1099 : byval, typlen);
1100 : }
1101 : }
1102 :
1103 13830 : dest->indexes = (int *) palloc(sizeof(int) * nindexes);
1104 13830 : memcpy(dest->indexes, src->indexes, sizeof(int) * nindexes);
1105 :
1106 13830 : dest->null_index = src->null_index;
1107 13830 : dest->default_index = src->default_index;
1108 :
1109 13830 : return dest;
1110 : }
1111 :
1112 : /*
1113 : * partition_bounds_merge
1114 : * Check to see whether every partition of 'outer_rel' matches/overlaps
1115 : * one partition of 'inner_rel' at most, and vice versa; and if so, build
1116 : * and return the partition bounds for a join relation between the rels,
1117 : * generating two lists of the matching/overlapping partitions, which are
1118 : * returned to *outer_parts and *inner_parts respectively.
1119 : *
1120 : * The lists contain the same number of partitions, and the partitions at the
1121 : * same positions in the lists indicate join pairs used for partitioned join.
1122 : * If a partition on one side matches/overlaps multiple partitions on the other
1123 : * side, this function returns NULL, setting *outer_parts and *inner_parts to
1124 : * NIL.
1125 : */
1126 : PartitionBoundInfo
1127 846 : partition_bounds_merge(int partnatts,
1128 : FmgrInfo *partsupfunc, Oid *partcollation,
1129 : RelOptInfo *outer_rel, RelOptInfo *inner_rel,
1130 : JoinType jointype,
1131 : List **outer_parts, List **inner_parts)
1132 : {
1133 : /*
1134 : * Currently, this function is called only from try_partitionwise_join(),
1135 : * so the join type should be INNER, LEFT, FULL, SEMI, or ANTI.
1136 : */
1137 : Assert(jointype == JOIN_INNER || jointype == JOIN_LEFT ||
1138 : jointype == JOIN_FULL || jointype == JOIN_SEMI ||
1139 : jointype == JOIN_ANTI);
1140 :
1141 : /* The partitioning strategies should be the same. */
1142 : Assert(outer_rel->boundinfo->strategy == inner_rel->boundinfo->strategy);
1143 :
1144 846 : *outer_parts = *inner_parts = NIL;
1145 846 : switch (outer_rel->boundinfo->strategy)
1146 : {
1147 0 : case PARTITION_STRATEGY_HASH:
1148 :
1149 : /*
1150 : * For hash partitioned tables, we currently support partitioned
1151 : * join only when they have exactly the same partition bounds.
1152 : *
1153 : * XXX: it might be possible to relax the restriction to support
1154 : * cases where hash partitioned tables have missing partitions
1155 : * and/or different moduli, but it's not clear if it would be
1156 : * useful to support the former case since it's unusual to have
1157 : * missing partitions. On the other hand, it would be useful to
1158 : * support the latter case, but in that case, there is a high
1159 : * probability that a partition on one side will match multiple
1160 : * partitions on the other side, which is the scenario the current
1161 : * implementation of partitioned join can't handle.
1162 : */
1163 0 : return NULL;
1164 :
1165 486 : case PARTITION_STRATEGY_LIST:
1166 486 : return merge_list_bounds(partsupfunc,
1167 : partcollation,
1168 : outer_rel,
1169 : inner_rel,
1170 : jointype,
1171 : outer_parts,
1172 : inner_parts);
1173 :
1174 360 : case PARTITION_STRATEGY_RANGE:
1175 360 : return merge_range_bounds(partnatts,
1176 : partsupfunc,
1177 : partcollation,
1178 : outer_rel,
1179 : inner_rel,
1180 : jointype,
1181 : outer_parts,
1182 : inner_parts);
1183 :
1184 0 : default:
1185 0 : elog(ERROR, "unexpected partition strategy: %d",
1186 : (int) outer_rel->boundinfo->strategy);
1187 : return NULL; /* keep compiler quiet */
1188 : }
1189 : }
1190 :
1191 : /*
1192 : * merge_list_bounds
1193 : * Create the partition bounds for a join relation between list
1194 : * partitioned tables, if possible
1195 : *
1196 : * In this function we try to find sets of matching partitions from both sides
1197 : * by comparing list values stored in their partition bounds. Since the list
1198 : * values appear in the ascending order, an algorithm similar to merge join is
1199 : * used for that. If a partition on one side doesn't have a matching
1200 : * partition on the other side, the algorithm tries to match it with the
1201 : * default partition on the other side if any; if not, the algorithm tries to
1202 : * match it with a dummy partition on the other side if it's on the
1203 : * non-nullable side of an outer join. Also, if both sides have the default
1204 : * partitions, the algorithm tries to match them with each other. We give up
1205 : * if the algorithm finds a partition matching multiple partitions on the
1206 : * other side, which is the scenario the current implementation of partitioned
1207 : * join can't handle.
1208 : */
1209 : static PartitionBoundInfo
1210 486 : merge_list_bounds(FmgrInfo *partsupfunc, Oid *partcollation,
1211 : RelOptInfo *outer_rel, RelOptInfo *inner_rel,
1212 : JoinType jointype,
1213 : List **outer_parts, List **inner_parts)
1214 : {
1215 486 : PartitionBoundInfo merged_bounds = NULL;
1216 486 : PartitionBoundInfo outer_bi = outer_rel->boundinfo;
1217 486 : PartitionBoundInfo inner_bi = inner_rel->boundinfo;
1218 486 : bool outer_has_default = partition_bound_has_default(outer_bi);
1219 486 : bool inner_has_default = partition_bound_has_default(inner_bi);
1220 486 : int outer_default = outer_bi->default_index;
1221 486 : int inner_default = inner_bi->default_index;
1222 486 : bool outer_has_null = partition_bound_accepts_nulls(outer_bi);
1223 486 : bool inner_has_null = partition_bound_accepts_nulls(inner_bi);
1224 : PartitionMap outer_map;
1225 : PartitionMap inner_map;
1226 : int outer_pos;
1227 : int inner_pos;
1228 486 : int next_index = 0;
1229 486 : int null_index = -1;
1230 486 : int default_index = -1;
1231 486 : List *merged_datums = NIL;
1232 486 : List *merged_indexes = NIL;
1233 :
1234 : Assert(*outer_parts == NIL);
1235 : Assert(*inner_parts == NIL);
1236 : Assert(outer_bi->strategy == inner_bi->strategy &&
1237 : outer_bi->strategy == PARTITION_STRATEGY_LIST);
1238 : /* List partitioning doesn't require kinds. */
1239 : Assert(!outer_bi->kind && !inner_bi->kind);
1240 :
1241 486 : init_partition_map(outer_rel, &outer_map);
1242 486 : init_partition_map(inner_rel, &inner_map);
1243 :
1244 : /*
1245 : * If the default partitions (if any) have been proven empty, deem them
1246 : * non-existent.
1247 : */
1248 486 : if (outer_has_default && is_dummy_partition(outer_rel, outer_default))
1249 24 : outer_has_default = false;
1250 486 : if (inner_has_default && is_dummy_partition(inner_rel, inner_default))
1251 0 : inner_has_default = false;
1252 :
1253 : /*
1254 : * Merge partitions from both sides. In each iteration we compare a pair
1255 : * of list values, one from each side, and decide whether the
1256 : * corresponding partitions match or not. If the two values match
1257 : * exactly, move to the next pair of list values, otherwise move to the
1258 : * next list value on the side with a smaller list value.
1259 : */
1260 486 : outer_pos = inner_pos = 0;
1261 3822 : while (outer_pos < outer_bi->ndatums || inner_pos < inner_bi->ndatums)
1262 : {
1263 3384 : int outer_index = -1;
1264 3384 : int inner_index = -1;
1265 : Datum *outer_datums;
1266 : Datum *inner_datums;
1267 : int cmpval;
1268 3384 : Datum *merged_datum = NULL;
1269 3384 : int merged_index = -1;
1270 :
1271 3384 : if (outer_pos < outer_bi->ndatums)
1272 : {
1273 : /*
1274 : * If the partition on the outer side has been proven empty,
1275 : * ignore it and move to the next datum on the outer side.
1276 : */
1277 3336 : outer_index = outer_bi->indexes[outer_pos];
1278 3336 : if (is_dummy_partition(outer_rel, outer_index))
1279 : {
1280 168 : outer_pos++;
1281 168 : continue;
1282 : }
1283 : }
1284 3216 : if (inner_pos < inner_bi->ndatums)
1285 : {
1286 : /*
1287 : * If the partition on the inner side has been proven empty,
1288 : * ignore it and move to the next datum on the inner side.
1289 : */
1290 3216 : inner_index = inner_bi->indexes[inner_pos];
1291 3216 : if (is_dummy_partition(inner_rel, inner_index))
1292 : {
1293 0 : inner_pos++;
1294 0 : continue;
1295 : }
1296 : }
1297 :
1298 : /* Get the list values. */
1299 6432 : outer_datums = outer_pos < outer_bi->ndatums ?
1300 3216 : outer_bi->datums[outer_pos] : NULL;
1301 6432 : inner_datums = inner_pos < inner_bi->ndatums ?
1302 3216 : inner_bi->datums[inner_pos] : NULL;
1303 :
1304 : /*
1305 : * We run this loop till both sides finish. This allows us to avoid
1306 : * duplicating code to handle the remaining values on the side which
1307 : * finishes later. For that we set the comparison parameter cmpval in
1308 : * such a way that it appears as if the side which finishes earlier
1309 : * has an extra value higher than any other value on the unfinished
1310 : * side. That way we advance the values on the unfinished side till
1311 : * all of its values are exhausted.
1312 : */
1313 3216 : if (outer_pos >= outer_bi->ndatums)
1314 48 : cmpval = 1;
1315 3168 : else if (inner_pos >= inner_bi->ndatums)
1316 0 : cmpval = -1;
1317 : else
1318 : {
1319 : Assert(outer_datums != NULL && inner_datums != NULL);
1320 3168 : cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
1321 : partcollation[0],
1322 : outer_datums[0],
1323 : inner_datums[0]));
1324 : }
1325 :
1326 3216 : if (cmpval == 0)
1327 : {
1328 : /* Two list values match exactly. */
1329 : Assert(outer_pos < outer_bi->ndatums);
1330 : Assert(inner_pos < inner_bi->ndatums);
1331 : Assert(outer_index >= 0);
1332 : Assert(inner_index >= 0);
1333 :
1334 : /*
1335 : * Try merging both partitions. If successful, add the list value
1336 : * and index of the merged partition below.
1337 : */
1338 1644 : merged_index = merge_matching_partitions(&outer_map, &inner_map,
1339 : outer_index, inner_index,
1340 : &next_index);
1341 1644 : if (merged_index == -1)
1342 30 : goto cleanup;
1343 :
1344 1614 : merged_datum = outer_datums;
1345 :
1346 : /* Move to the next pair of list values. */
1347 1614 : outer_pos++;
1348 1614 : inner_pos++;
1349 : }
1350 1572 : else if (cmpval < 0)
1351 : {
1352 : /* A list value missing from the inner side. */
1353 : Assert(outer_pos < outer_bi->ndatums);
1354 :
1355 : /*
1356 : * If the inner side has the default partition, or this is an
1357 : * outer join, try to assign a merged partition to the outer
1358 : * partition (see process_outer_partition()). Otherwise, the
1359 : * outer partition will not contribute to the result.
1360 : */
1361 636 : if (inner_has_default || IS_OUTER_JOIN(jointype))
1362 : {
1363 : /* Get the outer partition. */
1364 408 : outer_index = outer_bi->indexes[outer_pos];
1365 : Assert(outer_index >= 0);
1366 408 : merged_index = process_outer_partition(&outer_map,
1367 : &inner_map,
1368 : outer_has_default,
1369 : inner_has_default,
1370 : outer_index,
1371 : inner_default,
1372 : jointype,
1373 : &next_index,
1374 : &default_index);
1375 408 : if (merged_index == -1)
1376 6 : goto cleanup;
1377 402 : merged_datum = outer_datums;
1378 : }
1379 :
1380 : /* Move to the next list value on the outer side. */
1381 630 : outer_pos++;
1382 : }
1383 : else
1384 : {
1385 : /* A list value missing from the outer side. */
1386 : Assert(cmpval > 0);
1387 : Assert(inner_pos < inner_bi->ndatums);
1388 :
1389 : /*
1390 : * If the outer side has the default partition, or this is a FULL
1391 : * join, try to assign a merged partition to the inner partition
1392 : * (see process_inner_partition()). Otherwise, the inner
1393 : * partition will not contribute to the result.
1394 : */
1395 936 : if (outer_has_default || jointype == JOIN_FULL)
1396 : {
1397 : /* Get the inner partition. */
1398 252 : inner_index = inner_bi->indexes[inner_pos];
1399 : Assert(inner_index >= 0);
1400 252 : merged_index = process_inner_partition(&outer_map,
1401 : &inner_map,
1402 : outer_has_default,
1403 : inner_has_default,
1404 : inner_index,
1405 : outer_default,
1406 : jointype,
1407 : &next_index,
1408 : &default_index);
1409 252 : if (merged_index == -1)
1410 12 : goto cleanup;
1411 240 : merged_datum = inner_datums;
1412 : }
1413 :
1414 : /* Move to the next list value on the inner side. */
1415 924 : inner_pos++;
1416 : }
1417 :
1418 : /*
1419 : * If we assigned a merged partition, add the list value and index of
1420 : * the merged partition if appropriate.
1421 : */
1422 3168 : if (merged_index >= 0 && merged_index != default_index)
1423 : {
1424 2184 : merged_datums = lappend(merged_datums, merged_datum);
1425 2184 : merged_indexes = lappend_int(merged_indexes, merged_index);
1426 : }
1427 : }
1428 :
1429 : /*
1430 : * If the NULL partitions (if any) have been proven empty, deem them
1431 : * non-existent.
1432 : */
1433 630 : if (outer_has_null &&
1434 192 : is_dummy_partition(outer_rel, outer_bi->null_index))
1435 0 : outer_has_null = false;
1436 630 : if (inner_has_null &&
1437 192 : is_dummy_partition(inner_rel, inner_bi->null_index))
1438 0 : inner_has_null = false;
1439 :
1440 : /* Merge the NULL partitions if any. */
1441 438 : if (outer_has_null || inner_has_null)
1442 216 : merge_null_partitions(&outer_map, &inner_map,
1443 : outer_has_null, inner_has_null,
1444 : outer_bi->null_index, inner_bi->null_index,
1445 : jointype, &next_index, &null_index);
1446 : else
1447 : Assert(null_index == -1);
1448 :
1449 : /* Merge the default partitions if any. */
1450 438 : if (outer_has_default || inner_has_default)
1451 96 : merge_default_partitions(&outer_map, &inner_map,
1452 : outer_has_default, inner_has_default,
1453 : outer_default, inner_default,
1454 : jointype, &next_index, &default_index);
1455 : else
1456 : Assert(default_index == -1);
1457 :
1458 : /* If we have merged partitions, create the partition bounds. */
1459 438 : if (next_index > 0)
1460 : {
1461 : /* Fix the merged_indexes list if necessary. */
1462 438 : if (outer_map.did_remapping || inner_map.did_remapping)
1463 : {
1464 : Assert(jointype == JOIN_FULL);
1465 48 : fix_merged_indexes(&outer_map, &inner_map,
1466 : next_index, merged_indexes);
1467 : }
1468 :
1469 : /* Use maps to match partitions from inputs. */
1470 438 : generate_matching_part_pairs(outer_rel, inner_rel,
1471 : &outer_map, &inner_map,
1472 : next_index,
1473 : outer_parts, inner_parts);
1474 : Assert(*outer_parts != NIL);
1475 : Assert(*inner_parts != NIL);
1476 : Assert(list_length(*outer_parts) == list_length(*inner_parts));
1477 : Assert(list_length(*outer_parts) <= next_index);
1478 :
1479 : /* Make a PartitionBoundInfo struct to return. */
1480 438 : merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
1481 : merged_datums,
1482 : NIL,
1483 : merged_indexes,
1484 : null_index,
1485 : default_index);
1486 : Assert(merged_bounds);
1487 : }
1488 :
1489 0 : cleanup:
1490 : /* Free local memory before returning. */
1491 486 : list_free(merged_datums);
1492 486 : list_free(merged_indexes);
1493 486 : free_partition_map(&outer_map);
1494 486 : free_partition_map(&inner_map);
1495 :
1496 486 : return merged_bounds;
1497 : }
1498 :
1499 : /*
1500 : * merge_range_bounds
1501 : * Create the partition bounds for a join relation between range
1502 : * partitioned tables, if possible
1503 : *
1504 : * In this function we try to find sets of overlapping partitions from both
1505 : * sides by comparing ranges stored in their partition bounds. Since the
1506 : * ranges appear in the ascending order, an algorithm similar to merge join is
1507 : * used for that. If a partition on one side doesn't have an overlapping
1508 : * partition on the other side, the algorithm tries to match it with the
1509 : * default partition on the other side if any; if not, the algorithm tries to
1510 : * match it with a dummy partition on the other side if it's on the
1511 : * non-nullable side of an outer join. Also, if both sides have the default
1512 : * partitions, the algorithm tries to match them with each other. We give up
1513 : * if the algorithm finds a partition overlapping multiple partitions on the
1514 : * other side, which is the scenario the current implementation of partitioned
1515 : * join can't handle.
1516 : */
1517 : static PartitionBoundInfo
1518 360 : merge_range_bounds(int partnatts, FmgrInfo *partsupfuncs,
1519 : Oid *partcollations,
1520 : RelOptInfo *outer_rel, RelOptInfo *inner_rel,
1521 : JoinType jointype,
1522 : List **outer_parts, List **inner_parts)
1523 : {
1524 360 : PartitionBoundInfo merged_bounds = NULL;
1525 360 : PartitionBoundInfo outer_bi = outer_rel->boundinfo;
1526 360 : PartitionBoundInfo inner_bi = inner_rel->boundinfo;
1527 360 : bool outer_has_default = partition_bound_has_default(outer_bi);
1528 360 : bool inner_has_default = partition_bound_has_default(inner_bi);
1529 360 : int outer_default = outer_bi->default_index;
1530 360 : int inner_default = inner_bi->default_index;
1531 : PartitionMap outer_map;
1532 : PartitionMap inner_map;
1533 : int outer_index;
1534 : int inner_index;
1535 : int outer_lb_pos;
1536 : int inner_lb_pos;
1537 : PartitionRangeBound outer_lb;
1538 : PartitionRangeBound outer_ub;
1539 : PartitionRangeBound inner_lb;
1540 : PartitionRangeBound inner_ub;
1541 360 : int next_index = 0;
1542 360 : int default_index = -1;
1543 360 : List *merged_datums = NIL;
1544 360 : List *merged_kinds = NIL;
1545 360 : List *merged_indexes = NIL;
1546 :
1547 : Assert(*outer_parts == NIL);
1548 : Assert(*inner_parts == NIL);
1549 : Assert(outer_bi->strategy == inner_bi->strategy &&
1550 : outer_bi->strategy == PARTITION_STRATEGY_RANGE);
1551 :
1552 360 : init_partition_map(outer_rel, &outer_map);
1553 360 : init_partition_map(inner_rel, &inner_map);
1554 :
1555 : /*
1556 : * If the default partitions (if any) have been proven empty, deem them
1557 : * non-existent.
1558 : */
1559 360 : if (outer_has_default && is_dummy_partition(outer_rel, outer_default))
1560 12 : outer_has_default = false;
1561 360 : if (inner_has_default && is_dummy_partition(inner_rel, inner_default))
1562 0 : inner_has_default = false;
1563 :
1564 : /*
1565 : * Merge partitions from both sides. In each iteration we compare a pair
1566 : * of ranges, one from each side, and decide whether the corresponding
1567 : * partitions match or not. If the two ranges overlap, move to the next
1568 : * pair of ranges, otherwise move to the next range on the side with a
1569 : * lower range. outer_lb_pos/inner_lb_pos keep track of the positions of
1570 : * lower bounds in the datums arrays in the outer/inner
1571 : * PartitionBoundInfos respectively.
1572 : */
1573 360 : outer_lb_pos = inner_lb_pos = 0;
1574 360 : outer_index = get_range_partition(outer_rel, outer_bi, &outer_lb_pos,
1575 : &outer_lb, &outer_ub);
1576 360 : inner_index = get_range_partition(inner_rel, inner_bi, &inner_lb_pos,
1577 : &inner_lb, &inner_ub);
1578 1284 : while (outer_index >= 0 || inner_index >= 0)
1579 : {
1580 : bool overlap;
1581 : int ub_cmpval;
1582 : int lb_cmpval;
1583 990 : PartitionRangeBound merged_lb = {-1, NULL, NULL, true};
1584 990 : PartitionRangeBound merged_ub = {-1, NULL, NULL, false};
1585 990 : int merged_index = -1;
1586 :
1587 : /*
1588 : * We run this loop till both sides finish. This allows us to avoid
1589 : * duplicating code to handle the remaining ranges on the side which
1590 : * finishes later. For that we set the comparison parameter cmpval in
1591 : * such a way that it appears as if the side which finishes earlier
1592 : * has an extra range higher than any other range on the unfinished
1593 : * side. That way we advance the ranges on the unfinished side till
1594 : * all of its ranges are exhausted.
1595 : */
1596 990 : if (outer_index == -1)
1597 : {
1598 90 : overlap = false;
1599 90 : lb_cmpval = 1;
1600 90 : ub_cmpval = 1;
1601 : }
1602 900 : else if (inner_index == -1)
1603 : {
1604 36 : overlap = false;
1605 36 : lb_cmpval = -1;
1606 36 : ub_cmpval = -1;
1607 : }
1608 : else
1609 864 : overlap = compare_range_partitions(partnatts, partsupfuncs,
1610 : partcollations,
1611 : &outer_lb, &outer_ub,
1612 : &inner_lb, &inner_ub,
1613 : &lb_cmpval, &ub_cmpval);
1614 :
1615 990 : if (overlap)
1616 : {
1617 : /* Two ranges overlap; form a join pair. */
1618 :
1619 : PartitionRangeBound save_outer_ub;
1620 : PartitionRangeBound save_inner_ub;
1621 :
1622 : /* Both partitions should not have been merged yet. */
1623 : Assert(outer_index >= 0);
1624 : Assert(outer_map.merged_indexes[outer_index] == -1 &&
1625 : outer_map.merged[outer_index] == false);
1626 : Assert(inner_index >= 0);
1627 : Assert(inner_map.merged_indexes[inner_index] == -1 &&
1628 : inner_map.merged[inner_index] == false);
1629 :
1630 : /*
1631 : * Get the index of the merged partition. Both partitions aren't
1632 : * merged yet, so the partitions should be merged successfully.
1633 : */
1634 828 : merged_index = merge_matching_partitions(&outer_map, &inner_map,
1635 : outer_index, inner_index,
1636 : &next_index);
1637 : Assert(merged_index >= 0);
1638 :
1639 : /* Get the range bounds of the merged partition. */
1640 828 : get_merged_range_bounds(partnatts, partsupfuncs,
1641 : partcollations, jointype,
1642 : &outer_lb, &outer_ub,
1643 : &inner_lb, &inner_ub,
1644 : lb_cmpval, ub_cmpval,
1645 : &merged_lb, &merged_ub);
1646 :
1647 : /* Save the upper bounds of both partitions for use below. */
1648 828 : save_outer_ub = outer_ub;
1649 828 : save_inner_ub = inner_ub;
1650 :
1651 : /* Move to the next pair of ranges. */
1652 828 : outer_index = get_range_partition(outer_rel, outer_bi, &outer_lb_pos,
1653 : &outer_lb, &outer_ub);
1654 828 : inner_index = get_range_partition(inner_rel, inner_bi, &inner_lb_pos,
1655 : &inner_lb, &inner_ub);
1656 :
1657 : /*
1658 : * If the range of a partition on one side overlaps the range of
1659 : * the next partition on the other side, that will cause the
1660 : * partition on one side to match at least two partitions on the
1661 : * other side, which is the case that we currently don't support
1662 : * partitioned join for; give up.
1663 : */
1664 1032 : if (ub_cmpval > 0 && inner_index >= 0 &&
1665 204 : compare_range_bounds(partnatts, partsupfuncs, partcollations,
1666 : &save_outer_ub, &inner_lb) > 0)
1667 60 : goto cleanup;
1668 858 : if (ub_cmpval < 0 && outer_index >= 0 &&
1669 66 : compare_range_bounds(partnatts, partsupfuncs, partcollations,
1670 : &outer_lb, &save_inner_ub) < 0)
1671 18 : goto cleanup;
1672 :
1673 : /*
1674 : * A row from a non-overlapping portion (if any) of a partition on
1675 : * one side might find its join partner in the default partition
1676 : * (if any) on the other side, causing the same situation as
1677 : * above; give up in that case.
1678 : */
1679 774 : if ((outer_has_default && (lb_cmpval > 0 || ub_cmpval < 0)) ||
1680 24 : (inner_has_default && (lb_cmpval < 0 || ub_cmpval > 0)))
1681 6 : goto cleanup;
1682 : }
1683 162 : else if (ub_cmpval < 0)
1684 : {
1685 : /* A non-overlapping outer range. */
1686 :
1687 : /* The outer partition should not have been merged yet. */
1688 : Assert(outer_index >= 0);
1689 : Assert(outer_map.merged_indexes[outer_index] == -1 &&
1690 : outer_map.merged[outer_index] == false);
1691 :
1692 : /*
1693 : * If the inner side has the default partition, or this is an
1694 : * outer join, try to assign a merged partition to the outer
1695 : * partition (see process_outer_partition()). Otherwise, the
1696 : * outer partition will not contribute to the result.
1697 : */
1698 36 : if (inner_has_default || IS_OUTER_JOIN(jointype))
1699 : {
1700 24 : merged_index = process_outer_partition(&outer_map,
1701 : &inner_map,
1702 : outer_has_default,
1703 : inner_has_default,
1704 : outer_index,
1705 : inner_default,
1706 : jointype,
1707 : &next_index,
1708 : &default_index);
1709 24 : if (merged_index == -1)
1710 0 : goto cleanup;
1711 24 : merged_lb = outer_lb;
1712 24 : merged_ub = outer_ub;
1713 : }
1714 :
1715 : /* Move to the next range on the outer side. */
1716 36 : outer_index = get_range_partition(outer_rel, outer_bi, &outer_lb_pos,
1717 : &outer_lb, &outer_ub);
1718 : }
1719 : else
1720 : {
1721 : /* A non-overlapping inner range. */
1722 : Assert(ub_cmpval > 0);
1723 :
1724 : /* The inner partition should not have been merged yet. */
1725 : Assert(inner_index >= 0);
1726 : Assert(inner_map.merged_indexes[inner_index] == -1 &&
1727 : inner_map.merged[inner_index] == false);
1728 :
1729 : /*
1730 : * If the outer side has the default partition, or this is a FULL
1731 : * join, try to assign a merged partition to the inner partition
1732 : * (see process_inner_partition()). Otherwise, the inner
1733 : * partition will not contribute to the result.
1734 : */
1735 126 : if (outer_has_default || jointype == JOIN_FULL)
1736 : {
1737 66 : merged_index = process_inner_partition(&outer_map,
1738 : &inner_map,
1739 : outer_has_default,
1740 : inner_has_default,
1741 : inner_index,
1742 : outer_default,
1743 : jointype,
1744 : &next_index,
1745 : &default_index);
1746 66 : if (merged_index == -1)
1747 6 : goto cleanup;
1748 60 : merged_lb = inner_lb;
1749 60 : merged_ub = inner_ub;
1750 : }
1751 :
1752 : /* Move to the next range on the inner side. */
1753 120 : inner_index = get_range_partition(inner_rel, inner_bi, &inner_lb_pos,
1754 : &inner_lb, &inner_ub);
1755 : }
1756 :
1757 : /*
1758 : * If we assigned a merged partition, add the range bounds and index
1759 : * of the merged partition if appropriate.
1760 : */
1761 924 : if (merged_index >= 0 && merged_index != default_index)
1762 816 : add_merged_range_bounds(partnatts, partsupfuncs, partcollations,
1763 : &merged_lb, &merged_ub, merged_index,
1764 : &merged_datums, &merged_kinds,
1765 : &merged_indexes);
1766 : }
1767 :
1768 : /* Merge the default partitions if any. */
1769 294 : if (outer_has_default || inner_has_default)
1770 60 : merge_default_partitions(&outer_map, &inner_map,
1771 : outer_has_default, inner_has_default,
1772 : outer_default, inner_default,
1773 : jointype, &next_index, &default_index);
1774 : else
1775 : Assert(default_index == -1);
1776 :
1777 : /* If we have merged partitions, create the partition bounds. */
1778 294 : if (next_index > 0)
1779 : {
1780 : /*
1781 : * Unlike the case of list partitioning, we wouldn't have re-merged
1782 : * partitions, so did_remapping should be left alone.
1783 : */
1784 : Assert(!outer_map.did_remapping);
1785 : Assert(!inner_map.did_remapping);
1786 :
1787 : /* Use maps to match partitions from inputs. */
1788 294 : generate_matching_part_pairs(outer_rel, inner_rel,
1789 : &outer_map, &inner_map,
1790 : next_index,
1791 : outer_parts, inner_parts);
1792 : Assert(*outer_parts != NIL);
1793 : Assert(*inner_parts != NIL);
1794 : Assert(list_length(*outer_parts) == list_length(*inner_parts));
1795 : Assert(list_length(*outer_parts) == next_index);
1796 :
1797 : /* Make a PartitionBoundInfo struct to return. */
1798 294 : merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
1799 : merged_datums,
1800 : merged_kinds,
1801 : merged_indexes,
1802 : -1,
1803 : default_index);
1804 : Assert(merged_bounds);
1805 : }
1806 :
1807 0 : cleanup:
1808 : /* Free local memory before returning. */
1809 360 : list_free(merged_datums);
1810 360 : list_free(merged_kinds);
1811 360 : list_free(merged_indexes);
1812 360 : free_partition_map(&outer_map);
1813 360 : free_partition_map(&inner_map);
1814 :
1815 360 : return merged_bounds;
1816 : }
1817 :
1818 : /*
1819 : * init_partition_map
1820 : * Initialize a PartitionMap struct for given relation
1821 : */
1822 : static void
1823 1692 : init_partition_map(RelOptInfo *rel, PartitionMap *map)
1824 : {
1825 1692 : int nparts = rel->nparts;
1826 : int i;
1827 :
1828 1692 : map->nparts = nparts;
1829 1692 : map->merged_indexes = (int *) palloc(sizeof(int) * nparts);
1830 1692 : map->merged = (bool *) palloc(sizeof(bool) * nparts);
1831 1692 : map->did_remapping = false;
1832 1692 : map->old_indexes = (int *) palloc(sizeof(int) * nparts);
1833 6870 : for (i = 0; i < nparts; i++)
1834 : {
1835 5178 : map->merged_indexes[i] = map->old_indexes[i] = -1;
1836 5178 : map->merged[i] = false;
1837 : }
1838 1692 : }
1839 :
1840 : /*
1841 : * free_partition_map
1842 : */
1843 : static void
1844 1692 : free_partition_map(PartitionMap *map)
1845 : {
1846 1692 : pfree(map->merged_indexes);
1847 1692 : pfree(map->merged);
1848 1692 : pfree(map->old_indexes);
1849 1692 : }
1850 :
1851 : /*
1852 : * is_dummy_partition --- has partition been proven empty?
1853 : */
1854 : static bool
1855 9144 : is_dummy_partition(RelOptInfo *rel, int part_index)
1856 : {
1857 : RelOptInfo *part_rel;
1858 :
1859 : Assert(part_index >= 0);
1860 9144 : part_rel = rel->part_rels[part_index];
1861 9144 : if (part_rel == NULL || IS_DUMMY_REL(part_rel))
1862 252 : return true;
1863 8892 : return false;
1864 : }
1865 :
1866 : /*
1867 : * merge_matching_partitions
1868 : * Try to merge given outer/inner partitions, and return the index of a
1869 : * merged partition produced from them if successful, -1 otherwise
1870 : *
1871 : * If the merged partition is newly created, *next_index is incremented.
1872 : */
1873 : static int
1874 2718 : merge_matching_partitions(PartitionMap *outer_map, PartitionMap *inner_map,
1875 : int outer_index, int inner_index, int *next_index)
1876 : {
1877 : int outer_merged_index;
1878 : int inner_merged_index;
1879 : bool outer_merged;
1880 : bool inner_merged;
1881 :
1882 : Assert(outer_index >= 0 && outer_index < outer_map->nparts);
1883 2718 : outer_merged_index = outer_map->merged_indexes[outer_index];
1884 2718 : outer_merged = outer_map->merged[outer_index];
1885 : Assert(inner_index >= 0 && inner_index < inner_map->nparts);
1886 2718 : inner_merged_index = inner_map->merged_indexes[inner_index];
1887 2718 : inner_merged = inner_map->merged[inner_index];
1888 :
1889 : /*
1890 : * Handle cases where we have already assigned a merged partition to each
1891 : * of the given partitions.
1892 : */
1893 2718 : if (outer_merged_index >= 0 && inner_merged_index >= 0)
1894 : {
1895 : /*
1896 : * If the merged partitions are the same, no need to do anything;
1897 : * return the index of the merged partitions. Otherwise, if each of
1898 : * the given partitions has been merged with a dummy partition on the
1899 : * other side, re-map them to either of the two merged partitions.
1900 : * Otherwise, they can't be merged, so return -1.
1901 : */
1902 660 : if (outer_merged_index == inner_merged_index)
1903 : {
1904 : Assert(outer_merged);
1905 : Assert(inner_merged);
1906 552 : return outer_merged_index;
1907 : }
1908 108 : if (!outer_merged && !inner_merged)
1909 : {
1910 : /*
1911 : * This can only happen for a list-partitioning case. We re-map
1912 : * them to the merged partition with the smaller of the two merged
1913 : * indexes to preserve the property that the canonical order of
1914 : * list partitions is determined by the indexes assigned to the
1915 : * smallest list value of each partition.
1916 : */
1917 102 : if (outer_merged_index < inner_merged_index)
1918 : {
1919 54 : outer_map->merged[outer_index] = true;
1920 54 : inner_map->merged_indexes[inner_index] = outer_merged_index;
1921 54 : inner_map->merged[inner_index] = true;
1922 54 : inner_map->did_remapping = true;
1923 54 : inner_map->old_indexes[inner_index] = inner_merged_index;
1924 54 : return outer_merged_index;
1925 : }
1926 : else
1927 : {
1928 48 : inner_map->merged[inner_index] = true;
1929 48 : outer_map->merged_indexes[outer_index] = inner_merged_index;
1930 48 : outer_map->merged[outer_index] = true;
1931 48 : outer_map->did_remapping = true;
1932 48 : outer_map->old_indexes[outer_index] = outer_merged_index;
1933 48 : return inner_merged_index;
1934 : }
1935 : }
1936 6 : return -1;
1937 : }
1938 :
1939 : /* At least one of the given partitions should not have yet been merged. */
1940 : Assert(outer_merged_index == -1 || inner_merged_index == -1);
1941 :
1942 : /*
1943 : * If neither of them has been merged, merge them. Otherwise, if one has
1944 : * been merged with a dummy partition on the other side (and the other
1945 : * hasn't yet been merged with anything), re-merge them. Otherwise, they
1946 : * can't be merged, so return -1.
1947 : */
1948 2058 : if (outer_merged_index == -1 && inner_merged_index == -1)
1949 : {
1950 1758 : int merged_index = *next_index;
1951 :
1952 : Assert(!outer_merged);
1953 : Assert(!inner_merged);
1954 1758 : outer_map->merged_indexes[outer_index] = merged_index;
1955 1758 : outer_map->merged[outer_index] = true;
1956 1758 : inner_map->merged_indexes[inner_index] = merged_index;
1957 1758 : inner_map->merged[inner_index] = true;
1958 1758 : *next_index = *next_index + 1;
1959 1758 : return merged_index;
1960 : }
1961 300 : if (outer_merged_index >= 0 && !outer_map->merged[outer_index])
1962 : {
1963 : Assert(inner_merged_index == -1);
1964 : Assert(!inner_merged);
1965 264 : inner_map->merged_indexes[inner_index] = outer_merged_index;
1966 264 : inner_map->merged[inner_index] = true;
1967 264 : outer_map->merged[outer_index] = true;
1968 264 : return outer_merged_index;
1969 : }
1970 36 : if (inner_merged_index >= 0 && !inner_map->merged[inner_index])
1971 : {
1972 : Assert(outer_merged_index == -1);
1973 : Assert(!outer_merged);
1974 0 : outer_map->merged_indexes[outer_index] = inner_merged_index;
1975 0 : outer_map->merged[outer_index] = true;
1976 0 : inner_map->merged[inner_index] = true;
1977 0 : return inner_merged_index;
1978 : }
1979 36 : return -1;
1980 : }
1981 :
1982 : /*
1983 : * process_outer_partition
1984 : * Try to assign given outer partition a merged partition, and return the
1985 : * index of the merged partition if successful, -1 otherwise
1986 : *
1987 : * If the partition is newly created, *next_index is incremented. Also, if it
1988 : * is the default partition of the join relation, *default_index is set to the
1989 : * index if not already done.
1990 : */
1991 : static int
1992 432 : process_outer_partition(PartitionMap *outer_map,
1993 : PartitionMap *inner_map,
1994 : bool outer_has_default,
1995 : bool inner_has_default,
1996 : int outer_index,
1997 : int inner_default,
1998 : JoinType jointype,
1999 : int *next_index,
2000 : int *default_index)
2001 : {
2002 432 : int merged_index = -1;
2003 :
2004 : Assert(outer_index >= 0);
2005 :
2006 : /*
2007 : * If the inner side has the default partition, a row from the outer
2008 : * partition might find its join partner in the default partition; try
2009 : * merging the outer partition with the default partition. Otherwise,
2010 : * this should be an outer join, in which case the outer partition has to
2011 : * be scanned all the way anyway; merge the outer partition with a dummy
2012 : * partition on the other side.
2013 : */
2014 432 : if (inner_has_default)
2015 : {
2016 : Assert(inner_default >= 0);
2017 :
2018 : /*
2019 : * If the outer side has the default partition as well, the default
2020 : * partition on the inner side will have two matching partitions on
2021 : * the other side: the outer partition and the default partition on
2022 : * the outer side. Partitionwise join doesn't handle this scenario
2023 : * yet.
2024 : */
2025 6 : if (outer_has_default)
2026 0 : return -1;
2027 :
2028 6 : merged_index = merge_matching_partitions(outer_map, inner_map,
2029 : outer_index, inner_default,
2030 : next_index);
2031 6 : if (merged_index == -1)
2032 6 : return -1;
2033 :
2034 : /*
2035 : * If this is a FULL join, the default partition on the inner side has
2036 : * to be scanned all the way anyway, so the resulting partition will
2037 : * contain all key values from the default partition, which any other
2038 : * partition of the join relation will not contain. Thus the
2039 : * resulting partition will act as the default partition of the join
2040 : * relation; record the index in *default_index if not already done.
2041 : */
2042 0 : if (jointype == JOIN_FULL)
2043 : {
2044 0 : if (*default_index == -1)
2045 0 : *default_index = merged_index;
2046 : else
2047 : Assert(*default_index == merged_index);
2048 : }
2049 : }
2050 : else
2051 : {
2052 : Assert(IS_OUTER_JOIN(jointype));
2053 : Assert(jointype != JOIN_RIGHT);
2054 :
2055 : /* If we have already assigned a partition, no need to do anything. */
2056 426 : merged_index = outer_map->merged_indexes[outer_index];
2057 426 : if (merged_index == -1)
2058 402 : merged_index = merge_partition_with_dummy(outer_map, outer_index,
2059 : next_index);
2060 : }
2061 426 : return merged_index;
2062 : }
2063 :
2064 : /*
2065 : * process_inner_partition
2066 : * Try to assign given inner partition a merged partition, and return the
2067 : * index of the merged partition if successful, -1 otherwise
2068 : *
2069 : * If the partition is newly created, *next_index is incremented. Also, if it
2070 : * is the default partition of the join relation, *default_index is set to the
2071 : * index if not already done.
2072 : */
2073 : static int
2074 318 : process_inner_partition(PartitionMap *outer_map,
2075 : PartitionMap *inner_map,
2076 : bool outer_has_default,
2077 : bool inner_has_default,
2078 : int inner_index,
2079 : int outer_default,
2080 : JoinType jointype,
2081 : int *next_index,
2082 : int *default_index)
2083 : {
2084 318 : int merged_index = -1;
2085 :
2086 : Assert(inner_index >= 0);
2087 :
2088 : /*
2089 : * If the outer side has the default partition, a row from the inner
2090 : * partition might find its join partner in the default partition; try
2091 : * merging the inner partition with the default partition. Otherwise,
2092 : * this should be a FULL join, in which case the inner partition has to be
2093 : * scanned all the way anyway; merge the inner partition with a dummy
2094 : * partition on the other side.
2095 : */
2096 318 : if (outer_has_default)
2097 : {
2098 : Assert(outer_default >= 0);
2099 :
2100 : /*
2101 : * If the inner side has the default partition as well, the default
2102 : * partition on the outer side will have two matching partitions on
2103 : * the other side: the inner partition and the default partition on
2104 : * the inner side. Partitionwise join doesn't handle this scenario
2105 : * yet.
2106 : */
2107 204 : if (inner_has_default)
2108 12 : return -1;
2109 :
2110 192 : merged_index = merge_matching_partitions(outer_map, inner_map,
2111 : outer_default, inner_index,
2112 : next_index);
2113 192 : if (merged_index == -1)
2114 6 : return -1;
2115 :
2116 : /*
2117 : * If this is an outer join, the default partition on the outer side
2118 : * has to be scanned all the way anyway, so the resulting partition
2119 : * will contain all key values from the default partition, which any
2120 : * other partition of the join relation will not contain. Thus the
2121 : * resulting partition will act as the default partition of the join
2122 : * relation; record the index in *default_index if not already done.
2123 : */
2124 186 : if (IS_OUTER_JOIN(jointype))
2125 : {
2126 : Assert(jointype != JOIN_RIGHT);
2127 108 : if (*default_index == -1)
2128 72 : *default_index = merged_index;
2129 : else
2130 : Assert(*default_index == merged_index);
2131 : }
2132 : }
2133 : else
2134 : {
2135 : Assert(jointype == JOIN_FULL);
2136 :
2137 : /* If we have already assigned a partition, no need to do anything. */
2138 114 : merged_index = inner_map->merged_indexes[inner_index];
2139 114 : if (merged_index == -1)
2140 114 : merged_index = merge_partition_with_dummy(inner_map, inner_index,
2141 : next_index);
2142 : }
2143 300 : return merged_index;
2144 : }
2145 :
2146 : /*
2147 : * merge_null_partitions
2148 : * Merge the NULL partitions from a join's outer and inner sides.
2149 : *
2150 : * If the merged partition produced from them is the NULL partition of the join
2151 : * relation, *null_index is set to the index of the merged partition.
2152 : *
2153 : * Note: We assume here that the join clause for a partitioned join is strict
2154 : * because have_partkey_equi_join() requires that the corresponding operator
2155 : * be mergejoinable, and we currently assume that mergejoinable operators are
2156 : * strict (see MJEvalOuterValues()/MJEvalInnerValues()).
2157 : */
2158 : static void
2159 216 : merge_null_partitions(PartitionMap *outer_map,
2160 : PartitionMap *inner_map,
2161 : bool outer_has_null,
2162 : bool inner_has_null,
2163 : int outer_null,
2164 : int inner_null,
2165 : JoinType jointype,
2166 : int *next_index,
2167 : int *null_index)
2168 : {
2169 216 : bool consider_outer_null = false;
2170 216 : bool consider_inner_null = false;
2171 :
2172 : Assert(outer_has_null || inner_has_null);
2173 : Assert(*null_index == -1);
2174 :
2175 : /*
2176 : * Check whether the NULL partitions have already been merged and if so,
2177 : * set the consider_outer_null/consider_inner_null flags.
2178 : */
2179 216 : if (outer_has_null)
2180 : {
2181 : Assert(outer_null >= 0 && outer_null < outer_map->nparts);
2182 192 : if (outer_map->merged_indexes[outer_null] == -1)
2183 84 : consider_outer_null = true;
2184 : }
2185 216 : if (inner_has_null)
2186 : {
2187 : Assert(inner_null >= 0 && inner_null < inner_map->nparts);
2188 192 : if (inner_map->merged_indexes[inner_null] == -1)
2189 120 : consider_inner_null = true;
2190 : }
2191 :
2192 : /* If both flags are set false, we don't need to do anything. */
2193 216 : if (!consider_outer_null && !consider_inner_null)
2194 72 : return;
2195 :
2196 144 : if (consider_outer_null && !consider_inner_null)
2197 : {
2198 : Assert(outer_has_null);
2199 :
2200 : /*
2201 : * If this is an outer join, the NULL partition on the outer side has
2202 : * to be scanned all the way anyway; merge the NULL partition with a
2203 : * dummy partition on the other side. In that case
2204 : * consider_outer_null means that the NULL partition only contains
2205 : * NULL values as the key values, so the merged partition will do so;
2206 : * treat it as the NULL partition of the join relation.
2207 : */
2208 24 : if (IS_OUTER_JOIN(jointype))
2209 : {
2210 : Assert(jointype != JOIN_RIGHT);
2211 12 : *null_index = merge_partition_with_dummy(outer_map, outer_null,
2212 : next_index);
2213 : }
2214 : }
2215 120 : else if (!consider_outer_null && consider_inner_null)
2216 : {
2217 : Assert(inner_has_null);
2218 :
2219 : /*
2220 : * If this is a FULL join, the NULL partition on the inner side has to
2221 : * be scanned all the way anyway; merge the NULL partition with a
2222 : * dummy partition on the other side. In that case
2223 : * consider_inner_null means that the NULL partition only contains
2224 : * NULL values as the key values, so the merged partition will do so;
2225 : * treat it as the NULL partition of the join relation.
2226 : */
2227 60 : if (jointype == JOIN_FULL)
2228 0 : *null_index = merge_partition_with_dummy(inner_map, inner_null,
2229 : next_index);
2230 : }
2231 : else
2232 : {
2233 : Assert(consider_outer_null && consider_inner_null);
2234 : Assert(outer_has_null);
2235 : Assert(inner_has_null);
2236 :
2237 : /*
2238 : * If this is an outer join, the NULL partition on the outer side (and
2239 : * that on the inner side if this is a FULL join) have to be scanned
2240 : * all the way anyway, so merge them. Note that each of the NULL
2241 : * partitions isn't merged yet, so they should be merged successfully.
2242 : * Like the above, each of the NULL partitions only contains NULL
2243 : * values as the key values, so the merged partition will do so; treat
2244 : * it as the NULL partition of the join relation.
2245 : *
2246 : * Note: if this an INNER/SEMI join, the join clause will never be
2247 : * satisfied by two NULL values (see comments above), so both the NULL
2248 : * partitions can be eliminated.
2249 : */
2250 60 : if (IS_OUTER_JOIN(jointype))
2251 : {
2252 : Assert(jointype != JOIN_RIGHT);
2253 48 : *null_index = merge_matching_partitions(outer_map, inner_map,
2254 : outer_null, inner_null,
2255 : next_index);
2256 : Assert(*null_index >= 0);
2257 : }
2258 : }
2259 : }
2260 :
2261 : /*
2262 : * merge_default_partitions
2263 : * Merge the default partitions from a join's outer and inner sides.
2264 : *
2265 : * If the merged partition produced from them is the default partition of the
2266 : * join relation, *default_index is set to the index of the merged partition.
2267 : */
2268 : static void
2269 156 : merge_default_partitions(PartitionMap *outer_map,
2270 : PartitionMap *inner_map,
2271 : bool outer_has_default,
2272 : bool inner_has_default,
2273 : int outer_default,
2274 : int inner_default,
2275 : JoinType jointype,
2276 : int *next_index,
2277 : int *default_index)
2278 : {
2279 156 : int outer_merged_index = -1;
2280 156 : int inner_merged_index = -1;
2281 :
2282 : Assert(outer_has_default || inner_has_default);
2283 :
2284 : /* Get the merged partition indexes for the default partitions. */
2285 156 : if (outer_has_default)
2286 : {
2287 : Assert(outer_default >= 0 && outer_default < outer_map->nparts);
2288 120 : outer_merged_index = outer_map->merged_indexes[outer_default];
2289 : }
2290 156 : if (inner_has_default)
2291 : {
2292 : Assert(inner_default >= 0 && inner_default < inner_map->nparts);
2293 36 : inner_merged_index = inner_map->merged_indexes[inner_default];
2294 : }
2295 :
2296 156 : if (outer_has_default && !inner_has_default)
2297 : {
2298 : /*
2299 : * If this is an outer join, the default partition on the outer side
2300 : * has to be scanned all the way anyway; if we have not yet assigned a
2301 : * partition, merge the default partition with a dummy partition on
2302 : * the other side. The merged partition will act as the default
2303 : * partition of the join relation (see comments in
2304 : * process_inner_partition()).
2305 : */
2306 120 : if (IS_OUTER_JOIN(jointype))
2307 : {
2308 : Assert(jointype != JOIN_RIGHT);
2309 72 : if (outer_merged_index == -1)
2310 : {
2311 : Assert(*default_index == -1);
2312 0 : *default_index = merge_partition_with_dummy(outer_map,
2313 : outer_default,
2314 : next_index);
2315 : }
2316 : else
2317 : Assert(*default_index == outer_merged_index);
2318 : }
2319 : else
2320 : Assert(*default_index == -1);
2321 : }
2322 36 : else if (!outer_has_default && inner_has_default)
2323 : {
2324 : /*
2325 : * If this is a FULL join, the default partition on the inner side has
2326 : * to be scanned all the way anyway; if we have not yet assigned a
2327 : * partition, merge the default partition with a dummy partition on
2328 : * the other side. The merged partition will act as the default
2329 : * partition of the join relation (see comments in
2330 : * process_outer_partition()).
2331 : */
2332 36 : if (jointype == JOIN_FULL)
2333 : {
2334 0 : if (inner_merged_index == -1)
2335 : {
2336 : Assert(*default_index == -1);
2337 0 : *default_index = merge_partition_with_dummy(inner_map,
2338 : inner_default,
2339 : next_index);
2340 : }
2341 : else
2342 : Assert(*default_index == inner_merged_index);
2343 : }
2344 : else
2345 : Assert(*default_index == -1);
2346 : }
2347 : else
2348 : {
2349 : Assert(outer_has_default && inner_has_default);
2350 :
2351 : /*
2352 : * The default partitions have to be joined with each other, so merge
2353 : * them. Note that each of the default partitions isn't merged yet
2354 : * (see, process_outer_partition()/process_innerer_partition()), so
2355 : * they should be merged successfully. The merged partition will act
2356 : * as the default partition of the join relation.
2357 : */
2358 : Assert(outer_merged_index == -1);
2359 : Assert(inner_merged_index == -1);
2360 : Assert(*default_index == -1);
2361 0 : *default_index = merge_matching_partitions(outer_map,
2362 : inner_map,
2363 : outer_default,
2364 : inner_default,
2365 : next_index);
2366 : Assert(*default_index >= 0);
2367 : }
2368 156 : }
2369 :
2370 : /*
2371 : * merge_partition_with_dummy
2372 : * Assign given partition a new partition of a join relation
2373 : *
2374 : * Note: The caller assumes that the given partition doesn't have a non-dummy
2375 : * matching partition on the other side, but if the given partition finds the
2376 : * matching partition later, we will adjust the assignment.
2377 : */
2378 : static int
2379 528 : merge_partition_with_dummy(PartitionMap *map, int index, int *next_index)
2380 : {
2381 528 : int merged_index = *next_index;
2382 :
2383 : Assert(index >= 0 && index < map->nparts);
2384 : Assert(map->merged_indexes[index] == -1);
2385 : Assert(!map->merged[index]);
2386 528 : map->merged_indexes[index] = merged_index;
2387 : /* Leave the merged flag alone! */
2388 528 : *next_index = *next_index + 1;
2389 528 : return merged_index;
2390 : }
2391 :
2392 : /*
2393 : * fix_merged_indexes
2394 : * Adjust merged indexes of re-merged partitions
2395 : */
2396 : static void
2397 48 : fix_merged_indexes(PartitionMap *outer_map, PartitionMap *inner_map,
2398 : int nmerged, List *merged_indexes)
2399 : {
2400 : int *new_indexes;
2401 : int merged_index;
2402 : int i;
2403 : ListCell *lc;
2404 :
2405 : Assert(nmerged > 0);
2406 :
2407 48 : new_indexes = (int *) palloc(sizeof(int) * nmerged);
2408 312 : for (i = 0; i < nmerged; i++)
2409 264 : new_indexes[i] = -1;
2410 :
2411 : /* Build the mapping of old merged indexes to new merged indexes. */
2412 48 : if (outer_map->did_remapping)
2413 : {
2414 210 : for (i = 0; i < outer_map->nparts; i++)
2415 : {
2416 162 : merged_index = outer_map->old_indexes[i];
2417 162 : if (merged_index >= 0)
2418 48 : new_indexes[merged_index] = outer_map->merged_indexes[i];
2419 : }
2420 : }
2421 48 : if (inner_map->did_remapping)
2422 : {
2423 210 : for (i = 0; i < inner_map->nparts; i++)
2424 : {
2425 162 : merged_index = inner_map->old_indexes[i];
2426 162 : if (merged_index >= 0)
2427 48 : new_indexes[merged_index] = inner_map->merged_indexes[i];
2428 : }
2429 : }
2430 :
2431 : /* Fix the merged_indexes list using the mapping. */
2432 438 : foreach(lc, merged_indexes)
2433 : {
2434 390 : merged_index = lfirst_int(lc);
2435 : Assert(merged_index >= 0);
2436 390 : if (new_indexes[merged_index] >= 0)
2437 96 : lfirst_int(lc) = new_indexes[merged_index];
2438 : }
2439 :
2440 48 : pfree(new_indexes);
2441 48 : }
2442 :
2443 : /*
2444 : * generate_matching_part_pairs
2445 : * Generate a pair of lists of partitions that produce merged partitions
2446 : *
2447 : * The lists of partitions are built in the order of merged partition indexes,
2448 : * and returned in *outer_parts and *inner_parts.
2449 : */
2450 : static void
2451 732 : generate_matching_part_pairs(RelOptInfo *outer_rel, RelOptInfo *inner_rel,
2452 : PartitionMap *outer_map, PartitionMap *inner_map,
2453 : int nmerged,
2454 : List **outer_parts, List **inner_parts)
2455 : {
2456 732 : int outer_nparts = outer_map->nparts;
2457 732 : int inner_nparts = inner_map->nparts;
2458 : int *outer_indexes;
2459 : int *inner_indexes;
2460 : int max_nparts;
2461 : int i;
2462 :
2463 : Assert(nmerged > 0);
2464 : Assert(*outer_parts == NIL);
2465 : Assert(*inner_parts == NIL);
2466 :
2467 732 : outer_indexes = (int *) palloc(sizeof(int) * nmerged);
2468 732 : inner_indexes = (int *) palloc(sizeof(int) * nmerged);
2469 2796 : for (i = 0; i < nmerged; i++)
2470 2064 : outer_indexes[i] = inner_indexes[i] = -1;
2471 :
2472 : /* Set pairs of matching partitions. */
2473 : Assert(outer_nparts == outer_rel->nparts);
2474 : Assert(inner_nparts == inner_rel->nparts);
2475 732 : max_nparts = Max(outer_nparts, inner_nparts);
2476 3060 : for (i = 0; i < max_nparts; i++)
2477 : {
2478 2328 : if (i < outer_nparts)
2479 : {
2480 2220 : int merged_index = outer_map->merged_indexes[i];
2481 :
2482 2220 : if (merged_index >= 0)
2483 : {
2484 : Assert(merged_index < nmerged);
2485 1956 : outer_indexes[merged_index] = i;
2486 : }
2487 : }
2488 2328 : if (i < inner_nparts)
2489 : {
2490 2244 : int merged_index = inner_map->merged_indexes[i];
2491 :
2492 2244 : if (merged_index >= 0)
2493 : {
2494 : Assert(merged_index < nmerged);
2495 1920 : inner_indexes[merged_index] = i;
2496 : }
2497 : }
2498 : }
2499 :
2500 : /* Build the list pairs. */
2501 2796 : for (i = 0; i < nmerged; i++)
2502 : {
2503 2064 : int outer_index = outer_indexes[i];
2504 2064 : int inner_index = inner_indexes[i];
2505 :
2506 : /*
2507 : * If both partitions are dummy, it means the merged partition that
2508 : * had been assigned to the outer/inner partition was removed when
2509 : * re-merging the outer/inner partition in
2510 : * merge_matching_partitions(); ignore the merged partition.
2511 : */
2512 2064 : if (outer_index == -1 && inner_index == -1)
2513 96 : continue;
2514 :
2515 3924 : *outer_parts = lappend(*outer_parts, outer_index >= 0 ?
2516 1956 : outer_rel->part_rels[outer_index] : NULL);
2517 3888 : *inner_parts = lappend(*inner_parts, inner_index >= 0 ?
2518 1920 : inner_rel->part_rels[inner_index] : NULL);
2519 : }
2520 :
2521 732 : pfree(outer_indexes);
2522 732 : pfree(inner_indexes);
2523 732 : }
2524 :
2525 : /*
2526 : * build_merged_partition_bounds
2527 : * Create a PartitionBoundInfo struct from merged partition bounds
2528 : */
2529 : static PartitionBoundInfo
2530 732 : build_merged_partition_bounds(char strategy, List *merged_datums,
2531 : List *merged_kinds, List *merged_indexes,
2532 : int null_index, int default_index)
2533 : {
2534 : PartitionBoundInfo merged_bounds;
2535 732 : int ndatums = list_length(merged_datums);
2536 : int pos;
2537 : ListCell *lc;
2538 :
2539 732 : merged_bounds = (PartitionBoundInfo) palloc(sizeof(PartitionBoundInfoData));
2540 732 : merged_bounds->strategy = strategy;
2541 732 : merged_bounds->ndatums = ndatums;
2542 :
2543 732 : merged_bounds->datums = (Datum **) palloc(sizeof(Datum *) * ndatums);
2544 732 : pos = 0;
2545 4044 : foreach(lc, merged_datums)
2546 3312 : merged_bounds->datums[pos++] = (Datum *) lfirst(lc);
2547 :
2548 732 : if (strategy == PARTITION_STRATEGY_RANGE)
2549 : {
2550 : Assert(list_length(merged_kinds) == ndatums);
2551 294 : merged_bounds->kind = (PartitionRangeDatumKind **)
2552 294 : palloc(sizeof(PartitionRangeDatumKind *) * ndatums);
2553 294 : pos = 0;
2554 1560 : foreach(lc, merged_kinds)
2555 1266 : merged_bounds->kind[pos++] = (PartitionRangeDatumKind *) lfirst(lc);
2556 :
2557 : /* There are ndatums+1 indexes in the case of range partitioning. */
2558 294 : merged_indexes = lappend_int(merged_indexes, -1);
2559 294 : ndatums++;
2560 : }
2561 : else
2562 : {
2563 : Assert(strategy == PARTITION_STRATEGY_LIST);
2564 : Assert(merged_kinds == NIL);
2565 438 : merged_bounds->kind = NULL;
2566 : }
2567 :
2568 : /* interleaved_parts is always NULL for join relations. */
2569 732 : merged_bounds->interleaved_parts = NULL;
2570 :
2571 : Assert(list_length(merged_indexes) == ndatums);
2572 732 : merged_bounds->nindexes = ndatums;
2573 732 : merged_bounds->indexes = (int *) palloc(sizeof(int) * ndatums);
2574 732 : pos = 0;
2575 4338 : foreach(lc, merged_indexes)
2576 3606 : merged_bounds->indexes[pos++] = lfirst_int(lc);
2577 :
2578 732 : merged_bounds->null_index = null_index;
2579 732 : merged_bounds->default_index = default_index;
2580 :
2581 732 : return merged_bounds;
2582 : }
2583 :
2584 : /*
2585 : * get_range_partition
2586 : * Get the next non-dummy partition of a range-partitioned relation,
2587 : * returning the index of that partition
2588 : *
2589 : * *lb and *ub are set to the lower and upper bounds of that partition
2590 : * respectively, and *lb_pos is advanced to the next lower bound, if any.
2591 : */
2592 : static int
2593 2580 : get_range_partition(RelOptInfo *rel,
2594 : PartitionBoundInfo bi,
2595 : int *lb_pos,
2596 : PartitionRangeBound *lb,
2597 : PartitionRangeBound *ub)
2598 : {
2599 : int part_index;
2600 :
2601 : Assert(bi->strategy == PARTITION_STRATEGY_RANGE);
2602 :
2603 : do
2604 : {
2605 2580 : part_index = get_range_partition_internal(bi, lb_pos, lb, ub);
2606 2580 : if (part_index == -1)
2607 630 : return -1;
2608 1950 : } while (is_dummy_partition(rel, part_index));
2609 :
2610 1902 : return part_index;
2611 : }
2612 :
2613 : static int
2614 2580 : get_range_partition_internal(PartitionBoundInfo bi,
2615 : int *lb_pos,
2616 : PartitionRangeBound *lb,
2617 : PartitionRangeBound *ub)
2618 : {
2619 : /* Return the index as -1 if we've exhausted all lower bounds. */
2620 2580 : if (*lb_pos >= bi->ndatums)
2621 630 : return -1;
2622 :
2623 : /* A lower bound should have at least one more bound after it. */
2624 : Assert(*lb_pos + 1 < bi->ndatums);
2625 :
2626 : /* Set the lower bound. */
2627 1950 : lb->index = bi->indexes[*lb_pos];
2628 1950 : lb->datums = bi->datums[*lb_pos];
2629 1950 : lb->kind = bi->kind[*lb_pos];
2630 1950 : lb->lower = true;
2631 : /* Set the upper bound. */
2632 1950 : ub->index = bi->indexes[*lb_pos + 1];
2633 1950 : ub->datums = bi->datums[*lb_pos + 1];
2634 1950 : ub->kind = bi->kind[*lb_pos + 1];
2635 1950 : ub->lower = false;
2636 :
2637 : /* The index assigned to an upper bound should be valid. */
2638 : Assert(ub->index >= 0);
2639 :
2640 : /*
2641 : * Advance the position to the next lower bound. If there are no bounds
2642 : * left beyond the upper bound, we have reached the last lower bound.
2643 : */
2644 1950 : if (*lb_pos + 2 >= bi->ndatums)
2645 684 : *lb_pos = bi->ndatums;
2646 : else
2647 : {
2648 : /*
2649 : * If the index assigned to the bound next to the upper bound isn't
2650 : * valid, that is the next lower bound; else, the upper bound is also
2651 : * the lower bound of the next range partition.
2652 : */
2653 1266 : if (bi->indexes[*lb_pos + 2] < 0)
2654 474 : *lb_pos = *lb_pos + 2;
2655 : else
2656 792 : *lb_pos = *lb_pos + 1;
2657 : }
2658 :
2659 1950 : return ub->index;
2660 : }
2661 :
2662 : /*
2663 : * compare_range_partitions
2664 : * Compare the bounds of two range partitions, and return true if the
2665 : * two partitions overlap, false otherwise
2666 : *
2667 : * *lb_cmpval is set to -1, 0, or 1 if the outer partition's lower bound is
2668 : * lower than, equal to, or higher than the inner partition's lower bound
2669 : * respectively. Likewise, *ub_cmpval is set to -1, 0, or 1 if the outer
2670 : * partition's upper bound is lower than, equal to, or higher than the inner
2671 : * partition's upper bound respectively.
2672 : */
2673 : static bool
2674 864 : compare_range_partitions(int partnatts, FmgrInfo *partsupfuncs,
2675 : Oid *partcollations,
2676 : PartitionRangeBound *outer_lb,
2677 : PartitionRangeBound *outer_ub,
2678 : PartitionRangeBound *inner_lb,
2679 : PartitionRangeBound *inner_ub,
2680 : int *lb_cmpval, int *ub_cmpval)
2681 : {
2682 : /*
2683 : * Check if the outer partition's upper bound is lower than the inner
2684 : * partition's lower bound; if so the partitions aren't overlapping.
2685 : */
2686 864 : if (compare_range_bounds(partnatts, partsupfuncs, partcollations,
2687 : outer_ub, inner_lb) < 0)
2688 : {
2689 0 : *lb_cmpval = -1;
2690 0 : *ub_cmpval = -1;
2691 0 : return false;
2692 : }
2693 :
2694 : /*
2695 : * Check if the outer partition's lower bound is higher than the inner
2696 : * partition's upper bound; if so the partitions aren't overlapping.
2697 : */
2698 864 : if (compare_range_bounds(partnatts, partsupfuncs, partcollations,
2699 : outer_lb, inner_ub) > 0)
2700 : {
2701 36 : *lb_cmpval = 1;
2702 36 : *ub_cmpval = 1;
2703 36 : return false;
2704 : }
2705 :
2706 : /* All other cases indicate overlapping partitions. */
2707 828 : *lb_cmpval = compare_range_bounds(partnatts, partsupfuncs, partcollations,
2708 : outer_lb, inner_lb);
2709 828 : *ub_cmpval = compare_range_bounds(partnatts, partsupfuncs, partcollations,
2710 : outer_ub, inner_ub);
2711 828 : return true;
2712 : }
2713 :
2714 : /*
2715 : * get_merged_range_bounds
2716 : * Given the bounds of range partitions to be joined, determine the bounds
2717 : * of a merged partition produced from the range partitions
2718 : *
2719 : * *merged_lb and *merged_ub are set to the lower and upper bounds of the
2720 : * merged partition.
2721 : */
2722 : static void
2723 828 : get_merged_range_bounds(int partnatts, FmgrInfo *partsupfuncs,
2724 : Oid *partcollations, JoinType jointype,
2725 : PartitionRangeBound *outer_lb,
2726 : PartitionRangeBound *outer_ub,
2727 : PartitionRangeBound *inner_lb,
2728 : PartitionRangeBound *inner_ub,
2729 : int lb_cmpval, int ub_cmpval,
2730 : PartitionRangeBound *merged_lb,
2731 : PartitionRangeBound *merged_ub)
2732 : {
2733 : Assert(compare_range_bounds(partnatts, partsupfuncs, partcollations,
2734 : outer_lb, inner_lb) == lb_cmpval);
2735 : Assert(compare_range_bounds(partnatts, partsupfuncs, partcollations,
2736 : outer_ub, inner_ub) == ub_cmpval);
2737 :
2738 828 : switch (jointype)
2739 : {
2740 432 : case JOIN_INNER:
2741 : case JOIN_SEMI:
2742 :
2743 : /*
2744 : * An INNER/SEMI join will have the rows that fit both sides, so
2745 : * the lower bound of the merged partition will be the higher of
2746 : * the two lower bounds, and the upper bound of the merged
2747 : * partition will be the lower of the two upper bounds.
2748 : */
2749 432 : *merged_lb = (lb_cmpval > 0) ? *outer_lb : *inner_lb;
2750 432 : *merged_ub = (ub_cmpval < 0) ? *outer_ub : *inner_ub;
2751 432 : break;
2752 :
2753 324 : case JOIN_LEFT:
2754 : case JOIN_ANTI:
2755 :
2756 : /*
2757 : * A LEFT/ANTI join will have all the rows from the outer side, so
2758 : * the bounds of the merged partition will be the same as the
2759 : * outer bounds.
2760 : */
2761 324 : *merged_lb = *outer_lb;
2762 324 : *merged_ub = *outer_ub;
2763 324 : break;
2764 :
2765 72 : case JOIN_FULL:
2766 :
2767 : /*
2768 : * A FULL join will have all the rows from both sides, so the
2769 : * lower bound of the merged partition will be the lower of the
2770 : * two lower bounds, and the upper bound of the merged partition
2771 : * will be the higher of the two upper bounds.
2772 : */
2773 72 : *merged_lb = (lb_cmpval < 0) ? *outer_lb : *inner_lb;
2774 72 : *merged_ub = (ub_cmpval > 0) ? *outer_ub : *inner_ub;
2775 72 : break;
2776 :
2777 0 : default:
2778 0 : elog(ERROR, "unrecognized join type: %d", (int) jointype);
2779 : }
2780 828 : }
2781 :
2782 : /*
2783 : * add_merged_range_bounds
2784 : * Add the bounds of a merged partition to the lists of range bounds
2785 : */
2786 : static void
2787 816 : add_merged_range_bounds(int partnatts, FmgrInfo *partsupfuncs,
2788 : Oid *partcollations,
2789 : PartitionRangeBound *merged_lb,
2790 : PartitionRangeBound *merged_ub,
2791 : int merged_index,
2792 : List **merged_datums,
2793 : List **merged_kinds,
2794 : List **merged_indexes)
2795 : {
2796 : int cmpval;
2797 :
2798 816 : if (!*merged_datums)
2799 : {
2800 : /* First merged partition */
2801 : Assert(!*merged_kinds);
2802 : Assert(!*merged_indexes);
2803 330 : cmpval = 1;
2804 : }
2805 : else
2806 : {
2807 : PartitionRangeBound prev_ub;
2808 :
2809 : Assert(*merged_datums);
2810 : Assert(*merged_kinds);
2811 : Assert(*merged_indexes);
2812 :
2813 : /* Get the last upper bound. */
2814 486 : prev_ub.index = llast_int(*merged_indexes);
2815 486 : prev_ub.datums = (Datum *) llast(*merged_datums);
2816 486 : prev_ub.kind = (PartitionRangeDatumKind *) llast(*merged_kinds);
2817 486 : prev_ub.lower = false;
2818 :
2819 : /*
2820 : * We pass lower1 = false to partition_rbound_cmp() to prevent it from
2821 : * considering the last upper bound to be smaller than the lower bound
2822 : * of the merged partition when the values of the two range bounds
2823 : * compare equal.
2824 : */
2825 486 : cmpval = partition_rbound_cmp(partnatts, partsupfuncs, partcollations,
2826 : merged_lb->datums, merged_lb->kind,
2827 : false, &prev_ub);
2828 : Assert(cmpval >= 0);
2829 : }
2830 :
2831 : /*
2832 : * If the lower bound is higher than the last upper bound, add the lower
2833 : * bound with the index as -1 indicating that that is a lower bound; else,
2834 : * the last upper bound will be reused as the lower bound of the merged
2835 : * partition, so skip this.
2836 : */
2837 816 : if (cmpval > 0)
2838 : {
2839 576 : *merged_datums = lappend(*merged_datums, merged_lb->datums);
2840 576 : *merged_kinds = lappend(*merged_kinds, merged_lb->kind);
2841 576 : *merged_indexes = lappend_int(*merged_indexes, -1);
2842 : }
2843 :
2844 : /* Add the upper bound and index of the merged partition. */
2845 816 : *merged_datums = lappend(*merged_datums, merged_ub->datums);
2846 816 : *merged_kinds = lappend(*merged_kinds, merged_ub->kind);
2847 816 : *merged_indexes = lappend_int(*merged_indexes, merged_index);
2848 816 : }
2849 :
2850 : /*
2851 : * partitions_are_ordered
2852 : * Determine whether the partitions described by 'boundinfo' are ordered,
2853 : * that is partitions appearing earlier in the PartitionDesc sequence
2854 : * contain partition keys strictly less than those appearing later.
2855 : * Also, if NULL values are possible, they must come in the last
2856 : * partition defined in the PartitionDesc. 'live_parts' marks which
2857 : * partitions we should include when checking the ordering. Partitions
2858 : * that do not appear in 'live_parts' are ignored.
2859 : *
2860 : * If out of order, or there is insufficient info to know the order,
2861 : * then we return false.
2862 : */
2863 : bool
2864 24026 : partitions_are_ordered(PartitionBoundInfo boundinfo, Bitmapset *live_parts)
2865 : {
2866 : Assert(boundinfo != NULL);
2867 :
2868 24026 : switch (boundinfo->strategy)
2869 : {
2870 15366 : case PARTITION_STRATEGY_RANGE:
2871 :
2872 : /*
2873 : * RANGE-type partitioning guarantees that the partitions can be
2874 : * scanned in the order that they're defined in the PartitionDesc
2875 : * to provide sequential, non-overlapping ranges of tuples.
2876 : * However, if a DEFAULT partition exists and it's contained
2877 : * within live_parts, then the partitions are not ordered.
2878 : */
2879 15366 : if (!partition_bound_has_default(boundinfo) ||
2880 1816 : !bms_is_member(boundinfo->default_index, live_parts))
2881 14114 : return true;
2882 1252 : break;
2883 :
2884 8142 : case PARTITION_STRATEGY_LIST:
2885 :
2886 : /*
2887 : * LIST partitioned are ordered providing none of live_parts
2888 : * overlap with the partitioned table's interleaved partitions.
2889 : */
2890 8142 : if (!bms_overlap(live_parts, boundinfo->interleaved_parts))
2891 6582 : return true;
2892 :
2893 1560 : break;
2894 518 : default:
2895 : /* HASH, or some other strategy */
2896 518 : break;
2897 : }
2898 :
2899 3330 : return false;
2900 : }
2901 :
2902 : /*
2903 : * check_new_partition_bound
2904 : *
2905 : * Checks if the new partition's bound overlaps any of the existing partitions
2906 : * of parent. Also performs additional checks as necessary per strategy.
2907 : */
2908 : void
2909 8448 : check_new_partition_bound(char *relname, Relation parent,
2910 : PartitionBoundSpec *spec, ParseState *pstate)
2911 : {
2912 8448 : PartitionKey key = RelationGetPartitionKey(parent);
2913 8448 : PartitionDesc partdesc = RelationGetPartitionDesc(parent, false);
2914 8448 : PartitionBoundInfo boundinfo = partdesc->boundinfo;
2915 8448 : int with = -1;
2916 8448 : bool overlap = false;
2917 8448 : int overlap_location = -1;
2918 :
2919 8448 : if (spec->is_default)
2920 : {
2921 : /*
2922 : * The default partition bound never conflicts with any other
2923 : * partition's; if that's what we're attaching, the only possible
2924 : * problem is that one already exists, so check for that and we're
2925 : * done.
2926 : */
2927 520 : if (boundinfo == NULL || !partition_bound_has_default(boundinfo))
2928 496 : return;
2929 :
2930 : /* Default partition already exists, error out. */
2931 24 : ereport(ERROR,
2932 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2933 : errmsg("partition \"%s\" conflicts with existing default partition \"%s\"",
2934 : relname, get_rel_name(partdesc->oids[boundinfo->default_index])),
2935 : parser_errposition(pstate, spec->location)));
2936 : }
2937 :
2938 7928 : switch (key->strategy)
2939 : {
2940 436 : case PARTITION_STRATEGY_HASH:
2941 : {
2942 : Assert(spec->strategy == PARTITION_STRATEGY_HASH);
2943 : Assert(spec->remainder >= 0 && spec->remainder < spec->modulus);
2944 :
2945 436 : if (partdesc->nparts > 0)
2946 : {
2947 : int greatest_modulus;
2948 : int remainder;
2949 : int offset;
2950 :
2951 : /*
2952 : * Check rule that every modulus must be a factor of the
2953 : * next larger modulus. (For example, if you have a bunch
2954 : * of partitions that all have modulus 5, you can add a
2955 : * new partition with modulus 10 or a new partition with
2956 : * modulus 15, but you cannot add both a partition with
2957 : * modulus 10 and a partition with modulus 15, because 10
2958 : * is not a factor of 15.) We need only check the next
2959 : * smaller and next larger existing moduli, relying on
2960 : * previous enforcement of this rule to be sure that the
2961 : * rest are in line.
2962 : */
2963 :
2964 : /*
2965 : * Get the greatest (modulus, remainder) pair contained in
2966 : * boundinfo->datums that is less than or equal to the
2967 : * (spec->modulus, spec->remainder) pair.
2968 : */
2969 288 : offset = partition_hash_bsearch(boundinfo,
2970 : spec->modulus,
2971 : spec->remainder);
2972 288 : if (offset < 0)
2973 : {
2974 : int next_modulus;
2975 :
2976 : /*
2977 : * All existing moduli are greater or equal, so the
2978 : * new one must be a factor of the smallest one, which
2979 : * is first in the boundinfo.
2980 : */
2981 14 : next_modulus = DatumGetInt32(boundinfo->datums[0][0]);
2982 14 : if (next_modulus % spec->modulus != 0)
2983 6 : ereport(ERROR,
2984 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2985 : errmsg("every hash partition modulus must be a factor of the next larger modulus"),
2986 : errdetail("The new modulus %d is not a factor of %d, the modulus of existing partition \"%s\".",
2987 : spec->modulus, next_modulus,
2988 : get_rel_name(partdesc->oids[0]))));
2989 : }
2990 : else
2991 : {
2992 : int prev_modulus;
2993 :
2994 : /*
2995 : * We found the largest (modulus, remainder) pair less
2996 : * than or equal to the new one. That modulus must be
2997 : * a divisor of, or equal to, the new modulus.
2998 : */
2999 274 : prev_modulus = DatumGetInt32(boundinfo->datums[offset][0]);
3000 :
3001 274 : if (spec->modulus % prev_modulus != 0)
3002 6 : ereport(ERROR,
3003 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
3004 : errmsg("every hash partition modulus must be a factor of the next larger modulus"),
3005 : errdetail("The new modulus %d is not divisible by %d, the modulus of existing partition \"%s\".",
3006 : spec->modulus,
3007 : prev_modulus,
3008 : get_rel_name(partdesc->oids[offset]))));
3009 :
3010 268 : if (offset + 1 < boundinfo->ndatums)
3011 : {
3012 : int next_modulus;
3013 :
3014 : /*
3015 : * Look at the next higher (modulus, remainder)
3016 : * pair. That could have the same modulus and a
3017 : * larger remainder than the new pair, in which
3018 : * case we're good. If it has a larger modulus,
3019 : * the new modulus must divide that one.
3020 : */
3021 30 : next_modulus = DatumGetInt32(boundinfo->datums[offset + 1][0]);
3022 :
3023 30 : if (next_modulus % spec->modulus != 0)
3024 6 : ereport(ERROR,
3025 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
3026 : errmsg("every hash partition modulus must be a factor of the next larger modulus"),
3027 : errdetail("The new modulus %d is not a factor of %d, the modulus of existing partition \"%s\".",
3028 : spec->modulus, next_modulus,
3029 : get_rel_name(partdesc->oids[offset + 1]))));
3030 : }
3031 : }
3032 :
3033 270 : greatest_modulus = boundinfo->nindexes;
3034 270 : remainder = spec->remainder;
3035 :
3036 : /*
3037 : * Normally, the lowest remainder that could conflict with
3038 : * the new partition is equal to the remainder specified
3039 : * for the new partition, but when the new partition has a
3040 : * modulus higher than any used so far, we need to adjust.
3041 : */
3042 270 : if (remainder >= greatest_modulus)
3043 12 : remainder = remainder % greatest_modulus;
3044 :
3045 : /* Check every potentially-conflicting remainder. */
3046 : do
3047 : {
3048 396 : if (boundinfo->indexes[remainder] != -1)
3049 : {
3050 24 : overlap = true;
3051 24 : overlap_location = spec->location;
3052 24 : with = boundinfo->indexes[remainder];
3053 24 : break;
3054 : }
3055 372 : remainder += spec->modulus;
3056 372 : } while (remainder < greatest_modulus);
3057 : }
3058 :
3059 418 : break;
3060 : }
3061 :
3062 4062 : case PARTITION_STRATEGY_LIST:
3063 : {
3064 : Assert(spec->strategy == PARTITION_STRATEGY_LIST);
3065 :
3066 4062 : if (partdesc->nparts > 0)
3067 : {
3068 : ListCell *cell;
3069 :
3070 : Assert(boundinfo &&
3071 : boundinfo->strategy == PARTITION_STRATEGY_LIST &&
3072 : (boundinfo->ndatums > 0 ||
3073 : partition_bound_accepts_nulls(boundinfo) ||
3074 : partition_bound_has_default(boundinfo)));
3075 :
3076 5262 : foreach(cell, spec->listdatums)
3077 : {
3078 3152 : Const *val = lfirst_node(Const, cell);
3079 :
3080 3152 : overlap_location = val->location;
3081 3152 : if (!val->constisnull)
3082 : {
3083 : int offset;
3084 : bool equal;
3085 :
3086 3038 : offset = partition_list_bsearch(&key->partsupfunc[0],
3087 : key->partcollation,
3088 : boundinfo,
3089 : val->constvalue,
3090 : &equal);
3091 3038 : if (offset >= 0 && equal)
3092 : {
3093 18 : overlap = true;
3094 18 : with = boundinfo->indexes[offset];
3095 18 : break;
3096 : }
3097 : }
3098 114 : else if (partition_bound_accepts_nulls(boundinfo))
3099 : {
3100 6 : overlap = true;
3101 6 : with = boundinfo->null_index;
3102 6 : break;
3103 : }
3104 : }
3105 : }
3106 :
3107 4062 : break;
3108 : }
3109 :
3110 3430 : case PARTITION_STRATEGY_RANGE:
3111 : {
3112 : PartitionRangeBound *lower,
3113 : *upper;
3114 : int cmpval;
3115 :
3116 : Assert(spec->strategy == PARTITION_STRATEGY_RANGE);
3117 3430 : lower = make_one_partition_rbound(key, -1, spec->lowerdatums, true);
3118 3430 : upper = make_one_partition_rbound(key, -1, spec->upperdatums, false);
3119 :
3120 : /*
3121 : * First check if the resulting range would be empty with
3122 : * specified lower and upper bounds. partition_rbound_cmp
3123 : * cannot return zero here, since the lower-bound flags are
3124 : * different.
3125 : */
3126 3430 : cmpval = partition_rbound_cmp(key->partnatts,
3127 : key->partsupfunc,
3128 : key->partcollation,
3129 : lower->datums, lower->kind,
3130 : true, upper);
3131 : Assert(cmpval != 0);
3132 3430 : if (cmpval > 0)
3133 : {
3134 : /* Point to problematic key in the lower datums list. */
3135 12 : PartitionRangeDatum *datum = list_nth(spec->lowerdatums,
3136 : cmpval - 1);
3137 :
3138 12 : ereport(ERROR,
3139 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
3140 : errmsg("empty range bound specified for partition \"%s\"",
3141 : relname),
3142 : errdetail("Specified lower bound %s is greater than or equal to upper bound %s.",
3143 : get_range_partbound_string(spec->lowerdatums),
3144 : get_range_partbound_string(spec->upperdatums)),
3145 : parser_errposition(pstate, datum->location)));
3146 : }
3147 :
3148 3418 : if (partdesc->nparts > 0)
3149 : {
3150 : int offset;
3151 :
3152 : Assert(boundinfo &&
3153 : boundinfo->strategy == PARTITION_STRATEGY_RANGE &&
3154 : (boundinfo->ndatums > 0 ||
3155 : partition_bound_has_default(boundinfo)));
3156 :
3157 : /*
3158 : * Test whether the new lower bound (which is treated
3159 : * inclusively as part of the new partition) lies inside
3160 : * an existing partition, or in a gap.
3161 : *
3162 : * If it's inside an existing partition, the bound at
3163 : * offset + 1 will be the upper bound of that partition,
3164 : * and its index will be >= 0.
3165 : *
3166 : * If it's in a gap, the bound at offset + 1 will be the
3167 : * lower bound of the next partition, and its index will
3168 : * be -1. This is also true if there is no next partition,
3169 : * since the index array is initialised with an extra -1
3170 : * at the end.
3171 : */
3172 1904 : offset = partition_range_bsearch(key->partnatts,
3173 : key->partsupfunc,
3174 : key->partcollation,
3175 : boundinfo, lower,
3176 : &cmpval);
3177 :
3178 1904 : if (boundinfo->indexes[offset + 1] < 0)
3179 : {
3180 : /*
3181 : * Check that the new partition will fit in the gap.
3182 : * For it to fit, the new upper bound must be less
3183 : * than or equal to the lower bound of the next
3184 : * partition, if there is one.
3185 : */
3186 1868 : if (offset + 1 < boundinfo->ndatums)
3187 : {
3188 : Datum *datums;
3189 : PartitionRangeDatumKind *kind;
3190 : bool is_lower;
3191 :
3192 78 : datums = boundinfo->datums[offset + 1];
3193 78 : kind = boundinfo->kind[offset + 1];
3194 78 : is_lower = (boundinfo->indexes[offset + 1] == -1);
3195 :
3196 78 : cmpval = partition_rbound_cmp(key->partnatts,
3197 : key->partsupfunc,
3198 : key->partcollation,
3199 : datums, kind,
3200 : is_lower, upper);
3201 78 : if (cmpval < 0)
3202 : {
3203 : /*
3204 : * Point to problematic key in the upper
3205 : * datums list.
3206 : */
3207 : PartitionRangeDatum *datum =
3208 12 : list_nth(spec->upperdatums, Abs(cmpval) - 1);
3209 :
3210 : /*
3211 : * The new partition overlaps with the
3212 : * existing partition between offset + 1 and
3213 : * offset + 2.
3214 : */
3215 12 : overlap = true;
3216 12 : overlap_location = datum->location;
3217 12 : with = boundinfo->indexes[offset + 2];
3218 : }
3219 : }
3220 : }
3221 : else
3222 : {
3223 : /*
3224 : * The new partition overlaps with the existing
3225 : * partition between offset and offset + 1.
3226 : */
3227 : PartitionRangeDatum *datum;
3228 :
3229 : /*
3230 : * Point to problematic key in the lower datums list;
3231 : * if we have equality, point to the first one.
3232 : */
3233 36 : datum = cmpval == 0 ? linitial(spec->lowerdatums) :
3234 18 : list_nth(spec->lowerdatums, Abs(cmpval) - 1);
3235 36 : overlap = true;
3236 36 : overlap_location = datum->location;
3237 36 : with = boundinfo->indexes[offset + 1];
3238 : }
3239 : }
3240 :
3241 3418 : break;
3242 : }
3243 :
3244 0 : default:
3245 0 : elog(ERROR, "unexpected partition strategy: %d",
3246 : (int) key->strategy);
3247 : }
3248 :
3249 7898 : if (overlap)
3250 : {
3251 : Assert(with >= 0);
3252 96 : ereport(ERROR,
3253 : (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
3254 : errmsg("partition \"%s\" would overlap partition \"%s\"",
3255 : relname, get_rel_name(partdesc->oids[with])),
3256 : parser_errposition(pstate, overlap_location)));
3257 : }
3258 : }
3259 :
3260 : /*
3261 : * check_default_partition_contents
3262 : *
3263 : * This function checks if there exists a row in the default partition that
3264 : * would properly belong to the new partition being added. If it finds one,
3265 : * it throws an error.
3266 : */
3267 : void
3268 324 : check_default_partition_contents(Relation parent, Relation default_rel,
3269 : PartitionBoundSpec *new_spec)
3270 : {
3271 : List *new_part_constraints;
3272 : List *def_part_constraints;
3273 : List *all_parts;
3274 : ListCell *lc;
3275 :
3276 648 : new_part_constraints = (new_spec->strategy == PARTITION_STRATEGY_LIST)
3277 138 : ? get_qual_for_list(parent, new_spec)
3278 324 : : get_qual_for_range(parent, new_spec, false);
3279 : def_part_constraints =
3280 324 : get_proposed_default_constraint(new_part_constraints);
3281 :
3282 : /*
3283 : * Map the Vars in the constraint expression from parent's attnos to
3284 : * default_rel's.
3285 : */
3286 : def_part_constraints =
3287 324 : map_partition_varattnos(def_part_constraints, 1, default_rel,
3288 : parent);
3289 :
3290 : /*
3291 : * If the existing constraints on the default partition imply that it will
3292 : * not contain any row that would belong to the new partition, we can
3293 : * avoid scanning the default partition.
3294 : */
3295 324 : if (PartConstraintImpliedByRelConstraint(default_rel, def_part_constraints))
3296 : {
3297 14 : ereport(DEBUG1,
3298 : (errmsg_internal("updated partition constraint for default partition \"%s\" is implied by existing constraints",
3299 : RelationGetRelationName(default_rel))));
3300 14 : return;
3301 : }
3302 :
3303 : /*
3304 : * Scan the default partition and its subpartitions, and check for rows
3305 : * that do not satisfy the revised partition constraints.
3306 : */
3307 310 : if (default_rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
3308 52 : all_parts = find_all_inheritors(RelationGetRelid(default_rel),
3309 : AccessExclusiveLock, NULL);
3310 : else
3311 258 : all_parts = list_make1_oid(RelationGetRelid(default_rel));
3312 :
3313 744 : foreach(lc, all_parts)
3314 : {
3315 452 : Oid part_relid = lfirst_oid(lc);
3316 : Relation part_rel;
3317 : Expr *partition_constraint;
3318 : EState *estate;
3319 452 : ExprState *partqualstate = NULL;
3320 : Snapshot snapshot;
3321 : ExprContext *econtext;
3322 : TableScanDesc scan;
3323 : MemoryContext oldCxt;
3324 : TupleTableSlot *tupslot;
3325 :
3326 : /* Lock already taken above. */
3327 452 : if (part_relid != RelationGetRelid(default_rel))
3328 : {
3329 142 : part_rel = table_open(part_relid, NoLock);
3330 :
3331 : /*
3332 : * Map the Vars in the constraint expression from default_rel's
3333 : * the sub-partition's.
3334 : */
3335 142 : partition_constraint = make_ands_explicit(def_part_constraints);
3336 : partition_constraint = (Expr *)
3337 142 : map_partition_varattnos((List *) partition_constraint, 1,
3338 : part_rel, default_rel);
3339 :
3340 : /*
3341 : * If the partition constraints on default partition child imply
3342 : * that it will not contain any row that would belong to the new
3343 : * partition, we can avoid scanning the child table.
3344 : */
3345 142 : if (PartConstraintImpliedByRelConstraint(part_rel,
3346 : def_part_constraints))
3347 : {
3348 8 : ereport(DEBUG1,
3349 : (errmsg_internal("updated partition constraint for default partition \"%s\" is implied by existing constraints",
3350 : RelationGetRelationName(part_rel))));
3351 :
3352 8 : table_close(part_rel, NoLock);
3353 8 : continue;
3354 : }
3355 : }
3356 : else
3357 : {
3358 310 : part_rel = default_rel;
3359 310 : partition_constraint = make_ands_explicit(def_part_constraints);
3360 : }
3361 :
3362 : /*
3363 : * Only RELKIND_RELATION relations (i.e. leaf partitions) need to be
3364 : * scanned.
3365 : */
3366 444 : if (part_rel->rd_rel->relkind != RELKIND_RELATION)
3367 : {
3368 52 : if (part_rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
3369 0 : ereport(WARNING,
3370 : (errcode(ERRCODE_CHECK_VIOLATION),
3371 : errmsg("skipped scanning foreign table \"%s\" which is a partition of default partition \"%s\"",
3372 : RelationGetRelationName(part_rel),
3373 : RelationGetRelationName(default_rel))));
3374 :
3375 52 : if (RelationGetRelid(default_rel) != RelationGetRelid(part_rel))
3376 0 : table_close(part_rel, NoLock);
3377 :
3378 52 : continue;
3379 : }
3380 :
3381 392 : estate = CreateExecutorState();
3382 :
3383 : /* Build expression execution states for partition check quals */
3384 392 : partqualstate = ExecPrepareExpr(partition_constraint, estate);
3385 :
3386 392 : econtext = GetPerTupleExprContext(estate);
3387 392 : snapshot = RegisterSnapshot(GetLatestSnapshot());
3388 392 : tupslot = table_slot_create(part_rel, &estate->es_tupleTable);
3389 392 : scan = table_beginscan(part_rel, snapshot, 0, NULL);
3390 :
3391 : /*
3392 : * Switch to per-tuple memory context and reset it for each tuple
3393 : * produced, so we don't leak memory.
3394 : */
3395 392 : oldCxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
3396 :
3397 440 : while (table_scan_getnextslot(scan, ForwardScanDirection, tupslot))
3398 : {
3399 66 : econtext->ecxt_scantuple = tupslot;
3400 :
3401 66 : if (!ExecCheck(partqualstate, econtext))
3402 18 : ereport(ERROR,
3403 : (errcode(ERRCODE_CHECK_VIOLATION),
3404 : errmsg("updated partition constraint for default partition \"%s\" would be violated by some row",
3405 : RelationGetRelationName(default_rel)),
3406 : errtable(default_rel)));
3407 :
3408 48 : ResetExprContext(econtext);
3409 48 : CHECK_FOR_INTERRUPTS();
3410 : }
3411 :
3412 374 : MemoryContextSwitchTo(oldCxt);
3413 374 : table_endscan(scan);
3414 374 : UnregisterSnapshot(snapshot);
3415 374 : ExecDropSingleTupleTableSlot(tupslot);
3416 374 : FreeExecutorState(estate);
3417 :
3418 374 : if (RelationGetRelid(default_rel) != RelationGetRelid(part_rel))
3419 134 : table_close(part_rel, NoLock); /* keep the lock until commit */
3420 : }
3421 : }
3422 :
3423 : /*
3424 : * get_hash_partition_greatest_modulus
3425 : *
3426 : * Returns the greatest modulus of the hash partition bound.
3427 : * This is no longer used in the core code, but we keep it around
3428 : * in case external modules are using it.
3429 : */
3430 : int
3431 0 : get_hash_partition_greatest_modulus(PartitionBoundInfo bound)
3432 : {
3433 : Assert(bound && bound->strategy == PARTITION_STRATEGY_HASH);
3434 0 : return bound->nindexes;
3435 : }
3436 :
3437 : /*
3438 : * make_one_partition_rbound
3439 : *
3440 : * Return a PartitionRangeBound given a list of PartitionRangeDatum elements
3441 : * and a flag telling whether the bound is lower or not. Made into a function
3442 : * because there are multiple sites that want to use this facility.
3443 : */
3444 : static PartitionRangeBound *
3445 30900 : make_one_partition_rbound(PartitionKey key, int index, List *datums, bool lower)
3446 : {
3447 : PartitionRangeBound *bound;
3448 : ListCell *lc;
3449 : int i;
3450 :
3451 : Assert(datums != NIL);
3452 :
3453 30900 : bound = (PartitionRangeBound *) palloc0(sizeof(PartitionRangeBound));
3454 30900 : bound->index = index;
3455 30900 : bound->datums = (Datum *) palloc0(key->partnatts * sizeof(Datum));
3456 30900 : bound->kind = (PartitionRangeDatumKind *) palloc0(key->partnatts *
3457 : sizeof(PartitionRangeDatumKind));
3458 30900 : bound->lower = lower;
3459 :
3460 30900 : i = 0;
3461 71044 : foreach(lc, datums)
3462 : {
3463 40144 : PartitionRangeDatum *datum = lfirst_node(PartitionRangeDatum, lc);
3464 :
3465 : /* What's contained in this range datum? */
3466 40144 : bound->kind[i] = datum->kind;
3467 :
3468 40144 : if (datum->kind == PARTITION_RANGE_DATUM_VALUE)
3469 : {
3470 36780 : Const *val = castNode(Const, datum->value);
3471 :
3472 36780 : if (val->constisnull)
3473 0 : elog(ERROR, "invalid range bound datum");
3474 36780 : bound->datums[i] = val->constvalue;
3475 : }
3476 :
3477 40144 : i++;
3478 : }
3479 :
3480 30900 : return bound;
3481 : }
3482 :
3483 : /*
3484 : * partition_rbound_cmp
3485 : *
3486 : * For two range bounds this decides whether the 1st one (specified by
3487 : * datums1, kind1, and lower1) is <, =, or > the bound specified in *b2.
3488 : *
3489 : * 0 is returned if they are equal, otherwise a non-zero integer whose sign
3490 : * indicates the ordering, and whose absolute value gives the 1-based
3491 : * partition key number of the first mismatching column.
3492 : *
3493 : * partnatts, partsupfunc and partcollation give the number of attributes in the
3494 : * bounds to be compared, comparison function to be used and the collations of
3495 : * attributes, respectively.
3496 : *
3497 : * Note that if the values of the two range bounds compare equal, then we take
3498 : * into account whether they are upper or lower bounds, and an upper bound is
3499 : * considered to be smaller than a lower bound. This is important to the way
3500 : * that RelationBuildPartitionDesc() builds the PartitionBoundInfoData
3501 : * structure, which only stores the upper bound of a common boundary between
3502 : * two contiguous partitions.
3503 : */
3504 : static int32
3505 31320 : partition_rbound_cmp(int partnatts, FmgrInfo *partsupfunc,
3506 : Oid *partcollation,
3507 : Datum *datums1, PartitionRangeDatumKind *kind1,
3508 : bool lower1, PartitionRangeBound *b2)
3509 : {
3510 31320 : int32 colnum = 0;
3511 31320 : int32 cmpval = 0; /* placate compiler */
3512 : int i;
3513 31320 : Datum *datums2 = b2->datums;
3514 31320 : PartitionRangeDatumKind *kind2 = b2->kind;
3515 31320 : bool lower2 = b2->lower;
3516 :
3517 45050 : for (i = 0; i < partnatts; i++)
3518 : {
3519 : /* Track column number in case we need it for result */
3520 37086 : colnum++;
3521 :
3522 : /*
3523 : * First, handle cases where the column is unbounded, which should not
3524 : * invoke the comparison procedure, and should not consider any later
3525 : * columns. Note that the PartitionRangeDatumKind enum elements
3526 : * compare the same way as the values they represent.
3527 : */
3528 37086 : if (kind1[i] < kind2[i])
3529 1936 : return -colnum;
3530 35150 : else if (kind1[i] > kind2[i])
3531 6 : return colnum;
3532 35144 : else if (kind1[i] != PARTITION_RANGE_DATUM_VALUE)
3533 : {
3534 : /*
3535 : * The column bounds are both MINVALUE or both MAXVALUE. No later
3536 : * columns should be considered, but we still need to compare
3537 : * whether they are upper or lower bounds.
3538 : */
3539 258 : break;
3540 : }
3541 :
3542 34886 : cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[i],
3543 : partcollation[i],
3544 : datums1[i],
3545 : datums2[i]));
3546 34886 : if (cmpval != 0)
3547 21156 : break;
3548 : }
3549 :
3550 : /*
3551 : * If the comparison is anything other than equal, we're done. If they
3552 : * compare equal though, we still have to consider whether the boundaries
3553 : * are inclusive or exclusive. Exclusive one is considered smaller of the
3554 : * two.
3555 : */
3556 29378 : if (cmpval == 0 && lower1 != lower2)
3557 7028 : cmpval = lower1 ? 1 : -1;
3558 :
3559 29378 : return cmpval == 0 ? 0 : (cmpval < 0 ? -colnum : colnum);
3560 : }
3561 :
3562 : /*
3563 : * partition_rbound_datum_cmp
3564 : *
3565 : * Return whether range bound (specified in rb_datums and rb_kind)
3566 : * is <, =, or > partition key of tuple (tuple_datums)
3567 : *
3568 : * n_tuple_datums, partsupfunc and partcollation give number of attributes in
3569 : * the bounds to be compared, comparison function to be used and the collations
3570 : * of attributes resp.
3571 : */
3572 : int32
3573 1553914 : partition_rbound_datum_cmp(FmgrInfo *partsupfunc, Oid *partcollation,
3574 : Datum *rb_datums, PartitionRangeDatumKind *rb_kind,
3575 : Datum *tuple_datums, int n_tuple_datums)
3576 : {
3577 : int i;
3578 1553914 : int32 cmpval = -1;
3579 :
3580 1621828 : for (i = 0; i < n_tuple_datums; i++)
3581 : {
3582 1559398 : if (rb_kind[i] == PARTITION_RANGE_DATUM_MINVALUE)
3583 68434 : return -1;
3584 1490964 : else if (rb_kind[i] == PARTITION_RANGE_DATUM_MAXVALUE)
3585 68674 : return 1;
3586 :
3587 1422290 : cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[i],
3588 : partcollation[i],
3589 : rb_datums[i],
3590 : tuple_datums[i]));
3591 1422290 : if (cmpval != 0)
3592 1354376 : break;
3593 : }
3594 :
3595 1416806 : return cmpval;
3596 : }
3597 :
3598 : /*
3599 : * partition_hbound_cmp
3600 : *
3601 : * Compares modulus first, then remainder if modulus is equal.
3602 : */
3603 : static int32
3604 978 : partition_hbound_cmp(int modulus1, int remainder1, int modulus2, int remainder2)
3605 : {
3606 978 : if (modulus1 < modulus2)
3607 174 : return -1;
3608 804 : if (modulus1 > modulus2)
3609 60 : return 1;
3610 744 : if (modulus1 == modulus2 && remainder1 != remainder2)
3611 744 : return (remainder1 > remainder2) ? 1 : -1;
3612 0 : return 0;
3613 : }
3614 :
3615 : /*
3616 : * partition_list_bsearch
3617 : * Returns the index of the greatest bound datum that is less than equal
3618 : * to the given value or -1 if all of the bound datums are greater
3619 : *
3620 : * *is_equal is set to true if the bound datum at the returned index is equal
3621 : * to the input value.
3622 : */
3623 : int
3624 95338 : partition_list_bsearch(FmgrInfo *partsupfunc, Oid *partcollation,
3625 : PartitionBoundInfo boundinfo,
3626 : Datum value, bool *is_equal)
3627 : {
3628 : int lo,
3629 : hi,
3630 : mid;
3631 :
3632 95338 : lo = -1;
3633 95338 : hi = boundinfo->ndatums - 1;
3634 223180 : while (lo < hi)
3635 : {
3636 : int32 cmpval;
3637 :
3638 215986 : mid = (lo + hi + 1) / 2;
3639 215986 : cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
3640 : partcollation[0],
3641 : boundinfo->datums[mid][0],
3642 : value));
3643 215986 : if (cmpval <= 0)
3644 : {
3645 170932 : lo = mid;
3646 170932 : *is_equal = (cmpval == 0);
3647 170932 : if (*is_equal)
3648 88144 : break;
3649 : }
3650 : else
3651 45054 : hi = mid - 1;
3652 : }
3653 :
3654 95338 : return lo;
3655 : }
3656 :
3657 : /*
3658 : * partition_range_bsearch
3659 : * Returns the index of the greatest range bound that is less than or
3660 : * equal to the given range bound or -1 if all of the range bounds are
3661 : * greater
3662 : *
3663 : * Upon return from this function, *cmpval is set to 0 if the bound at the
3664 : * returned index matches the input range bound exactly, otherwise a
3665 : * non-zero integer whose sign indicates the ordering, and whose absolute
3666 : * value gives the 1-based partition key number of the first mismatching
3667 : * column.
3668 : */
3669 : static int
3670 1904 : partition_range_bsearch(int partnatts, FmgrInfo *partsupfunc,
3671 : Oid *partcollation,
3672 : PartitionBoundInfo boundinfo,
3673 : PartitionRangeBound *probe, int32 *cmpval)
3674 : {
3675 : int lo,
3676 : hi,
3677 : mid;
3678 :
3679 1904 : lo = -1;
3680 1904 : hi = boundinfo->ndatums - 1;
3681 5984 : while (lo < hi)
3682 : {
3683 4098 : mid = (lo + hi + 1) / 2;
3684 8196 : *cmpval = partition_rbound_cmp(partnatts, partsupfunc,
3685 : partcollation,
3686 4098 : boundinfo->datums[mid],
3687 4098 : boundinfo->kind[mid],
3688 4098 : (boundinfo->indexes[mid] == -1),
3689 : probe);
3690 4098 : if (*cmpval <= 0)
3691 : {
3692 3972 : lo = mid;
3693 3972 : if (*cmpval == 0)
3694 18 : break;
3695 : }
3696 : else
3697 126 : hi = mid - 1;
3698 : }
3699 :
3700 1904 : return lo;
3701 : }
3702 :
3703 : /*
3704 : * partition_range_datum_bsearch
3705 : * Returns the index of the greatest range bound that is less than or
3706 : * equal to the given tuple or -1 if all of the range bounds are greater
3707 : *
3708 : * *is_equal is set to true if the range bound at the returned index is equal
3709 : * to the input tuple.
3710 : */
3711 : int
3712 492564 : partition_range_datum_bsearch(FmgrInfo *partsupfunc, Oid *partcollation,
3713 : PartitionBoundInfo boundinfo,
3714 : int nvalues, Datum *values, bool *is_equal)
3715 : {
3716 : int lo,
3717 : hi,
3718 : mid;
3719 :
3720 492564 : lo = -1;
3721 492564 : hi = boundinfo->ndatums - 1;
3722 1517162 : while (lo < hi)
3723 : {
3724 : int32 cmpval;
3725 :
3726 1080436 : mid = (lo + hi + 1) / 2;
3727 1080436 : cmpval = partition_rbound_datum_cmp(partsupfunc,
3728 : partcollation,
3729 1080436 : boundinfo->datums[mid],
3730 1080436 : boundinfo->kind[mid],
3731 : values,
3732 : nvalues);
3733 1080436 : if (cmpval <= 0)
3734 : {
3735 622120 : lo = mid;
3736 622120 : *is_equal = (cmpval == 0);
3737 :
3738 622120 : if (*is_equal)
3739 55838 : break;
3740 : }
3741 : else
3742 458316 : hi = mid - 1;
3743 : }
3744 :
3745 492564 : return lo;
3746 : }
3747 :
3748 : /*
3749 : * partition_hash_bsearch
3750 : * Returns the index of the greatest (modulus, remainder) pair that is
3751 : * less than or equal to the given (modulus, remainder) pair or -1 if
3752 : * all of them are greater
3753 : */
3754 : int
3755 288 : partition_hash_bsearch(PartitionBoundInfo boundinfo,
3756 : int modulus, int remainder)
3757 : {
3758 : int lo,
3759 : hi,
3760 : mid;
3761 :
3762 288 : lo = -1;
3763 288 : hi = boundinfo->ndatums - 1;
3764 716 : while (lo < hi)
3765 : {
3766 : int32 cmpval,
3767 : bound_modulus,
3768 : bound_remainder;
3769 :
3770 428 : mid = (lo + hi + 1) / 2;
3771 428 : bound_modulus = DatumGetInt32(boundinfo->datums[mid][0]);
3772 428 : bound_remainder = DatumGetInt32(boundinfo->datums[mid][1]);
3773 428 : cmpval = partition_hbound_cmp(bound_modulus, bound_remainder,
3774 : modulus, remainder);
3775 428 : if (cmpval <= 0)
3776 : {
3777 366 : lo = mid;
3778 :
3779 366 : if (cmpval == 0)
3780 0 : break;
3781 : }
3782 : else
3783 62 : hi = mid - 1;
3784 : }
3785 :
3786 288 : return lo;
3787 : }
3788 :
3789 : /*
3790 : * qsort_partition_hbound_cmp
3791 : *
3792 : * Hash bounds are sorted by modulus, then by remainder.
3793 : */
3794 : static int32
3795 550 : qsort_partition_hbound_cmp(const void *a, const void *b)
3796 : {
3797 550 : const PartitionHashBound *h1 = (const PartitionHashBound *) a;
3798 550 : const PartitionHashBound *h2 = (const PartitionHashBound *) b;
3799 :
3800 550 : return partition_hbound_cmp(h1->modulus, h1->remainder,
3801 : h2->modulus, h2->remainder);
3802 : }
3803 :
3804 : /*
3805 : * qsort_partition_list_value_cmp
3806 : *
3807 : * Compare two list partition bound datums.
3808 : */
3809 : static int32
3810 19706 : qsort_partition_list_value_cmp(const void *a, const void *b, void *arg)
3811 : {
3812 19706 : Datum val1 = ((const PartitionListValue *) a)->value,
3813 19706 : val2 = ((const PartitionListValue *) b)->value;
3814 19706 : PartitionKey key = (PartitionKey) arg;
3815 :
3816 19706 : return DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[0],
3817 : key->partcollation[0],
3818 : val1, val2));
3819 : }
3820 :
3821 : /*
3822 : * qsort_partition_rbound_cmp
3823 : *
3824 : * Used when sorting range bounds across all range partitions.
3825 : */
3826 : static int32
3827 19574 : qsort_partition_rbound_cmp(const void *a, const void *b, void *arg)
3828 : {
3829 19574 : PartitionRangeBound *b1 = (*(PartitionRangeBound *const *) a);
3830 19574 : PartitionRangeBound *b2 = (*(PartitionRangeBound *const *) b);
3831 19574 : PartitionKey key = (PartitionKey) arg;
3832 :
3833 19574 : return compare_range_bounds(key->partnatts, key->partsupfunc,
3834 : key->partcollation,
3835 : b1, b2);
3836 : }
3837 :
3838 : /*
3839 : * get_partition_operator
3840 : *
3841 : * Return oid of the operator of the given strategy for the given partition
3842 : * key column. It is assumed that the partitioning key is of the same type as
3843 : * the chosen partitioning opclass, or at least binary-compatible. In the
3844 : * latter case, *need_relabel is set to true if the opclass is not of a
3845 : * polymorphic type (indicating a RelabelType node needed on top), otherwise
3846 : * false.
3847 : */
3848 : static Oid
3849 12132 : get_partition_operator(PartitionKey key, int col, StrategyNumber strategy,
3850 : bool *need_relabel)
3851 : {
3852 : Oid operoid;
3853 :
3854 : /*
3855 : * Get the operator in the partitioning opfamily using the opclass'
3856 : * declared input type as both left- and righttype.
3857 : */
3858 12132 : operoid = get_opfamily_member(key->partopfamily[col],
3859 12132 : key->partopcintype[col],
3860 12132 : key->partopcintype[col],
3861 : strategy);
3862 12132 : if (!OidIsValid(operoid))
3863 0 : elog(ERROR, "missing operator %d(%u,%u) in partition opfamily %u",
3864 : strategy, key->partopcintype[col], key->partopcintype[col],
3865 : key->partopfamily[col]);
3866 :
3867 : /*
3868 : * If the partition key column is not of the same type as the operator
3869 : * class and not polymorphic, tell caller to wrap the non-Const expression
3870 : * in a RelabelType. This matches what parse_coerce.c does.
3871 : */
3872 24326 : *need_relabel = (key->parttypid[col] != key->partopcintype[col] &&
3873 12188 : key->partopcintype[col] != RECORDOID &&
3874 56 : !IsPolymorphicType(key->partopcintype[col]));
3875 :
3876 12132 : return operoid;
3877 : }
3878 :
3879 : /*
3880 : * make_partition_op_expr
3881 : * Returns an Expr for the given partition key column with arg1 and
3882 : * arg2 as its leftop and rightop, respectively
3883 : */
3884 : static Expr *
3885 12132 : make_partition_op_expr(PartitionKey key, int keynum,
3886 : uint16 strategy, Expr *arg1, Expr *arg2)
3887 : {
3888 : Oid operoid;
3889 12132 : bool need_relabel = false;
3890 12132 : Expr *result = NULL;
3891 :
3892 : /* Get the correct btree operator for this partitioning column */
3893 12132 : operoid = get_partition_operator(key, keynum, strategy, &need_relabel);
3894 :
3895 : /*
3896 : * Chosen operator may be such that the non-Const operand needs to be
3897 : * coerced, so apply the same; see the comment in
3898 : * get_partition_operator().
3899 : */
3900 12132 : if (!IsA(arg1, Const) &&
3901 9142 : (need_relabel ||
3902 9096 : key->partcollation[keynum] != key->parttypcoll[keynum]))
3903 46 : arg1 = (Expr *) makeRelabelType(arg1,
3904 46 : key->partopcintype[keynum],
3905 : -1,
3906 46 : key->partcollation[keynum],
3907 : COERCE_EXPLICIT_CAST);
3908 :
3909 : /* Generate the actual expression */
3910 12132 : switch (key->strategy)
3911 : {
3912 2284 : case PARTITION_STRATEGY_LIST:
3913 : {
3914 2284 : List *elems = (List *) arg2;
3915 2284 : int nelems = list_length(elems);
3916 :
3917 : Assert(nelems >= 1);
3918 : Assert(keynum == 0);
3919 :
3920 3066 : if (nelems > 1 &&
3921 782 : !type_is_array(key->parttypid[keynum]))
3922 776 : {
3923 : ArrayExpr *arrexpr;
3924 : ScalarArrayOpExpr *saopexpr;
3925 :
3926 : /* Construct an ArrayExpr for the right-hand inputs */
3927 776 : arrexpr = makeNode(ArrayExpr);
3928 776 : arrexpr->array_typeid =
3929 776 : get_array_type(key->parttypid[keynum]);
3930 776 : arrexpr->array_collid = key->parttypcoll[keynum];
3931 776 : arrexpr->element_typeid = key->parttypid[keynum];
3932 776 : arrexpr->elements = elems;
3933 776 : arrexpr->multidims = false;
3934 776 : arrexpr->location = -1;
3935 :
3936 : /* Build leftop = ANY (rightop) */
3937 776 : saopexpr = makeNode(ScalarArrayOpExpr);
3938 776 : saopexpr->opno = operoid;
3939 776 : saopexpr->opfuncid = get_opcode(operoid);
3940 776 : saopexpr->hashfuncid = InvalidOid;
3941 776 : saopexpr->negfuncid = InvalidOid;
3942 776 : saopexpr->useOr = true;
3943 776 : saopexpr->inputcollid = key->partcollation[keynum];
3944 776 : saopexpr->args = list_make2(arg1, arrexpr);
3945 776 : saopexpr->location = -1;
3946 :
3947 776 : result = (Expr *) saopexpr;
3948 : }
3949 : else
3950 : {
3951 1508 : List *elemops = NIL;
3952 : ListCell *lc;
3953 :
3954 3022 : foreach(lc, elems)
3955 : {
3956 1514 : Expr *elem = lfirst(lc),
3957 : *elemop;
3958 :
3959 1514 : elemop = make_opclause(operoid,
3960 : BOOLOID,
3961 : false,
3962 : arg1, elem,
3963 : InvalidOid,
3964 1514 : key->partcollation[keynum]);
3965 1514 : elemops = lappend(elemops, elemop);
3966 : }
3967 :
3968 1508 : result = nelems > 1 ? makeBoolExpr(OR_EXPR, elemops, -1) : linitial(elemops);
3969 : }
3970 2284 : break;
3971 : }
3972 :
3973 9848 : case PARTITION_STRATEGY_RANGE:
3974 9848 : result = make_opclause(operoid,
3975 : BOOLOID,
3976 : false,
3977 : arg1, arg2,
3978 : InvalidOid,
3979 9848 : key->partcollation[keynum]);
3980 9848 : break;
3981 :
3982 0 : default:
3983 0 : elog(ERROR, "invalid partitioning strategy");
3984 : break;
3985 : }
3986 :
3987 12132 : return result;
3988 : }
3989 :
3990 : /*
3991 : * get_qual_for_hash
3992 : *
3993 : * Returns a CHECK constraint expression to use as a hash partition's
3994 : * constraint, given the parent relation and partition bound structure.
3995 : *
3996 : * The partition constraint for a hash partition is always a call to the
3997 : * built-in function satisfies_hash_partition().
3998 : */
3999 : static List *
4000 116 : get_qual_for_hash(Relation parent, PartitionBoundSpec *spec)
4001 : {
4002 116 : PartitionKey key = RelationGetPartitionKey(parent);
4003 : FuncExpr *fexpr;
4004 : Node *relidConst;
4005 : Node *modulusConst;
4006 : Node *remainderConst;
4007 : List *args;
4008 : ListCell *partexprs_item;
4009 : int i;
4010 :
4011 : /* Fixed arguments. */
4012 116 : relidConst = (Node *) makeConst(OIDOID,
4013 : -1,
4014 : InvalidOid,
4015 : sizeof(Oid),
4016 116 : ObjectIdGetDatum(RelationGetRelid(parent)),
4017 : false,
4018 : true);
4019 :
4020 116 : modulusConst = (Node *) makeConst(INT4OID,
4021 : -1,
4022 : InvalidOid,
4023 : sizeof(int32),
4024 116 : Int32GetDatum(spec->modulus),
4025 : false,
4026 : true);
4027 :
4028 116 : remainderConst = (Node *) makeConst(INT4OID,
4029 : -1,
4030 : InvalidOid,
4031 : sizeof(int32),
4032 116 : Int32GetDatum(spec->remainder),
4033 : false,
4034 : true);
4035 :
4036 116 : args = list_make3(relidConst, modulusConst, remainderConst);
4037 116 : partexprs_item = list_head(key->partexprs);
4038 :
4039 : /* Add an argument for each key column. */
4040 250 : for (i = 0; i < key->partnatts; i++)
4041 : {
4042 : Node *keyCol;
4043 :
4044 : /* Left operand */
4045 134 : if (key->partattrs[i] != 0)
4046 : {
4047 128 : keyCol = (Node *) makeVar(1,
4048 128 : key->partattrs[i],
4049 128 : key->parttypid[i],
4050 128 : key->parttypmod[i],
4051 128 : key->parttypcoll[i],
4052 : 0);
4053 : }
4054 : else
4055 : {
4056 6 : keyCol = (Node *) copyObject(lfirst(partexprs_item));
4057 6 : partexprs_item = lnext(key->partexprs, partexprs_item);
4058 : }
4059 :
4060 134 : args = lappend(args, keyCol);
4061 : }
4062 :
4063 116 : fexpr = makeFuncExpr(F_SATISFIES_HASH_PARTITION,
4064 : BOOLOID,
4065 : args,
4066 : InvalidOid,
4067 : InvalidOid,
4068 : COERCE_EXPLICIT_CALL);
4069 :
4070 116 : return list_make1(fexpr);
4071 : }
4072 :
4073 : /*
4074 : * get_qual_for_list
4075 : *
4076 : * Returns an implicit-AND list of expressions to use as a list partition's
4077 : * constraint, given the parent relation and partition bound structure.
4078 : *
4079 : * The function returns NIL for a default partition when it's the only
4080 : * partition since in that case there is no constraint.
4081 : */
4082 : static List *
4083 2340 : get_qual_for_list(Relation parent, PartitionBoundSpec *spec)
4084 : {
4085 2340 : PartitionKey key = RelationGetPartitionKey(parent);
4086 : List *result;
4087 : Expr *keyCol;
4088 : Expr *opexpr;
4089 : NullTest *nulltest;
4090 : ListCell *cell;
4091 2340 : List *elems = NIL;
4092 2340 : bool list_has_null = false;
4093 :
4094 : /*
4095 : * Only single-column list partitioning is supported, so we are worried
4096 : * only about the partition key with index 0.
4097 : */
4098 : Assert(key->partnatts == 1);
4099 :
4100 : /* Construct Var or expression representing the partition column */
4101 2340 : if (key->partattrs[0] != 0)
4102 2250 : keyCol = (Expr *) makeVar(1,
4103 2250 : key->partattrs[0],
4104 2250 : key->parttypid[0],
4105 2250 : key->parttypmod[0],
4106 2250 : key->parttypcoll[0],
4107 : 0);
4108 : else
4109 90 : keyCol = (Expr *) copyObject(linitial(key->partexprs));
4110 :
4111 : /*
4112 : * For default list partition, collect datums for all the partitions. The
4113 : * default partition constraint should check that the partition key is
4114 : * equal to none of those.
4115 : */
4116 2340 : if (spec->is_default)
4117 : {
4118 : int i;
4119 226 : int ndatums = 0;
4120 226 : PartitionDesc pdesc = RelationGetPartitionDesc(parent, false);
4121 226 : PartitionBoundInfo boundinfo = pdesc->boundinfo;
4122 :
4123 226 : if (boundinfo)
4124 : {
4125 226 : ndatums = boundinfo->ndatums;
4126 :
4127 226 : if (partition_bound_accepts_nulls(boundinfo))
4128 48 : list_has_null = true;
4129 : }
4130 :
4131 : /*
4132 : * If default is the only partition, there need not be any partition
4133 : * constraint on it.
4134 : */
4135 226 : if (ndatums == 0 && !list_has_null)
4136 32 : return NIL;
4137 :
4138 990 : for (i = 0; i < ndatums; i++)
4139 : {
4140 : Const *val;
4141 :
4142 : /*
4143 : * Construct Const from known-not-null datum. We must be careful
4144 : * to copy the value, because our result has to be able to outlive
4145 : * the relcache entry we're copying from.
4146 : */
4147 1592 : val = makeConst(key->parttypid[0],
4148 796 : key->parttypmod[0],
4149 796 : key->parttypcoll[0],
4150 796 : key->parttyplen[0],
4151 796 : datumCopy(*boundinfo->datums[i],
4152 796 : key->parttypbyval[0],
4153 796 : key->parttyplen[0]),
4154 : false, /* isnull */
4155 796 : key->parttypbyval[0]);
4156 :
4157 796 : elems = lappend(elems, val);
4158 : }
4159 : }
4160 : else
4161 : {
4162 : /*
4163 : * Create list of Consts for the allowed values, excluding any nulls.
4164 : */
4165 5336 : foreach(cell, spec->listdatums)
4166 : {
4167 3222 : Const *val = lfirst_node(Const, cell);
4168 :
4169 3222 : if (val->constisnull)
4170 54 : list_has_null = true;
4171 : else
4172 3168 : elems = lappend(elems, copyObject(val));
4173 : }
4174 : }
4175 :
4176 2308 : if (elems)
4177 : {
4178 : /*
4179 : * Generate the operator expression from the non-null partition
4180 : * values.
4181 : */
4182 2284 : opexpr = make_partition_op_expr(key, 0, BTEqualStrategyNumber,
4183 : keyCol, (Expr *) elems);
4184 : }
4185 : else
4186 : {
4187 : /*
4188 : * If there are no partition values, we don't need an operator
4189 : * expression.
4190 : */
4191 24 : opexpr = NULL;
4192 : }
4193 :
4194 2308 : if (!list_has_null)
4195 : {
4196 : /*
4197 : * Gin up a "col IS NOT NULL" test that will be ANDed with the main
4198 : * expression. This might seem redundant, but the partition routing
4199 : * machinery needs it.
4200 : */
4201 2206 : nulltest = makeNode(NullTest);
4202 2206 : nulltest->arg = keyCol;
4203 2206 : nulltest->nulltesttype = IS_NOT_NULL;
4204 2206 : nulltest->argisrow = false;
4205 2206 : nulltest->location = -1;
4206 :
4207 2206 : result = opexpr ? list_make2(nulltest, opexpr) : list_make1(nulltest);
4208 : }
4209 : else
4210 : {
4211 : /*
4212 : * Gin up a "col IS NULL" test that will be OR'd with the main
4213 : * expression.
4214 : */
4215 102 : nulltest = makeNode(NullTest);
4216 102 : nulltest->arg = keyCol;
4217 102 : nulltest->nulltesttype = IS_NULL;
4218 102 : nulltest->argisrow = false;
4219 102 : nulltest->location = -1;
4220 :
4221 102 : if (opexpr)
4222 : {
4223 : Expr *or;
4224 :
4225 78 : or = makeBoolExpr(OR_EXPR, list_make2(nulltest, opexpr), -1);
4226 78 : result = list_make1(or);
4227 : }
4228 : else
4229 24 : result = list_make1(nulltest);
4230 : }
4231 :
4232 : /*
4233 : * Note that, in general, applying NOT to a constraint expression doesn't
4234 : * necessarily invert the set of rows it accepts, because NOT (NULL) is
4235 : * NULL. However, the partition constraints we construct here never
4236 : * evaluate to NULL, so applying NOT works as intended.
4237 : */
4238 2308 : if (spec->is_default)
4239 : {
4240 194 : result = list_make1(make_ands_explicit(result));
4241 194 : result = list_make1(makeBoolExpr(NOT_EXPR, result, -1));
4242 : }
4243 :
4244 2308 : return result;
4245 : }
4246 :
4247 : /*
4248 : * get_qual_for_range
4249 : *
4250 : * Returns an implicit-AND list of expressions to use as a range partition's
4251 : * constraint, given the parent relation and partition bound structure.
4252 : *
4253 : * For a multi-column range partition key, say (a, b, c), with (al, bl, cl)
4254 : * as the lower bound tuple and (au, bu, cu) as the upper bound tuple, we
4255 : * generate an expression tree of the following form:
4256 : *
4257 : * (a IS NOT NULL) and (b IS NOT NULL) and (c IS NOT NULL)
4258 : * AND
4259 : * (a > al OR (a = al AND b > bl) OR (a = al AND b = bl AND c >= cl))
4260 : * AND
4261 : * (a < au OR (a = au AND b < bu) OR (a = au AND b = bu AND c < cu))
4262 : *
4263 : * It is often the case that a prefix of lower and upper bound tuples contains
4264 : * the same values, for example, (al = au), in which case, we will emit an
4265 : * expression tree of the following form:
4266 : *
4267 : * (a IS NOT NULL) and (b IS NOT NULL) and (c IS NOT NULL)
4268 : * AND
4269 : * (a = al)
4270 : * AND
4271 : * (b > bl OR (b = bl AND c >= cl))
4272 : * AND
4273 : * (b < bu OR (b = bu AND c < cu))
4274 : *
4275 : * If a bound datum is either MINVALUE or MAXVALUE, these expressions are
4276 : * simplified using the fact that any value is greater than MINVALUE and less
4277 : * than MAXVALUE. So, for example, if cu = MAXVALUE, c < cu is automatically
4278 : * true, and we need not emit any expression for it, and the last line becomes
4279 : *
4280 : * (b < bu) OR (b = bu), which is simplified to (b <= bu)
4281 : *
4282 : * In most common cases with only one partition column, say a, the following
4283 : * expression tree will be generated: a IS NOT NULL AND a >= al AND a < au
4284 : *
4285 : * For default partition, it returns the negation of the constraints of all
4286 : * the other partitions.
4287 : *
4288 : * External callers should pass for_default as false; we set it to true only
4289 : * when recursing.
4290 : */
4291 : static List *
4292 3054 : get_qual_for_range(Relation parent, PartitionBoundSpec *spec,
4293 : bool for_default)
4294 : {
4295 3054 : List *result = NIL;
4296 : ListCell *cell1,
4297 : *cell2,
4298 : *partexprs_item,
4299 : *partexprs_item_saved;
4300 : int i,
4301 : j;
4302 : PartitionRangeDatum *ldatum,
4303 : *udatum;
4304 3054 : PartitionKey key = RelationGetPartitionKey(parent);
4305 : Expr *keyCol;
4306 : Const *lower_val,
4307 : *upper_val;
4308 : List *lower_or_arms,
4309 : *upper_or_arms;
4310 : int num_or_arms,
4311 : current_or_arm;
4312 : ListCell *lower_or_start_datum,
4313 : *upper_or_start_datum;
4314 : bool need_next_lower_arm,
4315 : need_next_upper_arm;
4316 :
4317 3054 : if (spec->is_default)
4318 : {
4319 222 : List *or_expr_args = NIL;
4320 222 : PartitionDesc pdesc = RelationGetPartitionDesc(parent, false);
4321 222 : Oid *inhoids = pdesc->oids;
4322 222 : int nparts = pdesc->nparts,
4323 : i;
4324 :
4325 850 : for (i = 0; i < nparts; i++)
4326 : {
4327 628 : Oid inhrelid = inhoids[i];
4328 : HeapTuple tuple;
4329 : Datum datum;
4330 : bool isnull;
4331 : PartitionBoundSpec *bspec;
4332 :
4333 628 : tuple = SearchSysCache1(RELOID, inhrelid);
4334 628 : if (!HeapTupleIsValid(tuple))
4335 0 : elog(ERROR, "cache lookup failed for relation %u", inhrelid);
4336 :
4337 628 : datum = SysCacheGetAttr(RELOID, tuple,
4338 : Anum_pg_class_relpartbound,
4339 : &isnull);
4340 628 : if (isnull)
4341 0 : elog(ERROR, "null relpartbound for relation %u", inhrelid);
4342 :
4343 : bspec = (PartitionBoundSpec *)
4344 628 : stringToNode(TextDatumGetCString(datum));
4345 628 : if (!IsA(bspec, PartitionBoundSpec))
4346 0 : elog(ERROR, "expected PartitionBoundSpec");
4347 :
4348 628 : if (!bspec->is_default)
4349 : {
4350 : List *part_qual;
4351 :
4352 406 : part_qual = get_qual_for_range(parent, bspec, true);
4353 :
4354 : /*
4355 : * AND the constraints of the partition and add to
4356 : * or_expr_args
4357 : */
4358 812 : or_expr_args = lappend(or_expr_args, list_length(part_qual) > 1
4359 388 : ? makeBoolExpr(AND_EXPR, part_qual, -1)
4360 18 : : linitial(part_qual));
4361 : }
4362 628 : ReleaseSysCache(tuple);
4363 : }
4364 :
4365 222 : if (or_expr_args != NIL)
4366 : {
4367 : Expr *other_parts_constr;
4368 :
4369 : /*
4370 : * Combine the constraints obtained for non-default partitions
4371 : * using OR. As requested, each of the OR's args doesn't include
4372 : * the NOT NULL test for partition keys (which is to avoid its
4373 : * useless repetition). Add the same now.
4374 : */
4375 : other_parts_constr =
4376 308 : makeBoolExpr(AND_EXPR,
4377 : lappend(get_range_nulltest(key),
4378 154 : list_length(or_expr_args) > 1
4379 116 : ? makeBoolExpr(OR_EXPR, or_expr_args,
4380 : -1)
4381 38 : : linitial(or_expr_args)),
4382 : -1);
4383 :
4384 : /*
4385 : * Finally, the default partition contains everything *NOT*
4386 : * contained in the non-default partitions.
4387 : */
4388 154 : result = list_make1(makeBoolExpr(NOT_EXPR,
4389 : list_make1(other_parts_constr), -1));
4390 : }
4391 :
4392 222 : return result;
4393 : }
4394 :
4395 : /*
4396 : * If it is the recursive call for default, we skip the get_range_nulltest
4397 : * to avoid accumulating the NullTest on the same keys for each partition.
4398 : */
4399 2832 : if (!for_default)
4400 2426 : result = get_range_nulltest(key);
4401 :
4402 : /*
4403 : * Iterate over the key columns and check if the corresponding lower and
4404 : * upper datums are equal using the btree equality operator for the
4405 : * column's type. If equal, we emit single keyCol = common_value
4406 : * expression. Starting from the first column for which the corresponding
4407 : * lower and upper bound datums are not equal, we generate OR expressions
4408 : * as shown in the function's header comment.
4409 : */
4410 2832 : i = 0;
4411 2832 : partexprs_item = list_head(key->partexprs);
4412 2832 : partexprs_item_saved = partexprs_item; /* placate compiler */
4413 3372 : forboth(cell1, spec->lowerdatums, cell2, spec->upperdatums)
4414 : {
4415 : EState *estate;
4416 : MemoryContext oldcxt;
4417 : Expr *test_expr;
4418 : ExprState *test_exprstate;
4419 : Datum test_result;
4420 : bool isNull;
4421 :
4422 3372 : ldatum = lfirst_node(PartitionRangeDatum, cell1);
4423 3372 : udatum = lfirst_node(PartitionRangeDatum, cell2);
4424 :
4425 : /*
4426 : * Since get_range_key_properties() modifies partexprs_item, and we
4427 : * might need to start over from the previous expression in the later
4428 : * part of this function, save away the current value.
4429 : */
4430 3372 : partexprs_item_saved = partexprs_item;
4431 :
4432 3372 : get_range_key_properties(key, i, ldatum, udatum,
4433 : &partexprs_item,
4434 : &keyCol,
4435 : &lower_val, &upper_val);
4436 :
4437 : /*
4438 : * If either value is NULL, the corresponding partition bound is
4439 : * either MINVALUE or MAXVALUE, and we treat them as unequal, because
4440 : * even if they're the same, there is no common value to equate the
4441 : * key column with.
4442 : */
4443 3372 : if (!lower_val || !upper_val)
4444 : break;
4445 :
4446 : /* Create the test expression */
4447 2990 : estate = CreateExecutorState();
4448 2990 : oldcxt = MemoryContextSwitchTo(estate->es_query_cxt);
4449 2990 : test_expr = make_partition_op_expr(key, i, BTEqualStrategyNumber,
4450 : (Expr *) lower_val,
4451 : (Expr *) upper_val);
4452 2990 : fix_opfuncids((Node *) test_expr);
4453 2990 : test_exprstate = ExecInitExpr(test_expr, NULL);
4454 2990 : test_result = ExecEvalExprSwitchContext(test_exprstate,
4455 2990 : GetPerTupleExprContext(estate),
4456 : &isNull);
4457 2990 : MemoryContextSwitchTo(oldcxt);
4458 2990 : FreeExecutorState(estate);
4459 :
4460 : /* If not equal, go generate the OR expressions */
4461 2990 : if (!DatumGetBool(test_result))
4462 2450 : break;
4463 :
4464 : /*
4465 : * The bounds for the last key column can't be equal, because such a
4466 : * range partition would never be allowed to be defined (it would have
4467 : * an empty range otherwise).
4468 : */
4469 540 : if (i == key->partnatts - 1)
4470 0 : elog(ERROR, "invalid range bound specification");
4471 :
4472 : /* Equal, so generate keyCol = lower_val expression */
4473 540 : result = lappend(result,
4474 540 : make_partition_op_expr(key, i, BTEqualStrategyNumber,
4475 : keyCol, (Expr *) lower_val));
4476 :
4477 540 : i++;
4478 : }
4479 :
4480 : /* First pair of lower_val and upper_val that are not equal. */
4481 2832 : lower_or_start_datum = cell1;
4482 2832 : upper_or_start_datum = cell2;
4483 :
4484 : /* OR will have as many arms as there are key columns left. */
4485 2832 : num_or_arms = key->partnatts - i;
4486 2832 : current_or_arm = 0;
4487 2832 : lower_or_arms = upper_or_arms = NIL;
4488 2832 : need_next_lower_arm = need_next_upper_arm = true;
4489 3124 : while (current_or_arm < num_or_arms)
4490 : {
4491 3124 : List *lower_or_arm_args = NIL,
4492 3124 : *upper_or_arm_args = NIL;
4493 :
4494 : /* Restart scan of columns from the i'th one */
4495 3124 : j = i;
4496 3124 : partexprs_item = partexprs_item_saved;
4497 :
4498 3500 : for_both_cell(cell1, spec->lowerdatums, lower_or_start_datum,
4499 : cell2, spec->upperdatums, upper_or_start_datum)
4500 : {
4501 3500 : PartitionRangeDatum *ldatum_next = NULL,
4502 3500 : *udatum_next = NULL;
4503 :
4504 3500 : ldatum = lfirst_node(PartitionRangeDatum, cell1);
4505 3500 : if (lnext(spec->lowerdatums, cell1))
4506 746 : ldatum_next = castNode(PartitionRangeDatum,
4507 : lfirst(lnext(spec->lowerdatums, cell1)));
4508 3500 : udatum = lfirst_node(PartitionRangeDatum, cell2);
4509 3500 : if (lnext(spec->upperdatums, cell2))
4510 746 : udatum_next = castNode(PartitionRangeDatum,
4511 : lfirst(lnext(spec->upperdatums, cell2)));
4512 3500 : get_range_key_properties(key, j, ldatum, udatum,
4513 : &partexprs_item,
4514 : &keyCol,
4515 : &lower_val, &upper_val);
4516 :
4517 3500 : if (need_next_lower_arm && lower_val)
4518 : {
4519 : uint16 strategy;
4520 :
4521 : /*
4522 : * For the non-last columns of this arm, use the EQ operator.
4523 : * For the last column of this arm, use GT, unless this is the
4524 : * last column of the whole bound check, or the next bound
4525 : * datum is MINVALUE, in which case use GE.
4526 : */
4527 3212 : if (j - i < current_or_arm)
4528 322 : strategy = BTEqualStrategyNumber;
4529 2890 : else if (j == key->partnatts - 1 ||
4530 310 : (ldatum_next &&
4531 310 : ldatum_next->kind == PARTITION_RANGE_DATUM_MINVALUE))
4532 2622 : strategy = BTGreaterEqualStrategyNumber;
4533 : else
4534 268 : strategy = BTGreaterStrategyNumber;
4535 :
4536 3212 : lower_or_arm_args = lappend(lower_or_arm_args,
4537 3212 : make_partition_op_expr(key, j,
4538 : strategy,
4539 : keyCol,
4540 : (Expr *) lower_val));
4541 : }
4542 :
4543 3500 : if (need_next_upper_arm && upper_val)
4544 : {
4545 : uint16 strategy;
4546 :
4547 : /*
4548 : * For the non-last columns of this arm, use the EQ operator.
4549 : * For the last column of this arm, use LT, unless the next
4550 : * bound datum is MAXVALUE, in which case use LE.
4551 : */
4552 3106 : if (j - i < current_or_arm)
4553 256 : strategy = BTEqualStrategyNumber;
4554 2850 : else if (udatum_next &&
4555 274 : udatum_next->kind == PARTITION_RANGE_DATUM_MAXVALUE)
4556 30 : strategy = BTLessEqualStrategyNumber;
4557 : else
4558 2820 : strategy = BTLessStrategyNumber;
4559 :
4560 3106 : upper_or_arm_args = lappend(upper_or_arm_args,
4561 3106 : make_partition_op_expr(key, j,
4562 : strategy,
4563 : keyCol,
4564 : (Expr *) upper_val));
4565 : }
4566 :
4567 : /*
4568 : * Did we generate enough of OR's arguments? First arm considers
4569 : * the first of the remaining columns, second arm considers first
4570 : * two of the remaining columns, and so on.
4571 : */
4572 3500 : ++j;
4573 3500 : if (j - i > current_or_arm)
4574 : {
4575 : /*
4576 : * We must not emit any more arms if the new column that will
4577 : * be considered is unbounded, or this one was.
4578 : */
4579 3124 : if (!lower_val || !ldatum_next ||
4580 310 : ldatum_next->kind != PARTITION_RANGE_DATUM_VALUE)
4581 2868 : need_next_lower_arm = false;
4582 3124 : if (!upper_val || !udatum_next ||
4583 274 : udatum_next->kind != PARTITION_RANGE_DATUM_VALUE)
4584 2916 : need_next_upper_arm = false;
4585 3124 : break;
4586 : }
4587 : }
4588 :
4589 3124 : if (lower_or_arm_args != NIL)
4590 5780 : lower_or_arms = lappend(lower_or_arms,
4591 2890 : list_length(lower_or_arm_args) > 1
4592 256 : ? makeBoolExpr(AND_EXPR, lower_or_arm_args, -1)
4593 2634 : : linitial(lower_or_arm_args));
4594 :
4595 3124 : if (upper_or_arm_args != NIL)
4596 5700 : upper_or_arms = lappend(upper_or_arms,
4597 2850 : list_length(upper_or_arm_args) > 1
4598 208 : ? makeBoolExpr(AND_EXPR, upper_or_arm_args, -1)
4599 2642 : : linitial(upper_or_arm_args));
4600 :
4601 : /* If no work to do in the next iteration, break away. */
4602 3124 : if (!need_next_lower_arm && !need_next_upper_arm)
4603 2832 : break;
4604 :
4605 292 : ++current_or_arm;
4606 : }
4607 :
4608 : /*
4609 : * Generate the OR expressions for each of lower and upper bounds (if
4610 : * required), and append to the list of implicitly ANDed list of
4611 : * expressions.
4612 : */
4613 2832 : if (lower_or_arms != NIL)
4614 5268 : result = lappend(result,
4615 2634 : list_length(lower_or_arms) > 1
4616 190 : ? makeBoolExpr(OR_EXPR, lower_or_arms, -1)
4617 2444 : : linitial(lower_or_arms));
4618 2832 : if (upper_or_arms != NIL)
4619 5284 : result = lappend(result,
4620 2642 : list_length(upper_or_arms) > 1
4621 160 : ? makeBoolExpr(OR_EXPR, upper_or_arms, -1)
4622 2482 : : linitial(upper_or_arms));
4623 :
4624 : /*
4625 : * As noted above, for non-default, we return list with constant TRUE. If
4626 : * the result is NIL during the recursive call for default, it implies
4627 : * this is the only other partition which can hold every value of the key
4628 : * except NULL. Hence we return the NullTest result skipped earlier.
4629 : */
4630 2832 : if (result == NIL)
4631 0 : result = for_default
4632 0 : ? get_range_nulltest(key)
4633 0 : : list_make1(makeBoolConst(true, false));
4634 :
4635 2832 : return result;
4636 : }
4637 :
4638 : /*
4639 : * get_range_key_properties
4640 : * Returns range partition key information for a given column
4641 : *
4642 : * This is a subroutine for get_qual_for_range, and its API is pretty
4643 : * specialized to that caller.
4644 : *
4645 : * Constructs an Expr for the key column (returned in *keyCol) and Consts
4646 : * for the lower and upper range limits (returned in *lower_val and
4647 : * *upper_val). For MINVALUE/MAXVALUE limits, NULL is returned instead of
4648 : * a Const. All of these structures are freshly palloc'd.
4649 : *
4650 : * *partexprs_item points to the cell containing the next expression in
4651 : * the key->partexprs list, or NULL. It may be advanced upon return.
4652 : */
4653 : static void
4654 6872 : get_range_key_properties(PartitionKey key, int keynum,
4655 : PartitionRangeDatum *ldatum,
4656 : PartitionRangeDatum *udatum,
4657 : ListCell **partexprs_item,
4658 : Expr **keyCol,
4659 : Const **lower_val, Const **upper_val)
4660 : {
4661 : /* Get partition key expression for this column */
4662 6872 : if (key->partattrs[keynum] != 0)
4663 : {
4664 6144 : *keyCol = (Expr *) makeVar(1,
4665 6144 : key->partattrs[keynum],
4666 6144 : key->parttypid[keynum],
4667 6144 : key->parttypmod[keynum],
4668 6144 : key->parttypcoll[keynum],
4669 : 0);
4670 : }
4671 : else
4672 : {
4673 728 : if (*partexprs_item == NULL)
4674 0 : elog(ERROR, "wrong number of partition key expressions");
4675 728 : *keyCol = copyObject(lfirst(*partexprs_item));
4676 728 : *partexprs_item = lnext(key->partexprs, *partexprs_item);
4677 : }
4678 :
4679 : /* Get appropriate Const nodes for the bounds */
4680 6872 : if (ldatum->kind == PARTITION_RANGE_DATUM_VALUE)
4681 6404 : *lower_val = castNode(Const, copyObject(ldatum->value));
4682 : else
4683 468 : *lower_val = NULL;
4684 :
4685 6872 : if (udatum->kind == PARTITION_RANGE_DATUM_VALUE)
4686 6312 : *upper_val = castNode(Const, copyObject(udatum->value));
4687 : else
4688 560 : *upper_val = NULL;
4689 6872 : }
4690 :
4691 : /*
4692 : * get_range_nulltest
4693 : *
4694 : * A non-default range partition table does not currently allow partition
4695 : * keys to be null, so emit an IS NOT NULL expression for each key column.
4696 : */
4697 : static List *
4698 2580 : get_range_nulltest(PartitionKey key)
4699 : {
4700 2580 : List *result = NIL;
4701 : NullTest *nulltest;
4702 : ListCell *partexprs_item;
4703 : int i;
4704 :
4705 2580 : partexprs_item = list_head(key->partexprs);
4706 5932 : for (i = 0; i < key->partnatts; i++)
4707 : {
4708 : Expr *keyCol;
4709 :
4710 3352 : if (key->partattrs[i] != 0)
4711 : {
4712 3000 : keyCol = (Expr *) makeVar(1,
4713 3000 : key->partattrs[i],
4714 3000 : key->parttypid[i],
4715 3000 : key->parttypmod[i],
4716 3000 : key->parttypcoll[i],
4717 : 0);
4718 : }
4719 : else
4720 : {
4721 352 : if (partexprs_item == NULL)
4722 0 : elog(ERROR, "wrong number of partition key expressions");
4723 352 : keyCol = copyObject(lfirst(partexprs_item));
4724 352 : partexprs_item = lnext(key->partexprs, partexprs_item);
4725 : }
4726 :
4727 3352 : nulltest = makeNode(NullTest);
4728 3352 : nulltest->arg = keyCol;
4729 3352 : nulltest->nulltesttype = IS_NOT_NULL;
4730 3352 : nulltest->argisrow = false;
4731 3352 : nulltest->location = -1;
4732 3352 : result = lappend(result, nulltest);
4733 : }
4734 :
4735 2580 : return result;
4736 : }
4737 :
4738 : /*
4739 : * compute_partition_hash_value
4740 : *
4741 : * Compute the hash value for given partition key values.
4742 : */
4743 : uint64
4744 204588 : compute_partition_hash_value(int partnatts, FmgrInfo *partsupfunc, Oid *partcollation,
4745 : Datum *values, bool *isnull)
4746 : {
4747 : int i;
4748 204588 : uint64 rowHash = 0;
4749 204588 : Datum seed = UInt64GetDatum(HASH_PARTITION_SEED);
4750 :
4751 409308 : for (i = 0; i < partnatts; i++)
4752 : {
4753 : /* Nulls are just ignored */
4754 204720 : if (!isnull[i])
4755 : {
4756 : Datum hash;
4757 :
4758 : Assert(OidIsValid(partsupfunc[i].fn_oid));
4759 :
4760 : /*
4761 : * Compute hash for each datum value by calling respective
4762 : * datatype-specific hash functions of each partition key
4763 : * attribute.
4764 : */
4765 204654 : hash = FunctionCall2Coll(&partsupfunc[i], partcollation[i],
4766 204654 : values[i], seed);
4767 :
4768 : /* Form a single 64-bit hash value */
4769 204654 : rowHash = hash_combine64(rowHash, DatumGetUInt64(hash));
4770 : }
4771 : }
4772 :
4773 204588 : return rowHash;
4774 : }
4775 :
4776 : /*
4777 : * satisfies_hash_partition
4778 : *
4779 : * This is an SQL-callable function for use in hash partition constraints.
4780 : * The first three arguments are the parent table OID, modulus, and remainder.
4781 : * The remaining arguments are the value of the partitioning columns (or
4782 : * expressions); these are hashed and the results are combined into a single
4783 : * hash value by calling hash_combine64.
4784 : *
4785 : * Returns true if remainder produced when this computed single hash value is
4786 : * divided by the given modulus is equal to given remainder, otherwise false.
4787 : * NB: it's important that this never return null, as the constraint machinery
4788 : * would consider that to be a "pass".
4789 : *
4790 : * See get_qual_for_hash() for usage.
4791 : */
4792 : Datum
4793 228 : satisfies_hash_partition(PG_FUNCTION_ARGS)
4794 : {
4795 : typedef struct ColumnsHashData
4796 : {
4797 : Oid relid;
4798 : int nkeys;
4799 : Oid variadic_type;
4800 : int16 variadic_typlen;
4801 : bool variadic_typbyval;
4802 : char variadic_typalign;
4803 : Oid partcollid[PARTITION_MAX_KEYS];
4804 : FmgrInfo partsupfunc[FLEXIBLE_ARRAY_MEMBER];
4805 : } ColumnsHashData;
4806 : Oid parentId;
4807 : int modulus;
4808 : int remainder;
4809 228 : Datum seed = UInt64GetDatum(HASH_PARTITION_SEED);
4810 : ColumnsHashData *my_extra;
4811 228 : uint64 rowHash = 0;
4812 :
4813 : /* Return false if the parent OID, modulus, or remainder is NULL. */
4814 228 : if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2))
4815 12 : PG_RETURN_BOOL(false);
4816 216 : parentId = PG_GETARG_OID(0);
4817 216 : modulus = PG_GETARG_INT32(1);
4818 216 : remainder = PG_GETARG_INT32(2);
4819 :
4820 : /* Sanity check modulus and remainder. */
4821 216 : if (modulus <= 0)
4822 6 : ereport(ERROR,
4823 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4824 : errmsg("modulus for hash partition must be an integer value greater than zero")));
4825 210 : if (remainder < 0)
4826 6 : ereport(ERROR,
4827 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4828 : errmsg("remainder for hash partition must be an integer value greater than or equal to zero")));
4829 204 : if (remainder >= modulus)
4830 6 : ereport(ERROR,
4831 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4832 : errmsg("remainder for hash partition must be less than modulus")));
4833 :
4834 : /*
4835 : * Cache hash function information.
4836 : */
4837 198 : my_extra = (ColumnsHashData *) fcinfo->flinfo->fn_extra;
4838 198 : if (my_extra == NULL || my_extra->relid != parentId)
4839 : {
4840 : Relation parent;
4841 : PartitionKey key;
4842 : int j;
4843 :
4844 : /* Open parent relation and fetch partition key info */
4845 190 : parent = relation_open(parentId, AccessShareLock);
4846 184 : key = RelationGetPartitionKey(parent);
4847 :
4848 : /* Reject parent table that is not hash-partitioned. */
4849 184 : if (key == NULL || key->strategy != PARTITION_STRATEGY_HASH)
4850 12 : ereport(ERROR,
4851 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4852 : errmsg("\"%s\" is not a hash partitioned table",
4853 : get_rel_name(parentId))));
4854 :
4855 172 : if (!get_fn_expr_variadic(fcinfo->flinfo))
4856 : {
4857 142 : int nargs = PG_NARGS() - 3;
4858 :
4859 : /* complain if wrong number of column values */
4860 142 : if (key->partnatts != nargs)
4861 12 : ereport(ERROR,
4862 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4863 : errmsg("number of partitioning columns (%d) does not match number of partition keys provided (%d)",
4864 : key->partnatts, nargs)));
4865 :
4866 : /* allocate space for our cache */
4867 260 : fcinfo->flinfo->fn_extra =
4868 130 : MemoryContextAllocZero(fcinfo->flinfo->fn_mcxt,
4869 : offsetof(ColumnsHashData, partsupfunc) +
4870 130 : sizeof(FmgrInfo) * nargs);
4871 130 : my_extra = (ColumnsHashData *) fcinfo->flinfo->fn_extra;
4872 130 : my_extra->relid = parentId;
4873 130 : my_extra->nkeys = key->partnatts;
4874 130 : memcpy(my_extra->partcollid, key->partcollation,
4875 130 : key->partnatts * sizeof(Oid));
4876 :
4877 : /* check argument types and save fmgr_infos */
4878 302 : for (j = 0; j < key->partnatts; ++j)
4879 : {
4880 178 : Oid argtype = get_fn_expr_argtype(fcinfo->flinfo, j + 3);
4881 :
4882 178 : if (argtype != key->parttypid[j] && !IsBinaryCoercible(argtype, key->parttypid[j]))
4883 6 : ereport(ERROR,
4884 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4885 : errmsg("column %d of the partition key has type %s, but supplied value is of type %s",
4886 : j + 1, format_type_be(key->parttypid[j]), format_type_be(argtype))));
4887 :
4888 172 : fmgr_info_copy(&my_extra->partsupfunc[j],
4889 172 : &key->partsupfunc[j],
4890 172 : fcinfo->flinfo->fn_mcxt);
4891 : }
4892 : }
4893 : else
4894 : {
4895 30 : ArrayType *variadic_array = PG_GETARG_ARRAYTYPE_P(3);
4896 :
4897 : /* allocate space for our cache -- just one FmgrInfo in this case */
4898 60 : fcinfo->flinfo->fn_extra =
4899 30 : MemoryContextAllocZero(fcinfo->flinfo->fn_mcxt,
4900 : offsetof(ColumnsHashData, partsupfunc) +
4901 : sizeof(FmgrInfo));
4902 30 : my_extra = (ColumnsHashData *) fcinfo->flinfo->fn_extra;
4903 30 : my_extra->relid = parentId;
4904 30 : my_extra->nkeys = key->partnatts;
4905 30 : my_extra->variadic_type = ARR_ELEMTYPE(variadic_array);
4906 30 : get_typlenbyvalalign(my_extra->variadic_type,
4907 : &my_extra->variadic_typlen,
4908 : &my_extra->variadic_typbyval,
4909 : &my_extra->variadic_typalign);
4910 30 : my_extra->partcollid[0] = key->partcollation[0];
4911 :
4912 : /* check argument types */
4913 72 : for (j = 0; j < key->partnatts; ++j)
4914 54 : if (key->parttypid[j] != my_extra->variadic_type)
4915 12 : ereport(ERROR,
4916 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4917 : errmsg("column %d of the partition key has type \"%s\", but supplied value is of type \"%s\"",
4918 : j + 1,
4919 : format_type_be(key->parttypid[j]),
4920 : format_type_be(my_extra->variadic_type))));
4921 :
4922 18 : fmgr_info_copy(&my_extra->partsupfunc[0],
4923 : &key->partsupfunc[0],
4924 18 : fcinfo->flinfo->fn_mcxt);
4925 : }
4926 :
4927 : /* Hold lock until commit */
4928 142 : relation_close(parent, NoLock);
4929 : }
4930 :
4931 150 : if (!OidIsValid(my_extra->variadic_type))
4932 : {
4933 132 : int nkeys = my_extra->nkeys;
4934 : int i;
4935 :
4936 : /*
4937 : * For a non-variadic call, neither the number of arguments nor their
4938 : * types can change across calls, so avoid the expense of rechecking
4939 : * here.
4940 : */
4941 :
4942 306 : for (i = 0; i < nkeys; i++)
4943 : {
4944 : Datum hash;
4945 :
4946 : /* keys start from fourth argument of function. */
4947 174 : int argno = i + 3;
4948 :
4949 174 : if (PG_ARGISNULL(argno))
4950 0 : continue;
4951 :
4952 174 : hash = FunctionCall2Coll(&my_extra->partsupfunc[i],
4953 : my_extra->partcollid[i],
4954 : PG_GETARG_DATUM(argno),
4955 : seed);
4956 :
4957 : /* Form a single 64-bit hash value */
4958 174 : rowHash = hash_combine64(rowHash, DatumGetUInt64(hash));
4959 : }
4960 : }
4961 : else
4962 : {
4963 18 : ArrayType *variadic_array = PG_GETARG_ARRAYTYPE_P(3);
4964 : int i;
4965 : int nelems;
4966 : Datum *datum;
4967 : bool *isnull;
4968 :
4969 18 : deconstruct_array(variadic_array,
4970 : my_extra->variadic_type,
4971 18 : my_extra->variadic_typlen,
4972 18 : my_extra->variadic_typbyval,
4973 18 : my_extra->variadic_typalign,
4974 : &datum, &isnull, &nelems);
4975 :
4976 : /* complain if wrong number of column values */
4977 18 : if (nelems != my_extra->nkeys)
4978 6 : ereport(ERROR,
4979 : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4980 : errmsg("number of partitioning columns (%d) does not match number of partition keys provided (%d)",
4981 : my_extra->nkeys, nelems)));
4982 :
4983 36 : for (i = 0; i < nelems; i++)
4984 : {
4985 : Datum hash;
4986 :
4987 24 : if (isnull[i])
4988 0 : continue;
4989 :
4990 24 : hash = FunctionCall2Coll(&my_extra->partsupfunc[0],
4991 : my_extra->partcollid[0],
4992 24 : datum[i],
4993 : seed);
4994 :
4995 : /* Form a single 64-bit hash value */
4996 24 : rowHash = hash_combine64(rowHash, DatumGetUInt64(hash));
4997 : }
4998 : }
4999 :
5000 144 : PG_RETURN_BOOL(rowHash % modulus == remainder);
5001 : }
|
