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

 *

 * nodeBitmapOr.c

 *    routines to handle BitmapOr nodes.

 *

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

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

 *

 *

 * IDENTIFICATION

 *    src/backend/executor/nodeBitmapOr.c

 *

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

 */

/*

 * INTERFACE ROUTINES

 *    ExecInitBitmapOr  - initialize the BitmapOr node

 *    MultiExecBitmapOr - retrieve the result bitmap from the node

 *    ExecEndBitmapOr   - shut down the BitmapOr node

 *    ExecReScanBitmapOr  - rescan the BitmapOr node

 *

 *   NOTES

 *    BitmapOr nodes don't make use of their left and right

 *    subtrees, rather they maintain a list of subplans,

 *    much like Append nodes.  The logic is much simpler than

 *    Append, however, since we needn't cope with forward/backward

 *    execution.

 */

#include "postgres.h"

#include "executor/executor.h"

#include "executor/instrument.h"

#include "executor/nodeBitmapOr.h"

#include "nodes/tidbitmap.h"

#include "miscadmin.h"

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

 *    ExecBitmapOr

 *

 *    stub for pro forma compliance

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

 */

static TupleTableSlot *

ExecBitmapOr(PlanState *pstate)

{

  elog(ERROR, "BitmapOr node does not support ExecProcNode call convention");

  return NULL;

}

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

 *    ExecInitBitmapOr

 *

 *    Begin all of the subscans of the BitmapOr node.

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

 */

BitmapOrState *

ExecInitBitmapOr(BitmapOr *node, EState *estate, int eflags)

{

  BitmapOrState *bitmaporstate = makeNode(BitmapOrState);

  PlanState **bitmapplanstates;

  int     nplans;

  int     i;

  ListCell   *l;

  Plan     *initNode;

  /* check for unsupported flags */

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

  /*

   * Set up empty vector of subplan states

   */

  nplans = list_length(node->bitmapplans);

  bitmapplanstates = palloc0_array(PlanState *, nplans);

  /*

   * create new BitmapOrState for our BitmapOr node

   */

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

  bitmaporstate->ps.state = estate;

  bitmaporstate->ps.ExecProcNode = ExecBitmapOr;

  bitmaporstate->bitmapplans = bitmapplanstates;

  bitmaporstate->nplans = nplans;

  /*

   * call ExecInitNode on each of the plans to be executed and save the

   * results into the array "bitmapplanstates".

   */

  i = 0;

  foreach(l, node->bitmapplans)

  {

    initNode = (Plan *) lfirst(l);

    bitmapplanstates[i] = ExecInitNode(initNode, estate, eflags);

    i++;

  }

  /*

   * Miscellaneous initialization

   *

   * BitmapOr plans don't have expression contexts because they never call

   * ExecQual or ExecProject.  They don't need any tuple slots either.

   */

  return bitmaporstate;

}

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

 *     MultiExecBitmapOr

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

 */

Node *

MultiExecBitmapOr(BitmapOrState *node)

{

  PlanState **bitmapplans;

  int     nplans;

  int     i;

  TIDBitmap  *result = NULL;

  /* must provide our own instrumentation support */

  if (node->ps.instrument)

    InstrStartNode(node->ps.instrument);

  /*

   * get information from the node

   */

  bitmapplans = node->bitmapplans;

  nplans = node->nplans;

  /*

   * Scan all the subplans and OR their result bitmaps

   */

  for (i = 0; i < nplans; i++)

  {

    PlanState  *subnode = bitmapplans[i];

    TIDBitmap  *subresult;

    /*

     * We can special-case BitmapIndexScan children to avoid an explicit

     * tbm_union step for each child: just pass down the current result

     * bitmap and let the child OR directly into it.

     */

    if (IsA(subnode, BitmapIndexScanState))

    {

      if (result == NULL) /* first subplan */

      {

        /* XXX should we use less than work_mem for this? */

        result = tbm_create(work_mem * (Size) 1024,

                  ((BitmapOr *) node->ps.plan)->isshared ?

                  node->ps.state->es_query_dsa : NULL);

      }

      ((BitmapIndexScanState *) subnode)->biss_result = result;

      subresult = (TIDBitmap *) MultiExecProcNode(subnode);

      if (subresult != result)

        elog(ERROR, "unrecognized result from subplan");

    }

    else

    {

      /* standard implementation */

      subresult = (TIDBitmap *) MultiExecProcNode(subnode);

      if (!subresult || !IsA(subresult, TIDBitmap))

        elog(ERROR, "unrecognized result from subplan");

      if (result == NULL)

        result = subresult; /* first subplan */

      else

      {

        tbm_union(result, subresult);

        tbm_free(subresult);

      }

    }

  }

  /* We could return an empty result set here? */

  if (result == NULL)

    elog(ERROR, "BitmapOr doesn't support zero inputs");

  /* must provide our own instrumentation support */

  if (node->ps.instrument)

    InstrStopNode(node->ps.instrument, 0 /* XXX */ );

  return (Node *) result;

}

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

 *    ExecEndBitmapOr

 *

 *    Shuts down the subscans of the BitmapOr node.

 *

 *    Returns nothing of interest.

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

 */

void

ExecEndBitmapOr(BitmapOrState *node)

{

  PlanState **bitmapplans;

  int     nplans;

  int     i;

  /*

   * get information from the node

   */

  bitmapplans = node->bitmapplans;

  nplans = node->nplans;

  /*

   * shut down each of the subscans (that we've initialized)

   */

  for (i = 0; i < nplans; i++)

  {

    if (bitmapplans[i])

      ExecEndNode(bitmapplans[i]);

  }

}

void

ExecReScanBitmapOr(BitmapOrState *node)

{

  int     i;

  for (i = 0; i < node->nplans; i++)

  {

    PlanState  *subnode = node->bitmapplans[i];

    /*

     * ExecReScan doesn't know about my subplans, so I have to do

     * changed-parameter signaling myself.

     */

    if (node->ps.chgParam != NULL)

      UpdateChangedParamSet(subnode, node->ps.chgParam);

    /*

     * If chgParam of subnode is not null then plan will be re-scanned by

     * first ExecProcNode.

     */

    if (subnode->chgParam == NULL)

      ExecReScan(subnode);

  }

}