LCOV - code coverage report
Current view: top level - contrib/postgres_fdw - shippable.c (source / functions) Hit Total Coverage
Test: PostgreSQL 14devel Lines: 37 38 97.4 %
Date: 2021-01-26 02:06:48 Functions: 5 5 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * shippable.c
       4             :  *    Determine which database objects are shippable to a remote server.
       5             :  *
       6             :  * We need to determine whether particular functions, operators, and indeed
       7             :  * data types are shippable to a remote server for execution --- that is,
       8             :  * do they exist and have the same behavior remotely as they do locally?
       9             :  * Built-in objects are generally considered shippable.  Other objects can
      10             :  * be shipped if they are declared as such by the user.
      11             :  *
      12             :  * Note: there are additional filter rules that prevent shipping mutable
      13             :  * functions or functions using nonportable collations.  Those considerations
      14             :  * need not be accounted for here.
      15             :  *
      16             :  * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
      17             :  *
      18             :  * IDENTIFICATION
      19             :  *    contrib/postgres_fdw/shippable.c
      20             :  *
      21             :  *-------------------------------------------------------------------------
      22             :  */
      23             : 
      24             : #include "postgres.h"
      25             : 
      26             : #include "access/transam.h"
      27             : #include "catalog/dependency.h"
      28             : #include "postgres_fdw.h"
      29             : #include "utils/hsearch.h"
      30             : #include "utils/inval.h"
      31             : #include "utils/syscache.h"
      32             : 
      33             : /* Hash table for caching the results of shippability lookups */
      34             : static HTAB *ShippableCacheHash = NULL;
      35             : 
      36             : /*
      37             :  * Hash key for shippability lookups.  We include the FDW server OID because
      38             :  * decisions may differ per-server.  Otherwise, objects are identified by
      39             :  * their (local!) OID and catalog OID.
      40             :  */
      41             : typedef struct
      42             : {
      43             :     /* XXX we assume this struct contains no padding bytes */
      44             :     Oid         objid;          /* function/operator/type OID */
      45             :     Oid         classid;        /* OID of its catalog (pg_proc, etc) */
      46             :     Oid         serverid;       /* FDW server we are concerned with */
      47             : } ShippableCacheKey;
      48             : 
      49             : typedef struct
      50             : {
      51             :     ShippableCacheKey key;      /* hash key - must be first */
      52             :     bool        shippable;
      53             : } ShippableCacheEntry;
      54             : 
      55             : 
      56             : /*
      57             :  * Flush cache entries when pg_foreign_server is updated.
      58             :  *
      59             :  * We do this because of the possibility of ALTER SERVER being used to change
      60             :  * a server's extensions option.  We do not currently bother to check whether
      61             :  * objects' extension membership changes once a shippability decision has been
      62             :  * made for them, however.
      63             :  */
      64             : static void
      65          76 : InvalidateShippableCacheCallback(Datum arg, int cacheid, uint32 hashvalue)
      66             : {
      67             :     HASH_SEQ_STATUS status;
      68             :     ShippableCacheEntry *entry;
      69             : 
      70             :     /*
      71             :      * In principle we could flush only cache entries relating to the
      72             :      * pg_foreign_server entry being outdated; but that would be more
      73             :      * complicated, and it's probably not worth the trouble.  So for now, just
      74             :      * flush all entries.
      75             :      */
      76          76 :     hash_seq_init(&status, ShippableCacheHash);
      77          98 :     while ((entry = (ShippableCacheEntry *) hash_seq_search(&status)) != NULL)
      78             :     {
      79          22 :         if (hash_search(ShippableCacheHash,
      80          22 :                         (void *) &entry->key,
      81             :                         HASH_REMOVE,
      82             :                         NULL) == NULL)
      83           0 :             elog(ERROR, "hash table corrupted");
      84             :     }
      85          76 : }
      86             : 
      87             : /*
      88             :  * Initialize the backend-lifespan cache of shippability decisions.
      89             :  */
      90             : static void
      91           2 : InitializeShippableCache(void)
      92             : {
      93             :     HASHCTL     ctl;
      94             : 
      95             :     /* Create the hash table. */
      96           2 :     ctl.keysize = sizeof(ShippableCacheKey);
      97           2 :     ctl.entrysize = sizeof(ShippableCacheEntry);
      98           2 :     ShippableCacheHash =
      99           2 :         hash_create("Shippability cache", 256, &ctl, HASH_ELEM | HASH_BLOBS);
     100             : 
     101             :     /* Set up invalidation callback on pg_foreign_server. */
     102           2 :     CacheRegisterSyscacheCallback(FOREIGNSERVEROID,
     103             :                                   InvalidateShippableCacheCallback,
     104             :                                   (Datum) 0);
     105           2 : }
     106             : 
     107             : /*
     108             :  * Returns true if given object (operator/function/type) is shippable
     109             :  * according to the server options.
     110             :  *
     111             :  * Right now "shippability" is exclusively a function of whether the object
     112             :  * belongs to an extension declared by the user.  In the future we could
     113             :  * additionally have a list of functions/operators declared one at a time.
     114             :  */
     115             : static bool
     116          22 : lookup_shippable(Oid objectId, Oid classId, PgFdwRelationInfo *fpinfo)
     117             : {
     118             :     Oid         extensionOid;
     119             : 
     120             :     /*
     121             :      * Is object a member of some extension?  (Note: this is a fairly
     122             :      * expensive lookup, which is why we try to cache the results.)
     123             :      */
     124          22 :     extensionOid = getExtensionOfObject(classId, objectId);
     125             : 
     126             :     /* If so, is that extension in fpinfo->shippable_extensions? */
     127          32 :     if (OidIsValid(extensionOid) &&
     128          10 :         list_member_oid(fpinfo->shippable_extensions, extensionOid))
     129          10 :         return true;
     130             : 
     131          12 :     return false;
     132             : }
     133             : 
     134             : /*
     135             :  * Return true if given object is one of PostgreSQL's built-in objects.
     136             :  *
     137             :  * We use FirstGenbkiObjectId as the cutoff, so that we only consider
     138             :  * objects with hand-assigned OIDs to be "built in", not for instance any
     139             :  * function or type defined in the information_schema.
     140             :  *
     141             :  * Our constraints for dealing with types are tighter than they are for
     142             :  * functions or operators: we want to accept only types that are in pg_catalog,
     143             :  * else deparse_type_name might incorrectly fail to schema-qualify their names.
     144             :  * Thus we must exclude information_schema types.
     145             :  *
     146             :  * XXX there is a problem with this, which is that the set of built-in
     147             :  * objects expands over time.  Something that is built-in to us might not
     148             :  * be known to the remote server, if it's of an older version.  But keeping
     149             :  * track of that would be a huge exercise.
     150             :  */
     151             : bool
     152       13284 : is_builtin(Oid objectId)
     153             : {
     154       13284 :     return (objectId < FirstGenbkiObjectId);
     155             : }
     156             : 
     157             : /*
     158             :  * is_shippable
     159             :  *     Is this object (function/operator/type) shippable to foreign server?
     160             :  */
     161             : bool
     162       12422 : is_shippable(Oid objectId, Oid classId, PgFdwRelationInfo *fpinfo)
     163             : {
     164             :     ShippableCacheKey key;
     165             :     ShippableCacheEntry *entry;
     166             : 
     167             :     /* Built-in objects are presumed shippable. */
     168       12422 :     if (is_builtin(objectId))
     169       12296 :         return true;
     170             : 
     171             :     /* Otherwise, give up if user hasn't specified any shippable extensions. */
     172         126 :     if (fpinfo->shippable_extensions == NIL)
     173          42 :         return false;
     174             : 
     175             :     /* Initialize cache if first time through. */
     176          84 :     if (!ShippableCacheHash)
     177           2 :         InitializeShippableCache();
     178             : 
     179             :     /* Set up cache hash key */
     180          84 :     key.objid = objectId;
     181          84 :     key.classid = classId;
     182          84 :     key.serverid = fpinfo->server->serverid;
     183             : 
     184             :     /* See if we already cached the result. */
     185             :     entry = (ShippableCacheEntry *)
     186          84 :         hash_search(ShippableCacheHash,
     187             :                     (void *) &key,
     188             :                     HASH_FIND,
     189             :                     NULL);
     190             : 
     191          84 :     if (!entry)
     192             :     {
     193             :         /* Not found in cache, so perform shippability lookup. */
     194          22 :         bool        shippable = lookup_shippable(objectId, classId, fpinfo);
     195             : 
     196             :         /*
     197             :          * Don't create a new hash entry until *after* we have the shippable
     198             :          * result in hand, as the underlying catalog lookups might trigger a
     199             :          * cache invalidation.
     200             :          */
     201             :         entry = (ShippableCacheEntry *)
     202          22 :             hash_search(ShippableCacheHash,
     203             :                         (void *) &key,
     204             :                         HASH_ENTER,
     205             :                         NULL);
     206             : 
     207          22 :         entry->shippable = shippable;
     208             :     }
     209             : 
     210          84 :     return entry->shippable;
     211             : }

Generated by: LCOV version 1.13