| blob | e3824efe9b5f0342e266e21fbbaaeb3bdf8c195d |
1 /*-------------------------------------------------------------------------
2 *
3 * plancat.c
4 * routines for accessing the system catalogs
5 *
6 *
7 * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
8 * Portions Copyright (c) 1994, Regents of the University of California
9 *
10 *
11 * IDENTIFICATION
12 * src/backend/optimizer/util/plancat.c
13 *
14 *-------------------------------------------------------------------------
15 */
18 #include <math.h>
57 /* GUC parameter */
60 /* Hook for plugins to get control in get_relation_info() */
74 Relation heapRelation);
77 Relation relation);
79 Relation relation);
86 /*
87 * get_relation_info -
88 * Retrieves catalog information for a given relation.
89 *
90 * Given the Oid of the relation, return the following info into fields
91 * of the RelOptInfo struct:
92 *
93 * min_attr lowest valid AttrNumber
94 * max_attr highest valid AttrNumber
95 * indexlist list of IndexOptInfos for relation's indexes
96 * statlist list of StatisticExtInfo for relation's statistic objects
97 * serverid if it's a foreign table, the server OID
98 * fdwroutine if it's a foreign table, the FDW function pointers
99 * pages number of pages
100 * tuples number of tuples
101 * rel_parallel_workers user-defined number of parallel workers
102 *
103 * Also, add information about the relation's foreign keys to root->fkey_list.
104 *
105 * Also, initialize the attr_needed[] and attr_widths[] arrays. In most
106 * cases these are left as zeroes, but sometimes we need to compute attr
107 * widths here, and we may as well cache the results for costsize.c.
108 *
109 * If inhparent is true, all we need to do is set up the attr arrays:
110 * the RelOptInfo actually represents the appendrel formed by an inheritance
111 * tree, and so the parent rel's physical size and index information isn't
112 * important for it, however, for partitioned tables, we do populate the
113 * indexlist as the planner uses unique indexes as unique proofs for certain
114 * optimizations.
115 */
116 void
119 {
121 Relation relation;
125 /*
126 * We need not lock the relation since it was already locked, either by
127 * the rewriter or when expand_inherited_rtentry() added it to the query's
128 * rangetable.
129 */
132 /*
133 * Relations without a table AM can be used in a query only if they are of
134 * special-cased relkinds. This check prevents us from crashing later if,
135 * for example, a view's ON SELECT rule has gone missing. Note that
136 * table_open() already rejected indexes and composite types; spell the
137 * error the same way it does.
138 */
140 {
148 }
150 /* Temporary and unlogged relations are inaccessible during recovery. */
166 /*
167 * Estimate relation size --- unless it's an inheritance parent, in which
168 * case the size we want is not the rel's own size but the size of its
169 * inheritance tree. That will be computed in set_append_rel_size().
170 */
175 /* Retrieve the parallel_workers reloption, or -1 if not set. */
178 /*
179 * Make list of indexes. Ignore indexes on system catalogs if told to.
180 * Don't bother with indexes from traditional inheritance parents. For
181 * partitioned tables, we need a list of at least unique indexes as these
182 * serve as unique proofs for certain planner optimizations. However,
183 * let's not discriminate here and just record all partitioned indexes
184 * whether they're unique indexes or not.
185 */
189 else
193 {
195 LOCKMODE lmode;
200 /*
201 * For each index, we get the same type of lock that the executor will
202 * need, and do not release it. This saves a couple of trips to the
203 * shared lock manager while not creating any real loss of
204 * concurrency, because no schema changes could be happening on the
205 * index while we hold lock on the parent rel, and no lock type used
206 * for queries blocks any other kind of index operation.
207 */
211 {
213 Relation indexRelation;
214 Form_pg_index index;
218 nkeycolumns;
221 /*
222 * Extract info from the relation descriptor for the index.
223 */
227 /*
228 * Ignore invalid indexes, since they can't safely be used for
229 * queries. Note that this is OK because the data structure we
230 * are constructing is only used by the planner --- the executor
231 * still needs to insert into "invalid" indexes, if they're marked
232 * indisready.
233 */
235 {
238 }
240 /*
241 * If the index is valid, but cannot yet be used, ignore it; but
242 * mark the plan we are generating as transient. See
243 * src/backend/access/heap/README.HOT for discussion.
244 */
247 TransactionXmin))
248 {
252 }
270 {
273 }
276 {
280 }
284 /*
285 * We don't have an AM for partitioned indexes, so we'll just
286 * NULLify the AM related fields for those.
287 */
289 {
290 /* We copy just the fields we need, not all of rd_indam */
305 /* Fetch index opclass options */
308 /*
309 * Fetch the ordering information for the index, if any.
310 */
312 {
313 /*
314 * If it's a btree index, we can use its opfamily OIDs
315 * directly as the sort ordering opfamily OIDs.
316 */
324 {
329 }
330 }
332 {
333 /*
334 * Otherwise, identify the corresponding btree opfamilies
335 * by trying to map this index's "<" operators into btree.
336 * Since "<" uniquely defines the behavior of a sort
337 * order, this is a sufficient test.
338 *
339 * XXX This method is rather slow and also requires the
340 * undesirable assumption that the other index AM numbers
341 * its strategies the same as btree. It'd be better to
342 * have a way to explicitly declare the corresponding
343 * btree opfamily for each opfamily of the other index
344 * type. But given the lack of current or foreseeable
345 * amcanorder index types, it's not worth expending more
346 * effort on now.
347 */
353 {
355 Oid ltopr;
356 Oid btopfamily;
357 Oid btopcintype;
358 int16 btstrategy;
366 BTLessStrategyNumber);
374 {
375 /* Successful mapping */
377 }
378 else
379 {
380 /* Fail ... quietly treat index as unordered */
385 }
386 }
387 }
388 else
389 {
393 }
394 }
395 else
396 {
410 }
412 /*
413 * Fetch the index expressions and predicate, if any. We must
414 * modify the copies we obtain from the relcache to have the
415 * correct varno for the parent relation, so that they match up
416 * correctly against qual clauses.
417 */
425 /* Build targetlist using the completed indexprs data */
434 /*
435 * Estimate the index size. If it's not a partial index, we lock
436 * the number-of-tuples estimate to equal the parent table; if it
437 * is partial then we have to use the same methods as we would for
438 * a table, except we can be sure that the index is not larger
439 * than the table. We must ignore partitioned indexes here as as
440 * there are not physical indexes.
441 */
443 {
445 {
448 }
449 else
450 {
457 }
460 {
461 /*
462 * For btrees, get tree height while we have the index
463 * open
464 */
466 }
467 else
468 {
469 /* For other index types, just set it to "unknown" for now */
471 }
472 }
473 else
474 {
475 /* Zero these out for partitioned indexes */
479 }
483 /*
484 * We've historically used lcons() here. It'd make more sense to
485 * use lappend(), but that causes the planner to change behavior
486 * in cases where two indexes seem equally attractive. For now,
487 * stick with lcons() --- few tables should have so many indexes
488 * that the O(N^2) behavior of lcons() is really a problem.
489 */
491 }
494 }
500 /* Grab foreign-table info using the relcache, while we have it */
502 {
505 }
506 else
507 {
510 }
512 /* Collect info about relation's foreign keys, if relevant */
515 /* Collect info about functions implemented by the rel's table AM. */
521 /*
522 * Collect info about relation's partitioning scheme, if any. Only
523 * inheritance parents may be partitioned.
524 */
530 /*
531 * Allow a plugin to editorialize on the info we obtained from the
532 * catalogs. Actions might include altering the assumed relation size,
533 * removing an index, or adding a hypothetical index to the indexlist.
534 */
537 }
539 /*
540 * get_relation_foreign_keys -
541 * Retrieves foreign key information for a given relation.
542 *
543 * ForeignKeyOptInfos for relevant foreign keys are created and added to
544 * root->fkey_list. We do this now while we have the relcache entry open.
545 * We could sometimes avoid making useless ForeignKeyOptInfos if we waited
546 * until all RelOptInfos have been built, but the cost of re-opening the
547 * relcache entries would probably exceed any savings.
548 */
549 static void
552 {
557 /*
558 * If it's not a baserel, we don't care about its FKs. Also, if the query
559 * references only a single relation, we can skip the lookup since no FKs
560 * could satisfy the requirements below.
561 */
566 /*
567 * If it's the parent of an inheritance tree, ignore its FKs. We could
568 * make useful FK-based deductions if we found that all members of the
569 * inheritance tree have equivalent FK constraints, but detecting that
570 * would require code that hasn't been written.
571 */
575 /*
576 * Extract data about relation's FKs from the relcache. Note that this
577 * list belongs to the relcache and might disappear in a cache flush, so
578 * we must not do any further catalog access within this function.
579 */
582 /*
583 * Figure out which FKs are of interest for this query, and create
584 * ForeignKeyOptInfos for them. We want only FKs that reference some
585 * other RTE of the current query. In queries containing self-joins,
586 * there might be more than one other RTE for a referenced table, and we
587 * should make a ForeignKeyOptInfo for each occurrence.
588 *
589 * Ideally, we would ignore RTEs that correspond to non-baserels, but it's
590 * too hard to identify those here, so we might end up making some useless
591 * ForeignKeyOptInfos. If so, match_foreign_keys_to_quals() will remove
592 * them again.
593 */
595 {
597 Index rti;
600 /* conrelid should always be that of the table we're considering */
603 /* Scan to find other RTEs matching confrelid */
606 {
610 rti++;
611 /* Ignore if not the correct table */
615 /* Ignore if it's an inheritance parent; doesn't really match */
618 /* Ignore self-referential FKs; we only care about joins */
622 /* OK, let's make an entry */
630 /* zero out fields to be filled by match_foreign_keys_to_quals */
640 }
641 }
642 }
644 /*
645 * infer_arbiter_indexes -
646 * Determine the unique indexes used to arbitrate speculative insertion.
647 *
648 * Uses user-supplied inference clause expressions and predicate to match a
649 * unique index from those defined and ready on the heap relation (target).
650 * An exact match is required on columns/expressions (although they can appear
651 * in any order). However, the predicate given by the user need only restrict
652 * insertion to a subset of some part of the table covered by some particular
653 * unique index (in particular, a partial unique index) in order to be
654 * inferred.
655 *
656 * The implementation does not consider which B-Tree operator class any
657 * particular available unique index attribute uses, unless one was specified
658 * in the inference specification. The same is true of collations. In
659 * particular, there is no system dependency on the default operator class for
660 * the purposes of inference. If no opclass (or collation) is specified, then
661 * all matching indexes (that may or may not match the default in terms of
662 * each attribute opclass/collation) are used for inference.
663 */
664 List *
666 {
669 /* Iteration state */
671 Relation relation;
676 /* Normalized inference attributes and inference expressions: */
680 /* Results */
683 /*
684 * Quickly return NIL for ON CONFLICT DO NOTHING without an inference
685 * specification or named constraint. ON CONFLICT DO UPDATE statements
686 * must always provide one or the other (but parser ought to have caught
687 * that already).
688 */
693 /*
694 * We need not lock the relation since it was already locked, either by
695 * the rewriter or when expand_inherited_rtentry() added it to the query's
696 * rangetable.
697 */
702 /*
703 * Build normalized/BMS representation of plain indexed attributes, as
704 * well as a separate list of expression items. This simplifies matching
705 * the cataloged definition of indexes.
706 */
708 {
714 {
715 /* If not a plain Var, just shove it in inferElems for now */
718 }
730 }
732 /*
733 * Lookup named constraint's index. This is not immediately returned
734 * because some additional sanity checks are required.
735 */
737 {
744 }
746 /*
747 * Using that representation, iterate through the list of indexes on the
748 * target relation to try and find a match
749 */
753 {
755 Relation idxRel;
756 Form_pg_index idxForm;
760 AttrNumber natt;
763 /*
764 * Extract info from the relation descriptor for the index. Obtain
765 * the same lock type that the executor will ultimately use.
766 *
767 * Let executor complain about !indimmediate case directly, because
768 * enforcement needs to occur there anyway when an inference clause is
769 * omitted.
770 */
777 /*
778 * Note that we do not perform a check against indcheckxmin (like e.g.
779 * get_relation_info()) here to eliminate candidates, because
780 * uniqueness checking only cares about the most recently committed
781 * tuple versions.
782 */
784 /*
785 * Look for match on "ON constraint_name" variant, which may not be
786 * unique constraint. This can only be a constraint name.
787 */
789 {
800 }
802 {
803 /* No point in further work for index in named constraint case */
805 }
807 /*
808 * Only considering conventional inference at this point (not named
809 * constraints), so index under consideration can be immediately
810 * skipped if it's not unique
811 */
815 /* Build BMS representation of plain (non expression) index attrs */
818 {
824 }
826 /* Non-expression attributes (if any) must match */
830 /* Expression attributes (if any) must match */
833 {
836 /*
837 * Ensure that collation/opclass aspects of inference expression
838 * element match. Even though this loop is primarily concerned
839 * with matching expressions, it is a convenient point to check
840 * this for both expressions and ordinary (non-expression)
841 * attributes appearing as inference elements.
842 */
846 /*
847 * Plain Vars don't factor into count of expression elements, and
848 * the question of whether or not they satisfy the index
849 * definition has already been considered (they must).
850 */
854 /*
855 * Might as well avoid redundant check in the rare cases where
856 * infer_collation_opclass_match() is required to do real work.
857 * Otherwise, check that element expression appears in cataloged
858 * index definition.
859 */
866 }
868 /*
869 * Now that all inference elements were matched, ensure that the
870 * expression elements from inference clause are not missing any
871 * cataloged expressions. This does the right thing when unique
872 * indexes redundantly repeat the same attribute, or if attributes
873 * redundantly appear multiple times within an inference clause.
874 */
878 /*
879 * If it's a partial index, its predicate must be implied by the ON
880 * CONFLICT's WHERE clause.
881 */
888 next:
890 }
901 }
903 /*
904 * infer_collation_opclass_match - ensure infer element opclass/collation match
905 *
906 * Given unique index inference element from inference specification, if
907 * collation was specified, or if opclass was specified, verify that there is
908 * at least one matching indexed attribute (occasionally, there may be more).
909 * Skip this in the common case where inference specification does not include
910 * collation or opclass (instead matching everything, regardless of cataloged
911 * collation/opclass of indexed attribute).
912 *
913 * At least historically, Postgres has not offered collations or opclasses
914 * with alternative-to-default notions of equality, so these additional
915 * criteria should only be required infrequently.
916 *
917 * Don't give up immediately when an inference element matches some attribute
918 * cataloged as indexed but not matching additional opclass/collation
919 * criteria. This is done so that the implementation is as forgiving as
920 * possible of redundancy within cataloged index attributes (or, less
921 * usefully, within inference specification elements). If collations actually
922 * differ between apparently redundantly indexed attributes (redundant within
923 * or across indexes), then there really is no redundancy as such.
924 *
925 * Note that if an inference element specifies an opclass and a collation at
926 * once, both must match in at least one particular attribute within index
927 * catalog definition in order for that inference element to be considered
928 * inferred/satisfied.
929 */
930 static bool
933 {
934 AttrNumber natt;
939 /*
940 * If inference specification element lacks collation/opclass, then no
941 * need to check for exact match.
942 */
946 /*
947 * Lookup opfamily and input type, for matching indexes
948 */
950 {
953 }
956 {
963 nplain++;
967 {
968 /* Attribute needed to match opclass, but didn't */
970 }
974 {
975 /* Attribute needed to match collation, but didn't */
977 }
979 /* If one matching index att found, good enough -- return true */
981 {
984 }
986 {
989 /*
990 * Note that unlike routines like match_index_to_operand() we
991 * don't need to care about RelabelType. Neither the index
992 * definition nor the inference clause should contain them.
993 */
996 }
997 }
1000 }
1002 /*
1003 * estimate_rel_size - estimate # pages and # tuples in a table or index
1004 *
1005 * We also estimate the fraction of the pages that are marked all-visible in
1006 * the visibility map, for use in estimation of index-only scans.
1007 *
1008 * If attr_widths isn't NULL, it points to the zero-index entry of the
1009 * relation's attr_widths[] cache; we fill this in if we have need to compute
1010 * the attribute widths for estimation purposes.
1011 */
1012 void
1015 {
1016 BlockNumber curpages;
1017 BlockNumber relpages;
1019 BlockNumber relallvisible;
1023 {
1025 allvisfrac);
1026 }
1028 {
1029 /*
1030 * XXX: It'd probably be good to move this into a callback, individual
1031 * index types e.g. know if they have a metapage.
1032 */
1034 /* it has storage, ok to call the smgr */
1037 /* report estimated # pages */
1039 /* quick exit if rel is clearly empty */
1041 {
1045 }
1047 /* coerce values in pg_class to more desirable types */
1052 /*
1053 * Discount the metapage while estimating the number of tuples. This
1054 * is a kluge because it assumes more than it ought to about index
1055 * structure. Currently it's OK for btree, hash, and GIN indexes but
1056 * suspect for GiST indexes.
1057 */
1059 {
1060 curpages--;
1061 relpages--;
1062 }
1064 /* estimate number of tuples from previous tuple density */
1067 else
1068 {
1069 /*
1070 * If we have no data because the relation was never vacuumed,
1071 * estimate tuple width from attribute datatypes. We assume here
1072 * that the pages are completely full, which is OK for tables
1073 * (since they've presumably not been VACUUMed yet) but is
1074 * probably an overestimate for indexes. Fortunately
1075 * get_relation_info() can clamp the overestimate to the parent
1076 * table's size.
1077 *
1078 * Note: this code intentionally disregards alignment
1079 * considerations, because (a) that would be gilding the lily
1080 * considering how crude the estimate is, and (b) it creates
1081 * platform dependencies in the default plans which are kind of a
1082 * headache for regression testing.
1083 *
1084 * XXX: Should this logic be more index specific?
1085 */
1086 int32 tuple_width;
1091 /* note: integer division is intentional here */
1093 }
1096 /*
1097 * We use relallvisible as-is, rather than scaling it up like we do
1098 * for the pages and tuples counts, on the theory that any pages added
1099 * since the last VACUUM are most likely not marked all-visible. But
1100 * costsize.c wants it converted to a fraction.
1101 */
1106 else
1108 }
1109 else
1110 {
1111 /*
1112 * Just use whatever's in pg_class. This covers foreign tables,
1113 * sequences, and also relkinds without storage (shouldn't get here?);
1114 * see initializations in AddNewRelationTuple(). Note that FDW must
1115 * cope if reltuples is -1!
1116 */
1120 }
1121 }
1124 /*
1125 * get_rel_data_width
1126 *
1127 * Estimate the average width of (the data part of) the relation's tuples.
1128 *
1129 * If attr_widths isn't NULL, it points to the zero-index entry of the
1130 * relation's attr_widths[] cache; use and update that cache as appropriate.
1131 *
1132 * Currently we ignore dropped columns. Ideally those should be included
1133 * in the result, but we haven't got any way to get info about them; and
1134 * since they might be mostly NULLs, treating them as zero-width is not
1135 * necessarily the wrong thing anyway.
1136 */
1137 int32
1139 {
1144 {
1146 int32 item_width;
1151 /* use previously cached data, if any */
1153 {
1156 }
1158 /* This should match set_rel_width() in costsize.c */
1161 {
1164 }
1168 }
1171 }
1173 /*
1174 * get_relation_data_width
1175 *
1176 * External API for get_rel_data_width: same behavior except we have to
1177 * open the relcache entry.
1178 */
1179 int32
1181 {
1182 int32 result;
1183 Relation relation;
1185 /* As above, assume relation is already locked */
1193 }
1196 /*
1197 * get_relation_constraints
1198 *
1199 * Retrieve the applicable constraint expressions of the given relation.
1200 *
1201 * Returns a List (possibly empty) of constraint expressions. Each one
1202 * has been canonicalized, and its Vars are changed to have the varno
1203 * indicated by rel->relid. This allows the expressions to be easily
1204 * compared to expressions taken from WHERE.
1205 *
1206 * If include_noinherit is true, it's okay to include constraints that
1207 * are marked NO INHERIT.
1208 *
1209 * If include_notnull is true, "col IS NOT NULL" expressions are generated
1210 * and added to the result for each column that's marked attnotnull.
1211 *
1212 * If include_partition is true, and the relation is a partition,
1213 * also include the partitioning constraints.
1214 *
1215 * Note: at present this is invoked at most once per relation per planner
1216 * run, and in many cases it won't be invoked at all, so there seems no
1217 * point in caching the data in RelOptInfo.
1218 */
1225 {
1228 Relation relation;
1231 /*
1232 * We assume the relation has already been safely locked.
1233 */
1238 {
1243 {
1246 /*
1247 * If this constraint hasn't been fully validated yet, we must
1248 * ignore it here. Also ignore if NO INHERIT and we weren't told
1249 * that that's safe.
1250 */
1258 /*
1259 * Run each expression through const-simplification and
1260 * canonicalization. This is not just an optimization, but is
1261 * necessary, because we will be comparing it to
1262 * similarly-processed qual clauses, and may fail to detect valid
1263 * matches without this. This must match the processing done to
1264 * qual clauses in preprocess_expression()! (We can skip the
1265 * stuff involving subqueries, however, since we don't allow any
1266 * in check constraints.)
1267 */
1272 /* Fix Vars to have the desired varno */
1276 /*
1277 * Finally, convert to implicit-AND format (that is, a List) and
1278 * append the resulting item(s) to our output list.
1279 */
1282 }
1284 /* Add NOT NULL constraints in expression form, if requested */
1286 {
1290 {
1294 {
1298 i,
1305 /*
1306 * argisrow=false is correct even for a composite column,
1307 * because attnotnull does not represent a SQL-spec IS NOT
1308 * NULL test in such a case, just IS DISTINCT FROM NULL.
1309 */
1313 }
1314 }
1315 }
1316 }
1318 /*
1319 * Add partitioning constraints, if requested.
1320 */
1322 {
1323 /* make sure rel->partition_qual is set */
1326 }
1331 }
1333 /*
1334 * Try loading data for the statistics object.
1335 *
1336 * We don't know if the data (specified by statOid and inh value) exist.
1337 * The result is stored in stainfos list.
1338 */
1339 static void
1343 {
1344 Form_pg_statistic_ext_data dataForm;
1345 HeapTuple dtup;
1354 /* add one StatisticExtInfo for each kind built */
1356 {
1367 }
1370 {
1381 }
1384 {
1395 }
1398 {
1409 }
1412 }
1414 /*
1415 * get_relation_statistics
1416 * Retrieve extended statistics defined on the table.
1417 *
1418 * Returns a List (possibly empty) of StatisticExtInfo objects describing
1419 * the statistics. Note that this doesn't load the actual statistics data,
1420 * just the identifying metadata. Only stats actually built are considered.
1421 */
1424 {
1433 {
1435 Form_pg_statistic_ext staForm;
1436 HeapTuple htup;
1446 /*
1447 * First, build the array of columns covered. This is ultimately
1448 * wasted if no stats within the object have actually been built, but
1449 * it doesn't seem worth troubling over that case.
1450 */
1454 /*
1455 * Preprocess expressions (if any). We read the expressions, run them
1456 * through eval_const_expressions, and fix the varnos.
1457 *
1458 * XXX We don't know yet if there are any data for this stats object,
1459 * with either stxdinherit value. But it's reasonable to assume there
1460 * is at least one of those, possibly both. So it's better to process
1461 * keys and expressions here.
1462 */
1463 {
1465 Datum datum;
1467 /* decode expression (if any) */
1472 {
1479 /*
1480 * Run the expressions through eval_const_expressions. This is
1481 * not just an optimization, but is necessary, because the
1482 * planner will be comparing them to similarly-processed qual
1483 * clauses, and may fail to detect valid matches without this.
1484 * We must not use canonicalize_qual, however, since these
1485 * aren't qual expressions.
1486 */
1489 /* May as well fix opfuncids too */
1492 /*
1493 * Modify the copies we obtain from the relcache to have the
1494 * correct varno for the parent relation, so that they match
1495 * up correctly against qual clauses.
1496 */
1499 }
1500 }
1502 /* extract statistics for possible values of stxdinherit flag */
1510 }
1515 }
1517 /*
1518 * relation_excluded_by_constraints
1519 *
1520 * Detect whether the relation need not be scanned because it has either
1521 * self-inconsistent restrictions, or restrictions inconsistent with the
1522 * relation's applicable constraints.
1523 *
1524 * Note: this examines only rel->relid, rel->reloptkind, and
1525 * rel->baserestrictinfo; therefore it can be called before filling in
1526 * other fields of the RelOptInfo.
1527 */
1528 bool
1531 {
1540 /* As of now, constraint exclusion works only with simple relations. */
1543 /*
1544 * If there are no base restriction clauses, we have no hope of proving
1545 * anything below, so fall out quickly.
1546 */
1550 /*
1551 * Regardless of the setting of constraint_exclusion, detect
1552 * constant-FALSE-or-NULL restriction clauses. Because const-folding will
1553 * reduce "anything AND FALSE" to just "FALSE", any such case should
1554 * result in exactly one baserestrictinfo entry. This doesn't fire very
1555 * often, but it seems cheap enough to be worth doing anyway. (Without
1556 * this, we'd miss some optimizations that 9.5 and earlier found via much
1557 * more roundabout methods.)
1558 */
1560 {
1568 }
1570 /*
1571 * Skip further tests, depending on constraint_exclusion.
1572 */
1574 {
1576 /* In 'off' mode, never make any further tests */
1581 /*
1582 * When constraint_exclusion is set to 'partition' we only handle
1583 * appendrel members. Partition pruning has already been applied,
1584 * so there is no need to consider the rel's partition constraints
1585 * here.
1586 */
1593 /*
1594 * In 'on' mode, always apply constraint exclusion. If we are
1595 * considering a baserel that is a partition (i.e., it was
1596 * directly named rather than expanded from a parent table), then
1597 * its partition constraints haven't been considered yet, so
1598 * include them in the processing here.
1599 */
1603 }
1605 /*
1606 * Check for self-contradictory restriction clauses. We dare not make
1607 * deductions with non-immutable functions, but any immutable clauses that
1608 * are self-contradictory allow us to conclude the scan is unnecessary.
1609 *
1610 * Note: strip off RestrictInfo because predicate_refuted_by() isn't
1611 * expecting to see any in its predicate argument.
1612 */
1615 {
1620 }
1622 /*
1623 * We can use weak refutation here, since we're comparing restriction
1624 * clauses with restriction clauses.
1625 */
1629 /*
1630 * Only plain relations have constraints, so stop here for other rtekinds.
1631 */
1635 /*
1636 * If we are scanning just this table, we can use NO INHERIT constraints,
1637 * but not if we're scanning its children too. (Note that partitioned
1638 * tables should never have NO INHERIT constraints; but it's not necessary
1639 * for us to assume that here.)
1640 */
1643 /*
1644 * Currently, attnotnull constraints must be treated as NO INHERIT unless
1645 * this is a partitioned table. In future we might track their
1646 * inheritance status more accurately, allowing this to be refined.
1647 */
1650 /*
1651 * Fetch the appropriate set of constraint expressions.
1652 */
1654 include_noinherit,
1655 include_notnull,
1656 include_partition);
1658 /*
1659 * We do not currently enforce that CHECK constraints contain only
1660 * immutable functions, so it's necessary to check here. We daren't draw
1661 * conclusions from plan-time evaluation of non-immutable functions. Since
1662 * they're ANDed, we can just ignore any mutable constraints in the list,
1663 * and reason about the rest.
1664 */
1667 {
1672 }
1674 /*
1675 * The constraints are effectively ANDed together, so we can just try to
1676 * refute the entire collection at once. This may allow us to make proofs
1677 * that would fail if we took them individually.
1678 *
1679 * Note: we use rel->baserestrictinfo, not safe_restrictions as might seem
1680 * an obvious optimization. Some of the clauses might be OR clauses that
1681 * have volatile and nonvolatile subclauses, and it's OK to make
1682 * deductions with the nonvolatile parts.
1683 *
1684 * We need strong refutation because we have to prove that the constraints
1685 * would yield false, not just NULL.
1686 */
1691 }
1694 /*
1695 * build_physical_tlist
1696 *
1697 * Build a targetlist consisting of exactly the relation's user attributes,
1698 * in order. The executor can special-case such tlists to avoid a projection
1699 * step at runtime, so we use such tlists preferentially for scan nodes.
1700 *
1701 * Exception: if there are any dropped or missing columns, we punt and return
1702 * NIL. Ideally we would like to handle these cases too. However this
1703 * creates problems for ExecTypeFromTL, which may be asked to build a tupdesc
1704 * for a tlist that includes vars of no-longer-existent types. In theory we
1705 * could dig out the required info from the pg_attribute entries of the
1706 * relation, but that data is not readily available to ExecTypeFromTL.
1707 * For now, we don't apply the physical-tlist optimization when there are
1708 * dropped cols.
1709 *
1710 * We also support building a "physical" tlist for subqueries, functions,
1711 * values lists, table expressions, and CTEs, since the same optimization can
1712 * occur in SubqueryScan, FunctionScan, ValuesScan, CteScan, TableFunc,
1713 * NamedTuplestoreScan, and WorkTableScan nodes.
1714 */
1715 List *
1717 {
1721 Relation relation;
1726 numattrs;
1730 {
1732 /* Assume we already have adequate lock */
1737 {
1742 {
1743 /* found a dropped or missing col, so punt */
1746 }
1749 attrno,
1757 attrno,
1758 NULL,
1760 }
1768 {
1771 /*
1772 * A resjunk column of the subquery can be reflected as
1773 * resjunk in the physical tlist; we need not punt.
1774 */
1780 NULL,
1782 }
1791 /* Not all of these can have dropped cols, but share code anyway */
1795 {
1798 /*
1799 * A non-Var in expandRTE's output means a dropped column;
1800 * must punt.
1801 */
1803 {
1806 }
1811 NULL,
1813 }
1817 /* caller error */
1821 }
1824 }
1826 /*
1827 * build_index_tlist
1828 *
1829 * Build a targetlist representing the columns of the specified index.
1830 * Each column is represented by a Var for the corresponding base-relation
1831 * column, or an expression in base-relation Vars, as appropriate.
1832 *
1833 * There are never any dropped columns in indexes, so unlike
1834 * build_physical_tlist, we need no failure case.
1835 */
1838 Relation heapRelation)
1839 {
1847 {
1852 {
1853 /* simple column */
1858 else
1862 indexkey,
1867 }
1868 else
1869 {
1870 /* expression column */
1875 }
1880 NULL,
1882 }
1887 }
1889 /*
1890 * restriction_selectivity
1891 *
1892 * Returns the selectivity of a specified restriction operator clause.
1893 * This code executes registered procedures stored in the
1894 * operator relation, by calling the function manager.
1895 *
1896 * See clause_selectivity() for the meaning of the additional parameters.
1897 */
1898 Selectivity
1900 Oid operatorid,
1902 Oid inputcollid,
1904 {
1906 float8 result;
1908 /*
1909 * if the oprrest procedure is missing for whatever reason, use a
1910 * selectivity of 0.5
1911 */
1916 inputcollid,
1926 }
1928 /*
1929 * join_selectivity
1930 *
1931 * Returns the selectivity of a specified join operator clause.
1932 * This code executes registered procedures stored in the
1933 * operator relation, by calling the function manager.
1934 *
1935 * See clause_selectivity() for the meaning of the additional parameters.
1936 */
1937 Selectivity
1939 Oid operatorid,
1941 Oid inputcollid,
1942 JoinType jointype,
1944 {
1946 float8 result;
1948 /*
1949 * if the oprjoin procedure is missing for whatever reason, use a
1950 * selectivity of 0.5
1951 */
1956 inputcollid,
1967 }
1969 /*
1970 * function_selectivity
1971 *
1972 * Returns the selectivity of a specified boolean function clause.
1973 * This code executes registered procedures stored in the
1974 * pg_proc relation, by calling the function manager.
1975 *
1976 * See clause_selectivity() for the meaning of the additional parameters.
1977 */
1978 Selectivity
1980 Oid funcid,
1982 Oid inputcollid,
1985 JoinType jointype,
1987 {
1989 SupportRequestSelectivity req;
1992 /*
1993 * If no support function is provided, use our historical default
1994 * estimate, 0.3333333. This seems a pretty unprincipled choice, but
1995 * Postgres has been using that estimate for function calls since 1992.
1996 * The hoariness of this behavior suggests that we should not be in too
1997 * much hurry to use another value.
1998 */
2017 /* If support function fails, use default */
2025 }
2027 /*
2028 * add_function_cost
2029 *
2030 * Get an estimate of the execution cost of a function, and *add* it to
2031 * the contents of *cost. The estimate may include both one-time and
2032 * per-tuple components, since QualCost does.
2033 *
2034 * The funcid must always be supplied. If it is being called as the
2035 * implementation of a specific parsetree node (FuncExpr, OpExpr,
2036 * WindowFunc, etc), pass that as "node", else pass NULL.
2037 *
2038 * In some usages root might be NULL, too.
2039 */
2040 void
2043 {
2044 HeapTuple proctup;
2045 Form_pg_proc procform;
2053 {
2054 SupportRequestCost req;
2062 /* Initialize cost fields so that support function doesn't have to */
2071 {
2072 /* Success, so accumulate support function's estimate into *cost */
2077 }
2078 }
2080 /* No support function, or it failed, so rely on procost */
2084 }
2086 /*
2087 * get_function_rows
2088 *
2089 * Get an estimate of the number of rows returned by a set-returning function.
2090 *
2091 * The funcid must always be supplied. In current usage, the calling node
2092 * will always be supplied, and will be either a FuncExpr or OpExpr.
2093 * But it's a good idea to not fail if it's NULL.
2094 *
2095 * In some usages root might be NULL, too.
2096 *
2097 * Note: this returns the unfiltered result of the support function, if any.
2098 * It's usually a good idea to apply clamp_row_est() to the result, but we
2099 * leave it to the caller to do so.
2100 */
2101 double
2103 {
2104 HeapTuple proctup;
2105 Form_pg_proc procform;
2116 {
2117 SupportRequestRows req;
2132 {
2133 /* Success */
2136 }
2137 }
2139 /* No support function, or it failed, so rely on prorows */
2145 }
2147 /*
2148 * has_unique_index
2149 *
2150 * Detect whether there is a unique index on the specified attribute
2151 * of the specified relation, thus allowing us to conclude that all
2152 * the (non-null) values of the attribute are distinct.
2153 *
2154 * This function does not check the index's indimmediate property, which
2155 * means that uniqueness may transiently fail to hold intra-transaction.
2156 * That's appropriate when we are making statistical estimates, but beware
2157 * of using this for any correctness proofs.
2158 */
2159 bool
2161 {
2165 {
2168 /*
2169 * Note: ignore partial indexes, since they don't allow us to conclude
2170 * that all attr values are distinct, *unless* they are marked predOK
2171 * which means we know the index's predicate is satisfied by the
2172 * query. We don't take any interest in expressional indexes either.
2173 * Also, a multicolumn unique index doesn't allow us to conclude that
2174 * just the specified attr is unique.
2175 */
2181 }
2183 }
2186 /*
2187 * has_row_triggers
2188 *
2189 * Detect whether the specified relation has any row-level triggers for event.
2190 */
2191 bool
2193 {
2195 Relation relation;
2199 /* Assume we already have adequate lock */
2204 {
2223 /* There is no separate event for MERGE, only INSERT/UPDATE/DELETE */
2230 }
2234 }
2236 /*
2237 * has_stored_generated_columns
2238 *
2239 * Does table identified by RTI have any STORED GENERATED columns?
2240 */
2241 bool
2243 {
2245 Relation relation;
2246 TupleDesc tupdesc;
2249 /* Assume we already have adequate lock */
2258 }
2260 /*
2261 * get_dependent_generated_columns
2262 *
2263 * Get the column numbers of any STORED GENERATED columns of the relation
2264 * that depend on any column listed in target_cols. Both the input and
2265 * result bitmapsets contain column numbers offset by
2266 * FirstLowInvalidHeapAttributeNumber.
2267 */
2268 Bitmapset *
2271 {
2274 Relation relation;
2275 TupleDesc tupdesc;
2278 /* Assume we already have adequate lock */
2285 {
2287 {
2292 /* skip if not generated column */
2296 /* identify columns this generated column depends on */
2303 }
2304 }
2309 }
2311 /*
2312 * set_relation_partition_info
2313 *
2314 * Set partitioning scheme and related information for a partitioned table.
2315 */
2316 static void
2318 Relation relation)
2319 {
2320 PartitionDesc partdesc;
2322 /*
2323 * Create the PartitionDirectory infrastructure if we didn't already.
2324 */
2326 {
2329 }
2332 relation);
2339 }
2341 /*
2342 * find_partition_scheme
2343 *
2344 * Find or create a PartitionScheme for this Relation.
2345 */
2346 static PartitionScheme
2348 {
2352 i;
2353 PartitionScheme part_scheme;
2355 /* A partitioned table should have a partition key. */
2360 /* Search for a matching partition scheme and return if found one. */
2362 {
2365 /* Match partitioning strategy and number of keys. */
2370 /* Match partition key type properties. */
2379 /*
2380 * Length and byval information should match when partopcintype
2381 * matches.
2382 */
2388 /*
2389 * If partopfamily and partopcintype matched, must have the same
2390 * partition comparison functions. Note that we cannot reliably
2391 * Assert the equality of function structs themselves for they might
2392 * be different across PartitionKey's, so just Assert for the function
2393 * OIDs.
2394 */
2395 #ifdef USE_ASSERT_CHECKING
2399 #endif
2401 /* Found matching partition scheme. */
2403 }
2405 /*
2406 * Did not find matching partition scheme. Create one copying relevant
2407 * information from the relcache. We need to copy the contents of the
2408 * array since the relcache entry may not survive after we have closed the
2409 * relation.
2410 */
2439 CurrentMemoryContext);
2441 /* Add the partitioning scheme to PlannerInfo. */
2445 }
2447 /*
2448 * set_baserel_partition_key_exprs
2449 *
2450 * Builds partition key expressions for the given base relation and fills
2451 * rel->partexprs.
2452 */
2453 static void
2456 {
2466 /* A partitioned table should have a partition key. */
2474 {
2479 {
2480 /* Single column partition key is stored as a Var node. */
2487 }
2488 else
2489 {
2493 /* Re-stamp the expression with given varno. */
2497 }
2499 /* Base relations have a single expression per key. */
2501 }
2505 /*
2506 * A base relation does not have nullable partition key expressions, since
2507 * no outer join is involved. We still allocate an array of empty
2508 * expression lists to keep partition key expression handling code simple.
2509 * See build_joinrel_partition_info() and match_expr_to_partition_keys().
2510 */
2512 }
2514 /*
2515 * set_baserel_partition_constraint
2516 *
2517 * Builds the partition constraint for the given base relation and sets it
2518 * in the given RelOptInfo. All Var nodes are restamped with the relid of the
2519 * given relation.
2520 */
2521 static void
2523 {
2529 /*
2530 * Run the partition quals through const-simplification similar to check
2531 * constraints. We skip canonicalize_qual, though, because partition
2532 * quals should be in canonical form already; also, since the qual is in
2533 * implicit-AND format, we'd have to explicitly convert it to explicit-AND
2534 * format and back again.
2535 */
2538 {
2543 }
2544 }