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

 *

 * nodeNamedtuplestorescan.c

 *    routines to handle NamedTuplestoreScan nodes.

 *

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

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

 *

 *

 * IDENTIFICATION

 *    src/backend/executor/nodeNamedtuplestorescan.c

 *

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

 */

#include "postgres.h"

#include "executor/executor.h"

#include "executor/nodeNamedtuplestorescan.h"

#include "utils/queryenvironment.h"

static TupleTableSlot *NamedTuplestoreScanNext(NamedTuplestoreScanState *node);

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

 *    NamedTuplestoreScanNext

 *

 *    This is a workhorse for ExecNamedTuplestoreScan

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

 */

static TupleTableSlot *

NamedTuplestoreScanNext(NamedTuplestoreScanState *node)

{

  TupleTableSlot *slot;

  /* We intentionally do not support backward scan. */

  Assert(ScanDirectionIsForward(node->ss.ps.state->es_direction));

  /*

   * Get the next tuple from tuplestore. Return NULL if no more tuples.

   */

  slot = node->ss.ss_ScanTupleSlot;

  tuplestore_select_read_pointer(node->relation, node->readptr);

  (void) tuplestore_gettupleslot(node->relation, true, false, slot);

  return slot;

}

/*

 * NamedTuplestoreScanRecheck -- access method routine to recheck a tuple in

 * EvalPlanQual

 */

static bool

NamedTuplestoreScanRecheck(NamedTuplestoreScanState *node, TupleTableSlot *slot)

{

  /* nothing to check */

  return true;

}

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

 *    ExecNamedTuplestoreScan(node)

 *

 *    Scans the CTE sequentially and returns the next qualifying tuple.

 *    We call the ExecScan() routine and pass it the appropriate

 *    access method functions.

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

 */

static TupleTableSlot *

ExecNamedTuplestoreScan(PlanState *pstate)

{

  NamedTuplestoreScanState *node = castNode(NamedTuplestoreScanState, pstate);

  return ExecScan(&node->ss,

          (ExecScanAccessMtd) NamedTuplestoreScanNext,

          (ExecScanRecheckMtd) NamedTuplestoreScanRecheck);

}

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

 *    ExecInitNamedTuplestoreScan

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

 */

NamedTuplestoreScanState *

ExecInitNamedTuplestoreScan(NamedTuplestoreScan *node, EState *estate, int eflags)

{

  NamedTuplestoreScanState *scanstate;

  EphemeralNamedRelation enr;

  /* check for unsupported flags */

  Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));

  /*

   * NamedTuplestoreScan should not have any children.

   */

  Assert(outerPlan(node) == NULL);

  Assert(innerPlan(node) == NULL);

  /*

   * create new NamedTuplestoreScanState for node

   */

  scanstate = makeNode(NamedTuplestoreScanState);

  scanstate->ss.ps.plan = (Plan *) node;

  scanstate->ss.ps.state = estate;

  scanstate->ss.ps.ExecProcNode = ExecNamedTuplestoreScan;

  enr = get_ENR(estate->es_queryEnv, node->enrname);

  if (!enr)

    elog(ERROR, "executor could not find named tuplestore \"%s\"",

       node->enrname);

  Assert(enr->reldata);

  scanstate->relation = (Tuplestorestate *) enr->reldata;

  scanstate->tupdesc = ENRMetadataGetTupDesc(&(enr->md));

  scanstate->readptr =

    tuplestore_alloc_read_pointer(scanstate->relation, EXEC_FLAG_REWIND);

  /*

   * The new read pointer copies its position from read pointer 0, which

   * could be anywhere, so explicitly rewind it.

   */

  tuplestore_select_read_pointer(scanstate->relation, scanstate->readptr);

  tuplestore_rescan(scanstate->relation);

  /*

   * XXX: Should we add a function to free that read pointer when done?

   *

   * This was attempted, but it did not improve performance or memory usage

   * in any tested cases.

   */

  /*

   * Miscellaneous initialization

   *

   * create expression context for node

   */

  ExecAssignExprContext(estate, &scanstate->ss.ps);

  /*

   * The scan tuple type is specified for the tuplestore.

   */

  ExecInitScanTupleSlot(estate, &scanstate->ss, scanstate->tupdesc,

              &TTSOpsMinimalTuple);

  /*

   * Initialize result type and projection.

   */

  ExecInitResultTypeTL(&scanstate->ss.ps);

  ExecAssignScanProjectionInfo(&scanstate->ss);

  /*

   * initialize child expressions

   */

  scanstate->ss.ps.qual =

    ExecInitQual(node->scan.plan.qual, (PlanState *) scanstate);

  return scanstate;

}

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

 *    ExecReScanNamedTuplestoreScan

 *

 *    Rescans the relation.

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

 */

void

ExecReScanNamedTuplestoreScan(NamedTuplestoreScanState *node)

{

  Tuplestorestate *tuplestorestate = node->relation;

  if (node->ss.ps.ps_ResultTupleSlot)

    ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);

  ExecScanReScan(&node->ss);

  /*

   * Rewind my own pointer.

   */

  tuplestore_select_read_pointer(tuplestorestate, node->readptr);

  tuplestore_rescan(tuplestorestate);

}