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

 *

 * extendplan.c

 *    Extend core planner objects with additional private state

 *

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

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

 *

 * The interfaces defined in this file make it possible for loadable

 * modules to store their own private state inside of key planner data

 * structures -- specifically, the PlannerGlobal, PlannerInfo, and

 * RelOptInfo structures. This can make it much easier to write

 * reasonably efficient planner extensions; for instance, code that

 * uses set_join_pathlist_hook can arrange to compute a key intermediate

 * result once per joinrel rather than on every call.

 *

 * IDENTIFICATION

 *    src/backend/optimizer/util/extendplan.c

 *

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

 */

#include "postgres.h"

#include "optimizer/extendplan.h"

#include "port/pg_bitutils.h"

#include "utils/memutils.h"

static const char **PlannerExtensionNameArray = NULL;

static int  PlannerExtensionNamesAssigned = 0;

static int  PlannerExtensionNamesAllocated = 0;

/*

 * Map the name of a planner extension to an integer ID.

 *

 * Within the lifetime of a particular backend, the same name will be mapped

 * to the same ID every time. IDs are not stable across backends. Use the ID

 * that you get from this function to call the remaining functions in this

 * file.

 */

int

GetPlannerExtensionId(const char *extension_name)

{

  /* Search for an existing extension by this name; if found, return ID. */

  for (int i = 0; i < PlannerExtensionNamesAssigned; ++i)

    if (strcmp(PlannerExtensionNameArray[i], extension_name) == 0)

      return i;

  /* If there is no array yet, create one. */

  if (PlannerExtensionNameArray == NULL)

  {

    PlannerExtensionNamesAllocated = 16;

    PlannerExtensionNameArray = (const char **)

      MemoryContextAlloc(TopMemoryContext,

                 PlannerExtensionNamesAllocated

                 * sizeof(char *));

  }

  /* If there's an array but it's currently full, expand it. */

  if (PlannerExtensionNamesAssigned >= PlannerExtensionNamesAllocated)

  {

    int     i = pg_nextpower2_32(PlannerExtensionNamesAssigned + 1);

    PlannerExtensionNameArray = repalloc_array(PlannerExtensionNameArray, const char *, i);

    PlannerExtensionNamesAllocated = i;

  }

  /* Assign and return new ID. */

  PlannerExtensionNameArray[PlannerExtensionNamesAssigned] = extension_name;

  return PlannerExtensionNamesAssigned++;

}

/*

 * Store extension-specific state into a PlannerGlobal.

 */

void

SetPlannerGlobalExtensionState(PlannerGlobal *glob, int extension_id,

                 void *opaque)

{

  Assert(extension_id >= 0);

  /* If there is no array yet, create one. */

  if (glob->extension_state == NULL)

  {

    MemoryContext planner_cxt;

    Size    sz;

    planner_cxt = GetMemoryChunkContext(glob);

    glob->extension_state_allocated =

      Max(4, pg_nextpower2_32(extension_id + 1));

    sz = glob->extension_state_allocated * sizeof(void *);

    glob->extension_state = MemoryContextAllocZero(planner_cxt, sz);

  }

  /* If there's an array but it's currently full, expand it. */

  if (extension_id >= glob->extension_state_allocated)

  {

    int     i;

    i = pg_nextpower2_32(extension_id + 1);

    glob->extension_state = repalloc0_array(glob->extension_state, void *,

                        glob->extension_state_allocated, i);

    glob->extension_state_allocated = i;

  }

  glob->extension_state[extension_id] = opaque;

}

/*

 * Store extension-specific state into a PlannerInfo.

 */

void

SetPlannerInfoExtensionState(PlannerInfo *root, int extension_id,

               void *opaque)

{

  Assert(extension_id >= 0);

  /* If there is no array yet, create one. */

  if (root->extension_state == NULL)

  {

    Size    sz;

    root->extension_state_allocated =

      Max(4, pg_nextpower2_32(extension_id + 1));

    sz = root->extension_state_allocated * sizeof(void *);

    root->extension_state = MemoryContextAllocZero(root->planner_cxt, sz);

  }

  /* If there's an array but it's currently full, expand it. */

  if (extension_id >= root->extension_state_allocated)

  {

    int     i;

    i = pg_nextpower2_32(extension_id + 1);

    root->extension_state = repalloc0_array(root->extension_state, void *,

                        root->extension_state_allocated, i);

    root->extension_state_allocated = i;

  }

  root->extension_state[extension_id] = opaque;

}

/*

 * Store extension-specific state into a RelOptInfo.

 */

void

SetRelOptInfoExtensionState(RelOptInfo *rel, int extension_id,

              void *opaque)

{

  Assert(extension_id >= 0);

  /* If there is no array yet, create one. */

  if (rel->extension_state == NULL)

  {

    MemoryContext planner_cxt;

    Size    sz;

    planner_cxt = GetMemoryChunkContext(rel);

    rel->extension_state_allocated =

      Max(4, pg_nextpower2_32(extension_id + 1));

    sz = rel->extension_state_allocated * sizeof(void *);

    rel->extension_state = MemoryContextAllocZero(planner_cxt, sz);

  }

  /* If there's an array but it's currently full, expand it. */

  if (extension_id >= rel->extension_state_allocated)

  {

    int     i;

    i = pg_nextpower2_32(extension_id + 1);

    rel->extension_state = repalloc0_array(rel->extension_state, void *,

                         rel->extension_state_allocated, i);

    rel->extension_state_allocated = i;

  }

  rel->extension_state[extension_id] = opaque;

}