/*-------------------------------------------------------------------------

 *

 * spccache.c

 *    Tablespace cache management.

 *

 * We cache the parsed version of spcoptions for each tablespace to avoid

 * needing to reparse on every lookup.  Right now, there doesn't appear to

 * be a measurable performance gain from doing this, but that might change

 * in the future as we add more options.

 *

 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group

 * Portions Copyright (c) 1994, Regents of the University of California

 *

 * IDENTIFICATION

 *    src/backend/utils/cache/spccache.c

 *

 *-------------------------------------------------------------------------

 */

#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"

/* Hash table for information about each tablespace */

static HTAB *TableSpaceCacheHash = NULL;

typedef struct

{

  Oid     oid;      /* lookup key - must be first */

  TableSpaceOpts *opts;   /* options, or NULL if none */

} TableSpaceCacheEntry;

/*

 * InvalidateTableSpaceCacheCallback

 *    Flush all cache entries when pg_tablespace is updated.

 *

 * When pg_tablespace is updated, we must flush the cache entry at least

 * for that tablespace.  Currently, we just flush them all.  This is quick

 * and easy and doesn't cost much, since there shouldn't be terribly many

 * tablespaces, nor do we expect them to be frequently modified.

 */

static void

InvalidateTableSpaceCacheCallback(Datum arg, int cacheid, uint32 hashvalue)

{

  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");

  }

}

/*

 * InitializeTableSpaceCache

 *    Initialize the tablespace cache.

 */

static void

InitializeTableSpaceCache(void)

{

  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);

}

/*

 * get_tablespace

 *    Fetch TableSpaceCacheEntry structure for a specified table OID.

 *

 * Pointers returned by this function should not be stored, since a cache

 * flush will invalidate them.

 */

static TableSpaceCacheEntry *

get_tablespace(Oid spcid)

{

  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;

}

/*

 * get_tablespace_page_costs

 *    Return random and/or sequential page costs for a given tablespace.

 *

 *    This value is not locked by the transaction, so this value may

 *    be changed while a SELECT that has used these values for planning

 *    is still executing.

 */

void

get_tablespace_page_costs(Oid spcid,

              double *spc_random_page_cost,

              double *spc_seq_page_cost)

{

  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;

  }

}

/*

 * get_tablespace_io_concurrency

 *

 *    This value is not locked by the transaction, so this value may

 *    be changed while a SELECT that has used these values for planning

 *    is still executing.

 */

int

get_tablespace_io_concurrency(Oid spcid)

{

  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;

}

/*

 * get_tablespace_maintenance_io_concurrency

 */

int

get_tablespace_maintenance_io_concurrency(Oid spcid)

{

  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;

}