Load FK defs into relcache for use by planner

Fastpath ignores this if no triggers defined.

Author: Tomas Vondra, with fastpath and comments added by me
Reviewers: David Rowley, Simon Riggs

diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index e39c374f48c621cc7088e4d2dd1130b7c4dbef3a..f783a49ebac2129b364f8059f5a61c046e809a5e 100644 (file)
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2137,6 +2137,16 @@ _outIndexOptInfo(StringInfo str, const IndexOptInfo *node)
    /* we don't bother with fields copied from the index AM's API struct */
 }
 
+static void
+_outForeignKeyOptInfo(StringInfo str, const ForeignKeyOptInfo *node)
+{
+   WRITE_NODE_TYPE("FOREIGNKEYOPTINFO");
+
+   WRITE_OID_FIELD(conrelid);
+   WRITE_OID_FIELD(confrelid);
+   WRITE_INT_FIELD(nkeys);
+}
+
 static void
 _outEquivalenceClass(StringInfo str, const EquivalenceClass *node)
 {
@@ -3607,6 +3617,9 @@ _outNode(StringInfo str, const void *obj)
            case T_IndexOptInfo:
                _outIndexOptInfo(str, obj);
                break;
+           case T_ForeignKeyOptInfo:
+               _outForeignKeyOptInfo(str, obj);
+               break;
            case T_EquivalenceClass:
                _outEquivalenceClass(str, obj);
                break;

diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c
index 5bdeac0df64af14ec5c50586a9c536ad29fe862c..0f291275dcc08eb2358b3de91df8765f45906286 100644 (file)
--- a/src/backend/optimizer/util/plancat.c
+++ b/src/backend/optimizer/util/plancat.c
@@ -28,6 +28,7 @@
 #include "catalog/dependency.h"
 #include "catalog/heap.h"
 #include "catalog/pg_am.h"
+#include "catalog/pg_constraint.h"
 #include "foreign/fdwapi.h"
 #include "miscadmin.h"
 #include "nodes/makefuncs.h"
@@ -41,6 +42,7 @@
 #include "rewrite/rewriteManip.h"
 #include "storage/bufmgr.h"
 #include "utils/lsyscache.h"
+#include "utils/syscache.h"
 #include "utils/rel.h"
 #include "utils/snapmgr.h"
 
@@ -94,6 +96,9 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
    Relation    relation;
    bool        hasindex;
    List       *indexinfos = NIL;
+   List       *fkinfos = NIL;
+   List       *fkoidlist;
+   ListCell   *l;
 
    /*
     * We need not lock the relation since it was already locked, either by
@@ -141,7 +146,6 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
    if (hasindex)
    {
        List       *indexoidlist;
-       ListCell   *l;
        LOCKMODE    lmode;
 
        indexoidlist = RelationGetIndexList(relation);
@@ -388,6 +392,85 @@ get_relation_info(PlannerInfo *root, Oid relationObjectId, bool inhparent,
 
    rel->indexlist = indexinfos;
 
+   /*
+    * Load foreign key data. Note this is the definitional data from the
+    * catalog only and does not lock the referenced tables here. The
+    * precise definition of the FK is important and may affect the usage
+    * elsewhere in the planner, e.g. if the constraint is deferred or
+    * if the constraint is not valid then relying upon this in the executor
+    * may not be accurate, though might be considered a useful estimate for
+    * planning purposes.
+    */
+   fkoidlist = RelationGetFKeyList(relation);
+
+   foreach(l, fkoidlist)
+   {
+       int         i;
+       ArrayType  *arr;
+       Datum       adatum;
+       bool        isnull;
+       int         numkeys;
+       Oid         fkoid = lfirst_oid(l);
+
+       HeapTuple   htup = SearchSysCache1(CONSTROID, ObjectIdGetDatum(fkoid));
+       Form_pg_constraint constraint = (Form_pg_constraint) GETSTRUCT(htup);
+
+       ForeignKeyOptInfo *info;
+
+       Assert(constraint->contype == CONSTRAINT_FOREIGN);
+
+       info = makeNode(ForeignKeyOptInfo);
+
+       info->conrelid = constraint->conrelid;
+       info->confrelid = constraint->confrelid;
+
+       /* conkey */
+       adatum = SysCacheGetAttr(CONSTROID, htup,
+                                   Anum_pg_constraint_conkey, &isnull);
+       Assert(!isnull);
+
+       arr = DatumGetArrayTypeP(adatum);
+       numkeys = ARR_DIMS(arr)[0];
+       info->conkeys = (int*)palloc0(numkeys * sizeof(int));
+
+       for (i = 0; i < numkeys; i++)
+           info->conkeys[i] = ((int16 *) ARR_DATA_PTR(arr))[i];
+
+       /* confkey */
+       adatum = SysCacheGetAttr(CONSTROID, htup,
+                                   Anum_pg_constraint_confkey, &isnull);
+       Assert(!isnull);
+
+       arr = DatumGetArrayTypeP(adatum);
+       numkeys = ARR_DIMS(arr)[0];
+       info->confkeys = (int*)palloc0(numkeys * sizeof(int));
+
+       for (i = 0; i < numkeys; i++)
+           info->confkeys[i] = ((int16 *) ARR_DATA_PTR(arr))[i];
+
+       /* conpfeqop */
+       adatum = SysCacheGetAttr(CONSTROID, htup,
+                                   Anum_pg_constraint_conpfeqop, &isnull);
+       Assert(!isnull);
+
+       arr = DatumGetArrayTypeP(adatum);
+       numkeys = ARR_DIMS(arr)[0];
+       info->conpfeqop = (Oid*)palloc0(numkeys * sizeof(Oid));
+
+       for (i = 0; i < numkeys; i++)
+           info->conpfeqop[i] = ((Oid *) ARR_DATA_PTR(arr))[i];
+
+       info->nkeys = numkeys;
+
+       ReleaseSysCache(htup);
+
+       fkinfos = lcons(info, fkinfos);
+   }
+
+   list_free(fkoidlist);
+
+   rel->fkeylist = fkinfos;
+
    /* Grab foreign-table info using the relcache, while we have it */
    if (relation->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
    {

diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
index 130c06d81c8a921076642afa94170008923d9cb8..432feefa6094593ba934a7da68f24e959748b90f 100644 (file)
--- a/src/backend/utils/cache/relcache.c
+++ b/src/backend/utils/cache/relcache.c
@@ -2031,6 +2031,7 @@ RelationDestroyRelation(Relation relation, bool remember_tupdesc)
            FreeTupleDesc(relation->rd_att);
    }
    list_free(relation->rd_indexlist);
+   list_free(relation->rd_fkeylist);
    bms_free(relation->rd_indexattr);
    bms_free(relation->rd_keyattr);
    bms_free(relation->rd_idattr);
@@ -3956,6 +3957,79 @@ RelationGetIndexList(Relation relation)
    return result;
 }
 
+/*
+ * RelationGetFKeyList -- get a list of foreign key oids
+ *
+ * Use an index scan on pg_constraint to load in FK definitions,
+ * intended for use within the planner, not for enforcing FKs.
+ *
+ * Data is ordered by Oid, though this is not critical at this point
+ * since we do not lock the referenced relations.
+ */
+List *
+RelationGetFKeyList(Relation relation)
+{
+   Relation    conrel;
+   SysScanDesc conscan;
+   ScanKeyData skey;
+   HeapTuple   htup;
+   List       *result;
+   List       *oldlist;
+   MemoryContext oldcxt;
+
+   /* Quick exit if we already computed the list. */
+   if (relation->rd_fkeylist)
+       return list_copy(relation->rd_fkeylist);
+
+   /* Fast path if no FKs... if it doesn't have a trigger, it can't have a FK */
+   if (!relation->rd_rel->relhastriggers)
+       return NIL;
+   /*
+    * We build the list we intend to return (in the caller's context) while
+    * doing the scan.  After successfully completing the scan, we copy that
+    * list into the relcache entry.  This avoids cache-context memory leakage
+    * if we get some sort of error partway through.
+    */
+   result = NIL;
+
+   /* Prepare to scan pg_constraint for entries having conrelid = this rel. */
+   ScanKeyInit(&skey,
+               Anum_pg_constraint_conrelid,
+               BTEqualStrategyNumber, F_OIDEQ,
+               ObjectIdGetDatum(RelationGetRelid(relation)));
+
+   conrel = heap_open(ConstraintRelationId, AccessShareLock);
+   conscan = systable_beginscan(conrel, ConstraintRelidIndexId, true,
+                                NULL, 1, &skey);
+
+   while (HeapTupleIsValid(htup = systable_getnext(conscan)))
+   {
+       Form_pg_constraint constraint = (Form_pg_constraint) GETSTRUCT(htup);
+
+       /* return only foreign keys */
+       if (constraint->contype != CONSTRAINT_FOREIGN)
+           continue;
+
+       /* Add FK's OID to result list in the proper order */
+       result = insert_ordered_oid(result, HeapTupleGetOid(htup));
+   }
+
+   systable_endscan(conscan);
+
+   heap_close(conrel, AccessShareLock);
+
+   /* Now save a copy of the completed list in the relcache entry. */
+   oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
+   oldlist = relation->rd_fkeylist;
+   relation->rd_fkeylist = list_copy(result);
+   MemoryContextSwitchTo(oldcxt);
+
+   /* Don't leak the old list, if there is one */
+   list_free(oldlist);
+
+   return result;
+}
+
 /*
  * insert_ordered_oid
  *     Insert a new Oid into a sorted list of Oids, preserving ordering
@@ -4920,6 +4994,7 @@ load_relcache_init_file(bool shared)
        rel->rd_indexattr = NULL;
        rel->rd_keyattr = NULL;
        rel->rd_idattr = NULL;
+       rel->rd_fkeylist = NIL;
        rel->rd_createSubid = InvalidSubTransactionId;
        rel->rd_newRelfilenodeSubid = InvalidSubTransactionId;
        rel->rd_amcache = NULL;

diff --git a/src/include/nodes/nodes.h b/src/include/nodes/nodes.h
index 3f22bdb5a8a188464d83b48d1ef248b070fd394b..84efa8e886d266b7352c2803c105a6e23298867d 100644 (file)
--- a/src/include/nodes/nodes.h
+++ b/src/include/nodes/nodes.h
@@ -223,6 +223,7 @@ typedef enum NodeTag
    T_PlannerGlobal,
    T_RelOptInfo,
    T_IndexOptInfo,
+   T_ForeignKeyOptInfo,
    T_ParamPathInfo,
    T_Path,
    T_IndexPath,

diff --git a/src/include/nodes/relation.h b/src/include/nodes/relation.h
index 5264d3cc76ddd3de71f68c9d3c82b314143cd66c..d430f6e9fd4774787cfbb224c40c6e3a7475ac68 100644 (file)
--- a/src/include/nodes/relation.h
+++ b/src/include/nodes/relation.h
@@ -516,6 +516,7 @@ typedef struct RelOptInfo
    List       *lateral_vars;   /* LATERAL Vars and PHVs referenced by rel */
    Relids      lateral_referencers;    /* rels that reference me laterally */
    List       *indexlist;      /* list of IndexOptInfo */
+   List       *fkeylist;           /* list of ForeignKeyOptInfo */
    BlockNumber pages;          /* size estimates derived from pg_class */
    double      tuples;
    double      allvisfrac;
@@ -621,6 +622,27 @@ typedef struct IndexOptInfo
    void        (*amcostestimate) ();   /* AM's cost estimator */
 } IndexOptInfo;
 
+/*
+ * ForeignKeyOptInfo
+ *     Per-foreign-key information for planning/optimization
+ *
+ * Only includes columns from pg_constraint related to foreign keys.
+ *
+ * conkeys[], confkeys[] and conpfeqop[] each have nkeys entries.
+ */
+typedef struct ForeignKeyOptInfo
+{
+   NodeTag     type;
+
+   Oid         conrelid;   /* relation constrained by the foreign key */
+   Oid         confrelid;  /* relation referenced by the foreign key */
+
+   int         nkeys;      /* number of columns in the foreign key */
+   int        *conkeys;    /* attnums of columns in the constrained table */
+   int        *confkeys;   /* attnums of columns in the referenced table */
+   Oid        *conpfeqop;  /* OIDs of equality operators used by the FK */
+
+} ForeignKeyOptInfo;
 
 /*
  * EquivalenceClasses

diff --git a/src/include/utils/rel.h b/src/include/utils/rel.h
index f2bebf2c3ddb0cdcca1911aa3a1d083e6609fde9..51eb27a381bb16797b75c23871511753c4d9bb58 100644 (file)
--- a/src/include/utils/rel.h
+++ b/src/include/utils/rel.h
@@ -94,6 +94,9 @@ typedef struct RelationData
    Oid         rd_oidindex;    /* OID of unique index on OID, if any */
    Oid         rd_replidindex; /* OID of replica identity index, if any */
 
+   /* data managed by RelationGetFKList: */
+   List       *rd_fkeylist;        /* OIDs of foreign keys */
+
    /* data managed by RelationGetIndexAttrBitmap: */
    Bitmapset  *rd_indexattr;   /* identifies columns used in indexes */
    Bitmapset  *rd_keyattr;     /* cols that can be ref'd by foreign keys */

diff --git a/src/include/utils/relcache.h b/src/include/utils/relcache.h
index 1b4830462d52ba0c3fbfbdd341ee0abd741d631c..7f07c269145b3a76cead7f5efd6755a05d2916c5 100644 (file)
--- a/src/include/utils/relcache.h
+++ b/src/include/utils/relcache.h
@@ -38,6 +38,7 @@ extern void RelationClose(Relation relation);
  * Routines to compute/retrieve additional cached information
  */
 extern List *RelationGetIndexList(Relation relation);
+extern List *RelationGetFKeyList(Relation relation);
 extern Oid RelationGetOidIndex(Relation relation);
 extern Oid RelationGetReplicaIndex(Relation relation);
 extern List *RelationGetIndexExpressions(Relation relation);