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

 *

 * queryenvironment.c

 *    Query environment, to store context-specific values like ephemeral named

 *    relations.  Initial use is for named tuplestores for delta information

 *    from "normal" relations.

 *

 * The initial implementation uses a list because the number of such relations

 * in any one context is expected to be very small.  If that becomes a

 * performance problem, the implementation can be changed with no other impact

 * on callers, since this is an opaque structure.  This is the reason to

 * require a create function.

 *

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

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

 *

 *

 * IDENTIFICATION

 *    src/backend/utils/misc/queryenvironment.c

 *

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

 */

#include "postgres.h"

#include "access/table.h"

#include "utils/queryenvironment.h"

#include "utils/rel.h"

/*

 * Private state of a query environment.

 */

struct QueryEnvironment

{

  List     *namedRelList;

};

QueryEnvironment *

create_queryEnv(void)

{

  return palloc0_object(QueryEnvironment);

}

EphemeralNamedRelationMetadata

get_visible_ENR_metadata(QueryEnvironment *queryEnv, const char *refname)

{

  EphemeralNamedRelation enr;

  Assert(refname != NULL);

  if (queryEnv == NULL)

    return NULL;

  enr = get_ENR(queryEnv, refname);

  if (enr)

    return &(enr->md);

  return NULL;

}

/*

 * Register a named relation for use in the given environment.

 *

 * If this is intended exclusively for planning purposes, the tstate field can

 * be left NULL;

 */

void

register_ENR(QueryEnvironment *queryEnv, EphemeralNamedRelation enr)

{

  Assert(enr != NULL);

  Assert(get_ENR(queryEnv, enr->md.name) == NULL);

  queryEnv->namedRelList = lappend(queryEnv->namedRelList, enr);

}

/*

 * Unregister an ephemeral relation by name.  This will probably be a rarely

 * used function, but seems like it should be provided "just in case".

 */

void

unregister_ENR(QueryEnvironment *queryEnv, const char *name)

{

  EphemeralNamedRelation match;

  match = get_ENR(queryEnv, name);

  if (match)

    queryEnv->namedRelList = list_delete(queryEnv->namedRelList, match);

}

/*

 * This returns an ENR if there is a name match in the given collection.  It

 * must quietly return NULL if no match is found.

 */

EphemeralNamedRelation

get_ENR(QueryEnvironment *queryEnv, const char *name)

{

  ListCell   *lc;

  Assert(name != NULL);

  if (queryEnv == NULL)

    return NULL;

  foreach(lc, queryEnv->namedRelList)

  {

    EphemeralNamedRelation enr = (EphemeralNamedRelation) lfirst(lc);

    if (strcmp(enr->md.name, name) == 0)

      return enr;

  }

  return NULL;

}

/*

 * Gets the TupleDesc for a Ephemeral Named Relation, based on which field was

 * filled.

 *

 * When the TupleDesc is based on a relation from the catalogs, we count on

 * that relation being used at the same time, so that appropriate locks will

 * already be held.  Locking here would be too late anyway.

 */

TupleDesc

ENRMetadataGetTupDesc(EphemeralNamedRelationMetadata enrmd)

{

  TupleDesc tupdesc;

  /* One, and only one, of these fields must be filled. */

  Assert((enrmd->reliddesc == InvalidOid) != (enrmd->tupdesc == NULL));

  if (enrmd->tupdesc != NULL)

    tupdesc = enrmd->tupdesc;

  else

  {

    Relation  relation;

    relation = table_open(enrmd->reliddesc, NoLock);

    tupdesc = relation->rd_att;

    table_close(relation, NoLock);

  }

  return tupdesc;

}