#include "postgres.h"
#include "access/reloptions.h"
#include "catalog/pg_tablespace.h"
#include "commands/tablespace.h"
#include "miscadmin.h"
#include "optimizer/optimizer.h"
#include "storage/bufmgr.h"
#include "utils/catcache.h"
#include "utils/hsearch.h"
#include "utils/inval.h"
#include "utils/spccache.h"
#include "utils/syscache.h"
#include "varatt.h"

Include dependency graph for spccache.c:

Data Structures
struct	TableSpaceCacheEntry

Functions
static void	InvalidateTableSpaceCacheCallback (Datum arg, int cacheid, uint32 hashvalue)

static void	InitializeTableSpaceCache (void)

static TableSpaceCacheEntry *	get_tablespace (Oid spcid)

void	get_tablespace_page_costs (Oid spcid, double spc_random_page_cost, double spc_seq_page_cost)

int	get_tablespace_io_concurrency (Oid spcid)

int	get_tablespace_maintenance_io_concurrency (Oid spcid)

Variables
static HTAB *	TableSpaceCacheHash = NULL

Function Documentation

◆ get_tablespace()

static TableSpaceCacheEntry* get_tablespace ( Oid spcid )

static

Definition at line 107 of file spccache.c.

 {
     TableSpaceCacheEntry *spc;
     HeapTuple   tp;
     TableSpaceOpts *opts;
  
     /*
      * Since spcid is always from a pg_class tuple, InvalidOid implies the
      * default.
      */
     if (spcid == InvalidOid)
         spcid = MyDatabaseTableSpace;
  
     /* Find existing cache entry, if any. */
     if (!TableSpaceCacheHash)
         InitializeTableSpaceCache();
     spc = (TableSpaceCacheEntry *) hash_search(TableSpaceCacheHash,
                                                &spcid,
                                                HASH_FIND,
                                                NULL);
     if (spc)
         return spc;
  
     /*
      * Not found in TableSpace cache.  Check catcache.  If we don't find a
      * valid HeapTuple, it must mean someone has managed to request tablespace
      * details for a non-existent tablespace.  We'll just treat that case as
      * if no options were specified.
      */
     tp = SearchSysCache1(TABLESPACEOID, ObjectIdGetDatum(spcid));
     if (!HeapTupleIsValid(tp))
         opts = NULL;
     else
     {
         Datum       datum;
         bool        isNull;
  
         datum = SysCacheGetAttr(TABLESPACEOID,
                                 tp,
                                 Anum_pg_tablespace_spcoptions,
                                 &isNull);
         if (isNull)
             opts = NULL;
         else
         {
             bytea      *bytea_opts = tablespace_reloptions(datum, false);
  
             opts = MemoryContextAlloc(CacheMemoryContext, VARSIZE(bytea_opts));
             memcpy(opts, bytea_opts, VARSIZE(bytea_opts));
         }
         ReleaseSysCache(tp);
     }
  
     /*
      * Now create the cache entry.  It's important to do this only after
      * reading the pg_tablespace entry, since doing so could cause a cache
      * flush.
      */
     spc = (TableSpaceCacheEntry *) hash_search(TableSpaceCacheHash,
                                                &spcid,
                                                HASH_ENTER,
                                                NULL);
     spc->opts = opts;
     return spc;
 }

References CacheMemoryContext, HASH_ENTER, HASH_FIND, hash_search(), HeapTupleIsValid, InitializeTableSpaceCache(), InvalidOid, MemoryContextAlloc(), MyDatabaseTableSpace, ObjectIdGetDatum(), TableSpaceCacheEntry::opts, opts, ReleaseSysCache(), SearchSysCache1(), SysCacheGetAttr(), tablespace_reloptions(), TableSpaceCacheHash, and VARSIZE.

Referenced by get_tablespace_io_concurrency(), get_tablespace_maintenance_io_concurrency(), and get_tablespace_page_costs().

◆ get_tablespace_io_concurrency()

int get_tablespace_io_concurrency ( Oid spcid )

Definition at line 215 of file spccache.c.

 {
     TableSpaceCacheEntry *spc = get_tablespace(spcid);
  
     if (!spc->opts || spc->opts->effective_io_concurrency < 0)
         return effective_io_concurrency;
     else
         return spc->opts->effective_io_concurrency;
 }

References effective_io_concurrency, TableSpaceOpts::effective_io_concurrency, get_tablespace(), and TableSpaceCacheEntry::opts.

Referenced by ExecInitBitmapHeapScan(), and read_stream_begin_relation().

◆ get_tablespace_maintenance_io_concurrency()

int get_tablespace_maintenance_io_concurrency ( Oid spcid )

Definition at line 229 of file spccache.c.

 {
     TableSpaceCacheEntry *spc = get_tablespace(spcid);
  
     if (!spc->opts || spc->opts->maintenance_io_concurrency < 0)
         return maintenance_io_concurrency;
     else
         return spc->opts->maintenance_io_concurrency;
 }

References get_tablespace(), maintenance_io_concurrency, TableSpaceOpts::maintenance_io_concurrency, and TableSpaceCacheEntry::opts.

Referenced by heap_index_delete_tuples(), and read_stream_begin_relation().

◆ get_tablespace_page_costs()

void get_tablespace_page_costs	(	Oid	spcid,
		double *	spc_random_page_cost,
		double *	spc_seq_page_cost
	)

Definition at line 182 of file spccache.c.

 {
     TableSpaceCacheEntry *spc = get_tablespace(spcid);
  
     Assert(spc != NULL);
  
     if (spc_random_page_cost)
     {
         if (!spc->opts || spc->opts->random_page_cost < 0)
             *spc_random_page_cost = random_page_cost;
         else
             *spc_random_page_cost = spc->opts->random_page_cost;
     }
  
     if (spc_seq_page_cost)
     {
         if (!spc->opts || spc->opts->seq_page_cost < 0)
             *spc_seq_page_cost = seq_page_cost;
         else
             *spc_seq_page_cost = spc->opts->seq_page_cost;
     }
 }

References Assert, get_tablespace(), TableSpaceCacheEntry::opts, random_page_cost, TableSpaceOpts::random_page_cost, seq_page_cost, and TableSpaceOpts::seq_page_cost.

Referenced by brincostestimate(), cost_bitmap_heap_scan(), cost_index(), cost_samplescan(), cost_seqscan(), cost_tidrangescan(), cost_tidscan(), genericcostestimate(), gincostestimate(), and system_time_samplescangetsamplesize().

◆ InitializeTableSpaceCache()

static void InitializeTableSpaceCache ( void )

static

Definition at line 78 of file spccache.c.

 {
     HASHCTL     ctl;
  
     /* Initialize the hash table. */
     ctl.keysize = sizeof(Oid);
     ctl.entrysize = sizeof(TableSpaceCacheEntry);
     TableSpaceCacheHash =
         hash_create("TableSpace cache", 16, &ctl,
                     HASH_ELEM | HASH_BLOBS);
  
     /* Make sure we've initialized CacheMemoryContext. */
     if (!CacheMemoryContext)
         CreateCacheMemoryContext();
  
     /* Watch for invalidation events. */
     CacheRegisterSyscacheCallback(TABLESPACEOID,
                                   InvalidateTableSpaceCacheCallback,
                                   (Datum) 0);
 }

References CacheMemoryContext, CacheRegisterSyscacheCallback(), CreateCacheMemoryContext(), ctl, HASH_BLOBS, hash_create(), HASH_ELEM, InvalidateTableSpaceCacheCallback(), and TableSpaceCacheHash.

Referenced by get_tablespace().

◆ InvalidateTableSpaceCacheCallback()

static void InvalidateTableSpaceCacheCallback	(	Datum	arg,
		int	cacheid,
		uint32	hashvalue
	)

static

Definition at line 55 of file spccache.c.

 {
     HASH_SEQ_STATUS status;
     TableSpaceCacheEntry *spc;
  
     hash_seq_init(&status, TableSpaceCacheHash);
     while ((spc = (TableSpaceCacheEntry *) hash_seq_search(&status)) != NULL)
     {
         if (spc->opts)
             pfree(spc->opts);
         if (hash_search(TableSpaceCacheHash,
                         &spc->oid,
                         HASH_REMOVE,
                         NULL) == NULL)
             elog(ERROR, "hash table corrupted");
     }
 }