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