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