PostgreSQL Source Code  git master
print.c File Reference
#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"
Include dependency graph for print.c:

Go to the source code of this file.

Macros

#define LINELEN   78
 
#define INDENTSTOP   3
 
#define MAXINDENT   60
 
#define LINELEN   78
 

Functions

void print (const void *obj)
 
void pprint (const void *obj)
 
void elog_node_display (int lev, const char *title, const void *obj, bool pretty)
 
char * format_node_dump (const char *dump)
 
char * pretty_format_node_dump (const char *dump)
 
void print_rt (const List *rtable)
 
void print_expr (const Node *expr, const List *rtable)
 
void print_pathkeys (const List *pathkeys, const List *rtable)
 
void print_tl (const List *tlist, const List *rtable)
 
void print_slot (TupleTableSlot *slot)
 

Macro Definition Documentation

◆ INDENTSTOP

#define INDENTSTOP   3

Referenced by pretty_format_node_dump().

◆ LINELEN [1/2]

#define LINELEN   78

◆ LINELEN [2/2]

#define LINELEN   78

◆ MAXINDENT

#define MAXINDENT   60

Referenced by pretty_format_node_dump().

Function Documentation

◆ elog_node_display()

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

Definition at line 72 of file print.c.

References ereport, errdetail_internal(), errmsg_internal(), format_node_dump(), nodeToString(), pfree(), and pretty_format_node_dump().

Referenced by pg_plan_query(), and pg_rewrite_query().

73 {
74  char *s;
75  char *f;
76 
77  s = nodeToString(obj);
78  if (pretty)
80  else
81  f = format_node_dump(s);
82  pfree(s);
83  ereport(lev,
84  (errmsg_internal("%s:", title),
85  errdetail_internal("%s", f)));
86  pfree(f);
87 }
char * pretty_format_node_dump(const char *dump)
Definition: print.c:151
int errdetail_internal(const char *fmt,...)
Definition: elog.c:887
void pfree(void *pointer)
Definition: mcxt.c:1056
#define ereport(elevel, rest)
Definition: elog.h:141
int errmsg_internal(const char *fmt,...)
Definition: elog.c:814
char * format_node_dump(const char *dump)
Definition: print.c:97
char * nodeToString(const void *obj)
Definition: outfuncs.c:4316

◆ format_node_dump()

char* format_node_dump ( const char *  dump)

Definition at line 97 of file print.c.

References appendStringInfo(), StringInfoData::data, i, initStringInfo(), LINELEN, and generate_unaccent_rules::str.

Referenced by elog_node_display(), and print().

98 {
99 #define LINELEN 78
100  char line[LINELEN + 1];
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 }
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:78
void initStringInfo(StringInfo str)
Definition: stringinfo.c:46
#define LINELEN
int i

◆ pprint()

void pprint ( const void *  obj)

Definition at line 54 of file print.c.

References nodeToString(), pfree(), pretty_format_node_dump(), printf, and generate_unaccent_rules::stdout.

Referenced by preprocess_expression().

55 {
56  char *s;
57  char *f;
58 
59  s = nodeToString(obj);
61  pfree(s);
62  printf("%s\n", f);
63  fflush(stdout);
64  pfree(f);
65 }
char * pretty_format_node_dump(const char *dump)
Definition: print.c:151
#define printf(...)
Definition: port.h:198
void pfree(void *pointer)
Definition: mcxt.c:1056
char * nodeToString(const void *obj)
Definition: outfuncs.c:4316

◆ pretty_format_node_dump()

char* pretty_format_node_dump ( const char *  dump)

Definition at line 151 of file print.c.

References appendStringInfo(), StringInfoData::data, i, INDENTSTOP, initStringInfo(), LINELEN, MAXINDENT, Min, and generate_unaccent_rules::str.

Referenced by elog_node_display(), and pprint().

152 {
153 #define INDENTSTOP 3
154 #define MAXINDENT 60
155 #define LINELEN 78
156  char line[LINELEN + 1];
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 }
#define Min(x, y)
Definition: c.h:904
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:78
void initStringInfo(StringInfo str)
Definition: stringinfo.c:46
#define MAXINDENT
#define LINELEN
#define INDENTSTOP
int i

◆ print()

void print ( const void *  obj)

Definition at line 36 of file print.c.

References format_node_dump(), nodeToString(), pfree(), printf, and generate_unaccent_rules::stdout.

Referenced by generate_unaccent_rules::print_record().

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 }
#define printf(...)
Definition: port.h:198
void pfree(void *pointer)
Definition: mcxt.c:1056
char * format_node_dump(const char *dump)
Definition: print.c:97
char * nodeToString(const void *obj)
Definition: outfuncs.c:4316

◆ print_expr()

void print_expr ( const Node expr,
const List rtable 
)

Definition at line 321 of file print.c.

References Alias::aliasname, FuncExpr::args, OpExpr::args, Assert, attname, Const::constisnull, Const::consttype, Const::constvalue, RangeTblEntry::eref, FuncExpr::funcid, get_func_name(), get_leftop(), get_opname(), get_rightop(), get_rte_attribute_name(), getTypeOutputInfo(), INDEX_VAR, INNER_VAR, IsA, lfirst, list_length(), lnext(), OidOutputFunctionCall(), OpExpr::opno, OUTER_VAR, pfree(), print_expr(), printf, relname, rt_fetch, Var::varattno, and Var::varno.

Referenced by generate_partitionwise_join_paths(), print_expr(), print_pathkeys(), and print_tl().

322 {
323  if (expr == NULL)
324  {
325  printf("<>");
326  return;
327  }
328 
329  if (IsA(expr, Var))
330  {
331  const Var *var = (const Var *) expr;
332  char *relname,
333  *attname;
334 
335  switch (var->varno)
336  {
337  case INNER_VAR:
338  relname = "INNER";
339  attname = "?";
340  break;
341  case OUTER_VAR:
342  relname = "OUTER";
343  attname = "?";
344  break;
345  case INDEX_VAR:
346  relname = "INDEX";
347  attname = "?";
348  break;
349  default:
350  {
351  RangeTblEntry *rte;
352 
353  Assert(var->varno > 0 &&
354  (int) var->varno <= list_length(rtable));
355  rte = rt_fetch(var->varno, rtable);
356  relname = rte->eref->aliasname;
357  attname = get_rte_attribute_name(rte, var->varattno);
358  }
359  break;
360  }
361  printf("%s.%s", relname, attname);
362  }
363  else if (IsA(expr, Const))
364  {
365  const Const *c = (const Const *) expr;
366  Oid typoutput;
367  bool typIsVarlena;
368  char *outputstr;
369 
370  if (c->constisnull)
371  {
372  printf("NULL");
373  return;
374  }
375 
377  &typoutput, &typIsVarlena);
378 
379  outputstr = OidOutputFunctionCall(typoutput, c->constvalue);
380  printf("%s", outputstr);
381  pfree(outputstr);
382  }
383  else if (IsA(expr, OpExpr))
384  {
385  const OpExpr *e = (const OpExpr *) expr;
386  char *opname;
387 
388  opname = get_opname(e->opno);
389  if (list_length(e->args) > 1)
390  {
391  print_expr(get_leftop((const Expr *) e), rtable);
392  printf(" %s ", ((opname != NULL) ? opname : "(invalid operator)"));
393  print_expr(get_rightop((const Expr *) e), rtable);
394  }
395  else
396  {
397  /* we print prefix and postfix ops the same... */
398  printf("%s ", ((opname != NULL) ? opname : "(invalid operator)"));
399  print_expr(get_leftop((const Expr *) e), rtable);
400  }
401  }
402  else if (IsA(expr, FuncExpr))
403  {
404  const FuncExpr *e = (const FuncExpr *) expr;
405  char *funcname;
406  ListCell *l;
407 
408  funcname = get_func_name(e->funcid);
409  printf("%s(", ((funcname != NULL) ? funcname : "(invalid function)"));
410  foreach(l, e->args)
411  {
412  print_expr(lfirst(l), rtable);
413  if (lnext(e->args, l))
414  printf(",");
415  }
416  printf(")");
417  }
418  else
419  printf("unknown expr");
420 }
Datum constvalue
Definition: primnodes.h:200
#define IsA(nodeptr, _type_)
Definition: nodes.h:576
void getTypeOutputInfo(Oid type, Oid *typOutput, bool *typIsVarlena)
Definition: lsyscache.c:2674
List * args
Definition: primnodes.h:463
static ListCell * lnext(const List *l, const ListCell *c)
Definition: pg_list.h:321
AttrNumber varattno
Definition: primnodes.h:172
#define printf(...)
Definition: port.h:198
NameData relname
Definition: pg_class.h:35
unsigned int Oid
Definition: postgres_ext.h:31
Definition: primnodes.h:167
Oid consttype
Definition: primnodes.h:196
char * get_opname(Oid opno)
Definition: lsyscache.c:1117
void pfree(void *pointer)
Definition: mcxt.c:1056
Oid funcid
Definition: primnodes.h:455
NameData attname
Definition: pg_attribute.h:40
char * get_func_name(Oid funcid)
Definition: lsyscache.c:1410
char * c
static Node * get_leftop(const void *clause)
Definition: nodeFuncs.h:70
void print_expr(const Node *expr, const List *rtable)
Definition: print.c:321
#define rt_fetch(rangetable_index, rangetable)
Definition: parsetree.h:31
Index varno
Definition: primnodes.h:170
static Node * get_rightop(const void *clause)
Definition: nodeFuncs.h:82
#define INNER_VAR
Definition: primnodes.h:157
char * get_rte_attribute_name(RangeTblEntry *rte, AttrNumber attnum)
#define Assert(condition)
Definition: c.h:732
#define lfirst(lc)
Definition: pg_list.h:190
char * aliasname
Definition: primnodes.h:42
static int list_length(const List *l)
Definition: pg_list.h:169
e
Definition: preproc-init.c:82
char * OidOutputFunctionCall(Oid functionId, Datum val)
Definition: fmgr.c:1655
Oid opno
Definition: primnodes.h:502
Alias * eref
Definition: parsenodes.h:1092
List * args
Definition: primnodes.h:508
#define INDEX_VAR
Definition: primnodes.h:159
#define OUTER_VAR
Definition: primnodes.h:158
bool constisnull
Definition: primnodes.h:201

◆ print_pathkeys()

void print_pathkeys ( const List pathkeys,
const List rtable 
)

Definition at line 427 of file print.c.

References EquivalenceClass::ec_members, EquivalenceClass::ec_merged, eclass(), EquivalenceMember::em_expr, i, lfirst, lnext(), PathKey::pk_eclass, print_expr(), and printf.

Referenced by generate_partitionwise_join_paths().

428 {
429  const ListCell *i;
430 
431  printf("(");
432  foreach(i, pathkeys)
433  {
434  PathKey *pathkey = (PathKey *) lfirst(i);
436  ListCell *k;
437  bool first = true;
438 
439  eclass = pathkey->pk_eclass;
440  /* chase up, in case pathkey is non-canonical */
441  while (eclass->ec_merged)
442  eclass = eclass->ec_merged;
443 
444  printf("(");
445  foreach(k, eclass->ec_members)
446  {
448 
449  if (first)
450  first = false;
451  else
452  printf(", ");
453  print_expr((Node *) mem->em_expr, rtable);
454  }
455  printf(")");
456  if (lnext(pathkeys, i))
457  printf(", ");
458  }
459  printf(")\n");
460 }
static ListCell * lnext(const List *l, const ListCell *c)
Definition: pg_list.h:321
Definition: nodes.h:525
#define printf(...)
Definition: port.h:198
static struct cvec * eclass(struct vars *v, chr c, int cases)
Definition: regc_locale.c:508
void print_expr(const Node *expr, const List *rtable)
Definition: print.c:321
#define lfirst(lc)
Definition: pg_list.h:190
EquivalenceClass * pk_eclass
Definition: pathnodes.h:1011
int i
struct EquivalenceClass * ec_merged
Definition: pathnodes.h:946
List * ec_members
Definition: pathnodes.h:934

◆ print_rt()

void print_rt ( const List rtable)

Definition at line 254 of file print.c.

References Alias::aliasname, RangeTblEntry::eref, i, RangeTblEntry::inFromCl, RangeTblEntry::inh, lfirst, printf, RangeTblEntry::relid, RangeTblEntry::relkind, RTE_CTE, RTE_FUNCTION, RTE_JOIN, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_RESULT, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, and RangeTblEntry::rtekind.

255 {
256  const 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\t%c",
269  i, rte->eref->aliasname, rte->relid, rte->relkind);
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_FUNCTION:
280  printf("%d\t%s\t[rangefunction]",
281  i, rte->eref->aliasname);
282  break;
283  case RTE_TABLEFUNC:
284  printf("%d\t%s\t[table function]",
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  case RTE_NAMEDTUPLESTORE:
296  printf("%d\t%s\t[tuplestore]",
297  i, rte->eref->aliasname);
298  break;
299  case RTE_RESULT:
300  printf("%d\t%s\t[result]",
301  i, rte->eref->aliasname);
302  break;
303  default:
304  printf("%d\t%s\t[unknown rtekind]",
305  i, rte->eref->aliasname);
306  }
307 
308  printf("\t%s\t%s\n",
309  (rte->inh ? "inh" : ""),
310  (rte->inFromCl ? "inFromCl" : ""));
311  i++;
312  }
313 }
#define printf(...)
Definition: port.h:198
#define lfirst(lc)
Definition: pg_list.h:190
char * aliasname
Definition: primnodes.h:42
RTEKind rtekind
Definition: parsenodes.h:974
int i
Alias * eref
Definition: parsenodes.h:1092

◆ print_slot()

void print_slot ( TupleTableSlot slot)

Definition at line 493 of file print.c.

References debugtup(), printf, TupleTableSlot::tts_tupleDescriptor, and TupIsNull.

494 {
495  if (TupIsNull(slot))
496  {
497  printf("tuple is null.\n");
498  return;
499  }
500  if (!slot->tts_tupleDescriptor)
501  {
502  printf("no tuple descriptor.\n");
503  return;
504  }
505 
506  debugtup(slot, NULL);
507 }
#define printf(...)
Definition: port.h:198
#define TupIsNull(slot)
Definition: tuptable.h:293
TupleDesc tts_tupleDescriptor
Definition: tuptable.h:124
bool debugtup(TupleTableSlot *slot, DestReceiver *self)
Definition: printtup.c:614

◆ print_tl()

void print_tl ( const List tlist,
const List rtable 
)

Definition at line 467 of file print.c.

References TargetEntry::expr, lfirst, print_expr(), printf, TargetEntry::resname, TargetEntry::resno, and TargetEntry::ressortgroupref.

468 {
469  const ListCell *tl;
470 
471  printf("(\n");
472  foreach(tl, tlist)
473  {
474  TargetEntry *tle = (TargetEntry *) lfirst(tl);
475 
476  printf("\t%d %s\t", tle->resno,
477  tle->resname ? tle->resname : "<null>");
478  if (tle->ressortgroupref != 0)
479  printf("(%u):\t", tle->ressortgroupref);
480  else
481  printf(" :\t");
482  print_expr((Node *) tle->expr, rtable);
483  printf("\n");
484  }
485  printf(")\n");
486 }
Definition: nodes.h:525
#define printf(...)
Definition: port.h:198
char * resname
Definition: primnodes.h:1395
AttrNumber resno
Definition: primnodes.h:1394
void print_expr(const Node *expr, const List *rtable)
Definition: print.c:321
#define lfirst(lc)
Definition: pg_list.h:190
Expr * expr
Definition: primnodes.h:1393
Index ressortgroupref
Definition: primnodes.h:1396