granicus.if.org Git - postgresql/blob - src/backend/nodes/print.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * print.c
   4  *        various print routines (used mostly for debugging)
   5  *
   6  * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
   7  * Portions Copyright (c) 1994, Regents of the University of California
   8  *
   9  *
  10  * IDENTIFICATION
  11  *        src/backend/nodes/print.c
  12  *
  13  * HISTORY
  14  *        AUTHOR                        DATE                    MAJOR EVENT
  15  *        Andrew Yu                     Oct 26, 1994    file creation
  16  *
  17  *-------------------------------------------------------------------------
  18  */
  19
  20 #include "postgres.h"
  21
  22 #include "access/printtup.h"
  23 #include "lib/stringinfo.h"
  24 #include "nodes/print.h"
  25 #include "optimizer/clauses.h"
  26 #include "parser/parsetree.h"
  27 #include "utils/lsyscache.h"
  28 #include "utils/rel.h"
  29
  30
  31 /*
  32  * print
  33  *        print contents of Node to stdout
  34  */
  35 void
  36 print(void *obj)
  37 {
  38         char       *s;
  39         char       *f;
  40
  41         s = nodeToString(obj);
  42         f = format_node_dump(s);
  43         pfree(s);
  44         printf("%s\n", f);
  45         fflush(stdout);
  46         pfree(f);
  47 }
  48
  49 /*
  50  * pprint
  51  *        pretty-print contents of Node to stdout
  52  */
  53 void
  54 pprint(void *obj)
  55 {
  56         char       *s;
  57         char       *f;
  58
  59         s = nodeToString(obj);
  60         f = pretty_format_node_dump(s);
  61         pfree(s);
  62         printf("%s\n", f);
  63         fflush(stdout);
  64         pfree(f);
  65 }
  66
  67 /*
  68  * elog_node_display
  69  *        send pretty-printed contents of Node to postmaster log
  70  */
  71 void
  72 elog_node_display(int lev, const char *title, void *obj, bool pretty)
  73 {
  74         char       *s;
  75         char       *f;
  76
  77         s = nodeToString(obj);
  78         if (pretty)
  79                 f = pretty_format_node_dump(s);
  80         else
  81                 f = format_node_dump(s);
  82         pfree(s);
  83         ereport(lev,
  84                         (errmsg_internal("%s:", title),
  85                          errdetail("%s", f)));
  86         pfree(f);
  87 }
  88
  89 /*
  90  * Format a nodeToString output for display on a terminal.
  91  *
  92  * The result is a palloc'd string.
  93  *
  94  * This version just tries to break at whitespace.
  95  */
  96 char *
  97 format_node_dump(const char *dump)
  98 {
  99 #define LINELEN         78
 100         char            line[LINELEN + 1];
 101         StringInfoData str;
 102         int                     i;
 103         int                     j;
 104         int                     k;
 105
 106         initStringInfo(&str);
 107         i = 0;
 108         for (;;)
 109         {
 110                 for (j = 0; j < LINELEN && dump[i] != '\0'; i++, j++)
 111                         line[j] = dump[i];
 112                 if (dump[i] == '\0')
 113                         break;
 114                 if (dump[i] == ' ')
 115                 {
 116                         /* ok to break at adjacent space */
 117                         i++;
 118                 }
 119                 else
 120                 {
 121                         for (k = j - 1; k > 0; k--)
 122                                 if (line[k] == ' ')
 123                                         break;
 124                         if (k > 0)
 125                         {
 126                                 /* back up; will reprint all after space */
 127                                 i -= (j - k - 1);
 128                                 j = k;
 129                         }
 130                 }
 131                 line[j] = '\0';
 132                 appendStringInfo(&str, "%s\n", line);
 133         }
 134         if (j > 0)
 135         {
 136                 line[j] = '\0';
 137                 appendStringInfo(&str, "%s\n", line);
 138         }
 139         return str.data;
 140 #undef LINELEN
 141 }
 142
 143 /*
 144  * Format a nodeToString output for display on a terminal.
 145  *
 146  * The result is a palloc'd string.
 147  *
 148  * This version tries to indent intelligently.
 149  */
 150 char *
 151 pretty_format_node_dump(const char *dump)
 152 {
 153 #define INDENTSTOP      3
 154 #define MAXINDENT       60
 155 #define LINELEN         78
 156         char            line[LINELEN + 1];
 157         StringInfoData str;
 158         int                     indentLev;
 159         int                     indentDist;
 160         int                     i;
 161         int                     j;
 162
 163         initStringInfo(&str);
 164         indentLev = 0;                          /* logical indent level */
 165         indentDist = 0;                         /* physical indent distance */
 166         i = 0;
 167         for (;;)
 168         {
 169                 for (j = 0; j < indentDist; j++)
 170                         line[j] = ' ';
 171                 for (; j < LINELEN && dump[i] != '\0'; i++, j++)
 172                 {
 173                         line[j] = dump[i];
 174                         switch (line[j])
 175                         {
 176                                 case '}':
 177                                         if (j != indentDist)
 178                                         {
 179                                                 /* print data before the } */
 180                                                 line[j] = '\0';
 181                                                 appendStringInfo(&str, "%s\n", line);
 182                                         }
 183                                         /* print the } at indentDist */
 184                                         line[indentDist] = '}';
 185                                         line[indentDist + 1] = '\0';
 186                                         appendStringInfo(&str, "%s\n", line);
 187                                         /* outdent */
 188                                         if (indentLev > 0)
 189                                         {
 190                                                 indentLev--;
 191                                                 indentDist = Min(indentLev * INDENTSTOP, MAXINDENT);
 192                                         }
 193                                         j = indentDist - 1;
 194                                         /* j will equal indentDist on next loop iteration */
 195                                         /* suppress whitespace just after } */
 196                                         while (dump[i + 1] == ' ')
 197                                                 i++;
 198                                         break;
 199                                 case ')':
 200                                         /* force line break after ), unless another ) follows */
 201                                         if (dump[i + 1] != ')')
 202                                         {
 203                                                 line[j + 1] = '\0';
 204                                                 appendStringInfo(&str, "%s\n", line);
 205                                                 j = indentDist - 1;
 206                                                 while (dump[i + 1] == ' ')
 207                                                         i++;
 208                                         }
 209                                         break;
 210                                 case '{':
 211                                         /* force line break before { */
 212                                         if (j != indentDist)
 213                                         {
 214                                                 line[j] = '\0';
 215                                                 appendStringInfo(&str, "%s\n", line);
 216                                         }
 217                                         /* indent */
 218                                         indentLev++;
 219                                         indentDist = Min(indentLev * INDENTSTOP, MAXINDENT);
 220                                         for (j = 0; j < indentDist; j++)
 221                                                 line[j] = ' ';
 222                                         line[j] = dump[i];
 223                                         break;
 224                                 case ':':
 225                                         /* force line break before : */
 226                                         if (j != indentDist)
 227                                         {
 228                                                 line[j] = '\0';
 229                                                 appendStringInfo(&str, "%s\n", line);
 230                                         }
 231                                         j = indentDist;
 232                                         line[j] = dump[i];
 233                                         break;
 234                         }
 235                 }
 236                 line[j] = '\0';
 237                 if (dump[i] == '\0')
 238                         break;
 239                 appendStringInfo(&str, "%s\n", line);
 240         }
 241         if (j > 0)
 242                 appendStringInfo(&str, "%s\n", line);
 243         return str.data;
 244 #undef INDENTSTOP
 245 #undef MAXINDENT
 246 #undef LINELEN
 247 }
 248
 249 /*
 250  * print_rt
 251  *        print contents of range table
 252  */
 253 void
 254 print_rt(List *rtable)
 255 {
 256         ListCell   *l;
 257         int                     i = 1;
 258
 259         printf("resno\trefname  \trelid\tinFromCl\n");
 260         printf("-----\t---------\t-----\t--------\n");
 261         foreach(l, rtable)
 262         {
 263                 RangeTblEntry *rte = lfirst(l);
 264
 265                 switch (rte->rtekind)
 266                 {
 267                         case RTE_RELATION:
 268                                 printf("%d\t%s\t%u",
 269                                            i, rte->eref->aliasname, rte->relid);
 270                                 break;
 271                         case RTE_SUBQUERY:
 272                                 printf("%d\t%s\t[subquery]",
 273                                            i, rte->eref->aliasname);
 274                                 break;
 275                         case RTE_JOIN:
 276                                 printf("%d\t%s\t[join]",
 277                                            i, rte->eref->aliasname);
 278                                 break;
 279                         case RTE_SPECIAL:
 280                                 printf("%d\t%s\t[special]",
 281                                            i, rte->eref->aliasname);
 282                                 break;
 283                         case RTE_FUNCTION:
 284                                 printf("%d\t%s\t[rangefunction]",
 285                                            i, rte->eref->aliasname);
 286                                 break;
 287                         case RTE_VALUES:
 288                                 printf("%d\t%s\t[values list]",
 289                                            i, rte->eref->aliasname);
 290                                 break;
 291                         case RTE_CTE:
 292                                 printf("%d\t%s\t[cte]",
 293                                            i, rte->eref->aliasname);
 294                                 break;
 295                         default:
 296                                 printf("%d\t%s\t[unknown rtekind]",
 297                                            i, rte->eref->aliasname);
 298                 }
 299
 300                 printf("\t%s\t%s\n",
 301                            (rte->inh ? "inh" : ""),
 302                            (rte->inFromCl ? "inFromCl" : ""));
 303                 i++;
 304         }
 305 }
 306
 307
 308 /*
 309  * print_expr
 310  *        print an expression
 311  */
 312 void
 313 print_expr(Node *expr, List *rtable)
 314 {
 315         if (expr == NULL)
 316         {
 317                 printf("<>");
 318                 return;
 319         }
 320
 321         if (IsA(expr, Var))
 322         {
 323                 Var                *var = (Var *) expr;
 324                 char       *relname,
 325                                    *attname;
 326
 327                 switch (var->varno)
 328                 {
 329                         case INNER:
 330                                 relname = "INNER";
 331                                 attname = "?";
 332                                 break;
 333                         case OUTER:
 334                                 relname = "OUTER";
 335                                 attname = "?";
 336                                 break;
 337                         default:
 338                                 {
 339                                         RangeTblEntry *rte;
 340
 341                                         Assert(var->varno > 0 &&
 342                                                    (int) var->varno <= list_length(rtable));
 343                                         rte = rt_fetch(var->varno, rtable);
 344                                         relname = rte->eref->aliasname;
 345                                         attname = get_rte_attribute_name(rte, var->varattno);
 346                                 }
 347                                 break;
 348                 }
 349                 printf("%s.%s", relname, attname);
 350         }
 351         else if (IsA(expr, Const))
 352         {
 353                 Const      *c = (Const *) expr;
 354                 Oid                     typoutput;
 355                 bool            typIsVarlena;
 356                 char       *outputstr;
 357
 358                 if (c->constisnull)
 359                 {
 360                         printf("NULL");
 361                         return;
 362                 }
 363
 364                 getTypeOutputInfo(c->consttype,
 365                                                   &typoutput, &typIsVarlena);
 366
 367                 outputstr = OidOutputFunctionCall(typoutput, c->constvalue);
 368                 printf("%s", outputstr);
 369                 pfree(outputstr);
 370         }
 371         else if (IsA(expr, OpExpr))
 372         {
 373                 OpExpr     *e = (OpExpr *) expr;
 374                 char       *opname;
 375
 376                 opname = get_opname(e->opno);
 377                 if (list_length(e->args) > 1)
 378                 {
 379                         print_expr(get_leftop((Expr *) e), rtable);
 380                         printf(" %s ", ((opname != NULL) ? opname : "(invalid operator)"));
 381                         print_expr(get_rightop((Expr *) e), rtable);
 382                 }
 383                 else
 384                 {
 385                         /* we print prefix and postfix ops the same... */
 386                         printf("%s ", ((opname != NULL) ? opname : "(invalid operator)"));
 387                         print_expr(get_leftop((Expr *) e), rtable);
 388                 }
 389         }
 390         else if (IsA(expr, FuncExpr))
 391         {
 392                 FuncExpr   *e = (FuncExpr *) expr;
 393                 char       *funcname;
 394                 ListCell   *l;
 395
 396                 funcname = get_func_name(e->funcid);
 397                 printf("%s(", ((funcname != NULL) ? funcname : "(invalid function)"));
 398                 foreach(l, e->args)
 399                 {
 400                         print_expr(lfirst(l), rtable);
 401                         if (lnext(l))
 402                                 printf(",");
 403                 }
 404                 printf(")");
 405         }
 406         else
 407                 printf("unknown expr");
 408 }
 409
 410 /*
 411  * print_pathkeys -
 412  *        pathkeys list of PathKeys
 413  */
 414 void
 415 print_pathkeys(List *pathkeys, List *rtable)
 416 {
 417         ListCell   *i;
 418
 419         printf("(");
 420         foreach(i, pathkeys)
 421         {
 422                 PathKey    *pathkey = (PathKey *) lfirst(i);
 423                 EquivalenceClass *eclass;
 424                 ListCell   *k;
 425                 bool            first = true;
 426
 427                 eclass = pathkey->pk_eclass;
 428                 /* chase up, in case pathkey is non-canonical */
 429                 while (eclass->ec_merged)
 430                         eclass = eclass->ec_merged;
 431
 432                 printf("(");
 433                 foreach(k, eclass->ec_members)
 434                 {
 435                         EquivalenceMember *mem = (EquivalenceMember *) lfirst(k);
 436
 437                         if (first)
 438                                 first = false;
 439                         else
 440                                 printf(", ");
 441                         print_expr((Node *) mem->em_expr, rtable);
 442                 }
 443                 printf(")");
 444                 if (lnext(i))
 445                         printf(", ");
 446         }
 447         printf(")\n");
 448 }
 449
 450 /*
 451  * print_tl
 452  *        print targetlist in a more legible way.
 453  */
 454 void
 455 print_tl(List *tlist, List *rtable)
 456 {
 457         ListCell   *tl;
 458
 459         printf("(\n");
 460         foreach(tl, tlist)
 461         {
 462                 TargetEntry *tle = (TargetEntry *) lfirst(tl);
 463
 464                 printf("\t%d %s\t", tle->resno,
 465                            tle->resname ? tle->resname : "<null>");
 466                 if (tle->ressortgroupref != 0)
 467                         printf("(%u):\t", tle->ressortgroupref);
 468                 else
 469                         printf("    :\t");
 470                 print_expr((Node *) tle->expr, rtable);
 471                 printf("\n");
 472         }
 473         printf(")\n");
 474 }
 475
 476 /*
 477  * print_slot
 478  *        print out the tuple with the given TupleTableSlot
 479  */
 480 void
 481 print_slot(TupleTableSlot *slot)
 482 {
 483         if (TupIsNull(slot))
 484         {
 485                 printf("tuple is null.\n");
 486                 return;
 487         }
 488         if (!slot->tts_tupleDescriptor)
 489         {
 490                 printf("no tuple descriptor.\n");
 491                 return;
 492         }
 493
 494         debugtup(slot, NULL);
 495 }