src/backend/utils/error/debugutils.c - hawq - Git at Google

 /*
  * debugutils.c
  *
  * Routines for debugging Greenplum DB
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  *
  */

 #include "postgres.h"
 #include "fmgr.h"

 #include <stdio.h>
 #include <unistd.h>

 #include "nodes/plannodes.h"
 #include "utils/debugutils.h"
 #include "utils/lsyscache.h"


 static void
 printatt(unsigned attributeId,
 		 Form_pg_attribute attributeP,
 		 char *value, char *buf)
 {
 	sprintf(buf,
 			 "\t%2d: %s%s%s%s\t(typeid = %u, len = %d, typmod = %d, byval = %c)|",
 		   attributeId,
 		   NameStr(attributeP->attname),
 		   value != NULL ? " = \"" : "",
 		   value != NULL ? value : "",
 		   value != NULL ? "\"" : "",
 		   (unsigned int) (attributeP->atttypid),
 		   attributeP->attlen,
 		   attributeP->atttypmod,
 		   attributeP->attbyval ? 't' : 'f');
 }

 /*
  * Return a human readable string representation of a tuple. The returned
  * string must be pfree()d by the caller.
  */

 char *
 tup2str(TupleTableSlot *slot)
 {
 	TupleDesc	typeinfo = slot->tts_tupleDescriptor;
 	int			natts = typeinfo->natts;
 	int			i;
 	Datum		origattr,
 				attr;
 	char	   *value;
 	bool		isnull;
 	Oid			typoutput;
 	bool		typisvarlena;
 	char	   *buf;

 	buf = palloc(10 * 1024);
 	buf[0] = '\0';

 	for (i = 0; i < natts; ++i)
 	{
 		origattr = slot_getattr(slot, i + 1, &isnull);
 		if (isnull)
 			continue;
 		getTypeOutputInfo(typeinfo->attrs[i]->atttypid,
 						  &typoutput, &typisvarlena);

 		/*
 		 * If we have a toasted datum, forcibly detoast it here to avoid
 		 * memory leakage inside the type's output routine.
 		 */
 		if (typisvarlena)
 			attr = PointerGetDatum(PG_DETOAST_DATUM(origattr));
 		else
 			attr = origattr;

 		value = OidOutputFunctionCall(typoutput, attr);

 		printatt((unsigned) i + 1, typeinfo->attrs[i], value,
 				 &buf[strlen(buf)]);

 		pfree(value);

 		/* Clean up detoasted copy, if any */
 		if (attr != origattr)
 			pfree(DatumGetPointer(attr));
 	}
 	return buf;
 }

 extern char *plannode_type(Plan *p);

 static void
 drawnode(FILE *ofile, Plan *plan, List *nodelist)
 {
 	if(!plan)
 		return;

 	/* print out the node */
 	fprintf(ofile, "\"Node_0x%p\" [\n", plan);
 	fprintf(ofile, "label=\"%s %p flow %p\"\n", plannode_type(plan), plan, plan->flow);
 	fprintf(ofile, "];\n");

 	if(IsA(plan, Append))
 	{
 		Append *app = (Append *) plan;
 		ListCell *cell;
 		foreach(cell, app->appendplans)
 		{
 			Plan *child = (Plan *) lfirst(cell);
 			if(!list_member_ptr(nodelist, child))
 			{
 				nodelist = lappend(nodelist, child);
 				drawnode(ofile, child, nodelist);
 			}

 			fprintf(ofile, "\"Node_0x%p\" -> \"Node_0x%p\" [\n", plan, child);
 			fprintf(ofile, "];\n");
 		}
 	}
 	else if (IsA(plan, SubqueryScan))
 	{
 		SubqueryScan *subq = (SubqueryScan *) plan;
 		Plan *child = subq->subplan;
 		if(!list_member_ptr(nodelist, child))
 		{
 			nodelist = lappend(nodelist, child);
 			drawnode(ofile, child, nodelist);
 		}

 		fprintf(ofile, "\"Node_0x%p\" -> \"Node_0x%p\" [\n", plan, child);
 		fprintf(ofile, "];\n");
 	}
 	else
 	{
 		Plan *child = plan->lefttree;
 		if(child)
 		{
 			if(!list_member_ptr(nodelist, child))
 			{
 				nodelist = lappend(nodelist, child);
 				drawnode(ofile, child, nodelist);
 			}

 			fprintf(ofile, "\"Node_0x%p\" -> \"Node_0x%p\" [\n", plan, child);
 			fprintf(ofile, "];\n");
 		}
 		child = plan->righttree;
 		if(child)
 		{
 			if(!list_member_ptr(nodelist, child))
 			{
 				nodelist = lappend(nodelist, child);
 				drawnode(ofile, child, nodelist);
 			}

 			fprintf(ofile, "\"Node_0x%p\" -> \"Node_0x%p\" [\n", plan, child);
 			fprintf(ofile, "];\n");
 		}
 	}
 }

 /*
  * Write out a plan to be interpretted by dot(1). Tools available at
  * http://www.graphviz.org
  */
 void
 dotnode(void *node, const char *fname)
 {
 	List *nodelist = NULL;
 	FILE *ofile = fopen(fname, "w+");

 	/* Print dot header */

 	fprintf(ofile, "digraph g {\n");
 	fprintf(ofile, "graph [\n");
 	fprintf(ofile, "];\n");

 	fprintf(ofile, "node [\n");
 	fprintf(ofile, "fontsize = \"14\"\n");
 	fprintf(ofile, "shape = \"box\"\n");
 	fprintf(ofile, "];\n");
 	fprintf(ofile, "edge [\n");
 	fprintf(ofile, "fontsize = \"14\"\n");
 	fprintf(ofile, "];\n");

 	if(node)
 	{
 		nodelist = lappend(nodelist, node);
 		drawnode(ofile, (Plan *) node, nodelist);
 	}

 	fprintf(ofile, "}\n");
 	fclose(ofile);
 }

 /*
  * dump a tupledesc
  */
 void dump_tupdesc(TupleDesc tupdesc, const char *fname)
 {
 	FILE *ofile = fopen(fname, "w+");
     int i;

     fprintf(ofile, "TupleDesc: natts %d, hasoid %s\n", tupdesc->natts, tupdesc->tdhasoid ? "true" : "false");
     fprintf(ofile, "Name\t\tattlen\tattbyval\tattalign\n");
     fprintf(ofile, "==================================\n");
     for (i=0; i<tupdesc->natts; ++i)
     {
         Form_pg_attribute attr = tupdesc->attrs[i];
         fprintf(ofile, "%s, %d, %s, %c\n",
                     attr->attname.data, attr->attlen,
                     attr->attbyval ? "true" : "false",
                     attr->attalign
                );
     }

     fclose(ofile);
 }

 /*
  * dump a memtuple binding
  */
 void dump_mt_bind(MemTupleBinding *mt_bind, const char *fname)
 {
     FILE *ofile = fopen(fname, "w+");
     int i;

     fprintf(ofile, "Mt_bind: column_align %d, nbm_extra_size %d\n",
             mt_bind->column_align, mt_bind->null_bitmap_extra_size);
     fprintf(ofile, "TupleDesc: natts %d, hasoid %s\n",
                     mt_bind->tupdesc->natts,
                     mt_bind->tupdesc->tdhasoid ? "true" : "false");

     fprintf(ofile, " Small binding: vastart %d\n", mt_bind->bind.var_start);
     fprintf(ofile, "Name\t\tattlen\tattbyval\tattalign\toffset\tlen\tflag\tnb\tnm\tns\n");
     fprintf(ofile, "==================================\n");
     for (i=0; i<mt_bind->tupdesc->natts; ++i)
     {
         Form_pg_attribute attr = mt_bind->tupdesc->attrs[i];

         fprintf(ofile, "%s, %d, %s, %c, %d, %d, %d, %d, %d, %d\n",
                     attr->attname.data, attr->attlen,
                     attr->attbyval ? "true" : "false",
                     attr->attalign,
                     mt_bind->bind.bindings[i].offset,
                     mt_bind->bind.bindings[i].len,
                     mt_bind->bind.bindings[i].flag,
                     mt_bind->bind.bindings[i].null_byte,
                     mt_bind->bind.bindings[i].null_mask,
                     mt_bind->bind.null_saves[i]
                );
     }

     fprintf(ofile, "\n\n Large binding: vastart %d\n", mt_bind->large_bind.var_start);
     fprintf(ofile, "Name\t\tattlen\tattbyval\tattalign\toffset\tlen\tflag\tnb\tnm\tns\n");
     fprintf(ofile, "==================================\n");
     for (i=0; i<mt_bind->tupdesc->natts; ++i)
     {
         Form_pg_attribute attr = mt_bind->tupdesc->attrs[i];

         fprintf(ofile, "%s, %d, %s, %c, %d, %d, %d, %d, %d, %d\n",
                     attr->attname.data, attr->attlen,
                     attr->attbyval ? "true" : "false",
                     attr->attalign,
                     mt_bind->large_bind.bindings[i].offset,
                     mt_bind->large_bind.bindings[i].len,
                     mt_bind->large_bind.bindings[i].flag,
                     mt_bind->large_bind.bindings[i].null_byte,
                     mt_bind->large_bind.bindings[i].null_mask,
                     mt_bind->large_bind.null_saves[i]
                );
     }
 }

 #ifdef USE_ASSERT_CHECKING
 /*
  * Debugging - create/overwrite named file with contents of string.
  *
  * Use, e.g., with gdb to save debugging output.
  */

 #include <stdio.h>
 #include <string.h>

 int debug_write(const char *filename, const char *output_string)
 {
 	FILE *file;

 	file = fopen(filename, "w");

 	if ( !file )
 	{
 		fprintf(stderr, "debug_write: can't open \"%s\" for output", filename);
 		return 1;
 	}

 	if ( fprintf(file, "%s\n", output_string) == EOF )
 	{
 	    fprintf(stderr, "debug_write: can't write to \"%s\"", filename);
 		fclose(file);
 		return 1;
 	}

 	fclose(file);
 	return 0;
 }
 #endif
	/*
	* debugutils.c
	*
	* Routines for debugging Greenplum DB
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*
	*/

	#include "postgres.h"
	#include "fmgr.h"

	#include <stdio.h>
	#include <unistd.h>

	#include "nodes/plannodes.h"
	#include "utils/debugutils.h"
	#include "utils/lsyscache.h"


	static void
	printatt(unsigned attributeId,
	Form_pg_attribute attributeP,
	char value, char buf)
	{
	sprintf(buf,
	"\t%2d: %s%s%s%s\t(typeid = %u, len = %d, typmod = %d, byval = %c)\|",
	attributeId,
	NameStr(attributeP->attname),
	value != NULL ? " = \"" : "",
	value != NULL ? value : "",
	value != NULL ? "\"" : "",
	(unsigned int) (attributeP->atttypid),
	attributeP->attlen,
	attributeP->atttypmod,
	attributeP->attbyval ? 't' : 'f');
	}

	/*
	* Return a human readable string representation of a tuple. The returned
	* string must be pfree()d by the caller.
	*/

	char *
	tup2str(TupleTableSlot *slot)
	{
	TupleDesc typeinfo = slot->tts_tupleDescriptor;
	int natts = typeinfo->natts;
	int i;
	Datum origattr,
	attr;
	char *value;
	bool isnull;
	Oid typoutput;
	bool typisvarlena;
	char *buf;

	buf = palloc(10 * 1024);
	buf[0] = '\0';

	for (i = 0; i < natts; ++i)
	{
	origattr = slot_getattr(slot, i + 1, &isnull);
	if (isnull)
	continue;
	getTypeOutputInfo(typeinfo->attrs[i]->atttypid,
	&typoutput, &typisvarlena);

	/*
	* If we have a toasted datum, forcibly detoast it here to avoid
	* memory leakage inside the type's output routine.
	*/
	if (typisvarlena)
	attr = PointerGetDatum(PG_DETOAST_DATUM(origattr));
	else
	attr = origattr;

	value = OidOutputFunctionCall(typoutput, attr);

	printatt((unsigned) i + 1, typeinfo->attrs[i], value,
	&buf[strlen(buf)]);

	pfree(value);

	/* Clean up detoasted copy, if any */
	if (attr != origattr)
	pfree(DatumGetPointer(attr));
	}
	return buf;
	}

	extern char plannode_type(Plan p);

	static void
	drawnode(FILE ofile, Plan plan, List *nodelist)
	{
	if(!plan)
	return;

	/* print out the node */
	fprintf(ofile, "\"Node_0x%p\" [\n", plan);
	fprintf(ofile, "label=\"%s %p flow %p\"\n", plannode_type(plan), plan, plan->flow);
	fprintf(ofile, "];\n");

	if(IsA(plan, Append))
	{
	Append app = (Append ) plan;
	ListCell *cell;
	foreach(cell, app->appendplans)
	{
	Plan child = (Plan ) lfirst(cell);
	if(!list_member_ptr(nodelist, child))
	{
	nodelist = lappend(nodelist, child);
	drawnode(ofile, child, nodelist);
	}

	fprintf(ofile, "\"Node_0x%p\" -> \"Node_0x%p\" [\n", plan, child);
	fprintf(ofile, "];\n");
	}
	}
	else if (IsA(plan, SubqueryScan))
	{
	SubqueryScan subq = (SubqueryScan ) plan;
	Plan *child = subq->subplan;
	if(!list_member_ptr(nodelist, child))
	{
	nodelist = lappend(nodelist, child);
	drawnode(ofile, child, nodelist);
	}

	fprintf(ofile, "\"Node_0x%p\" -> \"Node_0x%p\" [\n", plan, child);
	fprintf(ofile, "];\n");
	}
	else
	{
	Plan *child = plan->lefttree;
	if(child)
	{
	if(!list_member_ptr(nodelist, child))
	{
	nodelist = lappend(nodelist, child);
	drawnode(ofile, child, nodelist);
	}

	fprintf(ofile, "\"Node_0x%p\" -> \"Node_0x%p\" [\n", plan, child);
	fprintf(ofile, "];\n");
	}
	child = plan->righttree;
	if(child)
	{
	if(!list_member_ptr(nodelist, child))
	{
	nodelist = lappend(nodelist, child);
	drawnode(ofile, child, nodelist);
	}

	fprintf(ofile, "\"Node_0x%p\" -> \"Node_0x%p\" [\n", plan, child);
	fprintf(ofile, "];\n");
	}
	}
	}

	/*
	* Write out a plan to be interpretted by dot(1). Tools available at
	* http://www.graphviz.org
	*/
	void
	dotnode(void node, const char fname)
	{
	List *nodelist = NULL;
	FILE *ofile = fopen(fname, "w+");

	/* Print dot header */

	fprintf(ofile, "digraph g {\n");
	fprintf(ofile, "graph [\n");
	fprintf(ofile, "];\n");

	fprintf(ofile, "node [\n");
	fprintf(ofile, "fontsize = \"14\"\n");
	fprintf(ofile, "shape = \"box\"\n");
	fprintf(ofile, "];\n");
	fprintf(ofile, "edge [\n");
	fprintf(ofile, "fontsize = \"14\"\n");
	fprintf(ofile, "];\n");

	if(node)
	{
	nodelist = lappend(nodelist, node);
	drawnode(ofile, (Plan *) node, nodelist);
	}

	fprintf(ofile, "}\n");
	fclose(ofile);
	}

	/*
	* dump a tupledesc
	*/
	void dump_tupdesc(TupleDesc tupdesc, const char *fname)
	{
	FILE *ofile = fopen(fname, "w+");
	int i;

	fprintf(ofile, "TupleDesc: natts %d, hasoid %s\n", tupdesc->natts, tupdesc->tdhasoid ? "true" : "false");
	fprintf(ofile, "Name\t\tattlen\tattbyval\tattalign\n");
	fprintf(ofile, "==================================\n");
	for (i=0; i<tupdesc->natts; ++i)
	{
	Form_pg_attribute attr = tupdesc->attrs[i];
	fprintf(ofile, "%s, %d, %s, %c\n",
	attr->attname.data, attr->attlen,
	attr->attbyval ? "true" : "false",
	attr->attalign
	);
	}

	fclose(ofile);
	}

	/*
	* dump a memtuple binding
	*/
	void dump_mt_bind(MemTupleBinding mt_bind, const char fname)
	{
	FILE *ofile = fopen(fname, "w+");
	int i;

	fprintf(ofile, "Mt_bind: column_align %d, nbm_extra_size %d\n",
	mt_bind->column_align, mt_bind->null_bitmap_extra_size);
	fprintf(ofile, "TupleDesc: natts %d, hasoid %s\n",
	mt_bind->tupdesc->natts,
	mt_bind->tupdesc->tdhasoid ? "true" : "false");

	fprintf(ofile, " Small binding: vastart %d\n", mt_bind->bind.var_start);
	fprintf(ofile, "Name\t\tattlen\tattbyval\tattalign\toffset\tlen\tflag\tnb\tnm\tns\n");
	fprintf(ofile, "==================================\n");
	for (i=0; i<mt_bind->tupdesc->natts; ++i)
	{
	Form_pg_attribute attr = mt_bind->tupdesc->attrs[i];

	fprintf(ofile, "%s, %d, %s, %c, %d, %d, %d, %d, %d, %d\n",
	attr->attname.data, attr->attlen,
	attr->attbyval ? "true" : "false",
	attr->attalign,
	mt_bind->bind.bindings[i].offset,
	mt_bind->bind.bindings[i].len,
	mt_bind->bind.bindings[i].flag,
	mt_bind->bind.bindings[i].null_byte,
	mt_bind->bind.bindings[i].null_mask,
	mt_bind->bind.null_saves[i]
	);
	}

	fprintf(ofile, "\n\n Large binding: vastart %d\n", mt_bind->large_bind.var_start);
	fprintf(ofile, "Name\t\tattlen\tattbyval\tattalign\toffset\tlen\tflag\tnb\tnm\tns\n");
	fprintf(ofile, "==================================\n");
	for (i=0; i<mt_bind->tupdesc->natts; ++i)
	{
	Form_pg_attribute attr = mt_bind->tupdesc->attrs[i];

	fprintf(ofile, "%s, %d, %s, %c, %d, %d, %d, %d, %d, %d\n",
	attr->attname.data, attr->attlen,
	attr->attbyval ? "true" : "false",
	attr->attalign,
	mt_bind->large_bind.bindings[i].offset,
	mt_bind->large_bind.bindings[i].len,
	mt_bind->large_bind.bindings[i].flag,
	mt_bind->large_bind.bindings[i].null_byte,
	mt_bind->large_bind.bindings[i].null_mask,
	mt_bind->large_bind.null_saves[i]
	);
	}
	}

	#ifdef USE_ASSERT_CHECKING
	/*
	* Debugging - create/overwrite named file with contents of string.
	*
	* Use, e.g., with gdb to save debugging output.
	*/

	#include <stdio.h>
	#include <string.h>

	int debug_write(const char filename, const char output_string)
	{
	FILE *file;

	file = fopen(filename, "w");

	if ( !file )
	{
	fprintf(stderr, "debug_write: can't open \"%s\" for output", filename);
	return 1;
	}

	if ( fprintf(file, "%s\n", output_string) == EOF )
	{
	fprintf(stderr, "debug_write: can't write to \"%s\"", filename);
	fclose(file);
	return 1;
	}

	fclose(file);
	return 0;
	}
	#endif