LCOV - code coverage report
Current view: top level - src/backend/optimizer/util - plancat.c (source / functions) Hit Total Coverage
Test: PostgreSQL 12beta2 Lines: 658 708 92.9 %
Date: 2019-06-19 14:06:47 Functions: 23 23 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * plancat.c
       4             :  *     routines for accessing the system catalogs
       5             :  *
       6             :  *
       7             :  * Portions Copyright (c) 1996-2019, 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             :  */
      16             : #include "postgres.h"
      17             : 
      18             : #include <math.h>
      19             : 
      20             : #include "access/genam.h"
      21             : #include "access/htup_details.h"
      22             : #include "access/nbtree.h"
      23             : #include "access/tableam.h"
      24             : #include "access/sysattr.h"
      25             : #include "access/table.h"
      26             : #include "access/transam.h"
      27             : #include "access/xlog.h"
      28             : #include "catalog/catalog.h"
      29             : #include "catalog/dependency.h"
      30             : #include "catalog/heap.h"
      31             : #include "catalog/pg_am.h"
      32             : #include "catalog/pg_proc.h"
      33             : #include "catalog/pg_statistic_ext.h"
      34             : #include "foreign/fdwapi.h"
      35             : #include "miscadmin.h"
      36             : #include "nodes/makefuncs.h"
      37             : #include "nodes/supportnodes.h"
      38             : #include "optimizer/clauses.h"
      39             : #include "optimizer/cost.h"
      40             : #include "optimizer/optimizer.h"
      41             : #include "optimizer/plancat.h"
      42             : #include "optimizer/prep.h"
      43             : #include "partitioning/partdesc.h"
      44             : #include "parser/parse_relation.h"
      45             : #include "parser/parsetree.h"
      46             : #include "rewrite/rewriteManip.h"
      47             : #include "statistics/statistics.h"
      48             : #include "storage/bufmgr.h"
      49             : #include "utils/builtins.h"
      50             : #include "utils/lsyscache.h"
      51             : #include "utils/partcache.h"
      52             : #include "utils/rel.h"
      53             : #include "utils/syscache.h"
      54             : #include "utils/snapmgr.h"
      55             : 
      56             : 
      57             : /* GUC parameter */
      58             : int         constraint_exclusion = CONSTRAINT_EXCLUSION_PARTITION;
      59             : 
      60             : /* Hook for plugins to get control in get_relation_info() */
      61             : get_relation_info_hook_type get_relation_info_hook = NULL;
      62             : 
      63             : 
      64             : static void get_relation_foreign_keys(PlannerInfo *root, RelOptInfo *rel,
      65             :                                       Relation relation, bool inhparent);
      66             : static bool infer_collation_opclass_match(InferenceElem *elem, Relation idxRel,
      67             :                                           List *idxExprs);
      68             : static List *get_relation_constraints(PlannerInfo *root,
      69             :                                       Oid relationObjectId, RelOptInfo *rel,
      70             :                                       bool include_noinherit,
      71             :                                       bool include_notnull,
      72             :                                       bool include_partition);
      73             : static List *build_index_tlist(PlannerInfo *root, IndexOptInfo *index,
      74             :                                Relation heapRelation);
      75             : static List *get_relation_statistics(RelOptInfo *rel, Relation relation);
      76             : static void set_relation_partition_info(PlannerInfo *root, RelOptInfo *rel,
      77             :                                         Relation relation);
      78             : static PartitionScheme find_partition_scheme(PlannerInfo *root, Relation rel);
      79             : static void set_baserel_partition_key_exprs(Relation relation,
      80             :                                             RelOptInfo *rel);
      81             : 
      82             : /*
      83             :  * get_relation_info -
      84             :  *    Retrieves catalog information for a given relation.
      85             :  *
      86             :  * Given the Oid of the relation, return the following info into fields
      87             :  * of the RelOptInfo struct:
      88             :  *
      89             :  *  min_attr    lowest valid AttrNumber
      90             :  *  max_attr    highest valid AttrNumber
      91             :  *  indexlist   list of IndexOptInfos for relation's indexes
      92             :  *  statlist    list of StatisticExtInfo for relation's statistic objects
      93             :  *  serverid    if it's a foreign table, the server OID
      94             :  *  fdwroutine  if it's a foreign table, the FDW function pointers
      95             :  *  pages       number of pages
      96             :  *  tuples      number of tuples
      97             :  *  rel_parallel_workers user-defined number of parallel workers
      98             :  *
      99             :  * Also, add information about the relation's foreign keys to root->fkey_list.
     100             :  *
     101             :  * Also, initialize the attr_needed[] and attr_widths[] arrays.  In most
     102             :  * cases these are left as zeroes, but sometimes we need to compute attr
     103             :  * widths here, and we may as well cache the results for costsize.c.
     104             :  *
     105             :  * If inhparent is true, all we need to do is set up the attr arrays:
     106             :  * the RelOptInfo actually represents the appendrel formed by an inheritance
     107             :  * tree, and so the parent rel's physical size and index information isn't
     108             :  * important for it.
     109             :  */
     110             : void
     111      260862 : get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
     112             :                   RelOptInfo *rel)
     113             : {
     114      260862 :     Index       varno = rel->relid;
     115             :     Relation    relation;
     116             :     bool        hasindex;
     117      260862 :     List       *indexinfos = NIL;
     118             : 
     119             :     /*
     120             :      * We need not lock the relation since it was already locked, either by
     121             :      * the rewriter or when expand_inherited_rtentry() added it to the query's
     122             :      * rangetable.
     123             :      */
     124      260862 :     relation = table_open(relationObjectId, NoLock);
     125             : 
     126             :     /* Temporary and unlogged relations are inaccessible during recovery. */
     127      260862 :     if (!RelationNeedsWAL(relation) && RecoveryInProgress())
     128           0 :         ereport(ERROR,
     129             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     130             :                  errmsg("cannot access temporary or unlogged relations during recovery")));
     131             : 
     132      260862 :     rel->min_attr = FirstLowInvalidHeapAttributeNumber + 1;
     133      260862 :     rel->max_attr = RelationGetNumberOfAttributes(relation);
     134      260862 :     rel->reltablespace = RelationGetForm(relation)->reltablespace;
     135             : 
     136             :     Assert(rel->max_attr >= rel->min_attr);
     137      260862 :     rel->attr_needed = (Relids *)
     138      260862 :         palloc0((rel->max_attr - rel->min_attr + 1) * sizeof(Relids));
     139      260862 :     rel->attr_widths = (int32 *)
     140      260862 :         palloc0((rel->max_attr - rel->min_attr + 1) * sizeof(int32));
     141             : 
     142             :     /*
     143             :      * Estimate relation size --- unless it's an inheritance parent, in which
     144             :      * case the size we want is not the rel's own size but the size of its
     145             :      * inheritance tree.  That will be computed in set_append_rel_size().
     146             :      */
     147      260862 :     if (!inhparent)
     148      230826 :         estimate_rel_size(relation, rel->attr_widths - rel->min_attr,
     149             :                           &rel->pages, &rel->tuples, &rel->allvisfrac);
     150             : 
     151             :     /* Retrieve the parallel_workers reloption, or -1 if not set. */
     152      260862 :     rel->rel_parallel_workers = RelationGetParallelWorkers(relation, -1);
     153             : 
     154             :     /*
     155             :      * Make list of indexes.  Ignore indexes on system catalogs if told to.
     156             :      * Don't bother with indexes for an inheritance parent, either.
     157             :      */
     158      491688 :     if (inhparent ||
     159      230826 :         (IgnoreSystemIndexes && IsSystemRelation(relation)))
     160       30036 :         hasindex = false;
     161             :     else
     162      230826 :         hasindex = relation->rd_rel->relhasindex;
     163             : 
     164      260862 :     if (hasindex)
     165             :     {
     166             :         List       *indexoidlist;
     167             :         LOCKMODE    lmode;
     168             :         ListCell   *l;
     169             : 
     170      191452 :         indexoidlist = RelationGetIndexList(relation);
     171             : 
     172             :         /*
     173             :          * For each index, we get the same type of lock that the executor will
     174             :          * need, and do not release it.  This saves a couple of trips to the
     175             :          * shared lock manager while not creating any real loss of
     176             :          * concurrency, because no schema changes could be happening on the
     177             :          * index while we hold lock on the parent rel, and no lock type used
     178             :          * for queries blocks any other kind of index operation.
     179             :          */
     180      191452 :         lmode = root->simple_rte_array[varno]->rellockmode;
     181             : 
     182      581144 :         foreach(l, indexoidlist)
     183             :         {
     184      389692 :             Oid         indexoid = lfirst_oid(l);
     185             :             Relation    indexRelation;
     186             :             Form_pg_index index;
     187             :             IndexAmRoutine *amroutine;
     188             :             IndexOptInfo *info;
     189             :             int         ncolumns,
     190             :                         nkeycolumns;
     191             :             int         i;
     192             : 
     193             :             /*
     194             :              * Extract info from the relation descriptor for the index.
     195             :              */
     196      389692 :             indexRelation = index_open(indexoid, lmode);
     197      389692 :             index = indexRelation->rd_index;
     198             : 
     199             :             /*
     200             :              * Ignore invalid indexes, since they can't safely be used for
     201             :              * queries.  Note that this is OK because the data structure we
     202             :              * are constructing is only used by the planner --- the executor
     203             :              * still needs to insert into "invalid" indexes, if they're marked
     204             :              * indisready.
     205             :              */
     206      389692 :             if (!index->indisvalid)
     207             :             {
     208          18 :                 index_close(indexRelation, NoLock);
     209          18 :                 continue;
     210             :             }
     211             : 
     212             :             /*
     213             :              * Ignore partitioned indexes, since they are not usable for
     214             :              * queries.
     215             :              */
     216      389674 :             if (indexRelation->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
     217             :             {
     218           4 :                 index_close(indexRelation, NoLock);
     219           4 :                 continue;
     220             :             }
     221             : 
     222             :             /*
     223             :              * If the index is valid, but cannot yet be used, ignore it; but
     224             :              * mark the plan we are generating as transient. See
     225             :              * src/backend/access/heap/README.HOT for discussion.
     226             :              */
     227      389836 :             if (index->indcheckxmin &&
     228         166 :                 !TransactionIdPrecedes(HeapTupleHeaderGetXmin(indexRelation->rd_indextuple->t_data),
     229             :                                        TransactionXmin))
     230             :             {
     231          10 :                 root->glob->transientPlan = true;
     232          10 :                 index_close(indexRelation, NoLock);
     233          10 :                 continue;
     234             :             }
     235             : 
     236      389660 :             info = makeNode(IndexOptInfo);
     237             : 
     238      389660 :             info->indexoid = index->indexrelid;
     239      389660 :             info->reltablespace =
     240      389660 :                 RelationGetForm(indexRelation)->reltablespace;
     241      389660 :             info->rel = rel;
     242      389660 :             info->ncolumns = ncolumns = index->indnatts;
     243      389660 :             info->nkeycolumns = nkeycolumns = index->indnkeyatts;
     244             : 
     245      389660 :             info->indexkeys = (int *) palloc(sizeof(int) * ncolumns);
     246      389660 :             info->indexcollations = (Oid *) palloc(sizeof(Oid) * nkeycolumns);
     247      389660 :             info->opfamily = (Oid *) palloc(sizeof(Oid) * nkeycolumns);
     248      389660 :             info->opcintype = (Oid *) palloc(sizeof(Oid) * nkeycolumns);
     249      389660 :             info->canreturn = (bool *) palloc(sizeof(bool) * ncolumns);
     250             : 
     251     1098636 :             for (i = 0; i < ncolumns; i++)
     252             :             {
     253      708976 :                 info->indexkeys[i] = index->indkey.values[i];
     254      708976 :                 info->canreturn[i] = index_can_return(indexRelation, i + 1);
     255             :             }
     256             : 
     257     1098336 :             for (i = 0; i < nkeycolumns; i++)
     258             :             {
     259      708676 :                 info->opfamily[i] = indexRelation->rd_opfamily[i];
     260      708676 :                 info->opcintype[i] = indexRelation->rd_opcintype[i];
     261      708676 :                 info->indexcollations[i] = indexRelation->rd_indcollation[i];
     262             :             }
     263             : 
     264      389660 :             info->relam = indexRelation->rd_rel->relam;
     265             : 
     266             :             /* We copy just the fields we need, not all of rd_indam */
     267      389660 :             amroutine = indexRelation->rd_indam;
     268      389660 :             info->amcanorderbyop = amroutine->amcanorderbyop;
     269      389660 :             info->amoptionalkey = amroutine->amoptionalkey;
     270      389660 :             info->amsearcharray = amroutine->amsearcharray;
     271      389660 :             info->amsearchnulls = amroutine->amsearchnulls;
     272      389660 :             info->amcanparallel = amroutine->amcanparallel;
     273      389660 :             info->amhasgettuple = (amroutine->amgettuple != NULL);
     274      779320 :             info->amhasgetbitmap = amroutine->amgetbitmap != NULL &&
     275      389660 :                 relation->rd_tableam->scan_bitmap_next_block != NULL;
     276      389660 :             info->amcostestimate = amroutine->amcostestimate;
     277             :             Assert(info->amcostestimate != NULL);
     278             : 
     279             :             /*
     280             :              * Fetch the ordering information for the index, if any.
     281             :              */
     282      389660 :             if (info->relam == BTREE_AM_OID)
     283             :             {
     284             :                 /*
     285             :                  * If it's a btree index, we can use its opfamily OIDs
     286             :                  * directly as the sort ordering opfamily OIDs.
     287             :                  */
     288             :                 Assert(amroutine->amcanorder);
     289             : 
     290      381242 :                 info->sortopfamily = info->opfamily;
     291      381242 :                 info->reverse_sort = (bool *) palloc(sizeof(bool) * nkeycolumns);
     292      381242 :                 info->nulls_first = (bool *) palloc(sizeof(bool) * nkeycolumns);
     293             : 
     294      966098 :                 for (i = 0; i < nkeycolumns; i++)
     295             :                 {
     296      584856 :                     int16       opt = indexRelation->rd_indoption[i];
     297             : 
     298      584856 :                     info->reverse_sort[i] = (opt & INDOPTION_DESC) != 0;
     299      584856 :                     info->nulls_first[i] = (opt & INDOPTION_NULLS_FIRST) != 0;
     300             :                 }
     301             :             }
     302        8418 :             else if (amroutine->amcanorder)
     303             :             {
     304             :                 /*
     305             :                  * Otherwise, identify the corresponding btree opfamilies by
     306             :                  * trying to map this index's "<" operators into btree.  Since
     307             :                  * "<" uniquely defines the behavior of a sort order, this is
     308             :                  * a sufficient test.
     309             :                  *
     310             :                  * XXX This method is rather slow and also requires the
     311             :                  * undesirable assumption that the other index AM numbers its
     312             :                  * strategies the same as btree.  It'd be better to have a way
     313             :                  * to explicitly declare the corresponding btree opfamily for
     314             :                  * each opfamily of the other index type.  But given the lack
     315             :                  * of current or foreseeable amcanorder index types, it's not
     316             :                  * worth expending more effort on now.
     317             :                  */
     318           0 :                 info->sortopfamily = (Oid *) palloc(sizeof(Oid) * nkeycolumns);
     319           0 :                 info->reverse_sort = (bool *) palloc(sizeof(bool) * nkeycolumns);
     320           0 :                 info->nulls_first = (bool *) palloc(sizeof(bool) * nkeycolumns);
     321             : 
     322           0 :                 for (i = 0; i < nkeycolumns; i++)
     323             :                 {
     324           0 :                     int16       opt = indexRelation->rd_indoption[i];
     325             :                     Oid         ltopr;
     326             :                     Oid         btopfamily;
     327             :                     Oid         btopcintype;
     328             :                     int16       btstrategy;
     329             : 
     330           0 :                     info->reverse_sort[i] = (opt & INDOPTION_DESC) != 0;
     331           0 :                     info->nulls_first[i] = (opt & INDOPTION_NULLS_FIRST) != 0;
     332             : 
     333           0 :                     ltopr = get_opfamily_member(info->opfamily[i],
     334           0 :                                                 info->opcintype[i],
     335           0 :                                                 info->opcintype[i],
     336             :                                                 BTLessStrategyNumber);
     337           0 :                     if (OidIsValid(ltopr) &&
     338           0 :                         get_ordering_op_properties(ltopr,
     339             :                                                    &btopfamily,
     340             :                                                    &btopcintype,
     341           0 :                                                    &btstrategy) &&
     342           0 :                         btopcintype == info->opcintype[i] &&
     343           0 :                         btstrategy == BTLessStrategyNumber)
     344             :                     {
     345             :                         /* Successful mapping */
     346           0 :                         info->sortopfamily[i] = btopfamily;
     347             :                     }
     348             :                     else
     349             :                     {
     350             :                         /* Fail ... quietly treat index as unordered */
     351           0 :                         info->sortopfamily = NULL;
     352           0 :                         info->reverse_sort = NULL;
     353           0 :                         info->nulls_first = NULL;
     354           0 :                         break;
     355             :                     }
     356             :                 }
     357             :             }
     358             :             else
     359             :             {
     360        8418 :                 info->sortopfamily = NULL;
     361        8418 :                 info->reverse_sort = NULL;
     362        8418 :                 info->nulls_first = NULL;
     363             :             }
     364             : 
     365             :             /*
     366             :              * Fetch the index expressions and predicate, if any.  We must
     367             :              * modify the copies we obtain from the relcache to have the
     368             :              * correct varno for the parent relation, so that they match up
     369             :              * correctly against qual clauses.
     370             :              */
     371      389660 :             info->indexprs = RelationGetIndexExpressions(indexRelation);
     372      389660 :             info->indpred = RelationGetIndexPredicate(indexRelation);
     373      389660 :             if (info->indexprs && varno != 1)
     374        1024 :                 ChangeVarNodes((Node *) info->indexprs, 1, varno, 0);
     375      389660 :             if (info->indpred && varno != 1)
     376          68 :                 ChangeVarNodes((Node *) info->indpred, 1, varno, 0);
     377             : 
     378             :             /* Build targetlist using the completed indexprs data */
     379      389660 :             info->indextlist = build_index_tlist(root, info, relation);
     380             : 
     381      389660 :             info->indrestrictinfo = NIL; /* set later, in indxpath.c */
     382      389660 :             info->predOK = false;    /* set later, in indxpath.c */
     383      389660 :             info->unique = index->indisunique;
     384      389660 :             info->immediate = index->indimmediate;
     385      389660 :             info->hypothetical = false;
     386             : 
     387             :             /*
     388             :              * Estimate the index size.  If it's not a partial index, we lock
     389             :              * the number-of-tuples estimate to equal the parent table; if it
     390             :              * is partial then we have to use the same methods as we would for
     391             :              * a table, except we can be sure that the index is not larger
     392             :              * than the table.
     393             :              */
     394      389660 :             if (info->indpred == NIL)
     395             :             {
     396      389012 :                 info->pages = RelationGetNumberOfBlocks(indexRelation);
     397      389012 :                 info->tuples = rel->tuples;
     398             :             }
     399             :             else
     400             :             {
     401             :                 double      allvisfrac; /* dummy */
     402             : 
     403         648 :                 estimate_rel_size(indexRelation, NULL,
     404             :                                   &info->pages, &info->tuples, &allvisfrac);
     405         648 :                 if (info->tuples > rel->tuples)
     406           0 :                     info->tuples = rel->tuples;
     407             :             }
     408             : 
     409      389660 :             if (info->relam == BTREE_AM_OID)
     410             :             {
     411             :                 /* For btrees, get tree height while we have the index open */
     412      381242 :                 info->tree_height = _bt_getrootheight(indexRelation);
     413             :             }
     414             :             else
     415             :             {
     416             :                 /* For other index types, just set it to "unknown" for now */
     417        8418 :                 info->tree_height = -1;
     418             :             }
     419             : 
     420      389660 :             index_close(indexRelation, NoLock);
     421             : 
     422      389660 :             indexinfos = lcons(info, indexinfos);
     423             :         }
     424             : 
     425      191452 :         list_free(indexoidlist);
     426             :     }
     427             : 
     428      260862 :     rel->indexlist = indexinfos;
     429             : 
     430      260862 :     rel->statlist = get_relation_statistics(rel, relation);
     431             : 
     432             :     /* Grab foreign-table info using the relcache, while we have it */
     433      260862 :     if (relation->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
     434             :     {
     435        1808 :         rel->serverid = GetForeignServerIdByRelId(RelationGetRelid(relation));
     436        1808 :         rel->fdwroutine = GetFdwRoutineForRelation(relation, true);
     437             :     }
     438             :     else
     439             :     {
     440      259054 :         rel->serverid = InvalidOid;
     441      259054 :         rel->fdwroutine = NULL;
     442             :     }
     443             : 
     444             :     /* Collect info about relation's foreign keys, if relevant */
     445      260854 :     get_relation_foreign_keys(root, rel, relation, inhparent);
     446             : 
     447             :     /*
     448             :      * Collect info about relation's partitioning scheme, if any. Only
     449             :      * inheritance parents may be partitioned.
     450             :      */
     451      260854 :     if (inhparent && relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
     452        5990 :         set_relation_partition_info(root, rel, relation);
     453             : 
     454      260854 :     table_close(relation, NoLock);
     455             : 
     456             :     /*
     457             :      * Allow a plugin to editorialize on the info we obtained from the
     458             :      * catalogs.  Actions might include altering the assumed relation size,
     459             :      * removing an index, or adding a hypothetical index to the indexlist.
     460             :      */
     461      260854 :     if (get_relation_info_hook)
     462           0 :         (*get_relation_info_hook) (root, relationObjectId, inhparent, rel);
     463      260854 : }
     464             : 
     465             : /*
     466             :  * get_relation_foreign_keys -
     467             :  *    Retrieves foreign key information for a given relation.
     468             :  *
     469             :  * ForeignKeyOptInfos for relevant foreign keys are created and added to
     470             :  * root->fkey_list.  We do this now while we have the relcache entry open.
     471             :  * We could sometimes avoid making useless ForeignKeyOptInfos if we waited
     472             :  * until all RelOptInfos have been built, but the cost of re-opening the
     473             :  * relcache entries would probably exceed any savings.
     474             :  */
     475             : static void
     476      260854 : get_relation_foreign_keys(PlannerInfo *root, RelOptInfo *rel,
     477             :                           Relation relation, bool inhparent)
     478             : {
     479      260854 :     List       *rtable = root->parse->rtable;
     480             :     List       *cachedfkeys;
     481             :     ListCell   *lc;
     482             : 
     483             :     /*
     484             :      * If it's not a baserel, we don't care about its FKs.  Also, if the query
     485             :      * references only a single relation, we can skip the lookup since no FKs
     486             :      * could satisfy the requirements below.
     487             :      */
     488      502680 :     if (rel->reloptkind != RELOPT_BASEREL ||
     489      241826 :         list_length(rtable) < 2)
     490      136226 :         return;
     491             : 
     492             :     /*
     493             :      * If it's the parent of an inheritance tree, ignore its FKs.  We could
     494             :      * make useful FK-based deductions if we found that all members of the
     495             :      * inheritance tree have equivalent FK constraints, but detecting that
     496             :      * would require code that hasn't been written.
     497             :      */
     498      124628 :     if (inhparent)
     499        1798 :         return;
     500             : 
     501             :     /*
     502             :      * Extract data about relation's FKs from the relcache.  Note that this
     503             :      * list belongs to the relcache and might disappear in a cache flush, so
     504             :      * we must not do any further catalog access within this function.
     505             :      */
     506      122830 :     cachedfkeys = RelationGetFKeyList(relation);
     507             : 
     508             :     /*
     509             :      * Figure out which FKs are of interest for this query, and create
     510             :      * ForeignKeyOptInfos for them.  We want only FKs that reference some
     511             :      * other RTE of the current query.  In queries containing self-joins,
     512             :      * there might be more than one other RTE for a referenced table, and we
     513             :      * should make a ForeignKeyOptInfo for each occurrence.
     514             :      *
     515             :      * Ideally, we would ignore RTEs that correspond to non-baserels, but it's
     516             :      * too hard to identify those here, so we might end up making some useless
     517             :      * ForeignKeyOptInfos.  If so, match_foreign_keys_to_quals() will remove
     518             :      * them again.
     519             :      */
     520      124214 :     foreach(lc, cachedfkeys)
     521             :     {
     522        1384 :         ForeignKeyCacheInfo *cachedfk = (ForeignKeyCacheInfo *) lfirst(lc);
     523             :         Index       rti;
     524             :         ListCell   *lc2;
     525             : 
     526             :         /* conrelid should always be that of the table we're considering */
     527             :         Assert(cachedfk->conrelid == RelationGetRelid(relation));
     528             : 
     529             :         /* Scan to find other RTEs matching confrelid */
     530        1384 :         rti = 0;
     531        6596 :         foreach(lc2, rtable)
     532             :         {
     533        5212 :             RangeTblEntry *rte = (RangeTblEntry *) lfirst(lc2);
     534             :             ForeignKeyOptInfo *info;
     535             : 
     536        5212 :             rti++;
     537             :             /* Ignore if not the correct table */
     538        8792 :             if (rte->rtekind != RTE_RELATION ||
     539        3580 :                 rte->relid != cachedfk->confrelid)
     540        4014 :                 continue;
     541             :             /* Ignore if it's an inheritance parent; doesn't really match */
     542        1198 :             if (rte->inh)
     543          98 :                 continue;
     544             :             /* Ignore self-referential FKs; we only care about joins */
     545        1100 :             if (rti == rel->relid)
     546          32 :                 continue;
     547             : 
     548             :             /* OK, let's make an entry */
     549        1068 :             info = makeNode(ForeignKeyOptInfo);
     550        1068 :             info->con_relid = rel->relid;
     551        1068 :             info->ref_relid = rti;
     552        1068 :             info->nkeys = cachedfk->nkeys;
     553        1068 :             memcpy(info->conkey, cachedfk->conkey, sizeof(info->conkey));
     554        1068 :             memcpy(info->confkey, cachedfk->confkey, sizeof(info->confkey));
     555        1068 :             memcpy(info->conpfeqop, cachedfk->conpfeqop, sizeof(info->conpfeqop));
     556             :             /* zero out fields to be filled by match_foreign_keys_to_quals */
     557        1068 :             info->nmatched_ec = 0;
     558        1068 :             info->nmatched_rcols = 0;
     559        1068 :             info->nmatched_ri = 0;
     560        1068 :             memset(info->eclass, 0, sizeof(info->eclass));
     561        1068 :             memset(info->rinfos, 0, sizeof(info->rinfos));
     562             : 
     563        1068 :             root->fkey_list = lappend(root->fkey_list, info);
     564             :         }
     565             :     }
     566             : }
     567             : 
     568             : /*
     569             :  * infer_arbiter_indexes -
     570             :  *    Determine the unique indexes used to arbitrate speculative insertion.
     571             :  *
     572             :  * Uses user-supplied inference clause expressions and predicate to match a
     573             :  * unique index from those defined and ready on the heap relation (target).
     574             :  * An exact match is required on columns/expressions (although they can appear
     575             :  * in any order).  However, the predicate given by the user need only restrict
     576             :  * insertion to a subset of some part of the table covered by some particular
     577             :  * unique index (in particular, a partial unique index) in order to be
     578             :  * inferred.
     579             :  *
     580             :  * The implementation does not consider which B-Tree operator class any
     581             :  * particular available unique index attribute uses, unless one was specified
     582             :  * in the inference specification. The same is true of collations.  In
     583             :  * particular, there is no system dependency on the default operator class for
     584             :  * the purposes of inference.  If no opclass (or collation) is specified, then
     585             :  * all matching indexes (that may or may not match the default in terms of
     586             :  * each attribute opclass/collation) are used for inference.
     587             :  */
     588             : List *
     589         960 : infer_arbiter_indexes(PlannerInfo *root)
     590             : {
     591         960 :     OnConflictExpr *onconflict = root->parse->onConflict;
     592             : 
     593             :     /* Iteration state */
     594             :     RangeTblEntry *rte;
     595             :     Relation    relation;
     596         960 :     Oid         indexOidFromConstraint = InvalidOid;
     597             :     List       *indexList;
     598             :     ListCell   *l;
     599             : 
     600             :     /* Normalized inference attributes and inference expressions: */
     601         960 :     Bitmapset  *inferAttrs = NULL;
     602         960 :     List       *inferElems = NIL;
     603             : 
     604             :     /* Results */
     605         960 :     List       *results = NIL;
     606             : 
     607             :     /*
     608             :      * Quickly return NIL for ON CONFLICT DO NOTHING without an inference
     609             :      * specification or named constraint.  ON CONFLICT DO UPDATE statements
     610             :      * must always provide one or the other (but parser ought to have caught
     611             :      * that already).
     612             :      */
     613        1116 :     if (onconflict->arbiterElems == NIL &&
     614         156 :         onconflict->constraint == InvalidOid)
     615         124 :         return NIL;
     616             : 
     617             :     /*
     618             :      * We need not lock the relation since it was already locked, either by
     619             :      * the rewriter or when expand_inherited_rtentry() added it to the query's
     620             :      * rangetable.
     621             :      */
     622         836 :     rte = rt_fetch(root->parse->resultRelation, root->parse->rtable);
     623             : 
     624         836 :     relation = table_open(rte->relid, NoLock);
     625             : 
     626             :     /*
     627             :      * Build normalized/BMS representation of plain indexed attributes, as
     628             :      * well as a separate list of expression items.  This simplifies matching
     629             :      * the cataloged definition of indexes.
     630             :      */
     631        1836 :     foreach(l, onconflict->arbiterElems)
     632             :     {
     633        1000 :         InferenceElem *elem = (InferenceElem *) lfirst(l);
     634             :         Var        *var;
     635             :         int         attno;
     636             : 
     637        1000 :         if (!IsA(elem->expr, Var))
     638             :         {
     639             :             /* If not a plain Var, just shove it in inferElems for now */
     640         112 :             inferElems = lappend(inferElems, elem->expr);
     641         112 :             continue;
     642             :         }
     643             : 
     644         888 :         var = (Var *) elem->expr;
     645         888 :         attno = var->varattno;
     646             : 
     647         888 :         if (attno == 0)
     648           0 :             ereport(ERROR,
     649             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     650             :                      errmsg("whole row unique index inference specifications are not supported")));
     651             : 
     652         888 :         inferAttrs = bms_add_member(inferAttrs,
     653             :                                     attno - FirstLowInvalidHeapAttributeNumber);
     654             :     }
     655             : 
     656             :     /*
     657             :      * Lookup named constraint's index.  This is not immediately returned
     658             :      * because some additional sanity checks are required.
     659             :      */
     660         836 :     if (onconflict->constraint != InvalidOid)
     661             :     {
     662          32 :         indexOidFromConstraint = get_constraint_index(onconflict->constraint);
     663             : 
     664          32 :         if (indexOidFromConstraint == InvalidOid)
     665           0 :             ereport(ERROR,
     666             :                     (errcode(ERRCODE_WRONG_OBJECT_TYPE),
     667             :                      errmsg("constraint in ON CONFLICT clause has no associated index")));
     668             :     }
     669             : 
     670             :     /*
     671             :      * Using that representation, iterate through the list of indexes on the
     672             :      * target relation to try and find a match
     673             :      */
     674         836 :     indexList = RelationGetIndexList(relation);
     675             : 
     676        1908 :     foreach(l, indexList)
     677             :     {
     678        1104 :         Oid         indexoid = lfirst_oid(l);
     679             :         Relation    idxRel;
     680             :         Form_pg_index idxForm;
     681             :         Bitmapset  *indexedAttrs;
     682             :         List       *idxExprs;
     683             :         List       *predExprs;
     684             :         AttrNumber  natt;
     685             :         ListCell   *el;
     686             : 
     687             :         /*
     688             :          * Extract info from the relation descriptor for the index.  Obtain
     689             :          * the same lock type that the executor will ultimately use.
     690             :          *
     691             :          * Let executor complain about !indimmediate case directly, because
     692             :          * enforcement needs to occur there anyway when an inference clause is
     693             :          * omitted.
     694             :          */
     695        1104 :         idxRel = index_open(indexoid, rte->rellockmode);
     696        1104 :         idxForm = idxRel->rd_index;
     697             : 
     698        1104 :         if (!idxForm->indisvalid)
     699           4 :             goto next;
     700             : 
     701             :         /*
     702             :          * Note that we do not perform a check against indcheckxmin (like e.g.
     703             :          * get_relation_info()) here to eliminate candidates, because
     704             :          * uniqueness checking only cares about the most recently committed
     705             :          * tuple versions.
     706             :          */
     707             : 
     708             :         /*
     709             :          * Look for match on "ON constraint_name" variant, which may not be
     710             :          * unique constraint.  This can only be a constraint name.
     711             :          */
     712        1100 :         if (indexOidFromConstraint == idxForm->indexrelid)
     713             :         {
     714          32 :             if (!idxForm->indisunique && onconflict->action == ONCONFLICT_UPDATE)
     715           4 :                 ereport(ERROR,
     716             :                         (errcode(ERRCODE_WRONG_OBJECT_TYPE),
     717             :                          errmsg("ON CONFLICT DO UPDATE not supported with exclusion constraints")));
     718             : 
     719          28 :             results = lappend_oid(results, idxForm->indexrelid);
     720          28 :             list_free(indexList);
     721          28 :             index_close(idxRel, NoLock);
     722          28 :             table_close(relation, NoLock);
     723          28 :             return results;
     724             :         }
     725        1068 :         else if (indexOidFromConstraint != InvalidOid)
     726             :         {
     727             :             /* No point in further work for index in named constraint case */
     728          12 :             goto next;
     729             :         }
     730             : 
     731             :         /*
     732             :          * Only considering conventional inference at this point (not named
     733             :          * constraints), so index under consideration can be immediately
     734             :          * skipped if it's not unique
     735             :          */
     736        1056 :         if (!idxForm->indisunique)
     737           0 :             goto next;
     738             : 
     739             :         /* Build BMS representation of plain (non expression) index attrs */
     740        1056 :         indexedAttrs = NULL;
     741        2472 :         for (natt = 0; natt < idxForm->indnkeyatts; natt++)
     742             :         {
     743        1416 :             int         attno = idxRel->rd_index->indkey.values[natt];
     744             : 
     745        1416 :             if (attno != 0)
     746        1208 :                 indexedAttrs = bms_add_member(indexedAttrs,
     747             :                                               attno - FirstLowInvalidHeapAttributeNumber);
     748             :         }
     749             : 
     750             :         /* Non-expression attributes (if any) must match */
     751        1056 :         if (!bms_equal(indexedAttrs, inferAttrs))
     752         240 :             goto next;
     753             : 
     754             :         /* Expression attributes (if any) must match */
     755         816 :         idxExprs = RelationGetIndexExpressions(idxRel);
     756        1860 :         foreach(el, onconflict->arbiterElems)
     757             :         {
     758        1076 :             InferenceElem *elem = (InferenceElem *) lfirst(el);
     759             : 
     760             :             /*
     761             :              * Ensure that collation/opclass aspects of inference expression
     762             :              * element match.  Even though this loop is primarily concerned
     763             :              * with matching expressions, it is a convenient point to check
     764             :              * this for both expressions and ordinary (non-expression)
     765             :              * attributes appearing as inference elements.
     766             :              */
     767        1076 :             if (!infer_collation_opclass_match(elem, idxRel, idxExprs))
     768          24 :                 goto next;
     769             : 
     770             :             /*
     771             :              * Plain Vars don't factor into count of expression elements, and
     772             :              * the question of whether or not they satisfy the index
     773             :              * definition has already been considered (they must).
     774             :              */
     775        1052 :             if (IsA(elem->expr, Var))
     776         940 :                 continue;
     777             : 
     778             :             /*
     779             :              * Might as well avoid redundant check in the rare cases where
     780             :              * infer_collation_opclass_match() is required to do real work.
     781             :              * Otherwise, check that element expression appears in cataloged
     782             :              * index definition.
     783             :              */
     784         212 :             if (elem->infercollid != InvalidOid ||
     785         196 :                 elem->inferopclass != InvalidOid ||
     786          96 :                 list_member(idxExprs, elem->expr))
     787         104 :                 continue;
     788             : 
     789           8 :             goto next;
     790             :         }
     791             : 
     792             :         /*
     793             :          * Now that all inference elements were matched, ensure that the
     794             :          * expression elements from inference clause are not missing any
     795             :          * cataloged expressions.  This does the right thing when unique
     796             :          * indexes redundantly repeat the same attribute, or if attributes
     797             :          * redundantly appear multiple times within an inference clause.
     798             :          */
     799         784 :         if (list_difference(idxExprs, inferElems) != NIL)
     800          36 :             goto next;
     801             : 
     802             :         /*
     803             :          * If it's a partial index, its predicate must be implied by the ON
     804             :          * CONFLICT's WHERE clause.
     805             :          */
     806         748 :         predExprs = RelationGetIndexPredicate(idxRel);
     807             : 
     808         748 :         if (!predicate_implied_by(predExprs, (List *) onconflict->arbiterWhere, false))
     809          24 :             goto next;
     810             : 
     811         724 :         results = lappend_oid(results, idxForm->indexrelid);
     812             : next:
     813        1072 :         index_close(idxRel, NoLock);
     814             :     }
     815             : 
     816         804 :     list_free(indexList);
     817         804 :     table_close(relation, NoLock);
     818             : 
     819         804 :     if (results == NIL)
     820         116 :         ereport(ERROR,
     821             :                 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
     822             :                  errmsg("there is no unique or exclusion constraint matching the ON CONFLICT specification")));
     823             : 
     824         688 :     return results;
     825             : }
     826             : 
     827             : /*
     828             :  * infer_collation_opclass_match - ensure infer element opclass/collation match
     829             :  *
     830             :  * Given unique index inference element from inference specification, if
     831             :  * collation was specified, or if opclass was specified, verify that there is
     832             :  * at least one matching indexed attribute (occasionally, there may be more).
     833             :  * Skip this in the common case where inference specification does not include
     834             :  * collation or opclass (instead matching everything, regardless of cataloged
     835             :  * collation/opclass of indexed attribute).
     836             :  *
     837             :  * At least historically, Postgres has not offered collations or opclasses
     838             :  * with alternative-to-default notions of equality, so these additional
     839             :  * criteria should only be required infrequently.
     840             :  *
     841             :  * Don't give up immediately when an inference element matches some attribute
     842             :  * cataloged as indexed but not matching additional opclass/collation
     843             :  * criteria.  This is done so that the implementation is as forgiving as
     844             :  * possible of redundancy within cataloged index attributes (or, less
     845             :  * usefully, within inference specification elements).  If collations actually
     846             :  * differ between apparently redundantly indexed attributes (redundant within
     847             :  * or across indexes), then there really is no redundancy as such.
     848             :  *
     849             :  * Note that if an inference element specifies an opclass and a collation at
     850             :  * once, both must match in at least one particular attribute within index
     851             :  * catalog definition in order for that inference element to be considered
     852             :  * inferred/satisfied.
     853             :  */
     854             : static bool
     855        1076 : infer_collation_opclass_match(InferenceElem *elem, Relation idxRel,
     856             :                               List *idxExprs)
     857             : {
     858             :     AttrNumber  natt;
     859        1076 :     Oid         inferopfamily = InvalidOid; /* OID of opclass opfamily */
     860        1076 :     Oid         inferopcinputtype = InvalidOid; /* OID of opclass input type */
     861        1076 :     int         nplain = 0;     /* # plain attrs observed */
     862             : 
     863             :     /*
     864             :      * If inference specification element lacks collation/opclass, then no
     865             :      * need to check for exact match.
     866             :      */
     867        1076 :     if (elem->infercollid == InvalidOid && elem->inferopclass == InvalidOid)
     868        1000 :         return true;
     869             : 
     870             :     /*
     871             :      * Lookup opfamily and input type, for matching indexes
     872             :      */
     873          76 :     if (elem->inferopclass)
     874             :     {
     875          56 :         inferopfamily = get_opclass_family(elem->inferopclass);
     876          56 :         inferopcinputtype = get_opclass_input_type(elem->inferopclass);
     877             :     }
     878             : 
     879         164 :     for (natt = 1; natt <= idxRel->rd_att->natts; natt++)
     880             :     {
     881         140 :         Oid         opfamily = idxRel->rd_opfamily[natt - 1];
     882         140 :         Oid         opcinputtype = idxRel->rd_opcintype[natt - 1];
     883         140 :         Oid         collation = idxRel->rd_indcollation[natt - 1];
     884         140 :         int         attno = idxRel->rd_index->indkey.values[natt - 1];
     885             : 
     886         140 :         if (attno != 0)
     887         112 :             nplain++;
     888             : 
     889         140 :         if (elem->inferopclass != InvalidOid &&
     890          44 :             (inferopfamily != opfamily || inferopcinputtype != opcinputtype))
     891             :         {
     892             :             /* Attribute needed to match opclass, but didn't */
     893          60 :             continue;
     894             :         }
     895             : 
     896         136 :         if (elem->infercollid != InvalidOid &&
     897          56 :             elem->infercollid != collation)
     898             :         {
     899             :             /* Attribute needed to match collation, but didn't */
     900          24 :             continue;
     901             :         }
     902             : 
     903             :         /* If one matching index att found, good enough -- return true */
     904          56 :         if (IsA(elem->expr, Var))
     905             :         {
     906          36 :             if (((Var *) elem->expr)->varattno == attno)
     907          36 :                 return true;
     908             :         }
     909          20 :         else if (attno == 0)
     910             :         {
     911          20 :             Node       *nattExpr = list_nth(idxExprs, (natt - 1) - nplain);
     912             : 
     913             :             /*
     914             :              * Note that unlike routines like match_index_to_operand() we
     915             :              * don't need to care about RelabelType.  Neither the index
     916             :              * definition nor the inference clause should contain them.
     917             :              */
     918          20 :             if (equal(elem->expr, nattExpr))
     919          16 :                 return true;
     920             :         }
     921             :     }
     922             : 
     923          24 :     return false;
     924             : }
     925             : 
     926             : /*
     927             :  * estimate_rel_size - estimate # pages and # tuples in a table or index
     928             :  *
     929             :  * We also estimate the fraction of the pages that are marked all-visible in
     930             :  * the visibility map, for use in estimation of index-only scans.
     931             :  *
     932             :  * If attr_widths isn't NULL, it points to the zero-index entry of the
     933             :  * relation's attr_widths[] cache; we fill this in if we have need to compute
     934             :  * the attribute widths for estimation purposes.
     935             :  */
     936             : void
     937      252362 : estimate_rel_size(Relation rel, int32 *attr_widths,
     938             :                   BlockNumber *pages, double *tuples, double *allvisfrac)
     939             : {
     940             :     BlockNumber curpages;
     941             :     BlockNumber relpages;
     942             :     double      reltuples;
     943             :     BlockNumber relallvisible;
     944             :     double      density;
     945             : 
     946      252362 :     switch (rel->rd_rel->relkind)
     947             :     {
     948             :         case RELKIND_RELATION:
     949             :         case RELKIND_MATVIEW:
     950             :         case RELKIND_TOASTVALUE:
     951      249472 :             table_relation_estimate_size(rel, attr_widths, pages, tuples,
     952             :                                          allvisfrac);
     953      249472 :             break;
     954             : 
     955             :         case RELKIND_INDEX:
     956             : 
     957             :             /*
     958             :              * XXX: It'd probably be good to move this into a callback,
     959             :              * individual index types e.g. know if they have a metapage.
     960             :              */
     961             : 
     962             :             /* it has storage, ok to call the smgr */
     963         648 :             curpages = RelationGetNumberOfBlocks(rel);
     964             : 
     965             :             /* coerce values in pg_class to more desirable types */
     966         648 :             relpages = (BlockNumber) rel->rd_rel->relpages;
     967         648 :             reltuples = (double) rel->rd_rel->reltuples;
     968         648 :             relallvisible = (BlockNumber) rel->rd_rel->relallvisible;
     969             : 
     970             :             /* report estimated # pages */
     971         648 :             *pages = curpages;
     972             :             /* quick exit if rel is clearly empty */
     973         648 :             if (curpages == 0)
     974             :             {
     975           0 :                 *tuples = 0;
     976           0 :                 *allvisfrac = 0;
     977           0 :                 break;
     978             :             }
     979             :             /* coerce values in pg_class to more desirable types */
     980         648 :             relpages = (BlockNumber) rel->rd_rel->relpages;
     981         648 :             reltuples = (double) rel->rd_rel->reltuples;
     982         648 :             relallvisible = (BlockNumber) rel->rd_rel->relallvisible;
     983             : 
     984             :             /*
     985             :              * Discount the metapage while estimating the number of tuples.
     986             :              * This is a kluge because it assumes more than it ought to about
     987             :              * index structure.  Currently it's OK for btree, hash, and GIN
     988             :              * indexes but suspect for GiST indexes.
     989             :              */
     990         648 :             if (relpages > 0)
     991             :             {
     992         648 :                 curpages--;
     993         648 :                 relpages--;
     994             :             }
     995             : 
     996             :             /* estimate number of tuples from previous tuple density */
     997         648 :             if (relpages > 0)
     998         380 :                 density = reltuples / (double) relpages;
     999             :             else
    1000             :             {
    1001             :                 /*
    1002             :                  * When we have no data because the relation was truncated,
    1003             :                  * estimate tuple width from attribute datatypes.  We assume
    1004             :                  * here that the pages are completely full, which is OK for
    1005             :                  * tables (since they've presumably not been VACUUMed yet) but
    1006             :                  * is probably an overestimate for indexes.  Fortunately
    1007             :                  * get_relation_info() can clamp the overestimate to the
    1008             :                  * parent table's size.
    1009             :                  *
    1010             :                  * Note: this code intentionally disregards alignment
    1011             :                  * considerations, because (a) that would be gilding the lily
    1012             :                  * considering how crude the estimate is, and (b) it creates
    1013             :                  * platform dependencies in the default plans which are kind
    1014             :                  * of a headache for regression testing.
    1015             :                  *
    1016             :                  * XXX: Should this logic be more index specific?
    1017             :                  */
    1018             :                 int32       tuple_width;
    1019             : 
    1020         268 :                 tuple_width = get_rel_data_width(rel, attr_widths);
    1021         268 :                 tuple_width += MAXALIGN(SizeofHeapTupleHeader);
    1022         268 :                 tuple_width += sizeof(ItemIdData);
    1023             :                 /* note: integer division is intentional here */
    1024         268 :                 density = (BLCKSZ - SizeOfPageHeaderData) / tuple_width;
    1025             :             }
    1026         648 :             *tuples = rint(density * (double) curpages);
    1027             : 
    1028             :             /*
    1029             :              * We use relallvisible as-is, rather than scaling it up like we
    1030             :              * do for the pages and tuples counts, on the theory that any
    1031             :              * pages added since the last VACUUM are most likely not marked
    1032             :              * all-visible.  But costsize.c wants it converted to a fraction.
    1033             :              */
    1034         648 :             if (relallvisible == 0 || curpages <= 0)
    1035         648 :                 *allvisfrac = 0;
    1036           0 :             else if ((double) relallvisible >= curpages)
    1037           0 :                 *allvisfrac = 1;
    1038             :             else
    1039           0 :                 *allvisfrac = (double) relallvisible / curpages;
    1040         648 :             break;
    1041             : 
    1042             :         case RELKIND_SEQUENCE:
    1043             :             /* Sequences always have a known size */
    1044         404 :             *pages = 1;
    1045         404 :             *tuples = 1;
    1046         404 :             *allvisfrac = 0;
    1047         404 :             break;
    1048             :         case RELKIND_FOREIGN_TABLE:
    1049             :             /* Just use whatever's in pg_class */
    1050        1808 :             *pages = rel->rd_rel->relpages;
    1051        1808 :             *tuples = rel->rd_rel->reltuples;
    1052        1808 :             *allvisfrac = 0;
    1053        1808 :             break;
    1054             :         default:
    1055             :             /* else it has no disk storage; probably shouldn't get here? */
    1056          30 :             *pages = 0;
    1057          30 :             *tuples = 0;
    1058          30 :             *allvisfrac = 0;
    1059          30 :             break;
    1060             :     }
    1061      252362 : }
    1062             : 
    1063             : 
    1064             : /*
    1065             :  * get_rel_data_width
    1066             :  *
    1067             :  * Estimate the average width of (the data part of) the relation's tuples.
    1068             :  *
    1069             :  * If attr_widths isn't NULL, it points to the zero-index entry of the
    1070             :  * relation's attr_widths[] cache; use and update that cache as appropriate.
    1071             :  *
    1072             :  * Currently we ignore dropped columns.  Ideally those should be included
    1073             :  * in the result, but we haven't got any way to get info about them; and
    1074             :  * since they might be mostly NULLs, treating them as zero-width is not
    1075             :  * necessarily the wrong thing anyway.
    1076             :  */
    1077             : int32
    1078       97872 : get_rel_data_width(Relation rel, int32 *attr_widths)
    1079             : {
    1080       97872 :     int32       tuple_width = 0;
    1081             :     int         i;
    1082             : 
    1083      447856 :     for (i = 1; i <= RelationGetNumberOfAttributes(rel); i++)
    1084             :     {
    1085      349984 :         Form_pg_attribute att = TupleDescAttr(rel->rd_att, i - 1);
    1086             :         int32       item_width;
    1087             : 
    1088      349984 :         if (att->attisdropped)
    1089        1612 :             continue;
    1090             : 
    1091             :         /* use previously cached data, if any */
    1092      348372 :         if (attr_widths != NULL && attr_widths[i] > 0)
    1093             :         {
    1094        4132 :             tuple_width += attr_widths[i];
    1095        4132 :             continue;
    1096             :         }
    1097             : 
    1098             :         /* This should match set_rel_width() in costsize.c */
    1099      344240 :         item_width = get_attavgwidth(RelationGetRelid(rel), i);
    1100      344240 :         if (item_width <= 0)
    1101             :         {
    1102      343378 :             item_width = get_typavgwidth(att->atttypid, att->atttypmod);
    1103             :             Assert(item_width > 0);
    1104             :         }
    1105      344240 :         if (attr_widths != NULL)
    1106      290464 :             attr_widths[i] = item_width;
    1107      344240 :         tuple_width += item_width;
    1108             :     }
    1109             : 
    1110       97872 :     return tuple_width;
    1111             : }
    1112             : 
    1113             : /*
    1114             :  * get_relation_data_width
    1115             :  *
    1116             :  * External API for get_rel_data_width: same behavior except we have to
    1117             :  * open the relcache entry.
    1118             :  */
    1119             : int32
    1120        1360 : get_relation_data_width(Oid relid, int32 *attr_widths)
    1121             : {
    1122             :     int32       result;
    1123             :     Relation    relation;
    1124             : 
    1125             :     /* As above, assume relation is already locked */
    1126        1360 :     relation = table_open(relid, NoLock);
    1127             : 
    1128        1360 :     result = get_rel_data_width(relation, attr_widths);
    1129             : 
    1130        1360 :     table_close(relation, NoLock);
    1131             : 
    1132        1360 :     return result;
    1133             : }
    1134             : 
    1135             : 
    1136             : /*
    1137             :  * get_relation_constraints
    1138             :  *
    1139             :  * Retrieve the applicable constraint expressions of the given relation.
    1140             :  *
    1141             :  * Returns a List (possibly empty) of constraint expressions.  Each one
    1142             :  * has been canonicalized, and its Vars are changed to have the varno
    1143             :  * indicated by rel->relid.  This allows the expressions to be easily
    1144             :  * compared to expressions taken from WHERE.
    1145             :  *
    1146             :  * If include_noinherit is true, it's okay to include constraints that
    1147             :  * are marked NO INHERIT.
    1148             :  *
    1149             :  * If include_notnull is true, "col IS NOT NULL" expressions are generated
    1150             :  * and added to the result for each column that's marked attnotnull.
    1151             :  *
    1152             :  * If include_partition is true, and the relation is a partition,
    1153             :  * also include the partitioning constraints.
    1154             :  *
    1155             :  * Note: at present this is invoked at most once per relation per planner
    1156             :  * run, and in many cases it won't be invoked at all, so there seems no
    1157             :  * point in caching the data in RelOptInfo.
    1158             :  */
    1159             : static List *
    1160       11566 : get_relation_constraints(PlannerInfo *root,
    1161             :                          Oid relationObjectId, RelOptInfo *rel,
    1162             :                          bool include_noinherit,
    1163             :                          bool include_notnull,
    1164             :                          bool include_partition)
    1165             : {
    1166       11566 :     List       *result = NIL;
    1167       11566 :     Index       varno = rel->relid;
    1168             :     Relation    relation;
    1169             :     TupleConstr *constr;
    1170             : 
    1171             :     /*
    1172             :      * We assume the relation has already been safely locked.
    1173             :      */
    1174       11566 :     relation = table_open(relationObjectId, NoLock);
    1175             : 
    1176       11566 :     constr = relation->rd_att->constr;
    1177       11566 :     if (constr != NULL)
    1178             :     {
    1179        4414 :         int         num_check = constr->num_check;
    1180             :         int         i;
    1181             : 
    1182        4662 :         for (i = 0; i < num_check; i++)
    1183             :         {
    1184             :             Node       *cexpr;
    1185             : 
    1186             :             /*
    1187             :              * If this constraint hasn't been fully validated yet, we must
    1188             :              * ignore it here.  Also ignore if NO INHERIT and we weren't told
    1189             :              * that that's safe.
    1190             :              */
    1191         248 :             if (!constr->check[i].ccvalid)
    1192          28 :                 continue;
    1193         220 :             if (constr->check[i].ccnoinherit && !include_noinherit)
    1194           0 :                 continue;
    1195             : 
    1196         220 :             cexpr = stringToNode(constr->check[i].ccbin);
    1197             : 
    1198             :             /*
    1199             :              * Run each expression through const-simplification and
    1200             :              * canonicalization.  This is not just an optimization, but is
    1201             :              * necessary, because we will be comparing it to
    1202             :              * similarly-processed qual clauses, and may fail to detect valid
    1203             :              * matches without this.  This must match the processing done to
    1204             :              * qual clauses in preprocess_expression()!  (We can skip the
    1205             :              * stuff involving subqueries, however, since we don't allow any
    1206             :              * in check constraints.)
    1207             :              */
    1208         220 :             cexpr = eval_const_expressions(root, cexpr);
    1209             : 
    1210         220 :             cexpr = (Node *) canonicalize_qual((Expr *) cexpr, true);
    1211             : 
    1212             :             /* Fix Vars to have the desired varno */
    1213         220 :             if (varno != 1)
    1214         208 :                 ChangeVarNodes(cexpr, 1, varno, 0);
    1215             : 
    1216             :             /*
    1217             :              * Finally, convert to implicit-AND format (that is, a List) and
    1218             :              * append the resulting item(s) to our output list.
    1219             :              */
    1220         220 :             result = list_concat(result,
    1221             :                                  make_ands_implicit((Expr *) cexpr));
    1222             :         }
    1223             : 
    1224             :         /* Add NOT NULL constraints in expression form, if requested */
    1225        4414 :         if (include_notnull && constr->has_not_null)
    1226             :         {
    1227        4098 :             int         natts = relation->rd_att->natts;
    1228             : 
    1229       13860 :             for (i = 1; i <= natts; i++)
    1230             :             {
    1231        9762 :                 Form_pg_attribute att = TupleDescAttr(relation->rd_att, i - 1);
    1232             : 
    1233        9762 :                 if (att->attnotnull && !att->attisdropped)
    1234             :                 {
    1235        6362 :                     NullTest   *ntest = makeNode(NullTest);
    1236             : 
    1237        6362 :                     ntest->arg = (Expr *) makeVar(varno,
    1238             :                                                   i,
    1239             :                                                   att->atttypid,
    1240             :                                                   att->atttypmod,
    1241             :                                                   att->attcollation,
    1242             :                                                   0);
    1243        6362 :                     ntest->nulltesttype = IS_NOT_NULL;
    1244             : 
    1245             :                     /*
    1246             :                      * argisrow=false is correct even for a composite column,
    1247             :                      * because attnotnull does not represent a SQL-spec IS NOT
    1248             :                      * NULL test in such a case, just IS DISTINCT FROM NULL.
    1249             :                      */
    1250        6362 :                     ntest->argisrow = false;
    1251        6362 :                     ntest->location = -1;
    1252        6362 :                     result = lappend(result, ntest);
    1253             :                 }
    1254             :             }
    1255             :         }
    1256             :     }
    1257             : 
    1258             :     /*
    1259             :      * Add partitioning constraints, if requested.
    1260             :      */
    1261       11566 :     if (include_partition && relation->rd_rel->relispartition)
    1262             :     {
    1263           8 :         List       *pcqual = RelationGetPartitionQual(relation);
    1264             : 
    1265           8 :         if (pcqual)
    1266             :         {
    1267             :             /*
    1268             :              * Run the partition quals through const-simplification similar to
    1269             :              * check constraints.  We skip canonicalize_qual, though, because
    1270             :              * partition quals should be in canonical form already; also,
    1271             :              * since the qual is in implicit-AND format, we'd have to
    1272             :              * explicitly convert it to explicit-AND format and back again.
    1273             :              */
    1274           8 :             pcqual = (List *) eval_const_expressions(root, (Node *) pcqual);
    1275             : 
    1276             :             /* Fix Vars to have the desired varno */
    1277           8 :             if (varno != 1)
    1278           0 :                 ChangeVarNodes((Node *) pcqual, 1, varno, 0);
    1279             : 
    1280           8 :             result = list_concat(result, pcqual);
    1281             :         }
    1282             :     }
    1283             : 
    1284       11566 :     table_close(relation, NoLock);
    1285             : 
    1286       11566 :     return result;
    1287             : }
    1288             : 
    1289             : /*
    1290             :  * get_relation_statistics
    1291             :  *      Retrieve extended statistics defined on the table.
    1292             :  *
    1293             :  * Returns a List (possibly empty) of StatisticExtInfo objects describing
    1294             :  * the statistics.  Note that this doesn't load the actual statistics data,
    1295             :  * just the identifying metadata.  Only stats actually built are considered.
    1296             :  */
    1297             : static List *
    1298      260862 : get_relation_statistics(RelOptInfo *rel, Relation relation)
    1299             : {
    1300             :     List       *statoidlist;
    1301      260862 :     List       *stainfos = NIL;
    1302             :     ListCell   *l;
    1303             : 
    1304      260862 :     statoidlist = RelationGetStatExtList(relation);
    1305             : 
    1306      261010 :     foreach(l, statoidlist)
    1307             :     {
    1308         148 :         Oid         statOid = lfirst_oid(l);
    1309             :         Form_pg_statistic_ext staForm;
    1310             :         HeapTuple   htup;
    1311             :         HeapTuple   dtup;
    1312         148 :         Bitmapset  *keys = NULL;
    1313             :         int         i;
    1314             : 
    1315         148 :         htup = SearchSysCache1(STATEXTOID, ObjectIdGetDatum(statOid));
    1316         148 :         if (!HeapTupleIsValid(htup))
    1317           0 :             elog(ERROR, "cache lookup failed for statistics object %u", statOid);
    1318         148 :         staForm = (Form_pg_statistic_ext) GETSTRUCT(htup);
    1319             : 
    1320         148 :         dtup = SearchSysCache1(STATEXTDATASTXOID, ObjectIdGetDatum(statOid));
    1321         148 :         if (!HeapTupleIsValid(dtup))
    1322           0 :             elog(ERROR, "cache lookup failed for statistics object %u", statOid);
    1323             : 
    1324             :         /*
    1325             :          * First, build the array of columns covered.  This is ultimately
    1326             :          * wasted if no stats within the object have actually been built, but
    1327             :          * it doesn't seem worth troubling over that case.
    1328             :          */
    1329         588 :         for (i = 0; i < staForm->stxkeys.dim1; i++)
    1330         440 :             keys = bms_add_member(keys, staForm->stxkeys.values[i]);
    1331             : 
    1332             :         /* add one StatisticExtInfo for each kind built */
    1333         148 :         if (statext_is_kind_built(dtup, STATS_EXT_NDISTINCT))
    1334             :         {
    1335          40 :             StatisticExtInfo *info = makeNode(StatisticExtInfo);
    1336             : 
    1337          40 :             info->statOid = statOid;
    1338          40 :             info->rel = rel;
    1339          40 :             info->kind = STATS_EXT_NDISTINCT;
    1340          40 :             info->keys = bms_copy(keys);
    1341             : 
    1342          40 :             stainfos = lcons(info, stainfos);
    1343             :         }
    1344             : 
    1345         148 :         if (statext_is_kind_built(dtup, STATS_EXT_DEPENDENCIES))
    1346             :         {
    1347          64 :             StatisticExtInfo *info = makeNode(StatisticExtInfo);
    1348             : 
    1349          64 :             info->statOid = statOid;
    1350          64 :             info->rel = rel;
    1351          64 :             info->kind = STATS_EXT_DEPENDENCIES;
    1352          64 :             info->keys = bms_copy(keys);
    1353             : 
    1354          64 :             stainfos = lcons(info, stainfos);
    1355             :         }
    1356             : 
    1357         148 :         if (statext_is_kind_built(dtup, STATS_EXT_MCV))
    1358             :         {
    1359         100 :             StatisticExtInfo *info = makeNode(StatisticExtInfo);
    1360             : 
    1361         100 :             info->statOid = statOid;
    1362         100 :             info->rel = rel;
    1363         100 :             info->kind = STATS_EXT_MCV;
    1364         100 :             info->keys = bms_copy(keys);
    1365             : 
    1366         100 :             stainfos = lcons(info, stainfos);
    1367             :         }
    1368             : 
    1369         148 :         ReleaseSysCache(htup);
    1370         148 :         ReleaseSysCache(dtup);
    1371         148 :         bms_free(keys);
    1372             :     }
    1373             : 
    1374      260862 :     list_free(statoidlist);
    1375             : 
    1376      260862 :     return stainfos;
    1377             : }
    1378             : 
    1379             : /*
    1380             :  * relation_excluded_by_constraints
    1381             :  *
    1382             :  * Detect whether the relation need not be scanned because it has either
    1383             :  * self-inconsistent restrictions, or restrictions inconsistent with the
    1384             :  * relation's applicable constraints.
    1385             :  *
    1386             :  * Note: this examines only rel->relid, rel->reloptkind, and
    1387             :  * rel->baserestrictinfo; therefore it can be called before filling in
    1388             :  * other fields of the RelOptInfo.
    1389             :  */
    1390             : bool
    1391      268612 : relation_excluded_by_constraints(PlannerInfo *root,
    1392             :                                  RelOptInfo *rel, RangeTblEntry *rte)
    1393             : {
    1394             :     bool        include_noinherit;
    1395             :     bool        include_notnull;
    1396      268612 :     bool        include_partition = false;
    1397             :     List       *safe_restrictions;
    1398             :     List       *constraint_pred;
    1399             :     List       *safe_constraints;
    1400             :     ListCell   *lc;
    1401             : 
    1402             :     /* As of now, constraint exclusion works only with simple relations. */
    1403             :     Assert(IS_SIMPLE_REL(rel));
    1404             : 
    1405             :     /*
    1406             :      * If there are no base restriction clauses, we have no hope of proving
    1407             :      * anything below, so fall out quickly.
    1408             :      */
    1409      268612 :     if (rel->baserestrictinfo == NIL)
    1410      116368 :         return false;
    1411             : 
    1412             :     /*
    1413             :      * Regardless of the setting of constraint_exclusion, detect
    1414             :      * constant-FALSE-or-NULL restriction clauses.  Because const-folding will
    1415             :      * reduce "anything AND FALSE" to just "FALSE", any such case should
    1416             :      * result in exactly one baserestrictinfo entry.  This doesn't fire very
    1417             :      * often, but it seems cheap enough to be worth doing anyway.  (Without
    1418             :      * this, we'd miss some optimizations that 9.5 and earlier found via much
    1419             :      * more roundabout methods.)
    1420             :      */
    1421      152244 :     if (list_length(rel->baserestrictinfo) == 1)
    1422             :     {
    1423      108674 :         RestrictInfo *rinfo = (RestrictInfo *) linitial(rel->baserestrictinfo);
    1424      108674 :         Expr       *clause = rinfo->clause;
    1425             : 
    1426      108864 :         if (clause && IsA(clause, Const) &&
    1427         380 :             (((Const *) clause)->constisnull ||
    1428         190 :              !DatumGetBool(((Const *) clause)->constvalue)))
    1429         190 :             return true;
    1430             :     }
    1431             : 
    1432             :     /*
    1433             :      * Skip further tests, depending on constraint_exclusion.
    1434             :      */
    1435      152054 :     switch (constraint_exclusion)
    1436             :     {
    1437             :         case CONSTRAINT_EXCLUSION_OFF:
    1438             :             /* In 'off' mode, never make any further tests */
    1439          52 :             return false;
    1440             : 
    1441             :         case CONSTRAINT_EXCLUSION_PARTITION:
    1442             : 
    1443             :             /*
    1444             :              * When constraint_exclusion is set to 'partition' we only handle
    1445             :              * appendrel members.  Normally, they are RELOPT_OTHER_MEMBER_REL
    1446             :              * relations, but we also consider inherited target relations as
    1447             :              * appendrel members for the purposes of constraint exclusion
    1448             :              * (since, indeed, they were appendrel members earlier in
    1449             :              * inheritance_planner).
    1450             :              *
    1451             :              * In both cases, partition pruning was already applied, so there
    1452             :              * is no need to consider the rel's partition constraints here.
    1453             :              */
    1454      293616 :             if (rel->reloptkind == RELOPT_OTHER_MEMBER_REL ||
    1455      151186 :                 (rel->relid == root->parse->resultRelation &&
    1456        9476 :                  root->inhTargetKind != INHKIND_NONE))
    1457             :                 break;          /* appendrel member, so process it */
    1458      140208 :             return false;
    1459             : 
    1460             :         case CONSTRAINT_EXCLUSION_ON:
    1461             : 
    1462             :             /*
    1463             :              * In 'on' mode, always apply constraint exclusion.  If we are
    1464             :              * considering a baserel that is a partition (i.e., it was
    1465             :              * directly named rather than expanded from a parent table), then
    1466             :              * its partition constraints haven't been considered yet, so
    1467             :              * include them in the processing here.
    1468             :              */
    1469         172 :             if (rel->reloptkind == RELOPT_BASEREL &&
    1470         100 :                 !(rel->relid == root->parse->resultRelation &&
    1471          24 :                   root->inhTargetKind != INHKIND_NONE))
    1472          64 :                 include_partition = true;
    1473          96 :             break;              /* always try to exclude */
    1474             :     }
    1475             : 
    1476             :     /*
    1477             :      * Check for self-contradictory restriction clauses.  We dare not make
    1478             :      * deductions with non-immutable functions, but any immutable clauses that
    1479             :      * are self-contradictory allow us to conclude the scan is unnecessary.
    1480             :      *
    1481             :      * Note: strip off RestrictInfo because predicate_refuted_by() isn't
    1482             :      * expecting to see any in its predicate argument.
    1483             :      */
    1484       11794 :     safe_restrictions = NIL;
    1485       31008 :     foreach(lc, rel->baserestrictinfo)
    1486             :     {
    1487       19214 :         RestrictInfo *rinfo = (RestrictInfo *) lfirst(lc);
    1488             : 
    1489       19214 :         if (!contain_mutable_functions((Node *) rinfo->clause))
    1490       18290 :             safe_restrictions = lappend(safe_restrictions, rinfo->clause);
    1491             :     }
    1492             : 
    1493             :     /*
    1494             :      * We can use weak refutation here, since we're comparing restriction
    1495             :      * clauses with restriction clauses.
    1496             :      */
    1497       11794 :     if (predicate_refuted_by(safe_restrictions, safe_restrictions, true))
    1498          64 :         return true;
    1499             : 
    1500             :     /*
    1501             :      * Only plain relations have constraints, so stop here for other rtekinds.
    1502             :      */
    1503       11730 :     if (rte->rtekind != RTE_RELATION)
    1504         164 :         return false;
    1505             : 
    1506             :     /*
    1507             :      * If we are scanning just this table, we can use NO INHERIT constraints,
    1508             :      * but not if we're scanning its children too.  (Note that partitioned
    1509             :      * tables should never have NO INHERIT constraints; but it's not necessary
    1510             :      * for us to assume that here.)
    1511             :      */
    1512       11566 :     include_noinherit = !rte->inh;
    1513             : 
    1514             :     /*
    1515             :      * Currently, attnotnull constraints must be treated as NO INHERIT unless
    1516             :      * this is a partitioned table.  In future we might track their
    1517             :      * inheritance status more accurately, allowing this to be refined.
    1518             :      */
    1519       11566 :     include_notnull = (!rte->inh || rte->relkind == RELKIND_PARTITIONED_TABLE);
    1520             : 
    1521             :     /*
    1522             :      * Fetch the appropriate set of constraint expressions.
    1523             :      */
    1524       11566 :     constraint_pred = get_relation_constraints(root, rte->relid, rel,
    1525             :                                                include_noinherit,
    1526             :                                                include_notnull,
    1527             :                                                include_partition);
    1528             : 
    1529             :     /*
    1530             :      * We do not currently enforce that CHECK constraints contain only
    1531             :      * immutable functions, so it's necessary to check here. We daren't draw
    1532             :      * conclusions from plan-time evaluation of non-immutable functions. Since
    1533             :      * they're ANDed, we can just ignore any mutable constraints in the list,
    1534             :      * and reason about the rest.
    1535             :      */
    1536       11566 :     safe_constraints = NIL;
    1537       18224 :     foreach(lc, constraint_pred)
    1538             :     {
    1539        6658 :         Node       *pred = (Node *) lfirst(lc);
    1540             : 
    1541        6658 :         if (!contain_mutable_functions(pred))
    1542        6658 :             safe_constraints = lappend(safe_constraints, pred);
    1543             :     }
    1544             : 
    1545             :     /*
    1546             :      * The constraints are effectively ANDed together, so we can just try to
    1547             :      * refute the entire collection at once.  This may allow us to make proofs
    1548             :      * that would fail if we took them individually.
    1549             :      *
    1550             :      * Note: we use rel->baserestrictinfo, not safe_restrictions as might seem
    1551             :      * an obvious optimization.  Some of the clauses might be OR clauses that
    1552             :      * have volatile and nonvolatile subclauses, and it's OK to make
    1553             :      * deductions with the nonvolatile parts.
    1554             :      *
    1555             :      * We need strong refutation because we have to prove that the constraints
    1556             :      * would yield false, not just NULL.
    1557             :      */
    1558       11566 :     if (predicate_refuted_by(safe_constraints, rel->baserestrictinfo, false))
    1559          56 :         return true;
    1560             : 
    1561       11510 :     return false;
    1562             : }
    1563             : 
    1564             : 
    1565             : /*
    1566             :  * build_physical_tlist
    1567             :  *
    1568             :  * Build a targetlist consisting of exactly the relation's user attributes,
    1569             :  * in order.  The executor can special-case such tlists to avoid a projection
    1570             :  * step at runtime, so we use such tlists preferentially for scan nodes.
    1571             :  *
    1572             :  * Exception: if there are any dropped or missing columns, we punt and return
    1573             :  * NIL.  Ideally we would like to handle these cases too.  However this
    1574             :  * creates problems for ExecTypeFromTL, which may be asked to build a tupdesc
    1575             :  * for a tlist that includes vars of no-longer-existent types.  In theory we
    1576             :  * could dig out the required info from the pg_attribute entries of the
    1577             :  * relation, but that data is not readily available to ExecTypeFromTL.
    1578             :  * For now, we don't apply the physical-tlist optimization when there are
    1579             :  * dropped cols.
    1580             :  *
    1581             :  * We also support building a "physical" tlist for subqueries, functions,
    1582             :  * values lists, table expressions, and CTEs, since the same optimization can
    1583             :  * occur in SubqueryScan, FunctionScan, ValuesScan, CteScan, TableFunc,
    1584             :  * NamedTuplestoreScan, and WorkTableScan nodes.
    1585             :  */
    1586             : List *
    1587       75224 : build_physical_tlist(PlannerInfo *root, RelOptInfo *rel)
    1588             : {
    1589       75224 :     List       *tlist = NIL;
    1590       75224 :     Index       varno = rel->relid;
    1591       75224 :     RangeTblEntry *rte = planner_rt_fetch(varno, root);
    1592             :     Relation    relation;
    1593             :     Query      *subquery;
    1594             :     Var        *var;
    1595             :     ListCell   *l;
    1596             :     int         attrno,
    1597             :                 numattrs;
    1598             :     List       *colvars;
    1599             : 
    1600       75224 :     switch (rte->rtekind)
    1601             :     {
    1602             :         case RTE_RELATION:
    1603             :             /* Assume we already have adequate lock */
    1604       65834 :             relation = table_open(rte->relid, NoLock);
    1605             : 
    1606       65834 :             numattrs = RelationGetNumberOfAttributes(relation);
    1607     1260908 :             for (attrno = 1; attrno <= numattrs; attrno++)
    1608             :             {
    1609     1195210 :                 Form_pg_attribute att_tup = TupleDescAttr(relation->rd_att,
    1610             :                                                           attrno - 1);
    1611             : 
    1612     1195210 :                 if (att_tup->attisdropped || att_tup->atthasmissing)
    1613             :                 {
    1614             :                     /* found a dropped or missing col, so punt */
    1615         136 :                     tlist = NIL;
    1616         136 :                     break;
    1617             :                 }
    1618             : 
    1619     1195074 :                 var = makeVar(varno,
    1620             :                               attrno,
    1621             :                               att_tup->atttypid,
    1622             :                               att_tup->atttypmod,
    1623             :                               att_tup->attcollation,
    1624             :                               0);
    1625             : 
    1626     1195074 :                 tlist = lappend(tlist,
    1627     1195074 :                                 makeTargetEntry((Expr *) var,
    1628             :                                                 attrno,
    1629             :                                                 NULL,
    1630             :                                                 false));
    1631             :             }
    1632             : 
    1633       65834 :             table_close(relation, NoLock);
    1634       65834 :             break;
    1635             : 
    1636             :         case RTE_SUBQUERY:
    1637         880 :             subquery = rte->subquery;
    1638        3548 :             foreach(l, subquery->targetList)
    1639             :             {
    1640        2668 :                 TargetEntry *tle = (TargetEntry *) lfirst(l);
    1641             : 
    1642             :                 /*
    1643             :                  * A resjunk column of the subquery can be reflected as
    1644             :                  * resjunk in the physical tlist; we need not punt.
    1645             :                  */
    1646        2668 :                 var = makeVarFromTargetEntry(varno, tle);
    1647             : 
    1648        2668 :                 tlist = lappend(tlist,
    1649        5336 :                                 makeTargetEntry((Expr *) var,
    1650        2668 :                                                 tle->resno,
    1651             :                                                 NULL,
    1652        2668 :                                                 tle->resjunk));
    1653             :             }
    1654         880 :             break;
    1655             : 
    1656             :         case RTE_FUNCTION:
    1657             :         case RTE_TABLEFUNC:
    1658             :         case RTE_VALUES:
    1659             :         case RTE_CTE:
    1660             :         case RTE_NAMEDTUPLESTORE:
    1661             :         case RTE_RESULT:
    1662             :             /* Not all of these can have dropped cols, but share code anyway */
    1663        8510 :             expandRTE(rte, varno, 0, -1, true /* include dropped */ ,
    1664             :                       NULL, &colvars);
    1665       30168 :             foreach(l, colvars)
    1666             :             {
    1667       21658 :                 var = (Var *) lfirst(l);
    1668             : 
    1669             :                 /*
    1670             :                  * A non-Var in expandRTE's output means a dropped column;
    1671             :                  * must punt.
    1672             :                  */
    1673       21658 :                 if (!IsA(var, Var))
    1674             :                 {
    1675           0 :                     tlist = NIL;
    1676           0 :                     break;
    1677             :                 }
    1678             : 
    1679       21658 :                 tlist = lappend(tlist,
    1680       21658 :                                 makeTargetEntry((Expr *) var,
    1681       21658 :                                                 var->varattno,
    1682             :                                                 NULL,
    1683             :                                                 false));
    1684             :             }
    1685        8510 :             break;
    1686             : 
    1687             :         default:
    1688             :             /* caller error */
    1689           0 :             elog(ERROR, "unsupported RTE kind %d in build_physical_tlist",
    1690             :                  (int) rte->rtekind);
    1691             :             break;
    1692             :     }
    1693             : 
    1694       75224 :     return tlist;
    1695             : }
    1696             : 
    1697             : /*
    1698             :  * build_index_tlist
    1699             :  *
    1700             :  * Build a targetlist representing the columns of the specified index.
    1701             :  * Each column is represented by a Var for the corresponding base-relation
    1702             :  * column, or an expression in base-relation Vars, as appropriate.
    1703             :  *
    1704             :  * There are never any dropped columns in indexes, so unlike
    1705             :  * build_physical_tlist, we need no failure case.
    1706             :  */
    1707             : static List *
    1708      389660 : build_index_tlist(PlannerInfo *root, IndexOptInfo *index,
    1709             :                   Relation heapRelation)
    1710             : {
    1711      389660 :     List       *tlist = NIL;
    1712      389660 :     Index       varno = index->rel->relid;
    1713             :     ListCell   *indexpr_item;
    1714             :     int         i;
    1715             : 
    1716      389660 :     indexpr_item = list_head(index->indexprs);
    1717     1098636 :     for (i = 0; i < index->ncolumns; i++)
    1718             :     {
    1719      708976 :         int         indexkey = index->indexkeys[i];
    1720             :         Expr       *indexvar;
    1721             : 
    1722      708976 :         if (indexkey != 0)
    1723             :         {
    1724             :             /* simple column */
    1725             :             const FormData_pg_attribute *att_tup;
    1726             : 
    1727      707658 :             if (indexkey < 0)
    1728           0 :                 att_tup = SystemAttributeDefinition(indexkey);
    1729             :             else
    1730      707658 :                 att_tup = TupleDescAttr(heapRelation->rd_att, indexkey - 1);
    1731             : 
    1732      707658 :             indexvar = (Expr *) makeVar(varno,
    1733             :                                         indexkey,
    1734             :                                         att_tup->atttypid,
    1735             :                                         att_tup->atttypmod,
    1736             :                                         att_tup->attcollation,
    1737             :                                         0);
    1738             :         }
    1739             :         else
    1740             :         {
    1741             :             /* expression column */
    1742        1318 :             if (indexpr_item == NULL)
    1743           0 :                 elog(ERROR, "wrong number of index expressions");
    1744        1318 :             indexvar = (Expr *) lfirst(indexpr_item);
    1745        1318 :             indexpr_item = lnext(indexpr_item);
    1746             :         }
    1747             : 
    1748      708976 :         tlist = lappend(tlist,
    1749      708976 :                         makeTargetEntry(indexvar,
    1750      708976 :                                         i + 1,
    1751             :                                         NULL,
    1752             :                                         false));
    1753             :     }
    1754      389660 :     if (indexpr_item != NULL)
    1755           0 :         elog(ERROR, "wrong number of index expressions");
    1756             : 
    1757      389660 :     return tlist;
    1758             : }
    1759             : 
    1760             : /*
    1761             :  * restriction_selectivity
    1762             :  *
    1763             :  * Returns the selectivity of a specified restriction operator clause.
    1764             :  * This code executes registered procedures stored in the
    1765             :  * operator relation, by calling the function manager.
    1766             :  *
    1767             :  * See clause_selectivity() for the meaning of the additional parameters.
    1768             :  */
    1769             : Selectivity
    1770      314134 : restriction_selectivity(PlannerInfo *root,
    1771             :                         Oid operatorid,
    1772             :                         List *args,
    1773             :                         Oid inputcollid,
    1774             :                         int varRelid)
    1775             : {
    1776      314134 :     RegProcedure oprrest = get_oprrest(operatorid);
    1777             :     float8      result;
    1778             : 
    1779             :     /*
    1780             :      * if the oprrest procedure is missing for whatever reason, use a
    1781             :      * selectivity of 0.5
    1782             :      */
    1783      314134 :     if (!oprrest)
    1784          56 :         return (Selectivity) 0.5;
    1785             : 
    1786      314078 :     result = DatumGetFloat8(OidFunctionCall4Coll(oprrest,
    1787             :                                                  inputcollid,
    1788             :                                                  PointerGetDatum(root),
    1789             :                                                  ObjectIdGetDatum(operatorid),
    1790             :                                                  PointerGetDatum(args),
    1791             :                                                  Int32GetDatum(varRelid)));
    1792             : 
    1793      314078 :     if (result < 0.0 || result > 1.0)
    1794           0 :         elog(ERROR, "invalid restriction selectivity: %f", result);
    1795             : 
    1796      314078 :     return (Selectivity) result;
    1797             : }
    1798             : 
    1799             : /*
    1800             :  * join_selectivity
    1801             :  *
    1802             :  * Returns the selectivity of a specified join operator clause.
    1803             :  * This code executes registered procedures stored in the
    1804             :  * operator relation, by calling the function manager.
    1805             :  *
    1806             :  * See clause_selectivity() for the meaning of the additional parameters.
    1807             :  */
    1808             : Selectivity
    1809      111488 : join_selectivity(PlannerInfo *root,
    1810             :                  Oid operatorid,
    1811             :                  List *args,
    1812             :                  Oid inputcollid,
    1813             :                  JoinType jointype,
    1814             :                  SpecialJoinInfo *sjinfo)
    1815             : {
    1816      111488 :     RegProcedure oprjoin = get_oprjoin(operatorid);
    1817             :     float8      result;
    1818             : 
    1819             :     /*
    1820             :      * if the oprjoin procedure is missing for whatever reason, use a
    1821             :      * selectivity of 0.5
    1822             :      */
    1823      111488 :     if (!oprjoin)
    1824         100 :         return (Selectivity) 0.5;
    1825             : 
    1826      111388 :     result = DatumGetFloat8(OidFunctionCall5Coll(oprjoin,
    1827             :                                                  inputcollid,
    1828             :                                                  PointerGetDatum(root),
    1829             :                                                  ObjectIdGetDatum(operatorid),
    1830             :                                                  PointerGetDatum(args),
    1831             :                                                  Int16GetDatum(jointype),
    1832             :                                                  PointerGetDatum(sjinfo)));
    1833             : 
    1834      111388 :     if (result < 0.0 || result > 1.0)
    1835           0 :         elog(ERROR, "invalid join selectivity: %f", result);
    1836             : 
    1837      111388 :     return (Selectivity) result;
    1838             : }
    1839             : 
    1840             : /*
    1841             :  * function_selectivity
    1842             :  *
    1843             :  * Returns the selectivity of a specified boolean function clause.
    1844             :  * This code executes registered procedures stored in the
    1845             :  * pg_proc relation, by calling the function manager.
    1846             :  *
    1847             :  * See clause_selectivity() for the meaning of the additional parameters.
    1848             :  */
    1849             : Selectivity
    1850        5234 : function_selectivity(PlannerInfo *root,
    1851             :                      Oid funcid,
    1852             :                      List *args,
    1853             :                      Oid inputcollid,
    1854             :                      bool is_join,
    1855             :                      int varRelid,
    1856             :                      JoinType jointype,
    1857             :                      SpecialJoinInfo *sjinfo)
    1858             : {
    1859        5234 :     RegProcedure prosupport = get_func_support(funcid);
    1860             :     SupportRequestSelectivity req;
    1861             :     SupportRequestSelectivity *sresult;
    1862             : 
    1863             :     /*
    1864             :      * If no support function is provided, use our historical default
    1865             :      * estimate, 0.3333333.  This seems a pretty unprincipled choice, but
    1866             :      * Postgres has been using that estimate for function calls since 1992.
    1867             :      * The hoariness of this behavior suggests that we should not be in too
    1868             :      * much hurry to use another value.
    1869             :      */
    1870        5234 :     if (!prosupport)
    1871        5230 :         return (Selectivity) 0.3333333;
    1872             : 
    1873           4 :     req.type = T_SupportRequestSelectivity;
    1874           4 :     req.root = root;
    1875           4 :     req.funcid = funcid;
    1876           4 :     req.args = args;
    1877           4 :     req.inputcollid = inputcollid;
    1878           4 :     req.is_join = is_join;
    1879           4 :     req.varRelid = varRelid;
    1880           4 :     req.jointype = jointype;
    1881           4 :     req.sjinfo = sjinfo;
    1882           4 :     req.selectivity = -1;       /* to catch failure to set the value */
    1883             : 
    1884           4 :     sresult = (SupportRequestSelectivity *)
    1885           4 :         DatumGetPointer(OidFunctionCall1(prosupport,
    1886             :                                          PointerGetDatum(&req)));
    1887             : 
    1888             :     /* If support function fails, use default */
    1889           4 :     if (sresult != &req)
    1890           0 :         return (Selectivity) 0.3333333;
    1891             : 
    1892           4 :     if (req.selectivity < 0.0 || req.selectivity > 1.0)
    1893           0 :         elog(ERROR, "invalid function selectivity: %f", req.selectivity);
    1894             : 
    1895           4 :     return (Selectivity) req.selectivity;
    1896             : }
    1897             : 
    1898             : /*
    1899             :  * add_function_cost
    1900             :  *
    1901             :  * Get an estimate of the execution cost of a function, and *add* it to
    1902             :  * the contents of *cost.  The estimate may include both one-time and
    1903             :  * per-tuple components, since QualCost does.
    1904             :  *
    1905             :  * The funcid must always be supplied.  If it is being called as the
    1906             :  * implementation of a specific parsetree node (FuncExpr, OpExpr,
    1907             :  * WindowFunc, etc), pass that as "node", else pass NULL.
    1908             :  *
    1909             :  * In some usages root might be NULL, too.
    1910             :  */
    1911             : void
    1912      662242 : add_function_cost(PlannerInfo *root, Oid funcid, Node *node,
    1913             :                   QualCost *cost)
    1914             : {
    1915             :     HeapTuple   proctup;
    1916             :     Form_pg_proc procform;
    1917             : 
    1918      662242 :     proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    1919      662242 :     if (!HeapTupleIsValid(proctup))
    1920           0 :         elog(ERROR, "cache lookup failed for function %u", funcid);
    1921      662242 :     procform = (Form_pg_proc) GETSTRUCT(proctup);
    1922             : 
    1923      662242 :     if (OidIsValid(procform->prosupport))
    1924             :     {
    1925             :         SupportRequestCost req;
    1926             :         SupportRequestCost *sresult;
    1927             : 
    1928       24814 :         req.type = T_SupportRequestCost;
    1929       24814 :         req.root = root;
    1930       24814 :         req.funcid = funcid;
    1931       24814 :         req.node = node;
    1932             : 
    1933             :         /* Initialize cost fields so that support function doesn't have to */
    1934       24814 :         req.startup = 0;
    1935       24814 :         req.per_tuple = 0;
    1936             : 
    1937       24814 :         sresult = (SupportRequestCost *)
    1938       24814 :             DatumGetPointer(OidFunctionCall1(procform->prosupport,
    1939             :                                              PointerGetDatum(&req)));
    1940             : 
    1941       24814 :         if (sresult == &req)
    1942             :         {
    1943             :             /* Success, so accumulate support function's estimate into *cost */
    1944          12 :             cost->startup += req.startup;
    1945          12 :             cost->per_tuple += req.per_tuple;
    1946          12 :             ReleaseSysCache(proctup);
    1947          12 :             return;
    1948             :         }
    1949             :     }
    1950             : 
    1951             :     /* No support function, or it failed, so rely on procost */
    1952      662230 :     cost->per_tuple += procform->procost * cpu_operator_cost;
    1953             : 
    1954      662230 :     ReleaseSysCache(proctup);
    1955             : }
    1956             : 
    1957             : /*
    1958             :  * get_function_rows
    1959             :  *
    1960             :  * Get an estimate of the number of rows returned by a set-returning function.
    1961             :  *
    1962             :  * The funcid must always be supplied.  In current usage, the calling node
    1963             :  * will always be supplied, and will be either a FuncExpr or OpExpr.
    1964             :  * But it's a good idea to not fail if it's NULL.
    1965             :  *
    1966             :  * In some usages root might be NULL, too.
    1967             :  *
    1968             :  * Note: this returns the unfiltered result of the support function, if any.
    1969             :  * It's usually a good idea to apply clamp_row_est() to the result, but we
    1970             :  * leave it to the caller to do so.
    1971             :  */
    1972             : double
    1973       30164 : get_function_rows(PlannerInfo *root, Oid funcid, Node *node)
    1974             : {
    1975             :     HeapTuple   proctup;
    1976             :     Form_pg_proc procform;
    1977             :     double      result;
    1978             : 
    1979       30164 :     proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    1980       30164 :     if (!HeapTupleIsValid(proctup))
    1981           0 :         elog(ERROR, "cache lookup failed for function %u", funcid);
    1982       30164 :     procform = (Form_pg_proc) GETSTRUCT(proctup);
    1983             : 
    1984             :     Assert(procform->proretset); /* else caller error */
    1985             : 
    1986       30164 :     if (OidIsValid(procform->prosupport))
    1987             :     {
    1988             :         SupportRequestRows req;
    1989             :         SupportRequestRows *sresult;
    1990             : 
    1991       18936 :         req.type = T_SupportRequestRows;
    1992       18936 :         req.root = root;
    1993       18936 :         req.funcid = funcid;
    1994       18936 :         req.node = node;
    1995             : 
    1996       18936 :         req.rows = 0;           /* just for sanity */
    1997             : 
    1998       18936 :         sresult = (SupportRequestRows *)
    1999       18936 :             DatumGetPointer(OidFunctionCall1(procform->prosupport,
    2000             :                                              PointerGetDatum(&req)));
    2001             : 
    2002       18936 :         if (sresult == &req)
    2003             :         {
    2004             :             /* Success */
    2005       18748 :             ReleaseSysCache(proctup);
    2006       18748 :             return req.rows;
    2007             :         }
    2008             :     }
    2009             : 
    2010             :     /* No support function, or it failed, so rely on prorows */
    2011       11416 :     result = procform->prorows;
    2012             : 
    2013       11416 :     ReleaseSysCache(proctup);
    2014             : 
    2015       11416 :     return result;
    2016             : }
    2017             : 
    2018             : /*
    2019             :  * has_unique_index
    2020             :  *
    2021             :  * Detect whether there is a unique index on the specified attribute
    2022             :  * of the specified relation, thus allowing us to conclude that all
    2023             :  * the (non-null) values of the attribute are distinct.
    2024             :  *
    2025             :  * This function does not check the index's indimmediate property, which
    2026             :  * means that uniqueness may transiently fail to hold intra-transaction.
    2027             :  * That's appropriate when we are making statistical estimates, but beware
    2028             :  * of using this for any correctness proofs.
    2029             :  */
    2030             : bool
    2031      762426 : has_unique_index(RelOptInfo *rel, AttrNumber attno)
    2032             : {
    2033             :     ListCell   *ilist;
    2034             : 
    2035     1874424 :     foreach(ilist, rel->indexlist)
    2036             :     {
    2037     1371680 :         IndexOptInfo *index = (IndexOptInfo *) lfirst(ilist);
    2038             : 
    2039             :         /*
    2040             :          * Note: ignore partial indexes, since they don't allow us to conclude
    2041             :          * that all attr values are distinct, *unless* they are marked predOK
    2042             :          * which means we know the index's predicate is satisfied by the
    2043             :          * query. We don't take any interest in expressional indexes either.
    2044             :          * Also, a multicolumn unique index doesn't allow us to conclude that
    2045             :          * just the specified attr is unique.
    2046             :          */
    2047     2374858 :         if (index->unique &&
    2048     1524104 :             index->nkeycolumns == 1 &&
    2049      780636 :             index->indexkeys[0] == attno &&
    2050      259744 :             (index->indpred == NIL || index->predOK))
    2051      259682 :             return true;
    2052             :     }
    2053      502744 :     return false;
    2054             : }
    2055             : 
    2056             : 
    2057             : /*
    2058             :  * has_row_triggers
    2059             :  *
    2060             :  * Detect whether the specified relation has any row-level triggers for event.
    2061             :  */
    2062             : bool
    2063         330 : has_row_triggers(PlannerInfo *root, Index rti, CmdType event)
    2064             : {
    2065         330 :     RangeTblEntry *rte = planner_rt_fetch(rti, root);
    2066             :     Relation    relation;
    2067             :     TriggerDesc *trigDesc;
    2068         330 :     bool        result = false;
    2069             : 
    2070             :     /* Assume we already have adequate lock */
    2071         330 :     relation = table_open(rte->relid, NoLock);
    2072             : 
    2073         330 :     trigDesc = relation->trigdesc;
    2074         330 :     switch (event)
    2075             :     {
    2076             :         case CMD_INSERT:
    2077         106 :             if (trigDesc &&
    2078          30 :                 (trigDesc->trig_insert_after_row ||
    2079          10 :                  trigDesc->trig_insert_before_row))
    2080          20 :                 result = true;
    2081          86 :             break;
    2082             :         case CMD_UPDATE:
    2083         186 :             if (trigDesc &&
    2084          72 :                 (trigDesc->trig_update_after_row ||
    2085          28 :                  trigDesc->trig_update_before_row))
    2086          32 :                 result = true;
    2087         142 :             break;
    2088             :         case CMD_DELETE:
    2089         130 :             if (trigDesc &&
    2090          46 :                 (trigDesc->trig_delete_after_row ||
    2091          18 :                  trigDesc->trig_delete_before_row))
    2092          14 :                 result = true;
    2093         102 :             break;
    2094             :         default:
    2095           0 :             elog(ERROR, "unrecognized CmdType: %d", (int) event);
    2096             :             break;
    2097             :     }
    2098             : 
    2099         330 :     table_close(relation, NoLock);
    2100         330 :     return result;
    2101             : }
    2102             : 
    2103             : bool
    2104         264 : has_stored_generated_columns(PlannerInfo *root, Index rti)
    2105             : {
    2106         264 :     RangeTblEntry *rte = planner_rt_fetch(rti, root);
    2107             :     Relation    relation;
    2108             :     TupleDesc   tupdesc;
    2109         264 :     bool        result = false;
    2110             : 
    2111             :     /* Assume we already have adequate lock */
    2112         264 :     relation = heap_open(rte->relid, NoLock);
    2113             : 
    2114         264 :     tupdesc = RelationGetDescr(relation);
    2115         264 :     result = tupdesc->constr && tupdesc->constr->has_generated_stored;
    2116             : 
    2117         264 :     heap_close(relation, NoLock);
    2118             : 
    2119         264 :     return result;
    2120             : }
    2121             : 
    2122             : /*
    2123             :  * set_relation_partition_info
    2124             :  *
    2125             :  * Set partitioning scheme and related information for a partitioned table.
    2126             :  */
    2127             : static void
    2128        5990 : set_relation_partition_info(PlannerInfo *root, RelOptInfo *rel,
    2129             :                             Relation relation)
    2130             : {
    2131             :     PartitionDesc partdesc;
    2132             : 
    2133             :     /* Create the PartitionDirectory infrastructure if we didn't already */
    2134        5990 :     if (root->glob->partition_directory == NULL)
    2135        6412 :         root->glob->partition_directory =
    2136        3206 :             CreatePartitionDirectory(CurrentMemoryContext);
    2137             : 
    2138        5990 :     partdesc = PartitionDirectoryLookup(root->glob->partition_directory,
    2139             :                                         relation);
    2140        5990 :     rel->part_scheme = find_partition_scheme(root, relation);
    2141             :     Assert(partdesc != NULL && rel->part_scheme != NULL);
    2142        5990 :     rel->boundinfo = partdesc->boundinfo;
    2143        5990 :     rel->nparts = partdesc->nparts;
    2144        5990 :     set_baserel_partition_key_exprs(relation, rel);
    2145        5990 :     rel->partition_qual = RelationGetPartitionQual(relation);
    2146        5990 : }
    2147             : 
    2148             : /*
    2149             :  * find_partition_scheme
    2150             :  *
    2151             :  * Find or create a PartitionScheme for this Relation.
    2152             :  */
    2153             : static PartitionScheme
    2154        5990 : find_partition_scheme(PlannerInfo *root, Relation relation)
    2155             : {
    2156        5990 :     PartitionKey partkey = RelationGetPartitionKey(relation);
    2157             :     ListCell   *lc;
    2158             :     int         partnatts,
    2159             :                 i;
    2160             :     PartitionScheme part_scheme;
    2161             : 
    2162             :     /* A partitioned table should have a partition key. */
    2163             :     Assert(partkey != NULL);
    2164             : 
    2165        5990 :     partnatts = partkey->partnatts;
    2166             : 
    2167             :     /* Search for a matching partition scheme and return if found one. */
    2168        6970 :     foreach(lc, root->part_schemes)
    2169             :     {
    2170        3028 :         part_scheme = lfirst(lc);
    2171             : 
    2172             :         /* Match partitioning strategy and number of keys. */
    2173        5568 :         if (partkey->strategy != part_scheme->strategy ||
    2174        2540 :             partnatts != part_scheme->partnatts)
    2175         760 :             continue;
    2176             : 
    2177             :         /* Match partition key type properties. */
    2178        2268 :         if (memcmp(partkey->partopfamily, part_scheme->partopfamily,
    2179        2048 :                    sizeof(Oid) * partnatts) != 0 ||
    2180        2048 :             memcmp(partkey->partopcintype, part_scheme->partopcintype,
    2181        2048 :                    sizeof(Oid) * partnatts) != 0 ||
    2182        2048 :             memcmp(partkey->partcollation, part_scheme->partcollation,
    2183             :                    sizeof(Oid) * partnatts) != 0)
    2184         220 :             continue;
    2185             : 
    2186             :         /*
    2187             :          * Length and byval information should match when partopcintype
    2188             :          * matches.
    2189             :          */
    2190             :         Assert(memcmp(partkey->parttyplen, part_scheme->parttyplen,
    2191             :                       sizeof(int16) * partnatts) == 0);
    2192             :         Assert(memcmp(partkey->parttypbyval, part_scheme->parttypbyval,
    2193             :                       sizeof(bool) * partnatts) == 0);
    2194             : 
    2195             :         /*
    2196             :          * If partopfamily and partopcintype matched, must have the same
    2197             :          * partition comparison functions.  Note that we cannot reliably
    2198             :          * Assert the equality of function structs themselves for they might
    2199             :          * be different across PartitionKey's, so just Assert for the function
    2200             :          * OIDs.
    2201             :          */
    2202             : #ifdef USE_ASSERT_CHECKING
    2203             :         for (i = 0; i < partkey->partnatts; i++)
    2204             :             Assert(partkey->partsupfunc[i].fn_oid ==
    2205             :                    part_scheme->partsupfunc[i].fn_oid);
    2206             : #endif
    2207             : 
    2208             :         /* Found matching partition scheme. */
    2209        2048 :         return part_scheme;
    2210             :     }
    2211             : 
    2212             :     /*
    2213             :      * Did not find matching partition scheme. Create one copying relevant
    2214             :      * information from the relcache. We need to copy the contents of the
    2215             :      * array since the relcache entry may not survive after we have closed the
    2216             :      * relation.
    2217             :      */
    2218        3942 :     part_scheme = (PartitionScheme) palloc0(sizeof(PartitionSchemeData));
    2219        3942 :     part_scheme->strategy = partkey->strategy;
    2220        3942 :     part_scheme->partnatts = partkey->partnatts;
    2221             : 
    2222        3942 :     part_scheme->partopfamily = (Oid *) palloc(sizeof(Oid) * partnatts);
    2223        3942 :     memcpy(part_scheme->partopfamily, partkey->partopfamily,
    2224             :            sizeof(Oid) * partnatts);
    2225             : 
    2226        3942 :     part_scheme->partopcintype = (Oid *) palloc(sizeof(Oid) * partnatts);
    2227        3942 :     memcpy(part_scheme->partopcintype, partkey->partopcintype,
    2228             :            sizeof(Oid) * partnatts);
    2229             : 
    2230        3942 :     part_scheme->partcollation = (Oid *) palloc(sizeof(Oid) * partnatts);
    2231        3942 :     memcpy(part_scheme->partcollation, partkey->partcollation,
    2232             :            sizeof(Oid) * partnatts);
    2233             : 
    2234        3942 :     part_scheme->parttyplen = (int16 *) palloc(sizeof(int16) * partnatts);
    2235        3942 :     memcpy(part_scheme->parttyplen, partkey->parttyplen,
    2236             :            sizeof(int16) * partnatts);
    2237             : 
    2238        3942 :     part_scheme->parttypbyval = (bool *) palloc(sizeof(bool) * partnatts);
    2239        3942 :     memcpy(part_scheme->parttypbyval, partkey->parttypbyval,
    2240             :            sizeof(bool) * partnatts);
    2241             : 
    2242        3942 :     part_scheme->partsupfunc = (FmgrInfo *)
    2243        3942 :         palloc(sizeof(FmgrInfo) * partnatts);
    2244        8612 :     for (i = 0; i < partnatts; i++)
    2245        4670 :         fmgr_info_copy(&part_scheme->partsupfunc[i], &partkey->partsupfunc[i],
    2246             :                        CurrentMemoryContext);
    2247             : 
    2248             :     /* Add the partitioning scheme to PlannerInfo. */
    2249        3942 :     root->part_schemes = lappend(root->part_schemes, part_scheme);
    2250             : 
    2251        3942 :     return part_scheme;
    2252             : }
    2253             : 
    2254             : /*
    2255             :  * set_baserel_partition_key_exprs
    2256             :  *
    2257             :  * Builds partition key expressions for the given base relation and sets them
    2258             :  * in given RelOptInfo.  Any single column partition keys are converted to Var
    2259             :  * nodes.  All Var nodes are restamped with the relid of given relation.
    2260             :  */
    2261             : static void
    2262        5990 : set_baserel_partition_key_exprs(Relation relation,
    2263             :                                 RelOptInfo *rel)
    2264             : {
    2265        5990 :     PartitionKey partkey = RelationGetPartitionKey(relation);
    2266             :     int         partnatts;
    2267             :     int         cnt;
    2268             :     List      **partexprs;
    2269             :     ListCell   *lc;
    2270        5990 :     Index       varno = rel->relid;
    2271             : 
    2272             :     Assert(IS_SIMPLE_REL(rel) && rel->relid > 0);
    2273             : 
    2274             :     /* A partitioned table should have a partition key. */
    2275             :     Assert(partkey != NULL);
    2276             : 
    2277        5990 :     partnatts = partkey->partnatts;
    2278        5990 :     partexprs = (List **) palloc(sizeof(List *) * partnatts);
    2279        5990 :     lc = list_head(partkey->partexprs);
    2280             : 
    2281       12728 :     for (cnt = 0; cnt < partnatts; cnt++)
    2282             :     {
    2283             :         Expr       *partexpr;
    2284        6738 :         AttrNumber  attno = partkey->partattrs[cnt];
    2285             : 
    2286        6738 :         if (attno != InvalidAttrNumber)
    2287             :         {
    2288             :             /* Single column partition key is stored as a Var node. */
    2289             :             Assert(attno > 0);
    2290             : 
    2291       18642 :             partexpr = (Expr *) makeVar(varno, attno,
    2292        6214 :                                         partkey->parttypid[cnt],
    2293        6214 :                                         partkey->parttypmod[cnt],
    2294        6214 :                                         partkey->parttypcoll[cnt], 0);
    2295             :         }
    2296             :         else
    2297             :         {
    2298         524 :             if (lc == NULL)
    2299           0 :                 elog(ERROR, "wrong number of partition key expressions");
    2300             : 
    2301             :             /* Re-stamp the expression with given varno. */
    2302         524 :             partexpr = (Expr *) copyObject(lfirst(lc));
    2303         524 :             ChangeVarNodes((Node *) partexpr, 1, varno, 0);
    2304         524 :             lc = lnext(lc);
    2305             :         }
    2306             : 
    2307        6738 :         partexprs[cnt] = list_make1(partexpr);
    2308             :     }
    2309             : 
    2310        5990 :     rel->partexprs = partexprs;
    2311             : 
    2312             :     /*
    2313             :      * A base relation can not have nullable partition key expressions. We
    2314             :      * still allocate array of empty expressions lists to keep partition key
    2315             :      * expression handling code simple. See build_joinrel_partition_info() and
    2316             :      * match_expr_to_partition_keys().
    2317             :      */
    2318        5990 :     rel->nullable_partexprs = (List **) palloc0(sizeof(List *) * partnatts);
    2319        5990 : }

Generated by: LCOV version 1.13