shippable.c File Reference

#include "postgres.h"
#include "access/transam.h"
#include "catalog/dependency.h"
#include "postgres_fdw.h"
#include "utils/hsearch.h"
#include "utils/inval.h"
#include "utils/syscache.h"

Include dependency graph for shippable.c:

Go to the source code of this file.

Data Structures
struct	ShippableCacheKey
struct	ShippableCacheEntry

Functions
static void	InvalidateShippableCacheCallback (Datum arg, SysCacheIdentifier cacheid, uint32 hashvalue)
static void	InitializeShippableCache (void)
static bool	lookup_shippable (Oid objectId, Oid classId, PgFdwRelationInfo *fpinfo)
bool	is_builtin (Oid objectId)
bool	is_shippable (Oid objectId, Oid classId, PgFdwRelationInfo *fpinfo)

Variables
static HTAB *	ShippableCacheHash = NULL

Function Documentation

InitializeShippableCache()

static void InitializeShippableCache ( void  )

static

Definition at line 92 of file shippable.c.

{
    HASHCTL     ctl;
 
    /* Create the hash table. */
    ctl.keysize = sizeof(ShippableCacheKey);
    ctl.entrysize = sizeof(ShippableCacheEntry);
    ShippableCacheHash =
        hash_create("Shippability cache", 256, &ctl, HASH_ELEM | HASH_BLOBS);
 
    /* Set up invalidation callback on pg_foreign_server. */
    CacheRegisterSyscacheCallback(FOREIGNSERVEROID,
                                  InvalidateShippableCacheCallback,
                                  (Datum) 0);
}

References CacheRegisterSyscacheCallback(), ctl, fb(), HASH_BLOBS, hash_create(), HASH_ELEM, InvalidateShippableCacheCallback(), HASHCTL::keysize, and ShippableCacheHash.

Referenced by is_shippable().

InvalidateShippableCacheCallback()

static void InvalidateShippableCacheCallback ( Datum  arg, SysCacheIdentifier  cacheid, uint32  hashvalue  )

static

Definition at line 65 of file shippable.c.

{
    HASH_SEQ_STATUS status;
    ShippableCacheEntry *entry;
 
    /*
     * In principle we could flush only cache entries relating to the
     * pg_foreign_server entry being outdated; but that would be more
     * complicated, and it's probably not worth the trouble.  So for now, just
     * flush all entries.
     */
    hash_seq_init(&status, ShippableCacheHash);
    while ((entry = (ShippableCacheEntry *) hash_seq_search(&status)) != NULL)
    {
        if (hash_search(ShippableCacheHash,
                        &entry->key,
                        HASH_REMOVE,
                        NULL) == NULL)
            elog(ERROR, "hash table corrupted");
    }
}

References elog, ERROR, fb(), HASH_REMOVE, hash_search(), hash_seq_init(), hash_seq_search(), ShippableCacheEntry::key, and ShippableCacheHash.

Referenced by InitializeShippableCache().

is_builtin()

bool is_builtin

(

Oid

objectId

)

Definition at line 153 of file shippable.c.

{
    return (objectId < FirstGenbkiObjectId);
}

References FirstGenbkiObjectId.

Referenced by deparse_type_name(), and is_shippable().

is_shippable()

bool is_shippable	(	Oid	objectId,
		Oid	classId,
		PgFdwRelationInfo *	fpinfo
	)

Definition at line 163 of file shippable.c.

{
    ShippableCacheKey key;
    ShippableCacheEntry *entry;
 
    /* Built-in objects are presumed shippable. */
    if (is_builtin(objectId))
        return true;
 
    /* Otherwise, give up if user hasn't specified any shippable extensions. */
    if (fpinfo->shippable_extensions == NIL)
        return false;
 
    /* Initialize cache if first time through. */
    if (!ShippableCacheHash)
        InitializeShippableCache();
 
    /* Set up cache hash key */
    key.objid = objectId;
    key.classid = classId;
    key.serverid = fpinfo->server->serverid;
 
    /* See if we already cached the result. */
    entry = (ShippableCacheEntry *)
        hash_search(ShippableCacheHash, &key, HASH_FIND, NULL);
 
    if (!entry)
    {
        /* Not found in cache, so perform shippability lookup. */
        bool        shippable = lookup_shippable(objectId, classId, fpinfo);
 
        /*
         * Don't create a new hash entry until *after* we have the shippable
         * result in hand, as the underlying catalog lookups might trigger a
         * cache invalidation.
         */
        entry = (ShippableCacheEntry *)
            hash_search(ShippableCacheHash, &key, HASH_ENTER, NULL);
 
        entry->shippable = shippable;
    }
 
    return entry->shippable;
}

References fb(), HASH_ENTER, HASH_FIND, hash_search(), InitializeShippableCache(), is_builtin(), lookup_shippable(), NIL, ShippableCacheEntry::shippable, and ShippableCacheHash.

Referenced by add_foreign_ordered_paths(), foreign_expr_walker(), get_useful_pathkeys_for_relation(), and is_foreign_pathkey().

lookup_shippable()

static bool lookup_shippable ( Oid  objectId, Oid  classId, PgFdwRelationInfo *  fpinfo  )

static

Definition at line 117 of file shippable.c.

{
    Oid         extensionOid;
 
    /*
     * Is object a member of some extension?  (Note: this is a fairly
     * expensive lookup, which is why we try to cache the results.)
     */
    extensionOid = getExtensionOfObject(classId, objectId);
 
    /* If so, is that extension in fpinfo->shippable_extensions? */
    if (OidIsValid(extensionOid) &&
        list_member_oid(fpinfo->shippable_extensions, extensionOid))
        return true;
 
    return false;
}

References fb(), getExtensionOfObject(), list_member_oid(), and OidIsValid.

Referenced by is_shippable().

Variable Documentation

ShippableCacheHash

HTAB* ShippableCacheHash = NULL

static

Definition at line 34 of file shippable.c.

Referenced by InitializeShippableCache(), InvalidateShippableCacheCallback(), and is_shippable().