Quelle plancat.c
Sprache: C
/*------------------------------------------------------------------------- * * plancat . c * routines for accessing the system catalogs * * * Portions Copyright ( c ) 1996 - 2025 , PostgreSQL Global Development Group * Portions Copyright ( c ) 1994 , Regents of the University of California * * * IDENTIFICATION * src / backend / optimizer / util / plancat . c * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #include "postgres.h" #include <math.h>#include "access/genam.h" #include "access/htup_details.h" #include "access/nbtree.h" #include "access/sysattr.h" #include "access/table.h" #include "access/tableam.h" #include "access/transam.h" #include "access/xlog.h" #include "catalog/catalog.h" #include "catalog/heap.h" #include "catalog/pg_am.h" #include "catalog/pg_proc.h" #include "catalog/pg_statistic_ext.h" #include "catalog/pg_statistic_ext_data.h" #include "foreign/fdwapi.h" #include "miscadmin.h" #include "nodes/makefuncs.h" #include "nodes/nodeFuncs.h" #include "nodes/supportnodes.h" #include "optimizer/cost.h" #include "optimizer/optimizer.h" #include "optimizer/plancat.h" #include "parser/parse_relation.h" #include "parser/parsetree.h" #include "partitioning/partdesc.h" #include "rewrite/rewriteHandler.h" #include "rewrite/rewriteManip.h" #include "statistics/statistics.h" #include "storage/bufmgr.h" #include "tcop/tcopprot.h" #include "utils/builtins.h" #include "utils/lsyscache.h" #include "utils/partcache.h" #include "utils/rel.h" #include "utils/snapmgr.h" #include "utils/syscache.h" /* GUC parameter */ int constraint_exclusion = CONSTRAINT_EXCLUSION_PARTITION;/* Hook for plugins to get control in get_relation_info() */ static void get_relation_foreign_keys(PlannerInfo *root, RelOptInfo *rel,bool inhparent);static bool infer_collation_opclass_match(InferenceElem *elem, Relation idxRel,static List *get_relation_constraints(PlannerInfo *root,bool include_noinherit,bool include_notnull,bool include_partition);static List *build_index_tlist(PlannerInfo *root, IndexOptInfo *index,static List *get_relation_statistics(RelOptInfo *rel, Relation relation);static void set_relation_partition_info(PlannerInfo *root, RelOptInfo *rel,static PartitionScheme find_partition_scheme(PlannerInfo *root,static void set_baserel_partition_key_exprs(Relation relation,static void set_baserel_partition_constraint(Relation relation,/* * get_relation_info - * Retrieves catalog information for a given relation . * * Given the Oid of the relation , return the following info into fields * of the RelOptInfo struct : * * min_attr lowest valid AttrNumber * max_attr highest valid AttrNumber * indexlist list of IndexOptInfos for relation ' s indexes * statlist list of StatisticExtInfo for relation ' s statistic objects * serverid if it ' s a foreign table , the server OID * fdwroutine if it ' s a foreign table , the FDW function pointers * pages number of pages * tuples number of tuples * rel_parallel_workers user - defined number of parallel workers * * Also , add information about the relation ' s foreign keys to root - > fkey_list . * * Also , initialize the attr_needed [ ] and attr_widths [ ] arrays . In most * cases these are left as zeroes , but sometimes we need to compute attr * widths here , and we may as well cache the results for costsize . c . * * If inhparent is true , all we need to do is set up the attr arrays : * the RelOptInfo actually represents the appendrel formed by an inheritance * tree , and so the parent rel ' s physical size and index information isn ' t * important for it , however , for partitioned tables , we do populate the * indexlist as the planner uses unique indexes as unique proofs for certain * optimizations . void bool inhparent,bool hasindex;/* * We need not lock the relation since it was already locked , either by * the rewriter or when expand_inherited_rtentry ( ) added it to the query ' s * rangetable . /* * Relations without a table AM can be used in a query only if they are of * special - cased relkinds . This check prevents us from crashing later if , * for example , a view ' s ON SELECT rule has gone missing . Note that * table_open ( ) already rejected indexes and composite types ; spell the * error the same way it does . if (!relation->rd_tableam)if (!(relation->rd_rel->relkind == RELKIND_FOREIGN_TABLE ||"cannot open relation \" %s\"" ,/* Temporary and unlogged relations are inaccessible during recovery. */ if (!RelationIsPermanent(relation) && RecoveryInProgress())"cannot access temporary or unlogged relations during recovery" )));1 ;1 ) * sizeof (Relids));1 ) * sizeof (int32));/* * Record which columns are defined as NOT NULL . We leave this * unpopulated for non - partitioned inheritance parent relations as it ' s * ambiguous as to what it means . Some child tables may have a NOT NULL * constraint for a column while others may not . We could work harder and * build a unioned set of all child relations notnullattnums , but there ' s * currently no need . The RelOptInfo corresponding to the ! inh * RangeTblEntry does get populated . if (!inhparent || relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)for (int i = 0 ; i < relation->rd_att->natts; i++)if (attr->attnullability == ATTNULLABLE_VALID)1 );/* * Per RemoveAttributeById ( ) , dropped columns will have their * attnotnull unset , so we needn ' t check for dropped columns * in the above condition . /* * Estimate relation size - - - unless it ' s an inheritance parent , in which * case the size we want is not the rel ' s own size but the size of its * inheritance tree . That will be computed in set_append_rel_size ( ) . if (!inhparent)/* Retrieve the parallel_workers reloption, or -1 if not set. */ 1 );/* * Make list of indexes . Ignore indexes on system catalogs if told to . * Don ' t bother with indexes from traditional inheritance parents . For * partitioned tables , we need a list of at least unique indexes as these * serve as unique proofs for certain planner optimizations . However , * let ' s not discriminate here and just record all partitioned indexes * whether they ' re unique indexes or not . if ((inhparent && relation->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)false ;else if (hasindex)/* * For each index , we get the same type of lock that the executor will * need , and do not release it . This saves a couple of trips to the * shared lock manager while not creating any real loss of * concurrency , because no schema changes could be happening on the * index while we hold lock on the parent rel , and no lock type used * for queries blocks any other kind of index operation . int ncolumns,int i;/* * Extract info from the relation descriptor for the index . /* * Ignore invalid indexes , since they can ' t safely be used for * queries . Note that this is OK because the data structure we * are constructing is only used by the planner - - - the executor * still needs to insert into " invalid " indexes , if they ' re marked * indisready . if (!index->indisvalid)continue ;/* * If the index is valid , but cannot yet be used , ignore it ; but * mark the plan we are generating as transient . See * src / backend / access / heap / README . HOT for discussion . if (index->indcheckxmin &&),true ;continue ;int *) palloc(sizeof (int ) * ncolumns);sizeof (Oid) * nkeycolumns);sizeof (Oid) * nkeycolumns);sizeof (Oid) * nkeycolumns);bool *) palloc(sizeof (bool ) * ncolumns);for (i = 0 ; i < ncolumns; i++)1 );for (i = 0 ; i < nkeycolumns; i++)/* * We don ' t have an AM for partitioned indexes , so we ' ll just * NULLify the AM related fields for those . if (indexRelation->rd_rel->relkind != RELKIND_PARTITIONED_INDEX)/* We copy just the fields we need, not all of rd_indam */ /* Fetch index opclass options */ true );/* * Fetch the ordering information for the index , if any . if (info->relam == BTREE_AM_OID)/* * If it ' s a btree index , we can use its opfamily OIDs * directly as the sort ordering opfamily OIDs . bool *) palloc(sizeof (bool ) * nkeycolumns);bool *) palloc(sizeof (bool ) * nkeycolumns);for (i = 0 ; i < nkeycolumns; i++)0 ;0 ;else if (amroutine->amcanorder)/* * Otherwise , identify the corresponding btree opfamilies * by trying to map this index ' s " < " operators into btree . * Since " < " uniquely defines the behavior of a sort * order , this is a sufficient test . * * XXX This method is rather slow and complicated . It ' d * be better to have a way to explicitly declare the * corresponding btree opfamily for each opfamily of the * other index type . sizeof (Oid) * nkeycolumns);bool *) palloc(sizeof (bool ) * nkeycolumns);bool *) palloc(sizeof (bool ) * nkeycolumns);for (i = 0 ; i < nkeycolumns; i++)0 ;0 ;if (OidIsValid(ltopr) &&/* Successful mapping */ else /* Fail ... quietly treat index as unordered */ break ;else else false ;false ;false ;false ;false ;false ;false ;false ;/* * Fetch the index expressions and predicate , if any . We must * modify the copies we obtain from the relcache to have the * correct varno for the parent relation , so that they match up * correctly against qual clauses . if (info->indexprs && varno != 1 )1 , varno, 0 );if (info->indpred && varno != 1 )1 , varno, 0 );/* Build targetlist using the completed indexprs data */ /* set later, in indxpath.c */ false ; /* set later, in indxpath.c */ false ;/* * Estimate the index size . If it ' s not a partial index , we lock * the number - of - tuples estimate to equal the parent table ; if it * is partial then we have to use the same methods as we would for * a table , except we can be sure that the index is not larger * than the table . We must ignore partitioned indexes here as * there are not physical indexes . if (indexRelation->rd_rel->relkind != RELKIND_PARTITIONED_INDEX)if (info->indpred == NIL)else double allvisfrac; /* dummy */ if (info->tuples > rel->tuples)/* * Get tree height while we have the index open if (amroutine->amgettreeheight)else /* For other index types, just set it to "unknown" for now */ 1 ;else /* Zero these out for partitioned indexes */ 0 ;0 .0 ;1 ;/* * We ' ve historically used lcons ( ) here . It ' d make more sense to * use lappend ( ) , but that causes the planner to change behavior * in cases where two indexes seem equally attractive . For now , * stick with lcons ( ) - - - few tables should have so many indexes * that the O ( N ^ 2 ) behavior of lcons ( ) is really a problem . /* Grab foreign-table info using the relcache, while we have it */ if (relation->rd_rel->relkind == RELKIND_FOREIGN_TABLE)/* Check if the access to foreign tables is restricted */ if (unlikely((restrict_nonsystem_relation_kind & RESTRICT_RELKIND_FOREIGN_TABLE) != 0 ))/* there must not be built-in foreign tables */ "access to non-system foreign table is restricted" )));true );else /* Collect info about relation's foreign keys, if relevant */ /* Collect info about functions implemented by the rel's table AM. */ if (relation->rd_tableam &&/* * Collect info about relation ' s partitioning scheme , if any . Only * inheritance parents may be partitioned . if (inhparent && relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)/* * Allow a plugin to editorialize on the info we obtained from the * catalogs . Actions might include altering the assumed relation size , * removing an index , or adding a hypothetical index to the indexlist . if (get_relation_info_hook)/* * get_relation_foreign_keys - * Retrieves foreign key information for a given relation . * * ForeignKeyOptInfos for relevant foreign keys are created and added to * root - > fkey_list . We do this now while we have the relcache entry open . * We could sometimes avoid making useless ForeignKeyOptInfos if we waited * until all RelOptInfos have been built , but the cost of re - opening the * relcache entries would probably exceed any savings . static void bool inhparent)/* * If it ' s not a baserel , we don ' t care about its FKs . Also , if the query * references only a single relation , we can skip the lookup since no FKs * could satisfy the requirements below . if (rel->reloptkind != RELOPT_BASEREL ||2 )return ;/* * If it ' s the parent of an inheritance tree , ignore its FKs . We could * make useful FK - based deductions if we found that all members of the * inheritance tree have equivalent FK constraints , but detecting that * would require code that hasn ' t been written . if (inhparent)return ;/* * Extract data about relation ' s FKs from the relcache . Note that this * list belongs to the relcache and might disappear in a cache flush , so * we must not do any further catalog access within this function . /* * Figure out which FKs are of interest for this query , and create * ForeignKeyOptInfos for them . We want only FKs that reference some * other RTE of the current query . In queries containing self - joins , * there might be more than one other RTE for a referenced table , and we * should make a ForeignKeyOptInfo for each occurrence . * * Ideally , we would ignore RTEs that correspond to non - baserels , but it ' s * too hard to identify those here , so we might end up making some useless * ForeignKeyOptInfos . If so , match_foreign_keys_to_quals ( ) will remove * them again . /* conrelid should always be that of the table we're considering */ /* skip constraints currently not enforced */ if (!cachedfk->conenforced)continue ;/* Scan to find other RTEs matching confrelid */ 0 ;/* Ignore if not the correct table */ if (rte->rtekind != RTE_RELATION ||continue ;/* Ignore if it's an inheritance parent; doesn't really match */ if (rte->inh)continue ;/* Ignore self-referential FKs; we only care about joins */ if (rti == rel->relid)continue ;/* OK, let's make an entry */ sizeof (info->conkey));sizeof (info->confkey));sizeof (info->conpfeqop));/* zero out fields to be filled by match_foreign_keys_to_quals */ 0 ;0 ;0 ;0 ;0 , sizeof (info->eclass));0 , sizeof (info->fk_eclass_member));0 , sizeof (info->rinfos));/* * infer_arbiter_indexes - * Determine the unique indexes used to arbitrate speculative insertion . * * Uses user - supplied inference clause expressions and predicate to match a * unique index from those defined and ready on the heap relation ( target ) . * An exact match is required on columns / expressions ( although they can appear * in any order ) . However , the predicate given by the user need only restrict * insertion to a subset of some part of the table covered by some particular * unique index ( in particular , a partial unique index ) in order to be * inferred . * * The implementation does not consider which B - Tree operator class any * particular available unique index attribute uses , unless one was specified * in the inference specification . The same is true of collations . In * particular , there is no system dependency on the default operator class for * the purposes of inference . If no opclass ( or collation ) is specified , then * all matching indexes ( that may or may not match the default in terms of * each attribute opclass / collation ) are used for inference . * * Note : during index CONCURRENTLY operations , different transactions may * reference different sets of arbiter indexes . This can lead to false unique * constraint violations that wouldn ' t occur during normal operations . For * more information , see insert . sgml . /* Iteration state */ /* Normalized inference attributes and inference expressions: */ /* Results */ /* * Quickly return NIL for ON CONFLICT DO NOTHING without an inference * specification or named constraint . ON CONFLICT DO UPDATE statements * must always provide one or the other ( but parser ought to have caught * that already ) . if (onconflict->arbiterElems == NIL &&return NIL;/* * We need not lock the relation since it was already locked , either by * the rewriter or when expand_inherited_rtentry ( ) added it to the query ' s * rangetable . /* * Build normalized / BMS representation of plain indexed attributes , as * well as a separate list of expression items . This simplifies matching * the cataloged definition of indexes . int attno;if (!IsA(elem->expr, Var))/* If not a plain Var, just shove it in inferElems for now */ continue ;if (attno == 0 )"whole row unique index inference specifications are not supported" )));/* * Lookup named constraint ' s index . This is not immediately returned * because some additional sanity checks are required . if (onconflict->constraint != InvalidOid)if (indexOidFromConstraint == InvalidOid)"constraint in ON CONFLICT clause has no associated index" )));/* * Using that representation , iterate through the list of indexes on the * target relation to try and find a match /* * Extract info from the relation descriptor for the index . Obtain * the same lock type that the executor will ultimately use . * * Let executor complain about ! indimmediate case directly , because * enforcement needs to occur there anyway when an inference clause is * omitted . if (!idxForm->indisvalid)goto next;/* * Note that we do not perform a check against indcheckxmin ( like e . g . * get_relation_info ( ) ) here to eliminate candidates , because * uniqueness checking only cares about the most recently committed * tuple versions . /* * Look for match on " ON constraint_name " variant , which may not be * unique constraint . This can only be a constraint name . if (indexOidFromConstraint == idxForm->indexrelid)if (idxForm->indisexclusion && onconflict->action == ONCONFLICT_UPDATE)"ON CONFLICT DO UPDATE not supported with exclusion constraints" )));return results;else if (indexOidFromConstraint != InvalidOid)/* No point in further work for index in named constraint case */ goto next;/* * Only considering conventional inference at this point ( not named * constraints ) , so index under consideration can be immediately * skipped if it ' s not unique if (!idxForm->indisunique)goto next;/* * So - called unique constraints with WITHOUT OVERLAPS are really * exclusion constraints , so skip those too . if (idxForm->indisexclusion)goto next;/* Build BMS representation of plain (non expression) index attrs */ for (natt = 0 ; natt < idxForm->indnkeyatts; natt++)int attno = idxRel->rd_index->indkey.values[natt];if (attno != 0 )/* Non-expression attributes (if any) must match */ if (!bms_equal(indexedAttrs, inferAttrs))goto next;/* Expression attributes (if any) must match */ if (idxExprs && varno != 1 )1 , varno, 0 );/* * Ensure that collation / opclass aspects of inference expression * element match . Even though this loop is primarily concerned * with matching expressions , it is a convenient point to check * this for both expressions and ordinary ( non - expression ) * attributes appearing as inference elements . if (!infer_collation_opclass_match(elem, idxRel, idxExprs))goto next;/* * Plain Vars don ' t factor into count of expression elements , and * the question of whether or not they satisfy the index * definition has already been considered ( they must ) . if (IsA(elem->expr, Var))continue ;/* * Might as well avoid redundant check in the rare cases where * infer_collation_opclass_match ( ) is required to do real work . * Otherwise , check that element expression appears in cataloged * index definition . if (elem->infercollid != InvalidOid ||continue ;goto next;/* * Now that all inference elements were matched , ensure that the * expression elements from inference clause are not missing any * cataloged expressions . This does the right thing when unique * indexes redundantly repeat the same attribute , or if attributes * redundantly appear multiple times within an inference clause . if (list_difference(idxExprs, inferElems) != NIL)goto next;/* * If it ' s a partial index , its predicate must be implied by the ON * CONFLICT ' s WHERE clause . if (predExprs && varno != 1 )1 , varno, 0 );if (!predicate_implied_by(predExprs, (List *) onconflict->arbiterWhere, false ))goto next;if (results == NIL)"there is no unique or exclusion constraint matching the ON CONFLICT specification" )));return results;/* * infer_collation_opclass_match - ensure infer element opclass / collation match * * Given unique index inference element from inference specification , if * collation was specified , or if opclass was specified , verify that there is * at least one matching indexed attribute ( occasionally , there may be more ) . * Skip this in the common case where inference specification does not include * collation or opclass ( instead matching everything , regardless of cataloged * collation / opclass of indexed attribute ) . * * At least historically , Postgres has not offered collations or opclasses * with alternative - to - default notions of equality , so these additional * criteria should only be required infrequently . * * Don ' t give up immediately when an inference element matches some attribute * cataloged as indexed but not matching additional opclass / collation * criteria . This is done so that the implementation is as forgiving as * possible of redundancy within cataloged index attributes ( or , less * usefully , within inference specification elements ) . If collations actually * differ between apparently redundantly indexed attributes ( redundant within * or across indexes ) , then there really is no redundancy as such . * * Note that if an inference element specifies an opclass and a collation at * once , both must match in at least one particular attribute within index * catalog definition in order for that inference element to be considered * inferred / satisfied . static bool /* OID of opclass opfamily */ /* OID of opclass input type */ int nplain = 0 ; /* # plain attrs observed */ /* * If inference specification element lacks collation / opclass , then no * need to check for exact match . if (elem->infercollid == InvalidOid && elem->inferopclass == InvalidOid)return true ;/* * Lookup opfamily and input type , for matching indexes if (elem->inferopclass)for (natt = 1 ; natt <= idxRel->rd_att->natts; natt++)1 ];1 ];1 ];int attno = idxRel->rd_index->indkey.values[natt - 1 ];if (attno != 0 )if (elem->inferopclass != InvalidOid &&/* Attribute needed to match opclass, but didn't */ continue ;if (elem->infercollid != InvalidOid &&/* Attribute needed to match collation, but didn't */ continue ;/* If one matching index att found, good enough -- return true */ if (IsA(elem->expr, Var))if (((Var *) elem->expr)->varattno == attno)return true ;else if (attno == 0 )1 ) - nplain);/* * Note that unlike routines like match_index_to_operand ( ) we * don ' t need to care about RelabelType . Neither the index * definition nor the inference clause should contain them . if (equal(elem->expr, nattExpr))return true ;return false ;/* * estimate_rel_size - estimate # pages and # tuples in a table or index * * We also estimate the fraction of the pages that are marked all - visible in * the visibility map , for use in estimation of index - only scans . * * If attr_widths isn ' t NULL , it points to the zero - index entry of the * relation ' s attr_widths [ ] cache ; we fill this in if we have need to compute * the attribute widths for estimation purposes . void double *tuples, double *allvisfrac)double reltuples;double density;if (RELKIND_HAS_TABLE_AM(rel->rd_rel->relkind))else if (rel->rd_rel->relkind == RELKIND_INDEX)/* * XXX : It ' d probably be good to move this into a callback , individual * index types e . g . know if they have a metapage . /* it has storage, ok to call the smgr */ /* report estimated # pages */ /* quick exit if rel is clearly empty */ if (curpages == 0 )0 ;0 ;return ;/* coerce values in pg_class to more desirable types */ double ) rel->rd_rel->reltuples;/* * Discount the metapage while estimating the number of tuples . This * is a kluge because it assumes more than it ought to about index * structure . Currently it ' s OK for btree , hash , and GIN indexes but * suspect for GiST indexes . if (relpages > 0 )/* estimate number of tuples from previous tuple density */ if (reltuples >= 0 && relpages > 0 )double ) relpages;else /* * If we have no data because the relation was never vacuumed , * estimate tuple width from attribute datatypes . We assume here * that the pages are completely full , which is OK for tables * ( since they ' ve presumably not been VACUUMed yet ) but is * probably an overestimate for indexes . Fortunately * get_relation_info ( ) can clamp the overestimate to the parent * table ' s size . * * Note : this code intentionally disregards alignment * considerations , because ( a ) that would be gilding the lily * considering how crude the estimate is , and ( b ) it creates * platform dependencies in the default plans which are kind of a * headache for regression testing . * * XXX : Should this logic be more index specific ? sizeof (ItemIdData);/* note: integer division is intentional here */ double ) curpages);/* * We use relallvisible as - is , rather than scaling it up like we do * for the pages and tuples counts , on the theory that any pages added * since the last VACUUM are most likely not marked all - visible . But * costsize . c wants it converted to a fraction . if (relallvisible == 0 || curpages <= 0 )0 ;else if ((double ) relallvisible >= curpages)1 ;else double ) relallvisible / curpages;else /* * Just use whatever ' s in pg_class . This covers foreign tables , * sequences , and also relkinds without storage ( shouldn ' t get here ? ) ; * see initializations in AddNewRelationTuple ( ) . Note that FDW must * cope if reltuples is - 1 ! 0 ;/* * get_rel_data_width * * Estimate the average width of ( the data part of ) the relation ' s tuples . * * If attr_widths isn ' t NULL , it points to the zero - index entry of the * relation ' s attr_widths [ ] cache ; use and update that cache as appropriate . * * Currently we ignore dropped columns . Ideally those should be included * in the result , but we haven ' t got any way to get info about them ; and * since they might be mostly NULLs , treating them as zero - width is not * necessarily the wrong thing anyway . 0 ;int i;for (i = 1 ; i <= RelationGetNumberOfAttributes(rel); i++)1 );if (att->attisdropped)continue ;/* use previously cached data, if any */ if (attr_widths != NULL && attr_widths[i] > 0 )continue ;/* This should match set_rel_width() in costsize.c */ if (item_width <= 0 )0 );if (attr_widths != NULL)return clamp_width_est(tuple_width);/* * get_relation_data_width * * External API for get_rel_data_width : same behavior except we have to * open the relcache entry . /* As above, assume relation is already locked */ return result;/* * get_relation_constraints * * Retrieve the applicable constraint expressions of the given relation . * Only constraints that have been validated are considered . * * Returns a List ( possibly empty ) of constraint expressions . Each one * has been canonicalized , and its Vars are changed to have the varno * indicated by rel - > relid . This allows the expressions to be easily * compared to expressions taken from WHERE . * * If include_noinherit is true , it ' s okay to include constraints that * are marked NO INHERIT . * * If include_notnull is true , " col IS NOT NULL " expressions are generated * and added to the result for each column that ' s marked attnotnull . * * If include_partition is true , and the relation is a partition , * also include the partitioning constraints . * * Note : at present this is invoked at most once per relation per planner * run , and in many cases it won ' t be invoked at all , so there seems no * point in caching the data in RelOptInfo . static List *bool include_noinherit,bool include_notnull,bool include_partition)/* * We assume the relation has already been safely locked . if (constr != NULL)int num_check = constr->num_check;int i;for (i = 0 ; i < num_check; i++)/* * If this constraint hasn ' t been fully validated yet , we must * ignore it here . if (!constr->check[i].ccvalid)continue ;/* * NOT ENFORCED constraints are always marked as invalid , which * should have been ignored . /* * Also ignore if NO INHERIT and we weren ' t told that that ' s safe . if (constr->check[i].ccnoinherit && !include_noinherit)continue ;/* * Run each expression through const - simplification and * canonicalization . This is not just an optimization , but is * necessary , because we will be comparing it to * similarly - processed qual clauses , and may fail to detect valid * matches without this . This must match the processing done to * qual clauses in preprocess_expression ( ) ! ( We can skip the * stuff involving subqueries , however , since we don ' t allow any * in check constraints . ) true );/* Fix Vars to have the desired varno */ if (varno != 1 )1 , varno, 0 );/* * Finally , convert to implicit - AND format ( that is , a List ) and * append the resulting item ( s ) to our output list . /* Add NOT NULL constraints in expression form, if requested */ if (include_notnull && constr->has_not_null)int natts = relation->rd_att->natts;for (i = 1 ; i <= natts; i++)1 );if (att->attnullability == ATTNULLABLE_VALID && !att->attisdropped)1 );0 );/* * argisrow = false is correct even for a composite column , * because attnotnull does not represent a SQL - spec IS NOT * NULL test in such a case , just IS DISTINCT FROM NULL . false ;1 ;/* * Add partitioning constraints , if requested . if (include_partition && relation->rd_rel->relispartition)/* make sure rel->partition_qual is set */ /* * Expand virtual generated columns in the constraint expressions . if (result)return result;/* * Try loading data for the statistics object . * * We don ' t know if the data ( specified by statOid and inh value ) exist . * The result is stored in stainfos list . static void bool inh,if (!HeapTupleIsValid(dtup))return ;/* add one StatisticExtInfo for each kind built */ if (statext_is_kind_built(dtup, STATS_EXT_NDISTINCT))if (statext_is_kind_built(dtup, STATS_EXT_DEPENDENCIES))if (statext_is_kind_built(dtup, STATS_EXT_MCV))if (statext_is_kind_built(dtup, STATS_EXT_EXPRESSIONS))/* * get_relation_statistics * Retrieve extended statistics defined on the table . * * Returns a List ( possibly empty ) of StatisticExtInfo objects describing * the statistics . Note that this doesn ' t load the actual statistics data , * just the identifying metadata . Only stats actually built are considered . static List *int i;if (!HeapTupleIsValid(htup))"cache lookup failed for statistics object %u" , statOid);/* * First , build the array of columns covered . This is ultimately * wasted if no stats within the object have actually been built , but * it doesn ' t seem worth troubling over that case . for (i = 0 ; i < staForm->stxkeys.dim1; i++)/* * Preprocess expressions ( if any ) . We read the expressions , run them * through eval_const_expressions , and fix the varnos . * * XXX We don ' t know yet if there are any data for this stats object , * with either stxdinherit value . But it ' s reasonable to assume there * is at least one of those , possibly both . So it ' s better to process * keys and expressions here . bool isnull;/* decode expression (if any) */ if (!isnull)char *exprsString;/* * Run the expressions through eval_const_expressions . This is * not just an optimization , but is necessary , because the * planner will be comparing them to similarly - processed qual * clauses , and may fail to detect valid matches without this . * We must not use canonicalize_qual , however , since these * aren ' t qual expressions . /* May as well fix opfuncids too */ /* * Modify the copies we obtain from the relcache to have the * correct varno for the parent relation , so that they match * up correctly against qual clauses . if (varno != 1 )1 , varno, 0 );/* extract statistics for possible values of stxdinherit flag */ true , keys, exprs);false , keys, exprs);return stainfos;/* * relation_excluded_by_constraints * * Detect whether the relation need not be scanned because it has either * self - inconsistent restrictions , or restrictions inconsistent with the * relation ' s applicable constraints . * * Note : this examines only rel - > relid , rel - > reloptkind , and * rel - > baserestrictinfo ; therefore it can be called before filling in * other fields of the RelOptInfo . bool bool include_noinherit;bool include_notnull;bool include_partition = false ;/* As of now, constraint exclusion works only with simple relations. */ /* * If there are no base restriction clauses , we have no hope of proving * anything below , so fall out quickly . if (rel->baserestrictinfo == NIL)return false ;/* * Regardless of the setting of constraint_exclusion , detect * constant - FALSE - or - NULL restriction clauses . Although const - folding * will reduce " anything AND FALSE " to just " FALSE " , the baserestrictinfo * list can still have other members besides the FALSE constant , due to * qual pushdown and other mechanisms ; so check them all . This doesn ' t * fire very often , but it seems cheap enough to be worth doing anyway . * ( Without this , we ' d miss some optimizations that 9 . 5 and earlier found * via much more roundabout methods . ) if (clause && IsA(clause, Const ) &&Const *) clause)->constisnull ||Const *) clause)->constvalue)))return true ;/* * Skip further tests , depending on constraint_exclusion . switch (constraint_exclusion)case CONSTRAINT_EXCLUSION_OFF:/* In 'off' mode, never make any further tests */ return false ;case CONSTRAINT_EXCLUSION_PARTITION:/* * When constraint_exclusion is set to ' partition ' we only handle * appendrel members . Partition pruning has already been applied , * so there is no need to consider the rel ' s partition constraints * here . if (rel->reloptkind == RELOPT_OTHER_MEMBER_REL)break ; /* appendrel member, so process it */ return false ;case CONSTRAINT_EXCLUSION_ON:/* * In ' on ' mode , always apply constraint exclusion . If we are * considering a baserel that is a partition ( i . e . , it was * directly named rather than expanded from a parent table ) , then * its partition constraints haven ' t been considered yet , so * include them in the processing here . if (rel->reloptkind == RELOPT_BASEREL)true ;break ; /* always try to exclude */ /* * Check for self - contradictory restriction clauses . We dare not make * deductions with non - immutable functions , but any immutable clauses that * are self - contradictory allow us to conclude the scan is unnecessary . * * Note : strip off RestrictInfo because predicate_refuted_by ( ) isn ' t * expecting to see any in its predicate argument . if (!contain_mutable_functions((Node *) rinfo->clause))/* * We can use weak refutation here , since we ' re comparing restriction * clauses with restriction clauses . if (predicate_refuted_by(safe_restrictions, safe_restrictions, true ))return true ;/* * Only plain relations have constraints , so stop here for other rtekinds . if (rte->rtekind != RTE_RELATION)return false ;/* * If we are scanning just this table , we can use NO INHERIT constraints , * but not if we ' re scanning its children too . ( Note that partitioned * tables should never have NO INHERIT constraints ; but it ' s not necessary * for us to assume that here . ) /* * Currently , attnotnull constraints must be treated as NO INHERIT unless * this is a partitioned table . In future we might track their * inheritance status more accurately , allowing this to be refined . * * XXX do we need / want to change this ? /* * Fetch the appropriate set of constraint expressions . /* * We do not currently enforce that CHECK constraints contain only * immutable functions , so it ' s necessary to check here . We daren ' t draw * conclusions from plan - time evaluation of non - immutable functions . Since * they ' re ANDed , we can just ignore any mutable constraints in the list , * and reason about the rest . if (!contain_mutable_functions(pred))/* * The constraints are effectively ANDed together , so we can just try to * refute the entire collection at once . This may allow us to make proofs * that would fail if we took them individually . * * Note : we use rel - > baserestrictinfo , not safe_restrictions as might seem * an obvious optimization . Some of the clauses might be OR clauses that * have volatile and nonvolatile subclauses , and it ' s OK to make * deductions with the nonvolatile parts . * * We need strong refutation because we have to prove that the constraints * would yield false , not just NULL . if (predicate_refuted_by(safe_constraints, rel->baserestrictinfo, false ))return true ;return false ;/* * build_physical_tlist * * Build a targetlist consisting of exactly the relation ' s user attributes , * in order . The executor can special - case such tlists to avoid a projection * step at runtime , so we use such tlists preferentially for scan nodes . * * Exception : if there are any dropped or missing columns , we punt and return * NIL . Ideally we would like to handle these cases too . However this * creates problems for ExecTypeFromTL , which may be asked to build a tupdesc * for a tlist that includes vars of no - longer - existent types . In theory we * could dig out the required info from the pg_attribute entries of the * relation , but that data is not readily available to ExecTypeFromTL . * For now , we don ' t apply the physical - tlist optimization when there are * dropped cols . * * We also support building a " physical " tlist for subqueries , functions , * values lists , table expressions , and CTEs , since the same optimization can * occur in SubqueryScan , FunctionScan , ValuesScan , CteScan , TableFunc , * NamedTuplestoreScan , and WorkTableScan nodes . int attrno,switch (rte->rtekind)case RTE_RELATION:/* Assume we already have adequate lock */ for (attrno = 1 ; attrno <= numattrs; attrno++)1 );if (att_tup->attisdropped || att_tup->atthasmissing)/* found a dropped or missing col, so punt */ break ;0 );false ));break ;case RTE_SUBQUERY:/* * A resjunk column of the subquery can be reflected as * resjunk in the physical tlist ; we need not punt . break ;case RTE_FUNCTION:case RTE_TABLEFUNC:case RTE_VALUES:case RTE_CTE:case RTE_NAMEDTUPLESTORE:case RTE_RESULT:/* Not all of these can have dropped cols, but share code anyway */ 0 , VAR_RETURNING_DEFAULT, -1 ,true /* include dropped */ , NULL, &colvars); /* * A non - Var in expandRTE ' s output means a dropped column ; * must punt . if (!IsA(var, Var))break ;false ));break ;default :/* caller error */ "unsupported RTE kind %d in build_physical_tlist" ,int ) rte->rtekind);break ;return tlist;/* * build_index_tlist * * Build a targetlist representing the columns of the specified index . * Each column is represented by a Var for the corresponding base - relation * column , or an expression in base - relation Vars , as appropriate . * * There are never any dropped columns in indexes , so unlike * build_physical_tlist , we need no failure case . static List *int i;for (i = 0 ; i < index->ncolumns; i++)int indexkey = index->indexkeys[i];if (indexkey != 0 )/* simple column */ const FormData_pg_attribute *att_tup;if (indexkey < 0 )else 1 );0 );else /* expression column */ if (indexpr_item == NULL)"wrong number of index expressions" );1 ,false ));if (indexpr_item != NULL)"wrong number of index expressions" );return tlist;/* * restriction_selectivity * * Returns the selectivity of a specified restriction operator clause . * This code executes registered procedures stored in the * operator relation , by calling the function manager . * * See clause_selectivity ( ) for the meaning of the additional parameters . int varRelid)/* * if the oprrest procedure is missing for whatever reason , use a * selectivity of 0 . 5 if (!oprrest)return (Selectivity) 0 .5 ;if (result < 0 .0 || result > 1 .0 )"invalid restriction selectivity: %f" , result);return (Selectivity) result;/* * join_selectivity * * Returns the selectivity of a specified join operator clause . * This code executes registered procedures stored in the * operator relation , by calling the function manager . * * See clause_selectivity ( ) for the meaning of the additional parameters . /* * if the oprjoin procedure is missing for whatever reason , use a * selectivity of 0 . 5 if (!oprjoin)return (Selectivity) 0 .5 ;if (result < 0 .0 || result > 1 .0 )"invalid join selectivity: %f" , result);return (Selectivity) result;/* * function_selectivity * * Returns the selectivity of a specified boolean function clause . * This code executes registered procedures stored in the * pg_proc relation , by calling the function manager . * * See clause_selectivity ( ) for the meaning of the additional parameters . bool is_join,int varRelid,/* * If no support function is provided , use our historical default * estimate , 0 . 3333333 . This seems a pretty unprincipled choice , but * Postgres has been using that estimate for function calls since 1992 . * The hoariness of this behavior suggests that we should not be in too * much hurry to use another value . if (!prosupport)return (Selectivity) 0 .3333333 ;1 ; /* to catch failure to set the value */ /* If support function fails, use default */ if (sresult != &req)return (Selectivity) 0 .3333333 ;if (req.selectivity < 0 .0 || req.selectivity > 1 .0 )"invalid function selectivity: %f" , req.selectivity);return (Selectivity) req.selectivity;/* * add_function_cost * * Get an estimate of the execution cost of a function , and * add * it to * the contents of * cost . The estimate may include both one - time and * per - tuple components , since QualCost does . * * The funcid must always be supplied . If it is being called as the * implementation of a specific parsetree node ( FuncExpr , OpExpr , * WindowFunc , etc ) , pass that as " node " , else pass NULL . * * In some usages root might be NULL , too . void if (!HeapTupleIsValid(proctup))"cache lookup failed for function %u" , funcid);if (OidIsValid(procform->prosupport))/* Initialize cost fields so that support function doesn't have to */ 0 ;0 ;if (sresult == &req)/* Success, so accumulate support function's estimate into *cost */ return ;/* No support function, or it failed, so rely on procost */ /* * get_function_rows * * Get an estimate of the number of rows returned by a set - returning function . * * The funcid must always be supplied . In current usage , the calling node * will always be supplied , and will be either a FuncExpr or OpExpr . * But it ' s a good idea to not fail if it ' s NULL . * * In some usages root might be NULL , too . * * Note : this returns the unfiltered result of the support function , if any . * It ' s usually a good idea to apply clamp_row_est ( ) to the result , but we * leave it to the caller to do so . double double result;if (!HeapTupleIsValid(proctup))"cache lookup failed for function %u" , funcid);/* else caller error */ if (OidIsValid(procform->prosupport))0 ; /* just for sanity */ if (sresult == &req)/* Success */ return req.rows;/* No support function, or it failed, so rely on prorows */ return result;/* * has_unique_index * * Detect whether there is a unique index on the specified attribute * of the specified relation , thus allowing us to conclude that all * the ( non - null ) values of the attribute are distinct . * * This function does not check the index ' s indimmediate property , which * means that uniqueness may transiently fail to hold intra - transaction . * That ' s appropriate when we are making statistical estimates , but beware * of using this for any correctness proofs . bool /* * Note : ignore partial indexes , since they don ' t allow us to conclude * that all attr values are distinct , * unless * they are marked predOK * which means we know the index ' s predicate is satisfied by the * query . We don ' t take any interest in expressional indexes either . * Also , a multicolumn unique index doesn ' t allow us to conclude that * just the specified attr is unique . if (index->unique &&1 &&0 ] == attno &&return true ;return false ;/* * has_row_triggers * * Detect whether the specified relation has any row - level triggers for event . bool bool result = false ;/* Assume we already have adequate lock */ switch (event)case CMD_INSERT:if (trigDesc &&true ;break ;case CMD_UPDATE:if (trigDesc &&true ;break ;case CMD_DELETE:if (trigDesc &&true ;break ;/* There is no separate event for MERGE, only INSERT/UPDATE/DELETE */ case CMD_MERGE:false ;break ;default :"unrecognized CmdType: %d" , (int ) event);break ;return result;/* * has_transition_tables * * Detect whether the specified relation has any transition tables for event . bool bool result = false ;/* Currently foreign tables cannot have transition tables */ if (rte->relkind == RELKIND_FOREIGN_TABLE)return result;/* Assume we already have adequate lock */ switch (event)case CMD_INSERT:if (trigDesc &&true ;break ;case CMD_UPDATE:if (trigDesc &&true ;break ;case CMD_DELETE:if (trigDesc &&true ;break ;/* There is no separate event for MERGE, only INSERT/UPDATE/DELETE */ case CMD_MERGE:false ;break ;default :"unrecognized CmdType: %d" , (int ) event);break ;return result;/* * has_stored_generated_columns * * Does table identified by RTI have any STORED GENERATED columns ? bool bool result = false ;/* Assume we already have adequate lock */ return result;/* * get_dependent_generated_columns * * Get the column numbers of any STORED GENERATED columns of the relation * that depend on any column listed in target_cols . Both the input and * result bitmapsets contain column numbers offset by * FirstLowInvalidHeapAttributeNumber . /* Assume we already have adequate lock */ if (constr && constr->has_generated_stored)for (int i = 0 ; i < constr->num_defval; i++)/* skip if not generated column */ if (!TupleDescAttr(tupdesc, defval->adnum - 1 )->attgenerated)continue ;/* identify columns this generated column depends on */ 1 , &attrs_used);if (bms_overlap(target_cols, attrs_used))return dependentCols;/* * set_relation_partition_info * * Set partitioning scheme and related information for a partitioned table . static void /* * Create the PartitionDirectory infrastructure if we didn ' t already . if (root->glob->partition_directory == NULL)true );/* * find_partition_scheme * * Find or create a PartitionScheme for this Relation . static PartitionSchemeint partnatts,/* A partitioned table should have a partition key. */ /* Search for a matching partition scheme and return if found one. */ /* Match partitioning strategy and number of keys. */ if (partkey->strategy != part_scheme->strategy ||continue ;/* Match partition key type properties. */ if (memcmp(partkey->partopfamily, part_scheme->partopfamily,sizeof (Oid) * partnatts) != 0 ||sizeof (Oid) * partnatts) != 0 ||sizeof (Oid) * partnatts) != 0 )continue ;/* * Length and byval information should match when partopcintype * matches . sizeof (int16) * partnatts) == 0 );sizeof (bool ) * partnatts) == 0 );/* * If partopfamily and partopcintype matched , must have the same * partition comparison functions . Note that we cannot reliably * Assert the equality of function structs themselves for they might * be different across PartitionKey ' s , so just Assert for the function * OIDs . #ifdef USE_ASSERT_CHECKINGfor (i = 0 ; i < partkey->partnatts; i++)#endif /* Found matching partition scheme. */ return part_scheme;/* * Did not find matching partition scheme . Create one copying relevant * information from the relcache . We need to copy the contents of the * array since the relcache entry may not survive after we have closed the * relation . sizeof (PartitionSchemeData));sizeof (Oid) * partnatts);sizeof (Oid) * partnatts);sizeof (Oid) * partnatts);sizeof (Oid) * partnatts);sizeof (Oid) * partnatts);sizeof (Oid) * partnatts);sizeof (int16) * partnatts);sizeof (int16) * partnatts);bool *) palloc(sizeof (bool ) * partnatts);sizeof (bool ) * partnatts);sizeof (FmgrInfo) * partnatts);for (i = 0 ; i < partnatts; i++)/* Add the partitioning scheme to PlannerInfo. */ return part_scheme;/* * set_baserel_partition_key_exprs * * Builds partition key expressions for the given base relation and fills * rel - > partexprs . static void int partnatts;int cnt;0 );/* A partitioned table should have a partition key. */ sizeof (List *) * partnatts);for (cnt = 0 ; cnt < partnatts; cnt++)if (attno != InvalidAttrNumber)/* Single column partition key is stored as a Var node. */ 0 );0 );else if (lc == NULL)"wrong number of partition key expressions" );/* Re-stamp the expression with given varno. */ 1 , varno, 0 );/* Base relations have a single expression per key. */ /* * A base relation does not have nullable partition key expressions , since * no outer join is involved . We still allocate an array of empty * expression lists to keep partition key expression handling code simple . * See build_joinrel_partition_info ( ) and match_expr_to_partition_keys ( ) . sizeof (List *) * partnatts);/* * set_baserel_partition_constraint * * Builds the partition constraint for the given base relation and sets it * in the given RelOptInfo . All Var nodes are restamped with the relid of the * given relation . static void if (rel->partition_qual) /* already done */ return ;/* * Run the partition quals through const - simplification similar to check * constraints . We skip canonicalize_qual , though , because partition * quals should be in canonical form already ; also , since the qual is in * implicit - AND format , we ' d have to explicitly convert it to explicit - AND * format and back again . if (partconstr)if (rel->relid != 1 )1 , rel->relid, 0 );
Messung V0.5 in Prozent C=94 H=94 G=93
¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen0.93Angebot
(Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-08-08)
¤ *Eine klare Vorstellung vom Zielzustand
2026-08-25
Neuigkeiten Aktuelles Motto des Tages Open Source Software
Jenseits des Üblichen ....
Besucherstatistik
Statistik #Sources=141584 #Domains=752002
