| blob | 7651886229114a380d9299172cdd14b15ca01821 |
1 /*-------------------------------------------------------------------------
2 *
3 * execPartition.c
4 * Support routines for partitioning.
5 *
6 * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 * IDENTIFICATION
10 * src/backend/executor/execPartition.c
11 *
12 *-------------------------------------------------------------------------
13 */
36 /*-----------------------
37 * PartitionTupleRouting - Encapsulates all information required to
38 * route a tuple inserted into a partitioned table to one of its leaf
39 * partitions.
40 *
41 * partition_root
42 * The partitioned table that's the target of the command.
43 *
44 * partition_dispatch_info
45 * Array of 'max_dispatch' elements containing a pointer to a
46 * PartitionDispatch object for every partitioned table touched by tuple
47 * routing. The entry for the target partitioned table is *always*
48 * present in the 0th element of this array. See comment for
49 * PartitionDispatchData->indexes for details on how this array is
50 * indexed.
51 *
52 * nonleaf_partitions
53 * Array of 'max_dispatch' elements containing pointers to fake
54 * ResultRelInfo objects for nonleaf partitions, useful for checking
55 * the partition constraint.
56 *
57 * num_dispatch
58 * The current number of items stored in the 'partition_dispatch_info'
59 * array. Also serves as the index of the next free array element for
60 * new PartitionDispatch objects that need to be stored.
61 *
62 * max_dispatch
63 * The current allocated size of the 'partition_dispatch_info' array.
64 *
65 * partitions
66 * Array of 'max_partitions' elements containing a pointer to a
67 * ResultRelInfo for every leaf partition touched by tuple routing.
68 * Some of these are pointers to ResultRelInfos which are borrowed out of
69 * the owning ModifyTableState node. The remainder have been built
70 * especially for tuple routing. See comment for
71 * PartitionDispatchData->indexes for details on how this array is
72 * indexed.
73 *
74 * is_borrowed_rel
75 * Array of 'max_partitions' booleans recording whether a given entry
76 * in 'partitions' is a ResultRelInfo pointer borrowed from the owning
77 * ModifyTableState node, rather than being built here.
78 *
79 * num_partitions
80 * The current number of items stored in the 'partitions' array. Also
81 * serves as the index of the next free array element for new
82 * ResultRelInfo objects that need to be stored.
83 *
84 * max_partitions
85 * The current allocated size of the 'partitions' array.
86 *
87 * memcxt
88 * Memory context used to allocate subsidiary structs.
89 *-----------------------
90 */
91 struct PartitionTupleRouting
92 {
93 Relation partition_root;
102 MemoryContext memcxt;
103 };
105 /*-----------------------
106 * PartitionDispatch - information about one partitioned table in a partition
107 * hierarchy required to route a tuple to any of its partitions. A
108 * PartitionDispatch is always encapsulated inside a PartitionTupleRouting
109 * struct and stored inside its 'partition_dispatch_info' array.
110 *
111 * reldesc
112 * Relation descriptor of the table
113 *
114 * key
115 * Partition key information of the table
116 *
117 * keystate
118 * Execution state required for expressions in the partition key
119 *
120 * partdesc
121 * Partition descriptor of the table
122 *
123 * tupslot
124 * A standalone TupleTableSlot initialized with this table's tuple
125 * descriptor, or NULL if no tuple conversion between the parent is
126 * required.
127 *
128 * tupmap
129 * TupleConversionMap to convert from the parent's rowtype to this table's
130 * rowtype (when extracting the partition key of a tuple just before
131 * routing it through this table). A NULL value is stored if no tuple
132 * conversion is required.
133 *
134 * indexes
135 * Array of partdesc->nparts elements. For leaf partitions the index
136 * corresponds to the partition's ResultRelInfo in the encapsulating
137 * PartitionTupleRouting's partitions array. For partitioned partitions,
138 * the index corresponds to the PartitionDispatch for it in its
139 * partition_dispatch_info array. -1 indicates we've not yet allocated
140 * anything in PartitionTupleRouting for the partition.
141 *-----------------------
142 */
144 {
145 Relation reldesc;
146 PartitionKey key;
148 PartitionDesc partdesc;
157 PartitionDispatch dispatch,
163 PartitionDispatch dispatch,
188 PartitionDesc partdesc,
189 PartitionKey partkey,
201 /*
202 * ExecSetupPartitionTupleRouting - sets up information needed during
203 * tuple routing for partitioned tables, encapsulates it in
204 * PartitionTupleRouting, and returns it.
205 *
206 * Callers must use the returned PartitionTupleRouting during calls to
207 * ExecFindPartition(). The actual ResultRelInfo for a partition is only
208 * allocated when the partition is found for the first time.
209 *
210 * The current memory context is used to allocate this struct and all
211 * subsidiary structs that will be allocated from it later on. Typically
212 * it should be estate->es_query_cxt.
213 */
214 PartitionTupleRouting *
216 {
219 /*
220 * Here we attempt to expend as little effort as possible in setting up
221 * the PartitionTupleRouting. Each partition's ResultRelInfo is built on
222 * demand, only when we actually need to route a tuple to that partition.
223 * The reason for this is that a common case is for INSERT to insert a
224 * single tuple into a partitioned table and this must be fast.
225 */
229 /* Rest of members initialized by zeroing */
231 /*
232 * Initialize this table's PartitionDispatch object. Here we pass in the
233 * parent as NULL as we don't need to care about any parent of the target
234 * partitioned table.
235 */
240 }
242 /*
243 * ExecFindPartition -- Return the ResultRelInfo for the leaf partition that
244 * the tuple contained in *slot should belong to.
245 *
246 * If the partition's ResultRelInfo does not yet exist in 'proute' then we set
247 * one up or reuse one from mtstate's resultRelInfo array. When reusing a
248 * ResultRelInfo from the mtstate we verify that the relation is a valid
249 * target for INSERTs and initialize tuple routing information.
250 *
251 * rootResultRelInfo is the relation named in the query.
252 *
253 * estate must be non-NULL; we'll need it to compute any expressions in the
254 * partition keys. Also, its per-tuple contexts are used as evaluation
255 * scratch space.
256 *
257 * If no leaf partition is found, this routine errors out with the appropriate
258 * error message. An error may also be raised if the found target partition
259 * is not a valid target for an INSERT.
260 */
261 ResultRelInfo *
266 {
270 Relation rel;
271 PartitionDispatch dispatch;
272 PartitionDesc partdesc;
277 MemoryContext oldcxt;
280 /* use per-tuple context here to avoid leaking memory */
283 /*
284 * First check the root table's partition constraint, if any. No point in
285 * routing the tuple if it doesn't belong in the root table itself.
286 */
290 /* start with the root partitioned table */
293 {
302 /*
303 * Extract partition key from tuple. Expression evaluation machinery
304 * that FormPartitionKeyDatum() invokes expects ecxt_scantuple to
305 * point to the correct tuple slot. The slot might have changed from
306 * what was used for the parent table if the table of the current
307 * partitioning level has different tuple descriptor from the parent.
308 * So update ecxt_scantuple accordingly.
309 */
313 /*
314 * If this partitioned table has no partitions or no partition for
315 * these values, error out.
316 */
319 {
329 val_desc ?
333 }
337 {
338 /*
339 * We've reached the leaf -- hurray, we're done. Look to see if
340 * we've already got a ResultRelInfo for this partition.
341 */
343 {
344 /* ResultRelInfo already built */
347 }
348 else
349 {
350 /*
351 * If the partition is known in the owning ModifyTableState
352 * node, we can re-use that ResultRelInfo instead of creating
353 * a new one with ExecInitPartitionInfo().
354 */
359 {
360 /* Verify this ResultRelInfo allows INSERTs */
363 /*
364 * Initialize information needed to insert this and
365 * subsequent tuples routed to this partition.
366 */
369 }
370 else
371 {
372 /* We need to create a new one. */
374 dispatch,
376 }
377 }
380 /* Signal to terminate the loop */
382 }
383 else
384 {
385 /*
386 * Partition is a sub-partitioned table; get the PartitionDispatch
387 */
389 {
390 /* Already built. */
395 /*
396 * Move down to the next partition level and search again
397 * until we find a leaf partition that matches this tuple
398 */
400 }
401 else
402 {
403 /* Not yet built. Do that now. */
404 PartitionDispatch subdispatch;
406 /*
407 * Create the new PartitionDispatch. We pass the current one
408 * in as the parent PartitionDispatch
409 */
411 proute,
420 }
422 /*
423 * Convert the tuple to the new parent's layout, if different from
424 * the previous parent.
425 */
427 {
436 }
437 }
439 /*
440 * If this partition is the default one, we must check its partition
441 * constraint now, which may have changed concurrently due to
442 * partitions being added to the parent.
443 *
444 * (We do this here, and do not rely on ExecInsert doing it, because
445 * we don't want to miss doing it for non-leaf partitions.)
446 */
448 {
449 /*
450 * The tuple must match the partition's layout for the constraint
451 * expression to be evaluated successfully. If the partition is
452 * sub-partitioned, that would already be the case due to the code
453 * above, but for a leaf partition the tuple still matches the
454 * parent's layout.
455 *
456 * Note that we have a map to convert from root to current
457 * partition, but not from immediate parent to current partition.
458 * So if we have to convert, do it from the root slot; if not, use
459 * the root slot as-is.
460 */
462 {
468 else
470 }
473 }
474 }
476 /* Release the tuple in the lowest parent's dedicated slot. */
479 /* and restore ecxt's scantuple */
484 }
486 /*
487 * ExecInitPartitionInfo
488 * Lock the partition and initialize ResultRelInfo. Also setup other
489 * information for the partition and store it in the next empty slot in
490 * the proute->partitions array.
491 *
492 * Returns the ResultRelInfo
493 */
497 PartitionDispatch dispatch,
500 {
503 Relation partrel;
507 MemoryContext oldcxt;
517 partrel,
519 rootResultRelInfo,
522 /*
523 * Verify result relation is a valid target for an INSERT. An UPDATE of a
524 * partition-key becomes a DELETE+INSERT operation, so this check is still
525 * required when the operation is CMD_UPDATE.
526 */
529 /*
530 * Open partition indices. The user may have asked to check for conflicts
531 * within this leaf partition and do "nothing" instead of throwing an
532 * error. Be prepared in that case by initializing the index information
533 * needed by ExecInsert() to perform speculative insertions.
534 */
541 /*
542 * Build WITH CHECK OPTION constraints for the partition. Note that we
543 * didn't build the withCheckOptionList for partitions within the planner,
544 * but simple translation of varattnos will suffice. This only occurs for
545 * the INSERT case or in the case of UPDATE/MERGE tuple routing where we
546 * didn't find a result rel to reuse.
547 */
549 {
554 /*
555 * In the case of INSERT on a partitioned table, there is only one
556 * plan. Likewise, there is only one WCO list, not one per partition.
557 * For UPDATE/MERGE, there are as many WCO lists as there are plans.
558 */
569 /*
570 * Use the WCO list of the first plan as a reference to calculate
571 * attno's for the WCO list of this partition. In the INSERT case,
572 * that refers to the root partitioned table, whereas in the UPDATE
573 * tuple routing case, that refers to the first partition in the
574 * mtstate->resultRelInfo array. In any case, both that relation and
575 * this partition should have the same columns, so we should be able
576 * to map attributes successfully.
577 */
580 /*
581 * Convert Vars in it to contain this partition's attribute numbers.
582 */
583 part_attmap =
590 part_attmap,
593 /* We ignore the value of found_whole_row. */
596 {
602 }
606 }
608 /*
609 * Build the RETURNING projection for the partition. Note that we didn't
610 * build the returningList for partitions within the planner, but simple
611 * translation of varattnos will suffice. This only occurs for the INSERT
612 * case or in the case of UPDATE/MERGE tuple routing where we didn't find
613 * a result rel to reuse.
614 */
616 {
621 /* See the comment above for WCO lists. */
632 /*
633 * Use the RETURNING list of the first plan as a reference to
634 * calculate attno's for the RETURNING list of this partition. See
635 * the comment above for WCO lists for more details on why this is
636 * okay.
637 */
640 /*
641 * Convert Vars in it to contain this partition's attribute numbers.
642 */
644 part_attmap =
651 part_attmap,
654 /* We ignore the value of found_whole_row. */
658 /*
659 * Initialize the projection itself.
660 *
661 * Use the slot and the expression context that would have been set up
662 * in ExecInitModifyTable() for projection's output.
663 */
671 }
673 /* Set up information needed for routing tuples to the partition. */
677 /*
678 * If there is an ON CONFLICT clause, initialize state for it.
679 */
681 {
687 /*
688 * If there is a list of arbiter indexes, map it to a list of indexes
689 * in the partition. We do that by scanning the partition's index
690 * list and searching for ancestry relationships to each index in the
691 * ancestor table.
692 */
694 {
700 {
707 {
710 }
712 }
713 }
715 /*
716 * If the resulting lists are of inequal length, something is wrong.
717 * (This shouldn't happen, since arbiter index selection should not
718 * pick up an invalid index.)
719 */
725 /*
726 * In the DO UPDATE case, we have some more state to initialize.
727 */
729 {
740 /*
741 * Need a separate existing slot for each partition, as the
742 * partition could be of a different AM, even if the tuple
743 * descriptors match.
744 */
749 /*
750 * If the partition's tuple descriptor matches exactly the root
751 * parent (the common case), we can re-use most of the parent's ON
752 * CONFLICT SET state, skipping a bunch of work. Otherwise, we
753 * need to create state specific to this partition.
754 */
756 {
757 /*
758 * It's safe to reuse these from the partition root, as we
759 * only process one tuple at a time (therefore we won't
760 * overwrite needed data in slots), and the results of
761 * projections are independent of the underlying storage.
762 * Projections and where clauses themselves don't store state
763 * / are independent of the underlying storage.
764 */
771 }
772 else
773 {
777 /*
778 * Translate expressions in onConflictSet to account for
779 * different attribute numbers. For that, map partition
780 * varattnos twice: first to catch the EXCLUDED
781 * pseudo-relation (INNER_VAR), and second to handle the main
782 * target relation (firstVarno).
783 */
786 part_attmap =
793 part_attmap,
796 /* We ignore the value of found_whole_row. */
800 part_attmap,
803 /* We ignore the value of found_whole_row. */
805 /* Finally, adjust the target colnos to match the partition. */
807 leaf_part_rri);
809 /* create the tuple slot for the UPDATE SET projection */
814 /* build UPDATE SET projection state */
818 onconflcols,
819 partrelDesc,
820 econtext,
824 /*
825 * If there is a WHERE clause, initialize state where it will
826 * be evaluated, mapping the attribute numbers appropriately.
827 * As with onConflictSet, we need to map partition varattnos
828 * to the partition's tupdesc.
829 */
831 {
838 part_attmap,
841 /* We ignore the value of found_whole_row. */
845 part_attmap,
848 /* We ignore the value of found_whole_row. */
851 }
852 }
853 }
854 }
856 /*
857 * Since we've just initialized this ResultRelInfo, it's not in any list
858 * attached to the estate as yet. Add it, so that it can be found later.
859 *
860 * Note that the entries in this list appear in no predetermined order,
861 * because partition result rels are initialized as and when they're
862 * needed.
863 */
867 leaf_part_rri);
869 /*
870 * Initialize information about this partition that's needed to handle
871 * MERGE. We take the "first" result relation's mergeActionList as
872 * reference and make copy for this relation, converting stuff that
873 * references attribute numbers to match this relation's.
874 *
875 * This duplicates much of the logic in ExecInitMerge(), so something
876 * changes there, look here too.
877 */
879 {
886 part_attmap =
894 /* Initialize state for join condition checking. */
895 joinCondition =
898 part_attmap,
901 /* We ignore the value of found_whole_row. */
906 {
907 /* Make a copy for this relation to be safe. */
911 /* Generate the action's state for this relation */
915 /* And put the action in the appropriate list */
918 action_state);
921 {
924 /*
925 * ExecCheckPlanOutput() already done on the targetlist
926 * when "first" result relation initialized and it is same
927 * for all result relations.
928 */
937 /*
938 * Convert updateColnos from "first" result relation
939 * attribute numbers to this result rel's.
940 */
944 part_attmap);
950 econtext,
952 NULL);
959 }
961 /* found_whole_row intentionally ignored. */
965 part_attmap,
970 }
971 }
975 }
977 /*
978 * ExecInitRoutingInfo
979 * Set up information needed for translating tuples between root
980 * partitioned table format and partition format, and keep track of it
981 * in PartitionTupleRouting.
982 */
983 static void
987 PartitionDispatch dispatch,
991 {
992 MemoryContext oldcxt;
997 /*
998 * Set up tuple conversion between root parent and the partition if the
999 * two have different rowtypes. If conversion is indeed required, also
1000 * initialize a slot dedicated to storing this partition's converted
1001 * tuples. Various operations that are applied to tuples after routing,
1002 * such as checking constraints, will refer to this slot.
1003 */
1005 {
1008 /*
1009 * This pins the partition's TupleDesc, which will be released at the
1010 * end of the command.
1011 */
1014 }
1015 else
1018 /*
1019 * If the partition is a foreign table, let the FDW init itself for
1020 * routing tuples to the partition.
1021 */
1026 /*
1027 * Determine if the FDW supports batch insert and determine the batch size
1028 * (a FDW may support batching, but it may be disabled for the
1029 * server/table or for this particular query).
1030 *
1031 * If the FDW does not support batching, we set the batch size to 1.
1032 */
1038 else
1045 /*
1046 * Keep track of it in the PartitionTupleRouting->partitions array.
1047 */
1052 /* Allocate or enlarge the array, as needed */
1054 {
1056 {
1062 }
1063 else
1064 {
1072 }
1073 }
1080 }
1082 /*
1083 * ExecInitPartitionDispatchInfo
1084 * Lock the partitioned table (if not locked already) and initialize
1085 * PartitionDispatch for a partitioned table and store it in the next
1086 * available slot in the proute->partition_dispatch_info array. Also,
1087 * record the index into this array in the parent_pd->indexes[] array in
1088 * the partidx element so that we can properly retrieve the newly created
1089 * PartitionDispatch later.
1090 */
1091 static PartitionDispatch
1096 {
1097 Relation rel;
1098 PartitionDesc partdesc;
1099 PartitionDispatch pd;
1101 MemoryContext oldcxt;
1103 /*
1104 * For data modification, it is better that executor does not include
1105 * partitions being detached, except when running in snapshot-isolation
1106 * mode. This means that a read-committed transaction immediately gets a
1107 * "no partition for tuple" error when a tuple is inserted into a
1108 * partition that's being detached concurrently, but a transaction in
1109 * repeatable-read mode can still use such a partition.
1110 */
1118 /*
1119 * Only sub-partitioned tables need to be locked here. The root
1120 * partitioned table will already have been locked as it's referenced in
1121 * the query's rtable.
1122 */
1125 else
1136 {
1139 /*
1140 * For sub-partitioned tables where the column order differs from its
1141 * direct parent partitioned table, we must store a tuple table slot
1142 * initialized with its tuple descriptor and a tuple conversion map to
1143 * convert a tuple from its parent's rowtype to its own. This is to
1144 * make sure that we are looking at the correct row using the correct
1145 * tuple descriptor when computing its partition key for tuple
1146 * routing.
1147 */
1149 tupdesc,
1153 }
1154 else
1155 {
1156 /* Not required for the root partitioned table */
1159 }
1161 /*
1162 * Initialize with -1 to signify that the corresponding partition's
1163 * ResultRelInfo or PartitionDispatch has not been created yet.
1164 */
1167 /* Track in PartitionTupleRouting for later use */
1170 /* Allocate or enlarge the array, as needed */
1172 {
1174 {
1180 }
1181 else
1182 {
1190 }
1191 }
1194 /*
1195 * If setting up a PartitionDispatch for a sub-partitioned table, we may
1196 * also need a minimally valid ResultRelInfo for checking the partition
1197 * constraint later; set that up now.
1198 */
1200 {
1205 }
1206 else
1209 /*
1210 * Finally, if setting up a PartitionDispatch for a sub-partitioned table,
1211 * install a downlink in the parent to allow quick descent.
1212 */
1214 {
1217 }
1222 }
1224 /*
1225 * ExecCleanupTupleRouting -- Clean up objects allocated for partition tuple
1226 * routing.
1227 *
1228 * Close all the partitioned tables, leaf partitions, and their indices.
1229 */
1230 void
1233 {
1236 /*
1237 * Remember, proute->partition_dispatch_info[0] corresponds to the root
1238 * partitioned table, which we must not try to close, because it is the
1239 * main target table of the query that will be closed by callers such as
1240 * ExecEndPlan() or DoCopy(). Also, tupslot is NULL for the root
1241 * partitioned table.
1242 */
1244 {
1251 }
1254 {
1257 /* Allow any FDWs to shut down */
1261 resultRelInfo);
1263 /*
1264 * Close it if it's not one of the result relations borrowed from the
1265 * owning ModifyTableState; those will be closed by ExecEndPlan().
1266 */
1272 }
1273 }
1275 /* ----------------
1276 * FormPartitionKeyDatum
1277 * Construct values[] and isnull[] arrays for the partition key
1278 * of a tuple.
1279 *
1280 * pd Partition dispatch object of the partitioned table
1281 * slot Heap tuple from which to extract partition key
1282 * estate executor state for evaluating any partition key
1283 * expressions (must be non-NULL)
1284 * values Array of partition key Datums (output area)
1285 * isnull Array of is-null indicators (output area)
1286 *
1287 * the ecxt_scantuple slot of estate's per-tuple expr context must point to
1288 * the heap tuple passed in.
1289 * ----------------
1290 */
1291 static void
1297 {
1302 {
1303 /* Check caller has set up context correctly */
1307 /* First time through, set up expression evaluation state */
1309 }
1313 {
1315 Datum datum;
1319 {
1320 /* Plain column; get the value directly from the heap tuple */
1322 }
1323 else
1324 {
1325 /* Expression; need to evaluate it */
1332 }
1335 }
1339 }
1341 /*
1342 * The number of times the same partition must be found in a row before we
1343 * switch from a binary search for the given values to just checking if the
1344 * values belong to the last found partition. This must be above 0.
1345 */
1346 #define PARTITION_CACHED_FIND_THRESHOLD 16
1348 /*
1349 * get_partition_for_tuple
1350 * Finds partition of relation which accepts the partition key specified
1351 * in values and isnull.
1352 *
1353 * Calling this function can be quite expensive when LIST and RANGE
1354 * partitioned tables have many partitions. This is due to the binary search
1355 * that's done to find the correct partition. Many of the use cases for LIST
1356 * and RANGE partitioned tables make it likely that the same partition is
1357 * found in subsequent ExecFindPartition() calls. This is especially true for
1358 * cases such as RANGE partitioned tables on a TIMESTAMP column where the
1359 * partition key is the current time. When asked to find a partition for a
1360 * RANGE or LIST partitioned table, we record the partition index and datum
1361 * offset we've found for the given 'values' in the PartitionDesc (which is
1362 * stored in relcache), and if we keep finding the same partition
1363 * PARTITION_CACHED_FIND_THRESHOLD times in a row, then we'll enable caching
1364 * logic and instead of performing a binary search to find the correct
1365 * partition, we'll just double-check that 'values' still belong to the last
1366 * found partition, and if so, we'll return that partition index, thus
1367 * skipping the need for the binary search. If we fail to match the last
1368 * partition when double checking, then we fall back on doing a binary search.
1369 * In this case, unless we find 'values' belong to the DEFAULT partition,
1370 * we'll reset the number of times we've hit the same partition so that we
1371 * don't attempt to use the cache again until we've found that partition at
1372 * least PARTITION_CACHED_FIND_THRESHOLD times in a row.
1373 *
1374 * For cases where the partition changes on each lookup, the amount of
1375 * additional work required just amounts to recording the last found partition
1376 * and bound offset then resetting the found counter. This is cheap and does
1377 * not appear to cause any meaningful slowdowns for such cases.
1378 *
1379 * No caching of partitions is done when the last found partition is the
1380 * DEFAULT or NULL partition. For the case of the DEFAULT partition, there
1381 * is no bound offset storing the matching datum, so we cannot confirm the
1382 * indexes match. For the NULL partition, this is just so cheap, there's no
1383 * sense in caching.
1384 *
1385 * Return value is index of the partition (>= 0 and < partdesc->nparts) if one
1386 * found or -1 if none found.
1387 */
1388 static int
1390 {
1397 /*
1398 * In the switch statement below, when we perform a cached lookup for
1399 * RANGE and LIST partitioned tables, if we find that the last found
1400 * partition matches the 'values', we return the partition index right
1401 * away. We do this instead of breaking out of the switch as we don't
1402 * want to execute the code about the DEFAULT partition or do any updates
1403 * for any of the cache-related fields. That would be a waste of effort
1404 * as we already know it's not the DEFAULT partition and have no need to
1405 * increment the number of times we found the same partition any higher
1406 * than PARTITION_CACHED_FIND_THRESHOLD.
1407 */
1409 /* Route as appropriate based on partitioning strategy. */
1411 {
1413 {
1414 uint64 rowHash;
1416 /* hash partitioning is too cheap to bother caching */
1422 /*
1423 * HASH partitions can't have a DEFAULT partition and we don't
1424 * do any caching work for them, so just return the part index
1425 */
1427 }
1431 {
1432 /* this is far too cheap to bother doing any caching */
1434 {
1435 /*
1436 * When there is a NULL partition we just return that
1437 * directly. We don't have a bound_offset so it's not
1438 * valid to drop into the code after the switch which
1439 * checks and updates the cache fields. We perhaps should
1440 * be invalidating the details of the last cached
1441 * partition but there's no real need to. Keeping those
1442 * fields set gives a chance at matching to the cached
1443 * partition on the next lookup.
1444 */
1446 }
1447 }
1448 else
1449 {
1453 {
1456 int32 cmpval;
1458 /* does the last found datum index match this datum? */
1461 lastDatum,
1467 /* fall-through and do a manual lookup */
1468 }
1472 boundinfo,
1476 }
1480 {
1485 /*
1486 * No range includes NULL, so this will be accepted by the
1487 * default partition if there is one, and otherwise rejected.
1488 */
1490 {
1492 {
1495 }
1496 }
1498 /* NULLs belong in the DEFAULT partition */
1503 {
1507 int32 cmpval;
1509 /* check if the value is >= to the lower bound */
1512 lastDatums,
1513 kind,
1514 values,
1517 /*
1518 * If it's equal to the lower bound then no need to check
1519 * the upper bound.
1520 */
1525 {
1526 /* check if the value is below the upper bound */
1531 lastDatums,
1532 kind,
1533 values,
1538 }
1539 /* fall-through and do a manual lookup */
1540 }
1544 boundinfo,
1546 values,
1549 /*
1550 * The bound at bound_offset is less than or equal to the
1551 * tuple value, so the bound at offset+1 is the upper bound of
1552 * the partition we're looking for, if there actually exists
1553 * one.
1554 */
1556 }
1562 }
1564 /*
1565 * part_index < 0 means we failed to find a partition of this parent. Use
1566 * the default partition, if there is one.
1567 */
1569 {
1570 /*
1571 * No need to reset the cache fields here. The next set of values
1572 * might end up belonging to the cached partition, so leaving the
1573 * cache alone improves the chances of a cache hit on the next lookup.
1574 */
1576 }
1578 /* we should only make it here when the code above set bound_offset */
1581 /*
1582 * Attend to the cache fields. If the bound_offset matches the last
1583 * cached bound offset then we've found the same partition as last time,
1584 * so bump the count by one. If all goes well, we'll eventually reach
1585 * PARTITION_CACHED_FIND_THRESHOLD and try the cache path next time
1586 * around. Otherwise, we'll reset the cache count back to 1 to mark that
1587 * we've found this partition for the first time.
1588 */
1591 else
1592 {
1596 }
1599 }
1601 /*
1602 * ExecBuildSlotPartitionKeyDescription
1603 *
1604 * This works very much like BuildIndexValueDescription() and is currently
1605 * used for building error messages when ExecFindPartition() fails to find
1606 * partition for a row.
1607 */
1613 {
1614 StringInfoData buf;
1619 AclResult aclresult;
1624 /* If the user has table-level access, just go build the description. */
1627 {
1628 /*
1629 * Step through the columns of the partition key and make sure the
1630 * user has SELECT rights on all of them.
1631 */
1633 {
1636 /*
1637 * If this partition key column is an expression, we return no
1638 * detail rather than try to figure out what column(s) the
1639 * expression includes and if the user has SELECT rights on them.
1640 */
1645 }
1646 }
1653 {
1659 else
1660 {
1661 Oid foutoid;
1667 }
1672 /* truncate if needed */
1676 else
1677 {
1681 }
1682 }
1687 }
1689 /*
1690 * adjust_partition_colnos
1691 * Adjust the list of UPDATE target column numbers to account for
1692 * attribute differences between the parent and the partition.
1693 *
1694 * Note: mustn't be called if no adjustment is required.
1695 */
1698 {
1704 }
1706 /*
1707 * adjust_partition_colnos_using_map
1708 * Like adjust_partition_colnos, but uses a caller-supplied map instead
1709 * of assuming to map from the "root" result relation.
1710 *
1711 * Note: mustn't be called if no adjustment is required.
1712 */
1715 {
1722 {
1729 parentattrno);
1732 }
1735 }
1737 /*-------------------------------------------------------------------------
1738 * Run-Time Partition Pruning Support.
1739 *
1740 * The following series of functions exist to support the removal of unneeded
1741 * subplans for queries against partitioned tables. The supporting functions
1742 * here are designed to work with any plan type which supports an arbitrary
1743 * number of subplans, e.g. Append, MergeAppend.
1744 *
1745 * When pruning involves comparison of a partition key to a constant, it's
1746 * done by the planner. However, if we have a comparison to a non-constant
1747 * but not volatile expression, that presents an opportunity for run-time
1748 * pruning by the executor, allowing irrelevant partitions to be skipped
1749 * dynamically.
1750 *
1751 * We must distinguish expressions containing PARAM_EXEC Params from
1752 * expressions that don't contain those. Even though a PARAM_EXEC Param is
1753 * considered to be a stable expression, it can change value from one plan
1754 * node scan to the next during query execution. Stable comparison
1755 * expressions that don't involve such Params allow partition pruning to be
1756 * done once during executor startup. Expressions that do involve such Params
1757 * require us to prune separately for each scan of the parent plan node.
1758 *
1759 * Note that pruning away unneeded subplans during executor startup has the
1760 * added benefit of not having to initialize the unneeded subplans at all.
1761 *
1762 *
1763 * Functions:
1764 *
1765 * ExecInitPartitionPruning:
1766 * Creates the PartitionPruneState required by ExecFindMatchingSubPlans.
1767 * Details stored include how to map the partition index returned by the
1768 * partition pruning code into subplan indexes. Also determines the set
1769 * of subplans to initialize considering the result of performing initial
1770 * pruning steps if any. Maps in PartitionPruneState are updated to
1771 * account for initial pruning possibly having eliminated some of the
1772 * subplans.
1773 *
1774 * ExecFindMatchingSubPlans:
1775 * Returns indexes of matching subplans after evaluating the expressions
1776 * that are safe to evaluate at a given point. This function is first
1777 * called during ExecInitPartitionPruning() to find the initially
1778 * matching subplans based on performing the initial pruning steps and
1779 * then must be called again each time the value of a Param listed in
1780 * PartitionPruneState's 'execparamids' changes.
1781 *-------------------------------------------------------------------------
1782 */
1784 /*
1785 * ExecInitPartitionPruning
1786 * Initialize data structure needed for run-time partition pruning and
1787 * do initial pruning if needed
1788 *
1789 * On return, *initially_valid_subplans is assigned the set of indexes of
1790 * child subplans that must be initialized along with the parent plan node.
1791 * Initial pruning is performed here if needed and in that case only the
1792 * surviving subplans' indexes are added.
1793 *
1794 * If subplans are indeed pruned, subplan_map arrays contained in the returned
1795 * PartitionPruneState are re-sequenced to not count those, though only if the
1796 * maps will be needed for subsequent execution pruning passes.
1797 */
1798 PartitionPruneState *
1803 {
1807 /* We may need an expression context to evaluate partition exprs */
1810 /* Create the working data structure for pruning */
1813 /*
1814 * Perform an initial partition prune pass, if required.
1815 */
1818 else
1819 {
1820 /* No pruning, so we'll need to initialize all subplans */
1824 }
1826 /*
1827 * Re-sequence subplan indexes contained in prunestate to account for any
1828 * that were removed above due to initial pruning. No need to do this if
1829 * no steps were removed.
1830 */
1832 {
1833 /*
1834 * We can safely skip this when !do_exec_prune, even though that
1835 * leaves invalid data in prunestate, because that data won't be
1836 * consulted again (cf initial Assert in ExecFindMatchingSubPlans).
1837 */
1841 n_total_subplans);
1842 }
1845 }
1847 /*
1848 * CreatePartitionPruneState
1849 * Build the data structure required for calling ExecFindMatchingSubPlans
1850 *
1851 * 'planstate' is the parent plan node's execution state.
1852 *
1853 * 'pruneinfo' is a PartitionPruneInfo as generated by
1854 * make_partition_pruneinfo. Here we build a PartitionPruneState containing a
1855 * PartitionPruningData for each partitioning hierarchy (i.e., each sublist of
1856 * pruneinfo->prune_infos), each of which contains a PartitionedRelPruningData
1857 * for each PartitionedRelPruneInfo appearing in that sublist. This two-level
1858 * system is needed to keep from confusing the different hierarchies when a
1859 * UNION ALL contains multiple partitioned tables as children. The data
1860 * stored in each PartitionedRelPruningData can be re-used each time we
1861 * re-evaluate which partitions match the pruning steps provided in each
1862 * PartitionedRelPruneInfo.
1863 */
1866 {
1874 /* For data reading, executor always includes detached partitions */
1882 /*
1883 * Allocate the data structure
1884 */
1890 /* other_subplans can change at runtime, so we need our own copy */
1896 /*
1897 * Create a short-term memory context which we'll use when making calls to
1898 * the partition pruning functions. This avoids possible memory leaks,
1899 * since the pruning functions call comparison functions that aren't under
1900 * our control.
1901 */
1905 ALLOCSET_DEFAULT_SIZES);
1909 {
1924 {
1927 Relation partrel;
1928 PartitionDesc partdesc;
1929 PartitionKey partkey;
1931 /*
1932 * We can rely on the copies of the partitioned table's partition
1933 * key and partition descriptor appearing in its relcache entry,
1934 * because that entry will be held open and locked for the
1935 * duration of this executor run.
1936 */
1940 partrel);
1942 /*
1943 * Initialize the subplan_map and subpart_map.
1944 *
1945 * The set of partitions that exist now might not be the same that
1946 * existed when the plan was made. The normal case is that it is;
1947 * optimize for that case with a quick comparison, and just copy
1948 * the subplan_map and make subpart_map point to the one in
1949 * PruneInfo.
1950 *
1951 * For the case where they aren't identical, we could have more
1952 * partitions on either side; or even exactly the same number of
1953 * them on both but the set of OIDs doesn't match fully. Handle
1954 * this by creating new subplan_map and subpart_map arrays that
1955 * corresponds to the ones in the PruneInfo where the new
1956 * partition descriptor's OIDs match. Any that don't match can be
1957 * set to -1, as if they were pruned. By construction, both
1958 * arrays are in partition bounds order.
1959 */
1966 {
1970 }
1971 else
1972 {
1976 /*
1977 * When the partition arrays are not identical, there could be
1978 * some new ones but it's also possible that one was removed;
1979 * we cope with both situations by walking the arrays and
1980 * discarding those that don't match.
1981 *
1982 * If the number of partitions on both sides match, it's still
1983 * possible that one partition has been detached and another
1984 * attached. Cope with that by creating a map that skips any
1985 * mismatches.
1986 */
1990 {
1991 /* Skip any InvalidOid relid_map entries */
1994 pd_idx++;
1996 recheck:
1999 {
2000 /* match... */
2005 pd_idx++;
2007 }
2009 /*
2010 * There isn't an exact match in the corresponding
2011 * positions of both arrays. Peek ahead in
2012 * pinfo->relid_map to see if we have a match for the
2013 * current partition in partdesc. Normally if a match
2014 * exists it's just one element ahead, and it means the
2015 * planner saw one extra partition that we no longer see
2016 * now (its concurrent detach finished just in between);
2017 * so we skip that one by updating pd_idx to the new
2018 * location and jumping above. We can then continue to
2019 * match the rest of the elements after skipping the OID
2020 * with no match; no future matches are tried for the
2021 * element that was skipped, because we know the arrays to
2022 * be in the same order.
2023 *
2024 * If we don't see a match anywhere in the rest of the
2025 * pinfo->relid_map array, that means we see an element
2026 * now that the planner didn't see, so mark that one as
2027 * pruned and move on.
2028 */
2030 {
2034 {
2037 }
2038 }
2042 }
2043 }
2045 /* present_parts is also subject to later modification */
2048 /*
2049 * Initialize pruning contexts as needed. Note that we must skip
2050 * execution-time partition pruning in EXPLAIN (GENERIC_PLAN),
2051 * since parameter values may be missing.
2052 */
2056 {
2060 econtext);
2061 /* Record whether initial pruning is needed at any level */
2063 }
2067 {
2071 econtext);
2072 /* Record whether exec pruning is needed at any level */
2074 }
2076 /*
2077 * Accumulate the IDs of all PARAM_EXEC Params affecting the
2078 * partitioning decisions at this plan node.
2079 */
2083 j++;
2084 }
2085 i++;
2086 }
2089 }
2091 /*
2092 * Initialize a PartitionPruneContext for the given list of pruning steps.
2093 */
2094 static void
2097 PartitionDesc partdesc,
2098 PartitionKey partkey,
2101 {
2115 /* We'll look up type-specific support functions as needed */
2123 /* Initialize expression state for each expression we need */
2127 {
2132 /* not needed for other step kinds */
2139 {
2144 {
2147 /* not needed for Consts */
2149 {
2152 keyno);
2154 /*
2155 * When planstate is NULL, pruning_steps is known not to
2156 * contain any expressions that depend on the parent plan.
2157 * Information of any available EXTERN parameters must be
2158 * passed explicitly in that case, which the caller must
2159 * have made available via econtext.
2160 */
2165 else
2168 }
2170 }
2171 }
2172 }
2173 }
2175 /*
2176 * PartitionPruneFixSubPlanMap
2177 * Fix mapping of partition indexes to subplan indexes contained in
2178 * prunestate by considering the new list of subplans that survived
2179 * initial pruning
2180 *
2181 * Current values of the indexes present in PartitionPruneState count all the
2182 * subplans that would be present before initial pruning was done. If initial
2183 * pruning got rid of some of the subplans, any subsequent pruning passes will
2184 * be looking at a different set of target subplans to choose from than those
2185 * in the pre-initial-pruning set, so the maps in PartitionPruneState
2186 * containing those indexes must be updated to reflect the new indexes of
2187 * subplans in the post-initial-pruning set.
2188 */
2189 static void
2193 {
2199 /*
2200 * First we must build a temporary array which maps old subplan indexes to
2201 * new ones. For convenience of initialization, we use 1-based indexes in
2202 * this array and leave pruned items as 0.
2203 */
2208 {
2211 }
2213 /*
2214 * Now we can update each PartitionedRelPruneInfo's subplan_map with new
2215 * subplan indexes. We must also recompute its present_parts bitmap.
2216 */
2218 {
2222 /*
2223 * Within each hierarchy, we perform this loop in back-to-front order
2224 * so that we determine present_parts for the lowest-level partitioned
2225 * tables first. This way we can tell whether a sub-partitioned
2226 * table's partitions were entirely pruned so we can exclude it from
2227 * the current level's present_parts.
2228 */
2230 {
2235 /* We just rebuild present_parts from scratch */
2240 {
2244 /*
2245 * If this partition existed as a subplan then change the old
2246 * subplan index to the new subplan index. The new index may
2247 * become -1 if the partition was pruned above, or it may just
2248 * come earlier in the subplan list due to some subplans being
2249 * removed earlier in the list. If it's a subpartition, add
2250 * it to present_parts unless it's entirely pruned.
2251 */
2253 {
2260 }
2262 {
2270 }
2271 }
2272 }
2273 }
2275 /*
2276 * We must also recompute the other_subplans set, since indexes in it may
2277 * change.
2278 */
2289 }
2291 /*
2292 * ExecFindMatchingSubPlans
2293 * Determine which subplans match the pruning steps detailed in
2294 * 'prunestate' for the current comparison expression values.
2295 *
2296 * Pass initial_prune if PARAM_EXEC Params cannot yet be evaluated. This
2297 * differentiates the initial executor-time pruning step from later
2298 * runtime pruning.
2299 */
2300 Bitmapset *
2303 {
2305 MemoryContext oldcontext;
2308 /*
2309 * Either we're here on the initial prune done during pruning
2310 * initialization, or we're at a point where PARAM_EXEC Params can be
2311 * evaluated *and* there are steps in which to do so.
2312 */
2315 /*
2316 * Switch to a temp context to avoid leaking memory in the executor's
2317 * query-lifespan memory context.
2318 */
2321 /*
2322 * For each hierarchy, do the pruning tests, and add nondeletable
2323 * subplans' indexes to "result".
2324 */
2326 {
2330 /*
2331 * We pass the zeroth item, belonging to the root table of the
2332 * hierarchy, and find_matching_subplans_recurse() takes care of
2333 * recursing to other (lower-level) parents as needed.
2334 */
2339 /* Expression eval may have used space in ExprContext too */
2342 }
2344 /* Add in any subplans that partition pruning didn't account for */
2349 /* Copy result out of the temp context before we reset it */
2355 }
2357 /*
2358 * find_matching_subplans_recurse
2359 * Recursive worker function for ExecFindMatchingSubPlans
2360 *
2361 * Adds valid (non-prunable) subplan IDs to *validsubplans
2362 */
2363 static void
2368 {
2372 /* Guard against stack overflow due to overly deep partition hierarchy. */
2375 /*
2376 * Prune as appropriate, if we have pruning steps matching the current
2377 * execution context. Otherwise just include all partitions at this
2378 * level.
2379 */
2386 else
2389 /* Translate partset into subplan indexes */
2392 {
2396 else
2397 {
2404 else
2405 {
2406 /*
2407 * We get here if the planner already pruned all the sub-
2408 * partitions for this partition. Silently ignore this
2409 * partition in this case. The end result is the same: we
2410 * would have pruned all partitions just the same, but we
2411 * don't have any pruning steps to execute to verify this.
2412 */
2413 }
2414 }
2415 }
2416 }