diff options
Diffstat (limited to 'src/include/executor/execdebug.h')
| -rw-r--r-- | src/include/executor/execdebug.h | 360 |
1 files changed, 180 insertions, 180 deletions
diff --git a/src/include/executor/execdebug.h b/src/include/executor/execdebug.h index 3a47ef01aa1..61d298403b3 100644 --- a/src/include/executor/execdebug.h +++ b/src/include/executor/execdebug.h @@ -1,12 +1,12 @@ /*------------------------------------------------------------------------- * * execdebug.h-- - * #defines governing debugging behaviour in the executor + * #defines governing debugging behaviour in the executor * * * Copyright (c) 1994, Regents of the University of California * - * $Id: execdebug.h,v 1.2 1996/11/08 00:46:14 scrappy Exp $ + * $Id: execdebug.h,v 1.3 1997/09/07 04:57:44 momjian Exp $ * *------------------------------------------------------------------------- */ @@ -16,368 +16,368 @@ #include "access/printtup.h" /* ---------------------------------------------------------------- - * debugging defines. + * debugging defines. * - * If you want certain debugging behaviour, then #define - * the variable to 1, else #undef it. -cim 10/26/89 + * If you want certain debugging behaviour, then #define + * the variable to 1, else #undef it. -cim 10/26/89 * ---------------------------------------------------------------- */ /* ---------------- - * EXEC_DEBUGSTORETUP is for tuple table debugging - this - * will print a message every time we call ExecStoreTuple. - * -cim 3/20/91 + * EXEC_DEBUGSTORETUP is for tuple table debugging - this + * will print a message every time we call ExecStoreTuple. + * -cim 3/20/91 * ---------------- */ #undef EXEC_DEBUGSTORETUP /* ---------------- - * EXEC_TUPLECOUNT is a #define which causes the - * executor keep track of tuple counts. This might be - * causing some problems with the decstation stuff so - * you might want to undefine this if you are doing work - * on the decs - cim 10/20/89 + * EXEC_TUPLECOUNT is a #define which causes the + * executor keep track of tuple counts. This might be + * causing some problems with the decstation stuff so + * you might want to undefine this if you are doing work + * on the decs - cim 10/20/89 * ---------------- */ #undef EXEC_TUPLECOUNT /* ---------------- - * EXEC_SHOWBUFSTATS controls whether or not buffer statistics - * are shown for each query. -cim 2/9/89 + * EXEC_SHOWBUFSTATS controls whether or not buffer statistics + * are shown for each query. -cim 2/9/89 * ---------------- */ #undef EXEC_SHOWBUFSTATS /* ---------------- - * EXEC_CONTEXTDEBUG turns on the printing of debugging information - * by CXT_printf() calls regarding which memory context is the - * CurrentMemoryContext for palloc() calls. + * EXEC_CONTEXTDEBUG turns on the printing of debugging information + * by CXT_printf() calls regarding which memory context is the + * CurrentMemoryContext for palloc() calls. * ---------------- */ #undef EXEC_CONTEXTDEBUG /* ---------------- - * EXEC_RETURNSIZE is a compile flag governing the - * behaviour of lispFmgr.. See ExecMakeFunctionResult(). - * Undefining this avoids a problem in the system cache. + * EXEC_RETURNSIZE is a compile flag governing the + * behaviour of lispFmgr.. See ExecMakeFunctionResult(). + * Undefining this avoids a problem in the system cache. * - * Note: undefining this means that there is incorrect - * information in the const nodes corresponding - * to function (or operator) results. The thing is, - * 99% of the time this is fine because when you do - * something like x = emp.sal + 1, you already know - * the type and size of x so the fact that + didn't - * return the correct size doesn't matter. - * With variable length stuff the size is stored in - * the first few bytes of the data so again, it's - * not likely to matter. + * Note: undefining this means that there is incorrect + * information in the const nodes corresponding + * to function (or operator) results. The thing is, + * 99% of the time this is fine because when you do + * something like x = emp.sal + 1, you already know + * the type and size of x so the fact that + didn't + * return the correct size doesn't matter. + * With variable length stuff the size is stored in + * the first few bytes of the data so again, it's + * not likely to matter. * ---------------- */ #undef EXEC_RETURNSIZE /* ---------------- - * EXEC_UTILSDEBUG is a flag which turns on debugging of the - * executor utilities by EU_printf() in eutils.c + * EXEC_UTILSDEBUG is a flag which turns on debugging of the + * executor utilities by EU_printf() in eutils.c * ---------------- */ #undef EXEC_UTILSDEBUG /* ---------------- - * EXEC_NESTLOOPDEBUG is a flag which turns on debugging of the - * nest loop node by NL_printf() and ENL_printf() in nestloop.c + * EXEC_NESTLOOPDEBUG is a flag which turns on debugging of the + * nest loop node by NL_printf() and ENL_printf() in nestloop.c * ---------------- */ #undef EXEC_NESTLOOPDEBUG /* ---------------- - * EXEC_PROCDEBUG is a flag which turns on debugging of - * ExecProcNode() by PN_printf() in procnode.c + * EXEC_PROCDEBUG is a flag which turns on debugging of + * ExecProcNode() by PN_printf() in procnode.c * ---------------- */ #undef EXEC_PROCDEBUG /* ---------------- - * EXEC_EVALDEBUG is a flag which turns on debugging of - * ExecEval and ExecTargetList() stuff by EV_printf() in qual.c + * EXEC_EVALDEBUG is a flag which turns on debugging of + * ExecEval and ExecTargetList() stuff by EV_printf() in qual.c * ---------------- */ #undef EXEC_EVALDEBUG /* ---------------- - * EXEC_SCANDEBUG is a flag which turns on debugging of - * the ExecSeqScan() stuff by S_printf() in seqscan.c + * EXEC_SCANDEBUG is a flag which turns on debugging of + * the ExecSeqScan() stuff by S_printf() in seqscan.c * ---------------- */ #undef EXEC_SCANDEBUG /* ---------------- - * EXEC_SORTDEBUG is a flag which turns on debugging of - * the ExecSort() stuff by SO_printf() in sort.c + * EXEC_SORTDEBUG is a flag which turns on debugging of + * the ExecSort() stuff by SO_printf() in sort.c * ---------------- */ #undef EXEC_SORTDEBUG /* ---------------- - * EXEC_MERGEJOINDEBUG is a flag which turns on debugging of - * the ExecMergeJoin() stuff by MJ_printf() in mergejoin.c + * EXEC_MERGEJOINDEBUG is a flag which turns on debugging of + * the ExecMergeJoin() stuff by MJ_printf() in mergejoin.c * ---------------- */ #undef EXEC_MERGEJOINDEBUG /* ---------------- - * EXEC_MERGEJOINPFREE is a flag which causes merge joins - * to pfree intermittant tuples (which is the proper thing) - * Not defining this means we avoid menory management problems - * at the cost of doing deallocation of stuff only at the - * end of the transaction + * EXEC_MERGEJOINPFREE is a flag which causes merge joins + * to pfree intermittant tuples (which is the proper thing) + * Not defining this means we avoid menory management problems + * at the cost of doing deallocation of stuff only at the + * end of the transaction * ---------------- */ #undef EXEC_MERGEJOINPFREE /* ---------------- - * EXEC_DEBUGINTERACTIVE is a flag which enables the - * user to issue "DEBUG" commands from an interactive - * backend. + * EXEC_DEBUGINTERACTIVE is a flag which enables the + * user to issue "DEBUG" commands from an interactive + * backend. * ---------------- */ #undef EXEC_DEBUGINTERACTIVE /* ---------------- - * EXEC_DEBUGVARIABLEFILE is string, which if defined will - * be loaded when the executor is initialized. If this - * string is not defined then nothing will be loaded.. + * EXEC_DEBUGVARIABLEFILE is string, which if defined will + * be loaded when the executor is initialized. If this + * string is not defined then nothing will be loaded.. * - * Example: + * Example: * * #define EXEC_DEBUGVARIABLEFILE "/a/postgres/cimarron/.pg_debugvars" # - * Note: since these variables are read at execution time, - * they can't affect the first query.. this hack should be - * replaced by something better sometime. -cim 11/2/89 + * Note: since these variables are read at execution time, + * they can't affect the first query.. this hack should be + * replaced by something better sometime. -cim 11/2/89 * ---------------- */ #undef EXEC_DEBUGVARIABLEFILE /* ---------------------------------------------------------------- - * #defines controlled by above definitions + * #defines controlled by above definitions * - * Note: most of these are "incomplete" because I didn't - * need the ones not defined. More should be added - * only as necessary -cim 10/26/89 + * Note: most of these are "incomplete" because I didn't + * need the ones not defined. More should be added + * only as necessary -cim 10/26/89 * ---------------------------------------------------------------- */ -#define T_OR_F(b) (b ? "true" : "false") -#define NULL_OR_TUPLE(slot) (TupIsNull(slot) ? "null" : "a tuple") +#define T_OR_F(b) (b ? "true" : "false") +#define NULL_OR_TUPLE(slot) (TupIsNull(slot) ? "null" : "a tuple") /* #define EXEC_TUPLECOUNT - XXX take out for now for executor stubbing -- jolly*/ /* ---------------- - * tuple count debugging defines + * tuple count debugging defines * ---------------- */ #ifdef EXEC_TUPLECOUNT -extern int NTupleProcessed; -extern int NTupleRetrieved; -extern int NTupleReplaced; -extern int NTupleAppended; -extern int NTupleDeleted; -extern int NIndexTupleProcessed; -extern int NIndexTupleInserted; - -#define IncrRetrieved() NTupleRetrieved++ -#define IncrAppended() NTupleAppended++ -#define IncrDeleted() NTupleDeleted++ -#define IncrReplaced() NTupleReplaced++ -#define IncrInserted() NTupleInserted++ -#define IncrProcessed() NTupleProcessed++ +extern int NTupleProcessed; +extern int NTupleRetrieved; +extern int NTupleReplaced; +extern int NTupleAppended; +extern int NTupleDeleted; +extern int NIndexTupleProcessed; +extern int NIndexTupleInserted; + +#define IncrRetrieved() NTupleRetrieved++ +#define IncrAppended() NTupleAppended++ +#define IncrDeleted() NTupleDeleted++ +#define IncrReplaced() NTupleReplaced++ +#define IncrInserted() NTupleInserted++ +#define IncrProcessed() NTupleProcessed++ #define IncrIndexProcessed() NIndexTupleProcessed++ -#define IncrIndexInserted() NIndexTupleInserted++ +#define IncrIndexInserted() NIndexTupleInserted++ #else #define IncrRetrieved() -#define IncrAppended() -#define IncrDeleted() -#define IncrReplaced() -#define IncrInserted() +#define IncrAppended() +#define IncrDeleted() +#define IncrReplaced() +#define IncrInserted() #define IncrProcessed() #define IncrIndexProcessed() #define IncrIndexInserted() -#endif /* EXEC_TUPLECOUNT */ +#endif /* EXEC_TUPLECOUNT */ /* ---------------- - * memory context debugging defines + * memory context debugging defines * ---------------- */ #ifdef EXEC_CONTEXTDEBUG -#define CXT_printf(s) printf(s) -#define CXT1_printf(s, a) printf(s, a) +#define CXT_printf(s) printf(s) +#define CXT1_printf(s, a) printf(s, a) #else -#define CXT_printf(s) -#define CXT1_printf(s, a) -#endif /* EXEC_CONTEXTDEBUG */ +#define CXT_printf(s) +#define CXT1_printf(s, a) +#endif /* EXEC_CONTEXTDEBUG */ /* ---------------- - * eutils debugging defines + * eutils debugging defines * ---------------- */ #ifdef EXEC_UTILSDEBUG -#define EU_nodeDisplay(l) nodeDisplay(l, 0) -#define EU_printf(s) printf(s) -#define EU1_printf(s, a) printf(s, a) -#define EU2_printf(s, a) printf(s, a, b) -#define EU3_printf(s, a) printf(s, a, b, c) -#define EU4_printf(s, a, b, c, d) printf(s, a, b, c, d) +#define EU_nodeDisplay(l) nodeDisplay(l, 0) +#define EU_printf(s) printf(s) +#define EU1_printf(s, a) printf(s, a) +#define EU2_printf(s, a) printf(s, a, b) +#define EU3_printf(s, a) printf(s, a, b, c) +#define EU4_printf(s, a, b, c, d) printf(s, a, b, c, d) #else -#define EU_nodeDisplay(l) -#define EU_printf(s) -#define EU1_printf(s, a) +#define EU_nodeDisplay(l) +#define EU_printf(s) +#define EU1_printf(s, a) #define EU2_printf(s, a, b) #define EU3_printf(s, a, b, c) -#define EU4_printf(s, a, b, c, d) -#endif /* EXEC_UTILSDEBUG */ +#define EU4_printf(s, a, b, c, d) +#endif /* EXEC_UTILSDEBUG */ /* ---------------- - * nest loop debugging defines + * nest loop debugging defines * ---------------- */ #ifdef EXEC_NESTLOOPDEBUG -#define NL_nodeDisplay(l) nodeDisplay(l, 0) -#define NL_printf(s) printf(s) -#define NL1_printf(s, a) printf(s, a) -#define NL4_printf(s, a, b, c, d) printf(s, a, b, c, d) -#define ENL1_printf(message) printf("ExecNestLoop: %s\n", message) +#define NL_nodeDisplay(l) nodeDisplay(l, 0) +#define NL_printf(s) printf(s) +#define NL1_printf(s, a) printf(s, a) +#define NL4_printf(s, a, b, c, d) printf(s, a, b, c, d) +#define ENL1_printf(message) printf("ExecNestLoop: %s\n", message) #else -#define NL_nodeDisplay(l) -#define NL_printf(s) -#define NL1_printf(s, a) -#define NL4_printf(s, a, b, c, d) +#define NL_nodeDisplay(l) +#define NL_printf(s) +#define NL1_printf(s, a) +#define NL4_printf(s, a, b, c, d) #define ENL1_printf(message) -#endif /* EXEC_NESTLOOPDEBUG */ +#endif /* EXEC_NESTLOOPDEBUG */ /* ---------------- - * proc node debugging defines + * proc node debugging defines * ---------------- */ #ifdef EXEC_PROCDEBUG -#define PN_printf(s) printf(s) -#define PN1_printf(s, p) printf(s, p) +#define PN_printf(s) printf(s) +#define PN1_printf(s, p) printf(s, p) #else -#define PN_printf(s) -#define PN1_printf(s, p) -#endif /* EXEC_PROCDEBUG */ +#define PN_printf(s) +#define PN1_printf(s, p) +#endif /* EXEC_PROCDEBUG */ /* ---------------- - * exec eval / target list debugging defines + * exec eval / target list debugging defines * ---------------- */ #ifdef EXEC_EVALDEBUG -#define EV_nodeDisplay(l) nodeDisplay(l, 0) -#define EV_printf(s) printf(s) -#define EV1_printf(s, a) printf(s, a) +#define EV_nodeDisplay(l) nodeDisplay(l, 0) +#define EV_printf(s) printf(s) +#define EV1_printf(s, a) printf(s, a) #define EV5_printf(s, a, b, c, d, e) printf(s, a, b, c, d, e) #else -#define EV_nodeDisplay(l) -#define EV_printf(s) -#define EV1_printf(s, a) -#define EV5_printf(s, a, b, c, d, e) -#endif /* EXEC_EVALDEBUG */ +#define EV_nodeDisplay(l) +#define EV_printf(s) +#define EV1_printf(s, a) +#define EV5_printf(s, a, b, c, d, e) +#endif /* EXEC_EVALDEBUG */ /* ---------------- - * scan debugging defines + * scan debugging defines * ---------------- */ #ifdef EXEC_SCANDEBUG -#define S_nodeDisplay(l) nodeDisplay(l, 0) -#define S_printf(s) printf(s) -#define S1_printf(s, p) printf(s, p) +#define S_nodeDisplay(l) nodeDisplay(l, 0) +#define S_printf(s) printf(s) +#define S1_printf(s, p) printf(s, p) #else -#define S_nodeDisplay(l) -#define S_printf(s) -#define S1_printf(s, p) -#endif /* EXEC_SCANDEBUG */ - +#define S_nodeDisplay(l) +#define S_printf(s) +#define S1_printf(s, p) +#endif /* EXEC_SCANDEBUG */ + /* ---------------- - * sort node debugging defines + * sort node debugging defines * ---------------- */ #ifdef EXEC_SORTDEBUG -#define SO_nodeDisplay(l) nodeDisplay(l, 0) -#define SO_printf(s) printf(s) -#define SO1_printf(s, p) printf(s, p) +#define SO_nodeDisplay(l) nodeDisplay(l, 0) +#define SO_printf(s) printf(s) +#define SO1_printf(s, p) printf(s, p) #else -#define SO_nodeDisplay(l) -#define SO_printf(s) -#define SO1_printf(s, p) -#endif /* EXEC_SORTDEBUG */ +#define SO_nodeDisplay(l) +#define SO_printf(s) +#define SO1_printf(s, p) +#endif /* EXEC_SORTDEBUG */ /* ---------------- - * merge join debugging defines + * merge join debugging defines * ---------------- */ #ifdef EXEC_MERGEJOINDEBUG -#define MJ_nodeDisplay(l) nodeDisplay(l, 0) -#define MJ_printf(s) printf(s) -#define MJ1_printf(s, p) printf(s, p) -#define MJ2_printf(s, p1, p2) printf(s, p1, p2) -#define MJ_debugtup(tuple, type) debugtup(tuple, type) -#define MJ_dump(context, state) ExecMergeTupleDump(econtext, state) +#define MJ_nodeDisplay(l) nodeDisplay(l, 0) +#define MJ_printf(s) printf(s) +#define MJ1_printf(s, p) printf(s, p) +#define MJ2_printf(s, p1, p2) printf(s, p1, p2) +#define MJ_debugtup(tuple, type) debugtup(tuple, type) +#define MJ_dump(context, state) ExecMergeTupleDump(econtext, state) #define MJ_DEBUG_QUAL(clause, res) \ MJ2_printf(" ExecQual(%s, econtext) returns %s\n", \ - CppAsString(clause), T_OR_F(res)); - + CppAsString(clause), T_OR_F(res)); + #define MJ_DEBUG_MERGE_COMPARE(qual, res) \ MJ2_printf(" MergeCompare(mergeclauses, %s, ..) returns %s\n", \ - CppAsString(qual), T_OR_F(res)); + CppAsString(qual), T_OR_F(res)); #define MJ_DEBUG_PROC_NODE(slot) \ MJ2_printf(" %s = ExecProcNode(innerPlan) returns %s\n", \ - CppAsString(slot), NULL_OR_TUPLE(slot)); + CppAsString(slot), NULL_OR_TUPLE(slot)); #else #define MJ_nodeDisplay(l) -#define MJ_printf(s) -#define MJ1_printf(s, p) +#define MJ_printf(s) +#define MJ1_printf(s, p) #define MJ2_printf(s, p1, p2) #define MJ_debugtup(tuple, type) #define MJ_dump(context, state) #define MJ_DEBUG_QUAL(clause, res) #define MJ_DEBUG_MERGE_COMPARE(qual, res) #define MJ_DEBUG_PROC_NODE(slot) -#endif /* EXEC_MERGEJOINDEBUG */ +#endif /* EXEC_MERGEJOINDEBUG */ /* ---------------------------------------------------------------- - * DO NOT DEFINE THESE EVER OR YOU WILL BURN! + * DO NOT DEFINE THESE EVER OR YOU WILL BURN! * ---------------------------------------------------------------- */ /* ---------------- - * DOESNOTWORK is currently placed around memory manager - * code that is known to cause problems. Code in between - * is likely not converted and probably won't work anyways. + * DOESNOTWORK is currently placed around memory manager + * code that is known to cause problems. Code in between + * is likely not converted and probably won't work anyways. * ---------------- */ #undef DOESNOTWORK /* ---------------- - * PERHAPSNEVER is placed around the "scan attribute" - * support code for the rule manager because for now we - * do things inefficiently. The correct solution to our - * problem is to add code to the parser/planner to save - * attribute information for the rule manager rather than - * have the executor have to grope through the entire plan - * for it so if we ever decide to make things better, - * we should probably delete the stuff in between PERHAPSNEVER.. + * PERHAPSNEVER is placed around the "scan attribute" + * support code for the rule manager because for now we + * do things inefficiently. The correct solution to our + * problem is to add code to the parser/planner to save + * attribute information for the rule manager rather than + * have the executor have to grope through the entire plan + * for it so if we ever decide to make things better, + * we should probably delete the stuff in between PERHAPSNEVER.. * ---------------- */ #undef PERHAPSNEVER /* ---------------- - * NOTYET is placed around any code not yet implemented - * in the executor. Only remove these when actually implementing - * said code. + * NOTYET is placed around any code not yet implemented + * in the executor. Only remove these when actually implementing + * said code. * ---------------- */ #undef NOTYET -extern long NDirectFileRead; -extern long NDirectFileWrite; +extern long NDirectFileRead; +extern long NDirectFileWrite; -#endif /* ExecDebugIncluded */ +#endif /* ExecDebugIncluded */ |