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

 *

 * print.c

 *    various print routines (used mostly for debugging)

 *

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

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

 *

 *

 * IDENTIFICATION

 *    src/backend/nodes/print.c

 *

 * HISTORY

 *    AUTHOR      DATE      MAJOR EVENT

 *    Andrew Yu     Oct 26, 1994  file creation

 *

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

 */

#include "postgres.h"

#include "access/printtup.h"

#include "lib/stringinfo.h"

#include "nodes/nodeFuncs.h"

#include "nodes/pathnodes.h"

#include "nodes/print.h"

#include "parser/parsetree.h"

#include "utils/lsyscache.h"

/*

 * print

 *    print contents of Node to stdout

 */

void

print(const void *obj)

{

  char     *s;

  char     *f;

  s = nodeToStringWithLocations(obj);

  f = format_node_dump(s);

  pfree(s);

  printf("%s\n", f);

  fflush(stdout);

  pfree(f);

}

/*

 * pprint

 *    pretty-print contents of Node to stdout

 */

void

pprint(const void *obj)

{

  char     *s;

  char     *f;

  s = nodeToStringWithLocations(obj);

  f = pretty_format_node_dump(s);

  pfree(s);

  printf("%s\n", f);

  fflush(stdout);

  pfree(f);

}

/*

 * elog_node_display

 *    send pretty-printed contents of Node to postmaster log

 */

void

elog_node_display(int lev, const char *title, const void *obj, bool pretty)

{

  char     *s;

  char     *f;

  s = nodeToStringWithLocations(obj);

  if (pretty)

    f = pretty_format_node_dump(s);

  else

    f = format_node_dump(s);

  pfree(s);

  ereport(lev,

      (errmsg_internal("%s:", title),

       errdetail_internal("%s", f)));

  pfree(f);

}

/*

 * Format a nodeToString output for display on a terminal.

 *

 * The result is a palloc'd string.

 *

 * This version just tries to break at whitespace.

 */

char *

format_node_dump(const char *dump)

{

#define LINELEN   78

  char    line[LINELEN + 1];

  StringInfoData str;

  int     i;

  int     j;

  int     k;

  initStringInfo(&str);

  i = 0;

  for (;;)

  {

    for (j = 0; j < LINELEN && dump[i] != '\0'; i++, j++)

      line[j] = dump[i];

    if (dump[i] == '\0')

      break;

    if (dump[i] == ' ')

    {

      /* ok to break at adjacent space */

      i++;

    }

    else

    {

      for (k = j - 1; k > 0; k--)

        if (line[k] == ' ')

          break;

      if (k > 0)

      {

        /* back up; will reprint all after space */

        i -= (j - k - 1);

        j = k;

      }

    }

    line[j] = '\0';

    appendStringInfo(&str, "%s\n", line);

  }

  if (j > 0)

  {

    line[j] = '\0';

    appendStringInfo(&str, "%s\n", line);

  }

  return str.data;

#undef LINELEN

}

/*

 * Format a nodeToString output for display on a terminal.

 *

 * The result is a palloc'd string.

 *

 * This version tries to indent intelligently.

 */

char *

pretty_format_node_dump(const char *dump)

{

#define INDENTSTOP  3

#define MAXINDENT 60

#define LINELEN   78

  char    line[LINELEN + 1];

  StringInfoData str;

  int     indentLev;

  int     indentDist;

  int     i;

  int     j;

  initStringInfo(&str);

  indentLev = 0;        /* logical indent level */

  indentDist = 0;       /* physical indent distance */

  i = 0;

  for (;;)

  {

    for (j = 0; j < indentDist; j++)

      line[j] = ' ';

    for (; j < LINELEN && dump[i] != '\0'; i++, j++)

    {

      line[j] = dump[i];

      switch (line[j])

      {

        case '}':

          if (j != indentDist)

          {

            /* print data before the } */

            line[j] = '\0';

            appendStringInfo(&str, "%s\n", line);

          }

          /* print the } at indentDist */

          line[indentDist] = '}';

          line[indentDist + 1] = '\0';

          appendStringInfo(&str, "%s\n", line);

          /* outdent */

          if (indentLev > 0)

          {

            indentLev--;

            indentDist = Min(indentLev * INDENTSTOP, MAXINDENT);

          }

          j = indentDist - 1;

          /* j will equal indentDist on next loop iteration */

          /* suppress whitespace just after } */

          while (dump[i + 1] == ' ')

            i++;

          break;

        case ')':

          /* force line break after ), unless another ) follows */

          if (dump[i + 1] != ')')

          {

            line[j + 1] = '\0';

            appendStringInfo(&str, "%s\n", line);

            j = indentDist - 1;

            while (dump[i + 1] == ' ')

              i++;

          }

          break;

        case '{':

          /* force line break before { */

          if (j != indentDist)

          {

            line[j] = '\0';

            appendStringInfo(&str, "%s\n", line);

          }

          /* indent */

          indentLev++;

          indentDist = Min(indentLev * INDENTSTOP, MAXINDENT);

          for (j = 0; j < indentDist; j++)

            line[j] = ' ';

          line[j] = dump[i];

          break;

        case ':':

          /* force line break before : */

          if (j != indentDist)

          {

            line[j] = '\0';

            appendStringInfo(&str, "%s\n", line);

          }

          j = indentDist;

          line[j] = dump[i];

          break;

      }

    }

    line[j] = '\0';

    if (dump[i] == '\0')

      break;

    appendStringInfo(&str, "%s\n", line);

  }

  if (j > 0)

    appendStringInfo(&str, "%s\n", line);

  return str.data;

#undef INDENTSTOP

#undef MAXINDENT

#undef LINELEN

}

/*

 * print_rt

 *    print contents of range table

 */

void

print_rt(const List *rtable)

{

  const ListCell *l;

  int     i = 1;

  printf("resno\trefname  \trelid\tinFromCl\n");

  printf("-----\t---------\t-----\t--------\n");

  foreach(l, rtable)

  {

    RangeTblEntry *rte = lfirst(l);

    switch (rte->rtekind)

    {

      case RTE_RELATION:

        printf("%d\t%s\t%u\t%c",

             i, rte->eref->aliasname, rte->relid, rte->relkind);

        break;

      case RTE_SUBQUERY:

        printf("%d\t%s\t[subquery]",

             i, rte->eref->aliasname);

        break;

      case RTE_JOIN:

        printf("%d\t%s\t[join]",

             i, rte->eref->aliasname);

        break;

      case RTE_FUNCTION:

        printf("%d\t%s\t[rangefunction]",

             i, rte->eref->aliasname);

        break;

      case RTE_TABLEFUNC:

        printf("%d\t%s\t[table function]",

             i, rte->eref->aliasname);

        break;

      case RTE_VALUES:

        printf("%d\t%s\t[values list]",

             i, rte->eref->aliasname);

        break;

      case RTE_CTE:

        printf("%d\t%s\t[cte]",

             i, rte->eref->aliasname);

        break;

      case RTE_NAMEDTUPLESTORE:

        printf("%d\t%s\t[tuplestore]",

             i, rte->eref->aliasname);

        break;

      case RTE_RESULT:

        printf("%d\t%s\t[result]",

             i, rte->eref->aliasname);

        break;

      case RTE_GROUP:

        printf("%d\t%s\t[group]",

             i, rte->eref->aliasname);

        break;

      default:

        printf("%d\t%s\t[unknown rtekind]",

             i, rte->eref->aliasname);

    }

    printf("\t%s\t%s\n",

         (rte->inh ? "inh" : ""),

         (rte->inFromCl ? "inFromCl" : ""));

    i++;

  }

}

/*

 * print_expr

 *    print an expression

 */

void

print_expr(const Node *expr, const List *rtable)

{

  if (expr == NULL)

  {

    printf("<>");

    return;

  }

  if (IsA(expr, Var))

  {

    const Var  *var = (const Var *) expr;

    char     *relname,

           *attname;

    switch (var->varno)

    {

      case INNER_VAR:

        relname = "INNER";

        attname = "?";

        break;

      case OUTER_VAR:

        relname = "OUTER";

        attname = "?";

        break;

      case INDEX_VAR:

        relname = "INDEX";

        attname = "?";

        break;

      default:

        {

          RangeTblEntry *rte;

          Assert(var->varno > 0 &&

               (int) var->varno <= list_length(rtable));

          rte = rt_fetch(var->varno, rtable);

          relname = rte->eref->aliasname;

          attname = get_rte_attribute_name(rte, var->varattno);

        }

        break;

    }

    printf("%s.%s", relname, attname);

  }

  else if (IsA(expr, Const))

  {

    const Const *c = (const Const *) expr;

    Oid     typoutput;

    bool    typIsVarlena;

    char     *outputstr;

    if (c->constisnull)

    {

      printf("NULL");

      return;

    }

    getTypeOutputInfo(c->consttype,

              &typoutput, &typIsVarlena);

    outputstr = OidOutputFunctionCall(typoutput, c->constvalue);

    printf("%s", outputstr);

    pfree(outputstr);

  }

  else if (IsA(expr, OpExpr))

  {

    const OpExpr *e = (const OpExpr *) expr;

    char     *opname;

    opname = get_opname(e->opno);

    if (list_length(e->args) > 1)

    {

      print_expr(get_leftop((const Expr *) e), rtable);

      printf(" %s ", ((opname != NULL) ? opname : "(invalid operator)"));

      print_expr(get_rightop((const Expr *) e), rtable);

    }

    else

    {

      printf("%s ", ((opname != NULL) ? opname : "(invalid operator)"));

      print_expr(get_leftop((const Expr *) e), rtable);

    }

  }

  else if (IsA(expr, FuncExpr))

  {

    const FuncExpr *e = (const FuncExpr *) expr;

    char     *funcname;

    ListCell   *l;

    funcname = get_func_name(e->funcid);

    printf("%s(", ((funcname != NULL) ? funcname : "(invalid function)"));

    foreach(l, e->args)

    {

      print_expr(lfirst(l), rtable);

      if (lnext(e->args, l))

        printf(",");

    }

    printf(")");

  }

  else

    printf("unknown expr");

}

/*

 * print_pathkeys -

 *    pathkeys list of PathKeys

 */

void

print_pathkeys(const List *pathkeys, const List *rtable)

{

  const ListCell *i;

  printf("(");

  foreach(i, pathkeys)

  {

    PathKey    *pathkey = (PathKey *) lfirst(i);

    EquivalenceClass *eclass;

    ListCell   *k;

    bool    first = true;

    eclass = pathkey->pk_eclass;

    /* chase up, in case pathkey is non-canonical */

    while (eclass->ec_merged)

      eclass = eclass->ec_merged;

    printf("(");

    foreach(k, eclass->ec_members)

    {

      EquivalenceMember *mem = (EquivalenceMember *) lfirst(k);

      if (first)

        first = false;

      else

        printf(", ");

      print_expr((Node *) mem->em_expr, rtable);

    }

    printf(")");

    if (lnext(pathkeys, i))

      printf(", ");

  }

  printf(")\n");

}

/*

 * print_tl

 *    print targetlist in a more legible way.

 */

void

print_tl(const List *tlist, const List *rtable)

{

  const ListCell *tl;

  printf("(\n");

  foreach(tl, tlist)

  {

    TargetEntry *tle = (TargetEntry *) lfirst(tl);

    printf("\t%d %s\t", tle->resno,

         tle->resname ? tle->resname : "<null>");

    if (tle->ressortgroupref != 0)

      printf("(%u):\t", tle->ressortgroupref);

    else

      printf("    :\t");

    print_expr((Node *) tle->expr, rtable);

    printf("\n");

  }

  printf(")\n");

}

/*

 * print_slot

 *    print out the tuple with the given TupleTableSlot

 */

void

print_slot(TupleTableSlot *slot)

{

  if (TupIsNull(slot))

  {

    printf("tuple is null.\n");

    return;

  }

  if (!slot->tts_tupleDescriptor)

  {

    printf("no tuple descriptor.\n");

    return;

  }

  debugtup(slot, NULL);

}