Adding upstream version 13.4.upstream/13.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 507 insertions, 0 deletions

diff --git a/src/backend/nodes/print.c b/src/backend/nodes/print.c
new file mode 100644
index 0000000..4247672
--- /dev/null
+++ b/src/backend/nodes/print.c
@@ -0,0 +1,507 @@
+/*-------------------------------------------------------------------------
+ *
+ * print.c
+ *	  various print routines (used mostly for debugging)
+ *
+ * Portions Copyright (c) 1996-2020, 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 = nodeToString(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 = nodeToString(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 = nodeToString(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;
+			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
+		{
+			/* we print prefix and postfix ops the same... */
+			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);
+}