| blob | 0e35b9d0ab9f1ca61c53c158383788efe51f257e |
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
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. Although const-folding
1553 * will reduce "anything AND FALSE" to just "FALSE", the baserestrictinfo
1554 * list can still have other members besides the FALSE constant, due to
1555 * qual pushdown and other mechanisms; so check them all. This doesn't
1556 * fire very often, but it seems cheap enough to be worth doing anyway.
1557 * (Without this, we'd miss some optimizations that 9.5 and earlier found
1558 * via much more roundabout methods.)
1559 */
1561 {
1569 }
1571 /*
1572 * Skip further tests, depending on constraint_exclusion.
1573 */
1575 {
1577 /* In 'off' mode, never make any further tests */
1582 /*
1583 * When constraint_exclusion is set to 'partition' we only handle
1584 * appendrel members. Partition pruning has already been applied,
1585 * so there is no need to consider the rel's partition constraints
1586 * here.
1587 */
1594 /*
1595 * In 'on' mode, always apply constraint exclusion. If we are
1596 * considering a baserel that is a partition (i.e., it was
1597 * directly named rather than expanded from a parent table), then
1598 * its partition constraints haven't been considered yet, so
1599 * include them in the processing here.
1600 */
1604 }
1606 /*
1607 * Check for self-contradictory restriction clauses. We dare not make
1608 * deductions with non-immutable functions, but any immutable clauses that
1609 * are self-contradictory allow us to conclude the scan is unnecessary.
1610 *
1611 * Note: strip off RestrictInfo because predicate_refuted_by() isn't
1612 * expecting to see any in its predicate argument.
1613 */
1616 {
1621 }
1623 /*
1624 * We can use weak refutation here, since we're comparing restriction
1625 * clauses with restriction clauses.
1626 */
1630 /*
1631 * Only plain relations have constraints, so stop here for other rtekinds.
1632 */
1636 /*
1637 * If we are scanning just this table, we can use NO INHERIT constraints,
1638 * but not if we're scanning its children too. (Note that partitioned
1639 * tables should never have NO INHERIT constraints; but it's not necessary
1640 * for us to assume that here.)
1641 */
1644 /*
1645 * Currently, attnotnull constraints must be treated as NO INHERIT unless
1646 * this is a partitioned table. In future we might track their
1647 * inheritance status more accurately, allowing this to be refined.
1648 *
1649 * XXX do we need/want to change this?
1650 */
1653 /*
1654 * Fetch the appropriate set of constraint expressions.
1655 */
1657 include_noinherit,
1658 include_notnull,
1659 include_partition);
1661 /*
1662 * We do not currently enforce that CHECK constraints contain only
1663 * immutable functions, so it's necessary to check here. We daren't draw
1664 * conclusions from plan-time evaluation of non-immutable functions. Since
1665 * they're ANDed, we can just ignore any mutable constraints in the list,
1666 * and reason about the rest.
1667 */
1670 {
1675 }
1677 /*
1678 * The constraints are effectively ANDed together, so we can just try to
1679 * refute the entire collection at once. This may allow us to make proofs
1680 * that would fail if we took them individually.
1681 *
1682 * Note: we use rel->baserestrictinfo, not safe_restrictions as might seem
1683 * an obvious optimization. Some of the clauses might be OR clauses that
1684 * have volatile and nonvolatile subclauses, and it's OK to make
1685 * deductions with the nonvolatile parts.
1686 *
1687 * We need strong refutation because we have to prove that the constraints
1688 * would yield false, not just NULL.
1689 */
1694 }
1697 /*
1698 * build_physical_tlist
1699 *
1700 * Build a targetlist consisting of exactly the relation's user attributes,
1701 * in order. The executor can special-case such tlists to avoid a projection
1702 * step at runtime, so we use such tlists preferentially for scan nodes.
1703 *
1704 * Exception: if there are any dropped or missing columns, we punt and return
1705 * NIL. Ideally we would like to handle these cases too. However this
1706 * creates problems for ExecTypeFromTL, which may be asked to build a tupdesc
1707 * for a tlist that includes vars of no-longer-existent types. In theory we
1708 * could dig out the required info from the pg_attribute entries of the
1709 * relation, but that data is not readily available to ExecTypeFromTL.
1710 * For now, we don't apply the physical-tlist optimization when there are
1711 * dropped cols.
1712 *
1713 * We also support building a "physical" tlist for subqueries, functions,
1714 * values lists, table expressions, and CTEs, since the same optimization can
1715 * occur in SubqueryScan, FunctionScan, ValuesScan, CteScan, TableFunc,
1716 * NamedTuplestoreScan, and WorkTableScan nodes.
1717 */
1718 List *
1720 {
1724 Relation relation;
1729 numattrs;
1733 {
1735 /* Assume we already have adequate lock */
1740 {
1745 {
1746 /* found a dropped or missing col, so punt */
1749 }
1752 attrno,
1760 attrno,
1761 NULL,
1763 }
1771 {
1774 /*
1775 * A resjunk column of the subquery can be reflected as
1776 * resjunk in the physical tlist; we need not punt.
1777 */
1783 NULL,
1785 }
1794 /* Not all of these can have dropped cols, but share code anyway */
1798 {
1801 /*
1802 * A non-Var in expandRTE's output means a dropped column;
1803 * must punt.
1804 */
1806 {
1809 }
1814 NULL,
1816 }
1820 /* caller error */
1824 }
1827 }
1829 /*
1830 * build_index_tlist
1831 *
1832 * Build a targetlist representing the columns of the specified index.
1833 * Each column is represented by a Var for the corresponding base-relation
1834 * column, or an expression in base-relation Vars, as appropriate.
1835 *
1836 * There are never any dropped columns in indexes, so unlike
1837 * build_physical_tlist, we need no failure case.
1838 */
1841 Relation heapRelation)
1842 {
1850 {
1855 {
1856 /* simple column */
1861 else
1865 indexkey,
1870 }
1871 else
1872 {
1873 /* expression column */
1878 }
1883 NULL,
1885 }
1890 }
1892 /*
1893 * restriction_selectivity
1894 *
1895 * Returns the selectivity of a specified restriction operator clause.
1896 * This code executes registered procedures stored in the
1897 * operator relation, by calling the function manager.
1898 *
1899 * See clause_selectivity() for the meaning of the additional parameters.
1900 */
1901 Selectivity
1903 Oid operatorid,
1905 Oid inputcollid,
1907 {
1909 float8 result;
1911 /*
1912 * if the oprrest procedure is missing for whatever reason, use a
1913 * selectivity of 0.5
1914 */
1919 inputcollid,
1929 }
1931 /*
1932 * join_selectivity
1933 *
1934 * Returns the selectivity of a specified join operator clause.
1935 * This code executes registered procedures stored in the
1936 * operator relation, by calling the function manager.
1937 *
1938 * See clause_selectivity() for the meaning of the additional parameters.
1939 */
1940 Selectivity
1942 Oid operatorid,
1944 Oid inputcollid,
1945 JoinType jointype,
1947 {
1949 float8 result;
1951 /*
1952 * if the oprjoin procedure is missing for whatever reason, use a
1953 * selectivity of 0.5
1954 */
1959 inputcollid,
1970 }
1972 /*
1973 * function_selectivity
1974 *
1975 * Returns the selectivity of a specified boolean function clause.
1976 * This code executes registered procedures stored in the
1977 * pg_proc relation, by calling the function manager.
1978 *
1979 * See clause_selectivity() for the meaning of the additional parameters.
1980 */
1981 Selectivity
1983 Oid funcid,
1985 Oid inputcollid,
1988 JoinType jointype,
1990 {
1992 SupportRequestSelectivity req;
1995 /*
1996 * If no support function is provided, use our historical default
1997 * estimate, 0.3333333. This seems a pretty unprincipled choice, but
1998 * Postgres has been using that estimate for function calls since 1992.
1999 * The hoariness of this behavior suggests that we should not be in too
2000 * much hurry to use another value.
2001 */
2020 /* If support function fails, use default */
2028 }
2030 /*
2031 * add_function_cost
2032 *
2033 * Get an estimate of the execution cost of a function, and *add* it to
2034 * the contents of *cost. The estimate may include both one-time and
2035 * per-tuple components, since QualCost does.
2036 *
2037 * The funcid must always be supplied. If it is being called as the
2038 * implementation of a specific parsetree node (FuncExpr, OpExpr,
2039 * WindowFunc, etc), pass that as "node", else pass NULL.
2040 *
2041 * In some usages root might be NULL, too.
2042 */
2043 void
2046 {
2047 HeapTuple proctup;
2048 Form_pg_proc procform;
2056 {
2057 SupportRequestCost req;
2065 /* Initialize cost fields so that support function doesn't have to */
2074 {
2075 /* Success, so accumulate support function's estimate into *cost */
2080 }
2081 }
2083 /* No support function, or it failed, so rely on procost */
2087 }
2089 /*
2090 * get_function_rows
2091 *
2092 * Get an estimate of the number of rows returned by a set-returning function.
2093 *
2094 * The funcid must always be supplied. In current usage, the calling node
2095 * will always be supplied, and will be either a FuncExpr or OpExpr.
2096 * But it's a good idea to not fail if it's NULL.
2097 *
2098 * In some usages root might be NULL, too.
2099 *
2100 * Note: this returns the unfiltered result of the support function, if any.
2101 * It's usually a good idea to apply clamp_row_est() to the result, but we
2102 * leave it to the caller to do so.
2103 */
2104 double
2106 {
2107 HeapTuple proctup;
2108 Form_pg_proc procform;
2119 {
2120 SupportRequestRows req;
2135 {
2136 /* Success */
2139 }
2140 }
2142 /* No support function, or it failed, so rely on prorows */
2148 }
2150 /*
2151 * has_unique_index
2152 *
2153 * Detect whether there is a unique index on the specified attribute
2154 * of the specified relation, thus allowing us to conclude that all
2155 * the (non-null) values of the attribute are distinct.
2156 *
2157 * This function does not check the index's indimmediate property, which
2158 * means that uniqueness may transiently fail to hold intra-transaction.
2159 * That's appropriate when we are making statistical estimates, but beware
2160 * of using this for any correctness proofs.
2161 */
2162 bool
2164 {
2168 {
2171 /*
2172 * Note: ignore partial indexes, since they don't allow us to conclude
2173 * that all attr values are distinct, *unless* they are marked predOK
2174 * which means we know the index's predicate is satisfied by the
2175 * query. We don't take any interest in expressional indexes either.
2176 * Also, a multicolumn unique index doesn't allow us to conclude that
2177 * just the specified attr is unique.
2178 */
2184 }
2186 }
2189 /*
2190 * has_row_triggers
2191 *
2192 * Detect whether the specified relation has any row-level triggers for event.
2193 */
2194 bool
2196 {
2198 Relation relation;
2202 /* Assume we already have adequate lock */
2207 {
2226 /* There is no separate event for MERGE, only INSERT/UPDATE/DELETE */
2233 }
2237 }
2239 /*
2240 * has_stored_generated_columns
2241 *
2242 * Does table identified by RTI have any STORED GENERATED columns?
2243 */
2244 bool
2246 {
2248 Relation relation;
2249 TupleDesc tupdesc;
2252 /* Assume we already have adequate lock */
2261 }
2263 /*
2264 * get_dependent_generated_columns
2265 *
2266 * Get the column numbers of any STORED GENERATED columns of the relation
2267 * that depend on any column listed in target_cols. Both the input and
2268 * result bitmapsets contain column numbers offset by
2269 * FirstLowInvalidHeapAttributeNumber.
2270 */
2271 Bitmapset *
2274 {
2277 Relation relation;
2278 TupleDesc tupdesc;
2281 /* Assume we already have adequate lock */
2288 {
2290 {
2295 /* skip if not generated column */
2299 /* identify columns this generated column depends on */
2306 }
2307 }
2312 }
2314 /*
2315 * set_relation_partition_info
2316 *
2317 * Set partitioning scheme and related information for a partitioned table.
2318 */
2319 static void
2321 Relation relation)
2322 {
2323 PartitionDesc partdesc;
2325 /*
2326 * Create the PartitionDirectory infrastructure if we didn't already.
2327 */
2329 {
2332 }
2335 relation);
2342 }
2344 /*
2345 * find_partition_scheme
2346 *
2347 * Find or create a PartitionScheme for this Relation.
2348 */
2349 static PartitionScheme
2351 {
2355 i;
2356 PartitionScheme part_scheme;
2358 /* A partitioned table should have a partition key. */
2363 /* Search for a matching partition scheme and return if found one. */
2365 {
2368 /* Match partitioning strategy and number of keys. */
2373 /* Match partition key type properties. */
2382 /*
2383 * Length and byval information should match when partopcintype
2384 * matches.
2385 */
2391 /*
2392 * If partopfamily and partopcintype matched, must have the same
2393 * partition comparison functions. Note that we cannot reliably
2394 * Assert the equality of function structs themselves for they might
2395 * be different across PartitionKey's, so just Assert for the function
2396 * OIDs.
2397 */
2398 #ifdef USE_ASSERT_CHECKING
2402 #endif
2404 /* Found matching partition scheme. */
2406 }
2408 /*
2409 * Did not find matching partition scheme. Create one copying relevant
2410 * information from the relcache. We need to copy the contents of the
2411 * array since the relcache entry may not survive after we have closed the
2412 * relation.
2413 */
2442 CurrentMemoryContext);
2444 /* Add the partitioning scheme to PlannerInfo. */
2448 }
2450 /*
2451 * set_baserel_partition_key_exprs
2452 *
2453 * Builds partition key expressions for the given base relation and fills
2454 * rel->partexprs.
2455 */
2456 static void
2459 {
2469 /* A partitioned table should have a partition key. */
2477 {
2482 {
2483 /* Single column partition key is stored as a Var node. */
2490 }
2491 else
2492 {
2496 /* Re-stamp the expression with given varno. */
2500 }
2502 /* Base relations have a single expression per key. */
2504 }
2508 /*
2509 * A base relation does not have nullable partition key expressions, since
2510 * no outer join is involved. We still allocate an array of empty
2511 * expression lists to keep partition key expression handling code simple.
2512 * See build_joinrel_partition_info() and match_expr_to_partition_keys().
2513 */
2515 }
2517 /*
2518 * set_baserel_partition_constraint
2519 *
2520 * Builds the partition constraint for the given base relation and sets it
2521 * in the given RelOptInfo. All Var nodes are restamped with the relid of the
2522 * given relation.
2523 */
2524 static void
2526 {
2532 /*
2533 * Run the partition quals through const-simplification similar to check
2534 * constraints. We skip canonicalize_qual, though, because partition
2535 * quals should be in canonical form already; also, since the qual is in
2536 * implicit-AND format, we'd have to explicitly convert it to explicit-AND
2537 * format and back again.
2538 */
2541 {
2546 }
2547 }