develooper Front page | perl.dbd.pg.changes | Postings from March 2012

[DBD::Pg] rename all macros that call DBIS by appending _slow to their name

From:
dbdpg-commits
Date:
March 14, 2012 02:10
Subject:
[DBD::Pg] rename all macros that call DBIS by appending _slow to their name
Message ID:
1331673117-8036-1-git-send-email-dbdpg-commits@bucardo.org
Committed by Tim Bunce <Tim.Bunce@pobox.com>

rename all macros that call DBIS by appending _slow to their name

---
 Pg.h     |  160 +++++++-------
 dbdimp.c |  702 +++++++++++++++++++++++++++++++-------------------------------
 2 files changed, 431 insertions(+), 431 deletions(-)

diff --git a/Pg.h b/Pg.h
index 5b8ac2f..f90924f 100644
--- a/Pg.h
+++ b/Pg.h
@@ -68,10 +68,10 @@ DBISTATE_DECLARE;
 #include "dbdimp.h"
 #include "quote.h"
 
-#define TLEVEL	     (DBIS->debug & DBIc_TRACE_LEVEL_MASK)
-#define TFLAGS	     (DBIS->debug & DBIc_TRACE_FLAGS_MASK)
+#define TLEVEL_slow	     (DBIS->debug & DBIc_TRACE_LEVEL_MASK)
+#define TFLAGS_slow	     (DBIS->debug & DBIc_TRACE_FLAGS_MASK)
 
-#define TSQL	     (TFLAGS & 256) /* Defined in DBI */
+#define TSQL	     (TFLAGS_slow & 256) /* Defined in DBI */
 
 #define FLAGS_LIBPQ    0x01000000
 #define FLAGS_START    0x02000000
@@ -79,91 +79,91 @@ DBISTATE_DECLARE;
 #define FLAGS_PREFIX   0x08000000
 #define FLAGS_LOGIN    0x10000000
 
-#define TFLIBPQ      (TFLAGS & FLAGS_LIBPQ)
-#define TFSTART      (TFLAGS & FLAGS_START)
-#define TFEND        (TFLAGS & FLAGS_END)
-#define TFPREFIX     (TFLAGS & FLAGS_PREFIX)
-#define TFLOGIN      (TFLAGS & FLAGS_LOGIN)
+#define TFLIBPQ_slow      (TFLAGS_slow & FLAGS_LIBPQ)
+#define TFSTART_slow      (TFLAGS_slow & FLAGS_START)
+#define TFEND_slow        (TFLAGS_slow & FLAGS_END)
+#define TFPREFIX_slow     (TFLAGS_slow & FLAGS_PREFIX)
+#define TFLOGIN_slow      (TFLAGS_slow & FLAGS_LOGIN)
 
-#define TRACE1       (TLEVEL >= 1) /* Avoid using directly: DBI only */
-#define TRACE2       (TLEVEL >= 2) /* Avoid using directly: DBI only */
-#define TRACE3       (TLEVEL >= 3) /* Basic debugging */
-#define TRACE4       (TLEVEL >= 4) /* More detailed debugging */
-#define TRACE5       (TLEVEL >= 5) /* Very detailed debugging */
-#define TRACE6       (TLEVEL >= 6)
-#define TRACE7       (TLEVEL >= 7)
-#define TRACE8       (TLEVEL >= 8)
+#define TRACE1_slow       (TLEVEL_slow >= 1) /* Avoid using directly: DBI only */
+#define TRACE2_slow       (TLEVEL_slow >= 2) /* Avoid using directly: DBI only */
+#define TRACE3_slow       (TLEVEL_slow >= 3) /* Basic debugging */
+#define TRACE4_slow       (TLEVEL_slow >= 4) /* More detailed debugging */
+#define TRACE5_slow       (TLEVEL_slow >= 5) /* Very detailed debugging */
+#define TRACE6_slow       (TLEVEL_slow >= 6)
+#define TRACE7_slow       (TLEVEL_slow >= 7)
+#define TRACE8_slow       (TLEVEL_slow >= 8)
 
-#define TLIBPQ       (TRACE5 || TFLIBPQ)
-#define TSTART       (TRACE4 || TFSTART) /* Start of a major function */
-#define TEND         (TRACE4 || TFEND)   /* End of a major function   */
-#define TLOGIN       (TRACE5 || TFLOGIN) /* Connect and disconnect    */
+#define TLIBPQ_slow       (TRACE5_slow || TFLIBPQ_slow)
+#define TSTART_slow       (TRACE4_slow || TFSTART_slow) /* Start of a major function */
+#define TEND_slow         (TRACE4_slow || TFEND_slow)   /* End of a major function   */
+#define TLOGIN_slow       (TRACE5_slow || TFLOGIN_slow) /* Connect and disconnect    */
 
-#define TRACEWARN    (TRACE1) /* Non-fatal but serious problems */
+#define TRACEWARN_slow    (TRACE1_slow) /* Non-fatal but serious problems */
 
 /* Do we show a "dbdpg: " header? */
-#define THEADER      (TFPREFIX) ? "dbdpg: " : ""
+#define THEADER_slow      (TFPREFIX_slow) ? "dbdpg: " : ""
 
 #define TRC (void)PerlIO_printf
 
 /* Fancy stuff for tracing of commonly used libpq functions */
-#define TRACE_XX                   if (TLIBPQ) TRC(DBILOGFP,
-#define TRACE_PQBACKENDPID         TRACE_XX "%sPQbackendPID\n",          THEADER)
-#define TRACE_PQCANCEL             TRACE_XX "%sPQcancel\n",              THEADER)
-#define TRACE_PQCLEAR              TRACE_XX "%sPQclear\n",               THEADER)
-#define TRACE_PQCMDSTATUS          TRACE_XX "%sPQcmdStatus\n",           THEADER)
-#define TRACE_PQCMDTUPLES          TRACE_XX "%sPQcmdTuples\n",           THEADER)
-#define TRACE_PQCONNECTDB          TRACE_XX "%sPQconnectdb\n",           THEADER)
-#define TRACE_PQCONSUMEINPUT       TRACE_XX "%sPQconsumeInput\n",        THEADER)
-#define TRACE_PQCONSUMEINPUT       TRACE_XX "%sPQconsumeInput\n",        THEADER)
-#define TRACE_PQDB                 TRACE_XX "%sPQdb\n",                  THEADER)
-#define TRACE_PQENDCOPY            TRACE_XX "%sPQendcopy\n",             THEADER)
-#define TRACE_PQERRORMESSAGE       TRACE_XX "%sPQerrorMessage\n",        THEADER)
-#define TRACE_PQEXEC               TRACE_XX "%sPQexec\n",                THEADER)
-#define TRACE_PQEXECPARAMS         TRACE_XX "%sPQexecParams\n",          THEADER)
-#define TRACE_PQEXECPREPARED       TRACE_XX "%sPQexecPrepared\n",        THEADER)
-#define TRACE_PQFINISH             TRACE_XX "%sPQfinish\n",              THEADER)
-#define TRACE_PQFMOD               TRACE_XX "%sPQfmod\n",                THEADER)
-#define TRACE_PQFNAME              TRACE_XX "%sPQfname\n",               THEADER)
-#define TRACE_PQFREECANCEL         TRACE_XX "%sPQfreeCancel\n",          THEADER)
-#define TRACE_PQFREEMEM            TRACE_XX "%sPQfreemem\n",             THEADER)
-#define TRACE_PQFREEMEM            TRACE_XX "%sPQfreemem\n",             THEADER)
-#define TRACE_PQFSIZE              TRACE_XX "%sPQfsize\n",               THEADER)
-#define TRACE_PQFTABLECOL          TRACE_XX "%sPQftableCol\n",           THEADER)
-#define TRACE_PQFTABLE             TRACE_XX "%sPQftable\n",              THEADER)
-#define TRACE_PQFTYPE              TRACE_XX "%sPQftype\n",               THEADER)
-#define TRACE_PQGETCANCEL          TRACE_XX "%sPQgetCancel\n",           THEADER)
-#define TRACE_PQGETCOPYDATA        TRACE_XX "%sPQgetCopyData\n",         THEADER)
-#define TRACE_PQGETISNULL          TRACE_XX "%sPQgetisnull\n",           THEADER)
-#define TRACE_PQGETRESULT          TRACE_XX "%sPQgetResult\n",           THEADER)
-#define TRACE_PQGETVALUE           TRACE_XX "%sPQgetvalue\n",            THEADER)
-#define TRACE_PQHOST               TRACE_XX "%sPQhost\n",                THEADER)
-#define TRACE_PQISBUSY             TRACE_XX "%sPQisBusy\n",              THEADER)
-#define TRACE_PQNFIELDS            TRACE_XX "%sPQnfields\n",             THEADER)
-#define TRACE_PQNOTIFIES           TRACE_XX "%sPQnotifies\n",            THEADER)
-#define TRACE_PQNTUPLES            TRACE_XX "%sPQntuples\n",             THEADER)
-#define TRACE_PQOIDVALUE           TRACE_XX "%sPQoidValue\n",            THEADER)
-#define TRACE_PQOPTIONS            TRACE_XX "%sPQoptions\n",             THEADER)
-#define TRACE_PQPARAMETERSTATUS    TRACE_XX "%sPQparameterStatus\n",     THEADER)
-#define TRACE_PQPASS               TRACE_XX "%sPQpass\n",                THEADER)
-#define TRACE_PQPORT               TRACE_XX "%sPQport\n",                THEADER)
-#define TRACE_PQPREPARE            TRACE_XX "%sPQprepare\n",             THEADER)
-#define TRACE_PQPROTOCOLVERSION    TRACE_XX "%sPQprotocolVersion\n",     THEADER)
-#define TRACE_PQPUTCOPYDATA        TRACE_XX "%sPQputCopyData\n",         THEADER)
-#define TRACE_PQPUTCOPYEND         TRACE_XX "%sPQputCopyEnd\n",          THEADER)
-#define TRACE_PQRESULTERRORFIELD   TRACE_XX "%sPQresultErrorField\n",    THEADER)
-#define TRACE_PQRESULTSTATUS       TRACE_XX "%sPQresultStatus\n",        THEADER)
-#define TRACE_PQSENDQUERY          TRACE_XX "%sPQsendQuery\n",           THEADER)
-#define TRACE_PQSENDQUERYPARAMS    TRACE_XX "%sPQsendQueryParams\n",     THEADER)
-#define TRACE_PQSENDQUERYPREPARED  TRACE_XX "%sPQsendQueryPrepared\n",   THEADER)
-#define TRACE_PQSERVERVERSION      TRACE_XX "%sPQserverVersion\n",       THEADER)
-#define TRACE_PQSETERRORVERBOSITY  TRACE_XX "%sPQsetErrorVerbosity\n",   THEADER)
-#define TRACE_PQSETNOTICEPROCESSOR TRACE_XX "%sPQsetNoticeProcessor\n",  THEADER)
-#define TRACE_PQSOCKET             TRACE_XX "%sPQsocket\n",              THEADER)
-#define TRACE_PQSTATUS             TRACE_XX "%sPQstatus\n",              THEADER)
-#define TRACE_PQTRACE              TRACE_XX "%sPQtrace\n",               THEADER)
-#define TRACE_PQTRANSACTIONSTATUS  TRACE_XX "%sPQtransactionStatus\n",   THEADER)
-#define TRACE_PQUNTRACE            TRACE_XX "%sPQuntrace\n",             THEADER)
-#define TRACE_PQUSER               TRACE_XX "%sPQuser\n",                THEADER)
+#define TRACE_XX                   if (TLIBPQ_slow) TRC(DBILOGFP,
+#define TRACE_PQBACKENDPID         TRACE_XX "%sPQbackendPID\n",          THEADER_slow)
+#define TRACE_PQCANCEL             TRACE_XX "%sPQcancel\n",              THEADER_slow)
+#define TRACE_PQCLEAR              TRACE_XX "%sPQclear\n",               THEADER_slow)
+#define TRACE_PQCMDSTATUS          TRACE_XX "%sPQcmdStatus\n",           THEADER_slow)
+#define TRACE_PQCMDTUPLES          TRACE_XX "%sPQcmdTuples\n",           THEADER_slow)
+#define TRACE_PQCONNECTDB          TRACE_XX "%sPQconnectdb\n",           THEADER_slow)
+#define TRACE_PQCONSUMEINPUT       TRACE_XX "%sPQconsumeInput\n",        THEADER_slow)
+#define TRACE_PQCONSUMEINPUT       TRACE_XX "%sPQconsumeInput\n",        THEADER_slow)
+#define TRACE_PQDB                 TRACE_XX "%sPQdb\n",                  THEADER_slow)
+#define TRACE_PQENDCOPY            TRACE_XX "%sPQendcopy\n",             THEADER_slow)
+#define TRACE_PQERRORMESSAGE       TRACE_XX "%sPQerrorMessage\n",        THEADER_slow)
+#define TRACE_PQEXEC               TRACE_XX "%sPQexec\n",                THEADER_slow)
+#define TRACE_PQEXECPARAMS         TRACE_XX "%sPQexecParams\n",          THEADER_slow)
+#define TRACE_PQEXECPREPARED       TRACE_XX "%sPQexecPrepared\n",        THEADER_slow)
+#define TRACE_PQFINISH             TRACE_XX "%sPQfinish\n",              THEADER_slow)
+#define TRACE_PQFMOD               TRACE_XX "%sPQfmod\n",                THEADER_slow)
+#define TRACE_PQFNAME              TRACE_XX "%sPQfname\n",               THEADER_slow)
+#define TRACE_PQFREECANCEL         TRACE_XX "%sPQfreeCancel\n",          THEADER_slow)
+#define TRACE_PQFREEMEM            TRACE_XX "%sPQfreemem\n",             THEADER_slow)
+#define TRACE_PQFREEMEM            TRACE_XX "%sPQfreemem\n",             THEADER_slow)
+#define TRACE_PQFSIZE              TRACE_XX "%sPQfsize\n",               THEADER_slow)
+#define TRACE_PQFTABLECOL          TRACE_XX "%sPQftableCol\n",           THEADER_slow)
+#define TRACE_PQFTABLE             TRACE_XX "%sPQftable\n",              THEADER_slow)
+#define TRACE_PQFTYPE              TRACE_XX "%sPQftype\n",               THEADER_slow)
+#define TRACE_PQGETCANCEL          TRACE_XX "%sPQgetCancel\n",           THEADER_slow)
+#define TRACE_PQGETCOPYDATA        TRACE_XX "%sPQgetCopyData\n",         THEADER_slow)
+#define TRACE_PQGETISNULL          TRACE_XX "%sPQgetisnull\n",           THEADER_slow)
+#define TRACE_PQGETRESULT          TRACE_XX "%sPQgetResult\n",           THEADER_slow)
+#define TRACE_PQGETVALUE           TRACE_XX "%sPQgetvalue\n",            THEADER_slow)
+#define TRACE_PQHOST               TRACE_XX "%sPQhost\n",                THEADER_slow)
+#define TRACE_PQISBUSY             TRACE_XX "%sPQisBusy\n",              THEADER_slow)
+#define TRACE_PQNFIELDS            TRACE_XX "%sPQnfields\n",             THEADER_slow)
+#define TRACE_PQNOTIFIES           TRACE_XX "%sPQnotifies\n",            THEADER_slow)
+#define TRACE_PQNTUPLES            TRACE_XX "%sPQntuples\n",             THEADER_slow)
+#define TRACE_PQOIDVALUE           TRACE_XX "%sPQoidValue\n",            THEADER_slow)
+#define TRACE_PQOPTIONS            TRACE_XX "%sPQoptions\n",             THEADER_slow)
+#define TRACE_PQPARAMETERSTATUS    TRACE_XX "%sPQparameterStatus\n",     THEADER_slow)
+#define TRACE_PQPASS               TRACE_XX "%sPQpass\n",                THEADER_slow)
+#define TRACE_PQPORT               TRACE_XX "%sPQport\n",                THEADER_slow)
+#define TRACE_PQPREPARE            TRACE_XX "%sPQprepare\n",             THEADER_slow)
+#define TRACE_PQPROTOCOLVERSION    TRACE_XX "%sPQprotocolVersion\n",     THEADER_slow)
+#define TRACE_PQPUTCOPYDATA        TRACE_XX "%sPQputCopyData\n",         THEADER_slow)
+#define TRACE_PQPUTCOPYEND         TRACE_XX "%sPQputCopyEnd\n",          THEADER_slow)
+#define TRACE_PQRESULTERRORFIELD   TRACE_XX "%sPQresultErrorField\n",    THEADER_slow)
+#define TRACE_PQRESULTSTATUS       TRACE_XX "%sPQresultStatus\n",        THEADER_slow)
+#define TRACE_PQSENDQUERY          TRACE_XX "%sPQsendQuery\n",           THEADER_slow)
+#define TRACE_PQSENDQUERYPARAMS    TRACE_XX "%sPQsendQueryParams\n",     THEADER_slow)
+#define TRACE_PQSENDQUERYPREPARED  TRACE_XX "%sPQsendQueryPrepared\n",   THEADER_slow)
+#define TRACE_PQSERVERVERSION      TRACE_XX "%sPQserverVersion\n",       THEADER_slow)
+#define TRACE_PQSETERRORVERBOSITY  TRACE_XX "%sPQsetErrorVerbosity\n",   THEADER_slow)
+#define TRACE_PQSETNOTICEPROCESSOR TRACE_XX "%sPQsetNoticeProcessor\n",  THEADER_slow)
+#define TRACE_PQSOCKET             TRACE_XX "%sPQsocket\n",              THEADER_slow)
+#define TRACE_PQSTATUS             TRACE_XX "%sPQstatus\n",              THEADER_slow)
+#define TRACE_PQTRACE              TRACE_XX "%sPQtrace\n",               THEADER_slow)
+#define TRACE_PQTRANSACTIONSTATUS  TRACE_XX "%sPQtransactionStatus\n",   THEADER_slow)
+#define TRACE_PQUNTRACE            TRACE_XX "%sPQuntrace\n",             THEADER_slow)
+#define TRACE_PQUSER               TRACE_XX "%sPQuser\n",                THEADER_slow)
 
 /* end of Pg.h */
diff --git a/dbdimp.c b/dbdimp.c
index 124dbb0..62a9de8 100644
--- a/dbdimp.c
+++ b/dbdimp.c
@@ -109,7 +109,7 @@ int dbd_db_login6 (SV * dbh, imp_dbh_t * imp_dbh, char * dbname, char * uid, cha
 	STRLEN         connect_string_size;
 	ConnStatusType connstatus;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin dbd_db_login\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin dbd_db_login\n", THEADER_slow);
   
 	/* DBD::Pg syntax: 'dbname=dbname;host=host;port=port', 'User', 'Pass' */
 	/* libpq syntax: 'dbname=dbname host=host port=port user=uid password=pwd' */
@@ -178,10 +178,10 @@ int dbd_db_login6 (SV * dbh, imp_dbh_t * imp_dbh, char * dbname, char * uid, cha
 	}
 	
 	/* Attempt the connection to the database */
-	if (TLOGIN) TRC(DBILOGFP, "%sLogin connection string: (%s)\n", THEADER, conn_str);
+	if (TLOGIN_slow) TRC(DBILOGFP, "%sLogin connection string: (%s)\n", THEADER_slow, conn_str);
 	TRACE_PQCONNECTDB;
 	imp_dbh->conn = PQconnectdb(conn_str);
-	if (TLOGIN) TRC(DBILOGFP, "%sConnection complete\n", THEADER);
+	if (TLOGIN_slow) TRC(DBILOGFP, "%sConnection complete\n", THEADER_slow);
 	Safefree(conn_str);
 
 	/* Set the initial sqlstate */
@@ -198,7 +198,7 @@ int dbd_db_login6 (SV * dbh, imp_dbh_t * imp_dbh, char * dbname, char * uid, cha
 		TRACE_PQFINISH;
 		PQfinish(imp_dbh->conn);
 		sv_free((SV *)imp_dbh->savepoints);
-		if (TEND) TRC(DBILOGFP, "%sEnd dbd_db_login (error)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_db_login (error)\n", THEADER_slow);
 		return 0;
 	}
 
@@ -251,7 +251,7 @@ int dbd_db_login6 (SV * dbh, imp_dbh_t * imp_dbh, char * dbname, char * uid, cha
 	/* Tell DBI that we should call disconnect when the handle dies */
 	DBIc_ACTIVE_on(imp_dbh);
 
-	if (TEND) TRC(DBILOGFP, "%sEnd dbd_db_login\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_db_login\n", THEADER_slow);
 
 	return 1;
 
@@ -268,8 +268,8 @@ static void pg_error (pTHX_ SV * h, int error_num, const char * error_msg)
 	size_t error_len;
 	imp_dbh_t * imp_dbh = (imp_dbh_t *)(DBIc_TYPE(imp_xxh) == DBIt_ST ? DBIc_PARENT_COM(imp_xxh) : imp_xxh);
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_error (message: %s number: %d)\n",
-					THEADER, error_msg, error_num);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_error (message: %s number: %d)\n",
+					THEADER_slow, error_msg, error_num);
 
 	error_len = strlen(error_msg);
 
@@ -287,7 +287,7 @@ static void pg_error (pTHX_ SV * h, int error_num, const char * error_msg)
 		SvUTF8_on(DBIc_ERRSTR(imp_xxh));
 #endif
 
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_error\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_error\n", THEADER_slow);
 
 } /* end of pg_error */
 
@@ -320,15 +320,15 @@ static void pg_warn (void * arg, const char * message)
 	else {
 		D_imp_dbh(tmp);
 
-		if (TSTART) TRC(DBILOGFP, "%sBegin pg_warn (message: %s DBIc_WARN: %d PrintWarn: %d)\n",
-						THEADER,
+		if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_warn (message: %s DBIc_WARN: %d PrintWarn: %d)\n",
+						THEADER_slow,
 						message, DBIc_WARN(imp_dbh) ? 1 : 0,
 						DBIc_is(imp_dbh, DBIcf_PrintWarn) ? 1 : 0);
 
 		if (DBIc_WARN(imp_dbh) && DBIc_is(imp_dbh, DBIcf_PrintWarn))
 			warn("%s", message);
 
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_warn\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_warn\n", THEADER_slow);
 	}
 
 } /* end of pg_warn */
@@ -343,7 +343,7 @@ static ExecStatusType _result(pTHX_ imp_dbh_t * imp_dbh, const char * sql)
 	PGresult *     result;
 	ExecStatusType status;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin _result (sql: %s)\n", THEADER, sql);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin _result (sql: %s)\n", THEADER_slow, sql);
 
 	if (TSQL) TRC(DBILOGFP, "%s;\n\n", sql);
 
@@ -355,7 +355,7 @@ static ExecStatusType _result(pTHX_ imp_dbh_t * imp_dbh, const char * sql)
 	TRACE_PQCLEAR;
 	PQclear(result);
 
-	if (TEND) TRC(DBILOGFP, "%sEnd _result\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd _result\n", THEADER_slow);
 	return status;
 
 } /* end of _result */
@@ -370,7 +370,7 @@ static ExecStatusType _sqlstate(pTHX_ imp_dbh_t * imp_dbh, PGresult * result)
 	ExecStatusType status   = PGRES_FATAL_ERROR; /* until proven otherwise */
 	bool           stateset = DBDPG_FALSE;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin _sqlstate\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin _sqlstate\n", THEADER_slow);
 
 	if (result) {
 		TRACE_PQRESULTSTATUS;
@@ -418,14 +418,14 @@ static ExecStatusType _sqlstate(pTHX_ imp_dbh_t * imp_dbh, PGresult * result)
 		}
 	}
 
-	if (TEND) TRC(DBILOGFP, "%sEnd _sqlstate (imp_dbh->sqlstate: %s)\n",
-				  THEADER, imp_dbh->sqlstate);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd _sqlstate (imp_dbh->sqlstate: %s)\n",
+				  THEADER_slow, imp_dbh->sqlstate);
 
-	if (TRACE7) TRC(DBILOGFP, "%s_sqlstate txn_status is %d\n",
-					THEADER, pg_db_txn_status(aTHX_ imp_dbh));
+	if (TRACE7_slow) TRC(DBILOGFP, "%s_sqlstate txn_status is %d\n",
+					THEADER_slow, pg_db_txn_status(aTHX_ imp_dbh));
 
 
-	if (TEND) TRC(DBILOGFP, "%sEnd _sqlstate (status: %d)\n", THEADER, status);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd _sqlstate (status: %d)\n", THEADER_slow, status);
 	return status;
 
 } /* end of _sqlstate */
@@ -439,24 +439,24 @@ int dbd_db_ping (SV * dbh)
 	PGTransactionStatusType tstatus;
 	ExecStatusType          status;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin dbd_db_ping\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin dbd_db_ping\n", THEADER_slow);
 
 	if (NULL == imp_dbh->conn) {
-		if (TEND) TRC(DBILOGFP, "%sEnd dbd_db_ping (error: no connection)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_db_ping (error: no connection)\n", THEADER_slow);
 		return -1;
 	}
 
 	tstatus = pg_db_txn_status(aTHX_ imp_dbh);
 
-	if (TRACE5) TRC(DBILOGFP, "%sdbd_db_ping txn_status is %d\n", THEADER, tstatus);
+	if (TRACE5_slow) TRC(DBILOGFP, "%sdbd_db_ping txn_status is %d\n", THEADER_slow, tstatus);
 
 	if (tstatus >= 4) { /* Unknown, so we err on the side of "bad" */
-		if (TEND) TRC(DBILOGFP, "%sEnd dbd_pg_ping (result: -2 unknown/bad)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_pg_ping (result: -2 unknown/bad)\n", THEADER_slow);
 		return -2;
 	}
 
 	if (tstatus != 0) {/* 2=active, 3=intrans, 4=inerror */
-		if (TEND) TRC(DBILOGFP, "%sEnd dbd_pg_ping (result: %d)\n", THEADER, 1+tstatus);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_pg_ping (result: %d)\n", THEADER_slow, 1+tstatus);
 		return 1+tstatus;
 	}
 
@@ -465,11 +465,11 @@ int dbd_db_ping (SV * dbh)
 	status = _result(aTHX_ imp_dbh, "SELECT 'DBD::Pg ping test'");
 
 	if (PGRES_TUPLES_OK == status) {
-		if (TEND) TRC(DBILOGFP, "%sEnd dbd_pg_ping (result: 1 PGRES_TUPLES_OK)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_pg_ping (result: 1 PGRES_TUPLES_OK)\n", THEADER_slow);
 		return 1;
 	}
 
-	if (TEND) TRC(DBILOGFP, "%sEnd dbd_pg_ping (result: -3)\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_pg_ping (result: -3)\n", THEADER_slow);
 	return -3;
 
 } /* end of dbd_db_ping */
@@ -479,7 +479,7 @@ int dbd_db_ping (SV * dbh)
 static PGTransactionStatusType pg_db_txn_status (pTHX_ imp_dbh_t * imp_dbh)
 {
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin PGTransactionStatusType\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin PGTransactionStatusType\n", THEADER_slow);
 	TRACE_PQTRANSACTIONSTATUS;
 	return PQtransactionStatus(imp_dbh->conn);
 
@@ -494,15 +494,15 @@ static int pg_db_rollback_commit (pTHX_ SV * dbh, imp_dbh_t * imp_dbh, int actio
 	PGTransactionStatusType tstatus;
 	ExecStatusType          status;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_rollback_commit (action: %s AutoCommit: %d BegunWork: %d)\n",
-					THEADER,
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_rollback_commit (action: %s AutoCommit: %d BegunWork: %d)\n",
+					THEADER_slow,
 					action ? "commit" : "rollback",
 					DBIc_is(imp_dbh, DBIcf_AutoCommit) ? 1 : 0,
 					DBIc_is(imp_dbh, DBIcf_BegunWork) ? 1 : 0);
 	
 	/* No action if AutoCommit = on or the connection is invalid */
 	if ((NULL == imp_dbh->conn) || (DBIc_has(imp_dbh, DBIcf_AutoCommit))) {
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_rollback_commit (result: 0)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_rollback_commit (result: 0)\n", THEADER_slow);
 		return 0;
 	}
 
@@ -510,31 +510,31 @@ static int pg_db_rollback_commit (pTHX_ SV * dbh, imp_dbh_t * imp_dbh, int actio
 	   ask it for the status directly and double-check things */
 
 	tstatus = pg_db_txn_status(aTHX_ imp_dbh);
-	if (TRACE4) TRC(DBILOGFP, "%sdbd_db_%s txn_status is %d\n", THEADER, action ? "commit" : "rollback", tstatus);
+	if (TRACE4_slow) TRC(DBILOGFP, "%sdbd_db_%s txn_status is %d\n", THEADER_slow, action ? "commit" : "rollback", tstatus);
 
 	if (PQTRANS_IDLE == tstatus) { /* Not in a transaction */
 		if (imp_dbh->done_begin) {
 			/* We think we ARE in a transaction but we really are not */
-			if (TRACEWARN)
-				TRC(DBILOGFP, "%sWarning: invalid done_begin turned off\n", THEADER);
+			if (TRACEWARN_slow)
+				TRC(DBILOGFP, "%sWarning: invalid done_begin turned off\n", THEADER_slow);
 			imp_dbh->done_begin = DBDPG_FALSE;
 		}
 	}
 	else if (PQTRANS_ACTIVE == tstatus) { /* Still active - probably in a COPY */
-		if (TRACEWARN)
-			TRC(DBILOGFP,"%sCommand in progress, so no done_begin checking!\n", THEADER);
+		if (TRACEWARN_slow)
+			TRC(DBILOGFP,"%sCommand in progress, so no done_begin checking!\n", THEADER_slow);
 	}
 	else if (PQTRANS_INTRANS == tstatus || PQTRANS_INERROR == tstatus) { /* In a (possibly failed) transaction */
 		if (!imp_dbh->done_begin) {
 			/* We think we are NOT in a transaction but we really are */
-			if (TRACEWARN)
-				TRC(DBILOGFP, "%sWarning: invalid done_begin turned on\n", THEADER);
+			if (TRACEWARN_slow)
+				TRC(DBILOGFP, "%sWarning: invalid done_begin turned on\n", THEADER_slow);
 			imp_dbh->done_begin = DBDPG_TRUE;
 		}
 	}
 	else { /* Something is wrong: transaction status unknown */
-		if (TRACEWARN)
-			TRC(DBILOGFP, "%sWarning: cannot determine transaction status\n", THEADER);
+		if (TRACEWARN_slow)
+			TRC(DBILOGFP, "%sWarning: cannot determine transaction status\n", THEADER_slow);
 	}
 
 	/* If begin_work has been called, turn AutoCommit back on and BegunWork off */
@@ -544,7 +544,7 @@ static int pg_db_rollback_commit (pTHX_ SV * dbh, imp_dbh_t * imp_dbh, int actio
 	}
 
 	if (!imp_dbh->done_begin) {
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_rollback_commit (result: 1)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_rollback_commit (result: 1)\n", THEADER_slow);
 		return 1;
 	}
 
@@ -556,7 +556,7 @@ static int pg_db_rollback_commit (pTHX_ SV * dbh, imp_dbh_t * imp_dbh, int actio
 	if (PGRES_COMMAND_OK != status) {
 		TRACE_PQERRORMESSAGE;
 		pg_error(aTHX_ dbh, status, PQerrorMessage(imp_dbh->conn));
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_rollback_commit (error: status not OK)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_rollback_commit (error: status not OK)\n", THEADER_slow);
 		return 0;
 	}
 
@@ -564,7 +564,7 @@ static int pg_db_rollback_commit (pTHX_ SV * dbh, imp_dbh_t * imp_dbh, int actio
 	av_undef(imp_dbh->savepoints);
 	imp_dbh->copystate=0;
 
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_db_rollback_commit (result: 1)\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_rollback_commit (result: 1)\n", THEADER_slow);
 	return 1;
 
 } /* end of pg_db_rollback_commit */
@@ -573,7 +573,7 @@ static int pg_db_rollback_commit (pTHX_ SV * dbh, imp_dbh_t * imp_dbh, int actio
 int dbd_db_commit (SV * dbh, imp_dbh_t * imp_dbh)
 {
 	dTHX;
-	if (TSTART) TRC(DBILOGFP, "%sBegin dbd_db_commit\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin dbd_db_commit\n", THEADER_slow);
 	return pg_db_rollback_commit(aTHX_ dbh, imp_dbh, 1);
 }
 
@@ -581,7 +581,7 @@ int dbd_db_commit (SV * dbh, imp_dbh_t * imp_dbh)
 int dbd_db_rollback (SV * dbh, imp_dbh_t * imp_dbh)
 {
 	dTHX;
-	if (TSTART) TRC(DBILOGFP, "%sBegin dbd_db_rollback\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin dbd_db_rollback\n", THEADER_slow);
 	return pg_db_rollback_commit(aTHX_ dbh, imp_dbh, 0);
 }
 
@@ -591,7 +591,7 @@ int dbd_db_disconnect (SV * dbh, imp_dbh_t * imp_dbh)
 {
 	dTHX;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin dbd_db_disconnect\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin dbd_db_disconnect\n", THEADER_slow);
 
 	/* We assume that disconnect will always work	
 	   since most errors imply already disconnected. */
@@ -600,8 +600,8 @@ int dbd_db_disconnect (SV * dbh, imp_dbh_t * imp_dbh)
 	
 	if (NULL != imp_dbh->conn) {
 		/* Attempt a rollback */
-		if (0 != dbd_db_rollback(dbh, imp_dbh) && TRACE5)
-			TRC(DBILOGFP, "%sdbd_db_disconnect: AutoCommit=off -> rollback\n", THEADER);
+		if (0 != dbd_db_rollback(dbh, imp_dbh) && TRACE5_slow)
+			TRC(DBILOGFP, "%sdbd_db_disconnect: AutoCommit=off -> rollback\n", THEADER_slow);
 		
 		TRACE_PQFINISH;
 		PQfinish(imp_dbh->conn);
@@ -612,9 +612,9 @@ int dbd_db_disconnect (SV * dbh, imp_dbh_t * imp_dbh)
 	/* The DESTROY method is the only one to 'free' memory.	*/
 	/* Note that statement objects may still exists for this dbh! */
 
-	if (TLOGIN) TRC(DBILOGFP, "%sDisconnection complete\n", THEADER);
+	if (TLOGIN_slow) TRC(DBILOGFP, "%sDisconnection complete\n", THEADER_slow);
 
-	if (TEND) TRC(DBILOGFP, "%sEnd dbd_db_disconnect\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_db_disconnect\n", THEADER_slow);
 	return 1;
 
 } /* end of dbd_db_disconnect */
@@ -625,7 +625,7 @@ void dbd_db_destroy (SV * dbh, imp_dbh_t * imp_dbh)
 {
 	dTHX;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin dbd_db_destroy\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin dbd_db_destroy\n", THEADER_slow);
 
 	if (DBIc_ACTIVE(imp_dbh))
 		(void)dbd_db_disconnect(dbh, imp_dbh);
@@ -644,7 +644,7 @@ void dbd_db_destroy (SV * dbh, imp_dbh_t * imp_dbh)
 
 	DBIc_IMPSET_off(imp_dbh);
 
-	if (TEND) TRC(DBILOGFP, "%sEnd dbd_db_destroy\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_db_destroy\n", THEADER_slow);
 
 } /* end of dbd_db_destroy */
 
@@ -657,7 +657,7 @@ SV * dbd_db_FETCH_attrib (SV * dbh, imp_dbh_t * imp_dbh, SV * keysv)
 	char * key = SvPV(keysv,kl);
 	SV *   retsv = Nullsv;
 	
-	if (TSTART) TRC(DBILOGFP, "%sBegin dbd_db_FETCH (key: %s)\n", THEADER, dbh ? key : key);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin dbd_db_FETCH (key: %s)\n", THEADER_slow, dbh ? key : key);
 
 	switch (kl) {
 
@@ -789,7 +789,7 @@ SV * dbd_db_FETCH_attrib (SV * dbh, imp_dbh_t * imp_dbh, SV * keysv)
 
 	}
 
-	if (TEND) TRC(DBILOGFP, "%sEnd dbd_db_FETCH_attrib\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_db_FETCH_attrib\n", THEADER_slow);
 
 	if (!retsv)
 		return Nullsv;
@@ -811,7 +811,7 @@ int dbd_db_STORE_attrib (SV * dbh, imp_dbh_t * imp_dbh, SV * keysv, SV * valuesv
 	unsigned int newval = SvTRUE(valuesv);
 	int          retval = 0;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin dbd_db_STORE (key: %s newval: %d kl:%d)\n", THEADER, key, newval, (int)kl);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin dbd_db_STORE (key: %s newval: %d kl:%d)\n", THEADER_slow, key, newval, (int)kl);
 	
 	switch (kl) {
 
@@ -831,8 +831,8 @@ int dbd_db_STORE_attrib (SV * dbh, imp_dbh_t * imp_dbh, SV * keysv, SV * valuesv
 		if (strEQ("AutoCommit", key)) {
 			if (newval != DBIc_has(imp_dbh, DBIcf_AutoCommit)) {
 				if (newval!=0) { /* It was off but is now on, so do a final commit */
-					if (0!=dbd_db_commit(dbh, imp_dbh) && TRACE4)
-						TRC(DBILOGFP, "%sSetting AutoCommit to 'on' forced a commit\n", THEADER);
+					if (0!=dbd_db_commit(dbh, imp_dbh) && TRACE4_slow)
+						TRC(DBILOGFP, "%sSetting AutoCommit to 'on' forced a commit\n", THEADER_slow);
 				}
 				DBIc_set(imp_dbh, DBIcf_AutoCommit, newval);
 			}
@@ -854,8 +854,8 @@ int dbd_db_STORE_attrib (SV * dbh, imp_dbh_t * imp_dbh, SV * keysv, SV * valuesv
 			imp_dbh->pg_errorlevel = 0==newval ? 0 : 2==newval ? 2 : 1;
 			TRACE_PQSETERRORVERBOSITY;
 			(void)PQsetErrorVerbosity(imp_dbh->conn, (PGVerbosity)imp_dbh->pg_errorlevel);
-			if (TRACE5)
-				TRC(DBILOGFP, "%sReset error verbosity to %d\n", THEADER, imp_dbh->pg_errorlevel);
+			if (TRACE5_slow)
+				TRC(DBILOGFP, "%sReset error verbosity to %d\n", THEADER_slow, imp_dbh->pg_errorlevel);
 			retval = 1;
 		}
 		break;
@@ -904,7 +904,7 @@ int dbd_db_STORE_attrib (SV * dbh, imp_dbh_t * imp_dbh, SV * keysv, SV * valuesv
 		break;
 	}
 
-	if (TEND) TRC(DBILOGFP, "%sEnd dbd_db_STORE_attrib\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_db_STORE_attrib\n", THEADER_slow);
 	return retval;
 
 } /* end of dbd_db_STORE_attrib */
@@ -919,7 +919,7 @@ SV * dbd_st_FETCH_attrib (SV * sth, imp_sth_t * imp_sth, SV * keysv)
 	SV *              retsv = Nullsv;
 	int               fields, x;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin dbd_st_FETCH (key: %s)\n", THEADER, key);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin dbd_st_FETCH (key: %s)\n", THEADER_slow, key);
 	
 	/* Some can be done before we have a result: */
 	switch (kl) {
@@ -1060,14 +1060,14 @@ SV * dbd_st_FETCH_attrib (SV * sth, imp_sth_t * imp_sth, SV * keysv)
 	}
 
 	if (retsv != Nullsv) {
-		if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_FETCH_attrib\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_FETCH_attrib\n", THEADER_slow);
 		return sv_2mortal(retsv);
 	}
 
 	if (! imp_sth->result) {
-		if (TRACEWARN)
-			TRC(DBILOGFP, "%sCannot fetch value of %s pre-execute\n", THEADER, key);
-		if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_FETCH_attrib\n", THEADER);
+		if (TRACEWARN_slow)
+			TRC(DBILOGFP, "%sCannot fetch value of %s pre-execute\n", THEADER_slow, key);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_FETCH_attrib\n", THEADER_slow);
 		return Nullsv;
 	}
 
@@ -1259,7 +1259,7 @@ SV * dbd_st_FETCH_attrib (SV * sth, imp_sth_t * imp_sth, SV * keysv)
 
 	}
 
-	if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_FETCH_attrib\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_FETCH_attrib\n", THEADER_slow);
 
 	if (retsv == Nullsv)
 		return Nullsv;
@@ -1279,8 +1279,8 @@ int dbd_st_STORE_attrib (SV * sth, imp_sth_t * imp_sth, SV * keysv, SV * valuesv
 	char * value = SvPV(valuesv,vl);
 	int    retval = 0;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin dbd_st_STORE (key: %s value: %s)\n",
-					THEADER, key, value);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin dbd_st_STORE (key: %s value: %s)\n",
+					THEADER_slow, key, value);
 	
 	switch (kl) {
 
@@ -1332,7 +1332,7 @@ int dbd_st_STORE_attrib (SV * sth, imp_sth_t * imp_sth, SV * keysv, SV * valuesv
 
 	}
 
-	if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_STORE_attrib\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_STORE_attrib\n", THEADER_slow);
 	return retval;
 
 } /* end of dbd_st_STORE_attrib */
@@ -1343,7 +1343,7 @@ int dbd_discon_all (SV * drh, imp_drh_t * imp_drh)
 {
 	dTHX;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin dbd_discon_all\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin dbd_discon_all\n", THEADER_slow);
 
 	/* The disconnect_all concept is flawed and needs more work */
 	if (!PL_dirty && !SvTRUE(get_sv("DBI::PERL_ENDING",0))) {
@@ -1351,7 +1351,7 @@ int dbd_discon_all (SV * drh, imp_drh_t * imp_drh)
 		sv_setpv(DBIc_ERRSTR(imp_drh), "disconnect_all not implemented");
 	}
 
-	if (TEND) TRC(DBILOGFP, "%sEnd dbd_discon_all\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_discon_all\n", THEADER_slow);
 	return 0;
 
 } /* end of dbd_discon_all */
@@ -1365,7 +1365,7 @@ int pg_db_getfd (imp_dbh_t * imp_dbh)
 {
 	dTHX;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_getfd\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_getfd\n", THEADER_slow);
 
 	TRACE_PQSOCKET;
 	return PQsocket(imp_dbh->conn);
@@ -1382,14 +1382,14 @@ SV * pg_db_pg_notifies (SV * dbh, imp_dbh_t * imp_dbh)
 	AV *       ret;
 	SV *       retsv;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_pg_notifies\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_pg_notifies\n", THEADER_slow);
 
 	TRACE_PQCONSUMEINPUT;
 	status = PQconsumeInput(imp_dbh->conn);
 	if (0 == status) { 
 		TRACE_PQERRORMESSAGE;
 		pg_error(aTHX_ dbh, PGRES_FATAL_ERROR, PQerrorMessage(imp_dbh->conn));
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_pg_notifies (error)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_pg_notifies (error)\n", THEADER_slow);
 		return &PL_sv_undef;
 	}
 
@@ -1397,7 +1397,7 @@ SV * pg_db_pg_notifies (SV * dbh, imp_dbh_t * imp_dbh)
 	notify = PQnotifies(imp_dbh->conn);
 
 	if (!notify) {
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_pg_notifies (undef)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_pg_notifies (undef)\n", THEADER_slow);
 		return &PL_sv_undef; 
 	}
 
@@ -1412,7 +1412,7 @@ SV * pg_db_pg_notifies (SV * dbh, imp_dbh_t * imp_dbh)
 
 	retsv = newRV_inc(sv_2mortal((SV*)ret));
 
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_db_pg_notifies\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_pg_notifies\n", THEADER_slow);
 	return sv_2mortal(retsv);
 
 } /* end of pg_db_pg_notifies */
@@ -1426,7 +1426,7 @@ int dbd_st_prepare (SV * sth, imp_sth_t * imp_sth, char * statement, SV * attrib
 	STRLEN mypos=0, wordstart, newsize; /* Used to find and set firstword */
 	SV **svp; /* To help parse the arguments */
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin dbd_st_prepare (statement: %s)\n", THEADER, statement);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin dbd_st_prepare (statement: %s)\n", THEADER_slow, statement);
 
 	if ('\0' == *statement)
 		croak ("Cannot prepare empty statement");
@@ -1524,9 +1524,9 @@ int dbd_st_prepare (SV * sth, imp_sth_t * imp_sth, char * statement, SV * attrib
 	  4. The attribute "pg_prepare_now" is true
 	  5. We are compiled on a 8 or greater server
 	*/
-	if (TRACE4)	TRC(DBILOGFP,
+	if (TRACE4_slow)	TRC(DBILOGFP,
 					"%sImmediate prepare decision: dml=%d direct=%d server_prepare=%d prepare_now=%d PGLIBVERSION=%d\n",
-					THEADER,
+					THEADER_slow,
 					imp_sth->is_dml,
 					imp_sth->direct,
 					imp_sth->server_prepare,
@@ -1539,7 +1539,7 @@ int dbd_st_prepare (SV * sth, imp_sth_t * imp_sth, char * statement, SV * attrib
 		&& imp_sth->prepare_now
 		&& PGLIBVERSION >= 80000
 		) {
-		if (TRACE5) TRC(DBILOGFP, "%sRunning an immediate prepare\n", THEADER);
+		if (TRACE5_slow) TRC(DBILOGFP, "%sRunning an immediate prepare\n", THEADER_slow);
 
 		if (pg_st_prepare_statement(aTHX_ sth, imp_sth)!=0) {
 			TRACE_PQERRORMESSAGE;
@@ -1550,7 +1550,7 @@ int dbd_st_prepare (SV * sth, imp_sth_t * imp_sth, char * statement, SV * attrib
 	/* Tell DBI to call destroy when this handle ends */
 	DBIc_IMPSET_on(imp_sth);
 
-	if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_prepare\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_prepare\n", THEADER_slow);
 	return 1;
 
 } /* end of dbd_st_prepare */
@@ -1598,17 +1598,17 @@ static void pg_st_split_statement (pTHX_ imp_sth_t * imp_sth, int version, char
 
 	ph_t *newph, *thisph, *currph = NULL; /* Placeholder structures to help build ll */
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_st_split_statement\n", THEADER);
-	if (TRACE6) TRC(DBILOGFP, "%spg_st_split_statement: (%s)\n", THEADER, statement);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_st_split_statement\n", THEADER_slow);
+	if (TRACE6_slow) TRC(DBILOGFP, "%spg_st_split_statement: (%s)\n", THEADER_slow, statement);
 	
 	/*
 	  If the pg_direct flag is set (or the string has no length), we do not split at all,
 	  but simply put everything verbatim into a single segment and return.
 	*/
 	if (imp_sth->direct || '\0' == *statement) {
-		if (TRACE4) {
+		if (TRACE4_slow) {
 			TRC(DBILOGFP, "%snot splitting due to %s\n",
-				THEADER, imp_sth->direct ? "pg_direct" : "empty string");
+				THEADER_slow, imp_sth->direct ? "pg_direct" : "empty string");
 		}
 		imp_sth->numsegs   = 1;
 		imp_sth->numphs    = 0;
@@ -1626,9 +1626,9 @@ static void pg_st_split_statement (pTHX_ imp_sth_t * imp_sth, int version, char
 		else {
 			imp_sth->seg->segment = NULL;
 		}
-		if (TRACE6) TRC(DBILOGFP, "%sdirect split = (%s) length=(%d)\n",
-						THEADER, imp_sth->seg->segment, (int)imp_sth->totalsize);
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_st_split_statement (direct)\n", THEADER);
+		if (TRACE6_slow) TRC(DBILOGFP, "%sdirect split = (%s) length=(%d)\n",
+						THEADER_slow, imp_sth->seg->segment, (int)imp_sth->totalsize);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_st_split_statement (direct)\n", THEADER_slow);
 		return;
 	}
 
@@ -1960,8 +1960,8 @@ static void pg_st_split_statement (pTHX_ imp_sth_t * imp_sth, int version, char
 		else {
 			newseg->segment = NULL;
 		}
-		if (TRACE6)
-			TRC(DBILOGFP, "%sCreated segment (%s)\n", THEADER, newseg->segment);
+		if (TRACE6_slow)
+			TRC(DBILOGFP, "%sCreated segment (%s)\n", THEADER_slow, newseg->segment);
 		
 		/* Tie it in to the previous one */
 		if (NULL==currseg) {
@@ -2005,7 +2005,7 @@ static void pg_st_split_statement (pTHX_ imp_sth_t * imp_sth, int version, char
 			if (!found)
 				croak("Invalid placeholders: must start at $1 and increment one at a time (expected: $%d)\n", xint);
 		}
-		if (TRACE6)	TRC(DBILOGFP, "%sSet number of placeholders to %d\n", THEADER, topdollar);
+		if (TRACE6_slow)	TRC(DBILOGFP, "%sSet number of placeholders to %d\n", THEADER_slow, topdollar);
 		imp_sth->numphs = topdollar;
 	}
 
@@ -2039,27 +2039,27 @@ static void pg_st_split_statement (pTHX_ imp_sth_t * imp_sth, int version, char
 		}
 	}
 
-	if (TRACE7) {
+	if (TRACE7_slow) {
 		TRC(DBILOGFP, "%sPlaceholder type: %d numsegs: %d numphs: %d\n",
-			THEADER, imp_sth->placeholder_type, imp_sth->numsegs, imp_sth->numphs);
+			THEADER_slow, imp_sth->placeholder_type, imp_sth->numsegs, imp_sth->numphs);
 		TRC(DBILOGFP, "%sPlaceholder numbers and segments:\n",
-			THEADER);
+			THEADER_slow);
 		for (currseg=imp_sth->seg; NULL != currseg; currseg=currseg->nextseg) {
 			TRC(DBILOGFP, "%sPH: (%d) SEG: (%s)\n",
-				THEADER, currseg->placeholder, currseg->segment);
+				THEADER_slow, currseg->placeholder, currseg->segment);
 		}
 		if (imp_sth->numphs) {
-			TRC(DBILOGFP, "%sPlaceholder number, fooname, id:\n", THEADER);
+			TRC(DBILOGFP, "%sPlaceholder number, fooname, id:\n", THEADER_slow);
 			for (xlen=1,currph=imp_sth->ph; NULL != currph; currph=currph->nextph,xlen++) {
 				TRC(DBILOGFP, "%s#%d FOONAME: (%s)\n",
-					THEADER, (int)xlen, currph->fooname);
+					THEADER_slow, (int)xlen, currph->fooname);
 			}
 		}
 	}
 
 	DBIc_NUM_PARAMS(imp_sth) = imp_sth->numphs;
 
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_st_split_statement\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_st_split_statement\n", THEADER_slow);
 	return;
 
 } /* end pg_st_split_statement */
@@ -2079,7 +2079,7 @@ static int pg_st_prepare_statement (pTHX_ SV * sth, imp_sth_t * imp_sth)
 	bool         oldprepare = DBDPG_TRUE;
 	ph_t *       currph;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_st_prepare_statement\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_st_prepare_statement\n", THEADER_slow);
 
 #if PGLIBVERSION >= 80000
 	oldprepare = DBDPG_FALSE;
@@ -2093,9 +2093,9 @@ static int pg_st_prepare_statement (pTHX_ SV * sth, imp_sth_t * imp_sth)
 			abs(imp_dbh->pid_number),
 			imp_dbh->prepare_number);
 
-	if (TRACE5)
+	if (TRACE5_slow)
 		TRC(DBILOGFP, "%sNew statement name (%s), oldprepare is %d\n",
-			THEADER, imp_sth->prepare_name, oldprepare);
+			THEADER_slow, imp_sth->prepare_name, oldprepare);
 
 	/* PQprepare was not added until 8.0 */
 
@@ -2161,8 +2161,8 @@ static int pg_st_prepare_statement (pTHX_ SV * sth, imp_sth_t * imp_sth)
 
 	statement[execsize] = '\0';
 
-	if (TRACE6)
-		TRC(DBILOGFP, "%sPrepared statement (%s)\n", THEADER, statement);
+	if (TRACE6_slow)
+		TRC(DBILOGFP, "%sPrepared statement (%s)\n", THEADER_slow, statement);
 
 	if (oldprepare) {
 		status = _result(aTHX_ imp_dbh, statement);
@@ -2188,8 +2188,8 @@ static int pg_st_prepare_statement (pTHX_ SV * sth, imp_sth_t * imp_sth)
 			TRACE_PQCLEAR;
 			PQclear(result);
 		}
-		if (TRACE6)
-			TRC(DBILOGFP, "%sUsing PQprepare: %s\n", THEADER, statement);
+		if (TRACE6_slow)
+			TRC(DBILOGFP, "%sUsing PQprepare: %s\n", THEADER_slow, statement);
 	}
 	Safefree(statement);
 	if (PGRES_COMMAND_OK != status) {
@@ -2197,14 +2197,14 @@ static int pg_st_prepare_statement (pTHX_ SV * sth, imp_sth_t * imp_sth)
 		Safefree(imp_sth->prepare_name);
 		imp_sth->prepare_name = NULL;
 		pg_error(aTHX_ sth, status, PQerrorMessage(imp_dbh->conn));
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_st_prepare_statement (error)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_st_prepare_statement (error)\n", THEADER_slow);
 		return -2;
 	}
 
 	imp_sth->prepared_by_us = DBDPG_TRUE; /* Done here so deallocate is not called spuriously */
 	imp_dbh->prepare_number++; /* We do this at the end so we don't increment if we fail above */
 
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_st_prepare_statement\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_st_prepare_statement\n", THEADER_slow);
 	return 0;
 	
 } /* end of pg_st_prepare_statement */
@@ -2228,8 +2228,8 @@ int dbd_bind_ph (SV * sth, imp_sth_t * imp_sth, SV * ph_name, SV * newvalue, IV
 
    	maxlen = 0; /* not used, this makes the compiler happy */
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin dbd_bind_ph (ph_name: %s)\n",
-					THEADER,
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin dbd_bind_ph (ph_name: %s)\n",
+					THEADER_slow,
 					neatsvpv(ph_name,0));
 
 	if (0==imp_sth->numphs)
@@ -2315,10 +2315,10 @@ int dbd_bind_ph (SV * sth, imp_sth_t * imp_sth, SV * ph_name, SV * newvalue, IV
 			croak("Cannot bind a reference\n");
 		}
 	}
-	if (TRACE5) {
-		TRC(DBILOGFP, "%sBind (%s) (type=%ld)\n", THEADER, name, (long)sql_type);
+	if (TRACE5_slow) {
+		TRC(DBILOGFP, "%sBind (%s) (type=%ld)\n", THEADER_slow, name, (long)sql_type);
 		if (attribs) {
-			TRC(DBILOGFP, "%sBind attribs (%s)", THEADER, neatsvpv(attribs,0));
+			TRC(DBILOGFP, "%sBind attribs (%s)", THEADER_slow, neatsvpv(attribs,0));
 		}
 	}
 
@@ -2334,7 +2334,7 @@ int dbd_bind_ph (SV * sth, imp_sth_t * imp_sth, SV * ph_name, SV * newvalue, IV
 			imp_sth->numbound++;
 			currph->bind_type = pg_type_data(PG_UNKNOWN);
 		}
-		if (TEND) TRC(DBILOGFP, "%sEnd dbd_bind_ph (special)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_bind_ph (special)\n", THEADER_slow);
 		return 1;
 	}
 
@@ -2412,26 +2412,26 @@ int dbd_bind_ph (SV * sth, imp_sth_t * imp_sth, SV * ph_name, SV * newvalue, IV
 	}
 
 	if (reprepare) {
-		if (TRACE5)
-			TRC(DBILOGFP, "%sBinding has forced a re-prepare\n", THEADER);
+		if (TRACE5_slow)
+			TRC(DBILOGFP, "%sBinding has forced a re-prepare\n", THEADER_slow);
 		/* Deallocate sets the prepare_name to NULL */
 		if (pg_st_deallocate_statement(aTHX_ sth, imp_sth)!=0) {
 			/* Deallocation failed. Let's mark it and move on */
 			Safefree(imp_sth->prepare_name);
 			imp_sth->prepare_name = NULL;
-			if (TRACEWARN)
-				TRC(DBILOGFP, "%sFailed to deallocate!\n", THEADER);
+			if (TRACEWARN_slow)
+				TRC(DBILOGFP, "%sFailed to deallocate!\n", THEADER_slow);
 		}
 	}
 
-	if (TRACE7)
+	if (TRACE7_slow)
 		TRC	(DBILOGFP,
 			 "%sPlaceholder (%s) bound as type (%s) (type_id=%d), length %d, value of (%s)\n",
-			 THEADER, name, currph->bind_type->type_name,
+			 THEADER_slow, name, currph->bind_type->type_name,
 			 currph->bind_type->type_id, (int)currph->valuelen,
 			 PG_BYTEA==currph->bind_type->type_id ? "(binary, not shown)" : value_string);
 
-	if (TEND) TRC(DBILOGFP, "%sEnd dbd_bind_ph\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_bind_ph\n", THEADER_slow);
 	return 1;
 
 } /* end of dbd_bind_ph */
@@ -2454,7 +2454,7 @@ SV * pg_stringify_array(SV *input, const char * array_delim, int server_version)
 	STRLEN stringlength;
 	SV * value;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_stringify_array\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_stringify_array\n", THEADER_slow);
 
 	toparr = (AV *) SvRV(input);
 	value = newSVpv("{", 1);
@@ -2463,7 +2463,7 @@ SV * pg_stringify_array(SV *input, const char * array_delim, int server_version)
 	if (av_len(toparr) < 0) {
 		av_clear(toparr);
 		sv_catpv(value, "}");
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_stringify_array (empty)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_stringify_array (empty)\n", THEADER_slow);
 		return value;
 	}
 
@@ -2574,7 +2574,7 @@ SV * pg_stringify_array(SV *input, const char * array_delim, int server_version)
 		sv_catpv(value, "}");
 	}
 
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_stringify_array (string: %s)\n", THEADER, neatsvpv(value,0));
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_stringify_array (string: %s)\n", THEADER_slow, neatsvpv(value,0));
 	return value;
 
 } /* end of pg_stringify_array */
@@ -2593,8 +2593,8 @@ static SV * pg_destringify_array(pTHX_ imp_dbh_t *imp_dbh, unsigned char * input
 	int    opening_braces = 0;
 	int    closing_braces = 0;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_destringify_array (string: %s quotechar: %c)\n",
-					THEADER, input, coltype->array_delimeter);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_destringify_array (string: %s quotechar: %c)\n",
+					THEADER_slow, input, coltype->array_delimeter);
 
 	/*
 	  Note: we don't do careful balance checking here, as this is coming straight from 
@@ -2715,7 +2715,7 @@ static SV * pg_destringify_array(pTHX_ imp_dbh_t *imp_dbh, unsigned char * input
 	}
 	Safefree(string);
 
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_destringify_array\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_destringify_array\n", THEADER_slow);
 	return newRV_noinc((SV*)av);
 
 } /* end of pg_destringify_array */
@@ -2732,8 +2732,8 @@ int pg_quickexec (SV * dbh, const char * sql, const int asyncflag)
 	char *                  cmdStatus = NULL;
 	int                     rows = 0;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_quickexec (query: %s async: %d async_status: %d)\n",
-			THEADER, sql, asyncflag, imp_dbh->async_status);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_quickexec (query: %s async: %d async_status: %d)\n",
+			THEADER_slow, sql, asyncflag, imp_dbh->async_status);
 
 	if (NULL == imp_dbh->conn) {
 		pg_error(aTHX_ dbh, PGRES_FATAL_ERROR, "Database handle has been disconnected");
@@ -2752,10 +2752,10 @@ int pg_quickexec (SV * dbh, const char * sql, const int asyncflag)
 
 	/* If we are still waiting on an async, handle it */
 	if (imp_dbh->async_status) {
-		if (TRACE5) TRC(DBILOGFP, "%shandling old async\n", THEADER);
+		if (TRACE5_slow) TRC(DBILOGFP, "%shandling old async\n", THEADER_slow);
 		rows = handle_old_async(aTHX_ dbh, imp_dbh, asyncflag);
 		if (rows) {
-			if (TEND) TRC(DBILOGFP, "%sEnd pg_quickexec (async rows: %d)\n", THEADER, rows);
+			if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_quickexec (async rows: %d)\n", THEADER_slow, rows);
 			return rows;
 		}
 	}
@@ -2766,7 +2766,7 @@ int pg_quickexec (SV * dbh, const char * sql, const int asyncflag)
 		if (PGRES_COMMAND_OK != status) {
 			TRACE_PQERRORMESSAGE;
 			pg_error(aTHX_ dbh, status, PQerrorMessage(imp_dbh->conn));
-			if (TEND) TRC(DBILOGFP, "%sEnd pg_quickexec (error: begin failed)\n", THEADER);
+			if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_quickexec (error: begin failed)\n", THEADER_slow);
 			return -2;
 		}
 		imp_dbh->done_begin = DBDPG_TRUE;
@@ -2776,7 +2776,7 @@ int pg_quickexec (SV * dbh, const char * sql, const int asyncflag)
 			if (PGRES_COMMAND_OK != status) {
 				TRACE_PQERRORMESSAGE;
 				pg_error(aTHX_ dbh, status, PQerrorMessage(imp_dbh->conn));
-				if (TEND) TRC(DBILOGFP, "%sEnd pg_quickexec (error: set transaction read only failed)\n", THEADER);
+				if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_quickexec (error: set transaction read only failed)\n", THEADER_slow);
 				return -2;
 			}
 		}
@@ -2789,19 +2789,19 @@ int pg_quickexec (SV * dbh, const char * sql, const int asyncflag)
 
 	/* Asynchronous commands get kicked off and return undef */
 	if (asyncflag & PG_ASYNC) {
-		if (TRACE4) TRC(DBILOGFP, "%sGoing asychronous with do()\n", THEADER);
+		if (TRACE4_slow) TRC(DBILOGFP, "%sGoing asychronous with do()\n", THEADER_slow);
 		TRACE_PQSENDQUERY;
 		if (! PQsendQuery(imp_dbh->conn, sql)) {
-			if (TRACE4) TRC(DBILOGFP, "%sPQsendQuery failed\n", THEADER);
+			if (TRACE4_slow) TRC(DBILOGFP, "%sPQsendQuery failed\n", THEADER_slow);
 			TRACE_PQERRORMESSAGE;
 			pg_error(aTHX_ dbh, status, PQerrorMessage(imp_dbh->conn));
-			if (TEND) TRC(DBILOGFP, "%sEnd pg_quickexec (error: async do failed)\n", THEADER);
+			if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_quickexec (error: async do failed)\n", THEADER_slow);
 			return -2;
 		}
 		imp_dbh->async_status = 1;
 		imp_dbh->async_sth = NULL; /* Needed? */
 
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_quickexec (async)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_quickexec (async)\n", THEADER_slow);
 		return 0;
 	}
 
@@ -2813,7 +2813,7 @@ int pg_quickexec (SV * dbh, const char * sql, const int asyncflag)
 
 	imp_dbh->copystate = 0; /* Assume not in copy mode until told otherwise */
 
-	if (TRACE4) TRC(DBILOGFP, "%sGot a status of %d\n", THEADER, status);
+	if (TRACE4_slow) TRC(DBILOGFP, "%sGot a status of %d\n", THEADER_slow, status);
 	switch (status) {
 	case PGRES_TUPLES_OK:
 		TRACE_PQNTUPLES;
@@ -2867,7 +2867,7 @@ int pg_quickexec (SV * dbh, const char * sql, const int asyncflag)
 		PQclear(result);
 	}
 	else {
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_quickexec (no result)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_quickexec (no result)\n", THEADER_slow);
 		return -2;
 	}
 
@@ -2884,8 +2884,8 @@ int pg_quickexec (SV * dbh, const char * sql, const int asyncflag)
 		}
 	}
 
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_quickexec (rows: %d, txn_status: %d)\n",
-				  THEADER, rows, txn_status);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_quickexec (rows: %d, txn_status: %d)\n",
+				  THEADER_slow, rows, txn_status);
 	return rows;
 
 } /* end of pg_quickexec */
@@ -2905,7 +2905,7 @@ int dbd_st_execute (SV * sth, imp_sth_t * imp_sth)
 	int           num_fields;
 	int           ret = -2;
 	
-	if (TSTART) TRC(DBILOGFP, "%sBegin dbd_st_execute\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin dbd_st_execute\n", THEADER_slow);
 	
 	if (NULL == imp_dbh->conn) {
 		pg_error(aTHX_ sth, PGRES_FATAL_ERROR, "Cannot call execute on a disconnected database handle");
@@ -2921,7 +2921,7 @@ int dbd_st_execute (SV * sth, imp_sth_t * imp_sth)
 		for (currph=imp_sth->ph; NULL != currph; currph=currph->nextph) {
 			if (NULL == currph->bind_type) {
 				pg_error(aTHX_ sth, PGRES_FATAL_ERROR, "execute called with an unbound placeholder");
-				if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_execute (error: unbound placeholder)\n", THEADER);
+				if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_execute (error: unbound placeholder)\n", THEADER_slow);
 				return -2;
 			}
 			if (currph->isinout) {
@@ -2936,10 +2936,10 @@ int dbd_st_execute (SV * sth, imp_sth_t * imp_sth)
 
 	/* Check for old async transactions */
 	if (imp_dbh->async_status) {
-		if (TRACE7) TRC(DBILOGFP, "%sAttempting to handle existing async transaction\n", THEADER);
+		if (TRACE7_slow) TRC(DBILOGFP, "%sAttempting to handle existing async transaction\n", THEADER_slow);
 		ret = handle_old_async(aTHX_ sth, imp_dbh, imp_sth->async_flag);
 		if (ret) {
-			if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_execute (async ret: %d)\n", THEADER, ret);
+			if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_execute (async ret: %d)\n", THEADER_slow, ret);
 			return ret;
 		}
 	}
@@ -2950,7 +2950,7 @@ int dbd_st_execute (SV * sth, imp_sth_t * imp_sth)
 		if (PGRES_COMMAND_OK != status) {
 			TRACE_PQERRORMESSAGE;
 			pg_error(aTHX_ sth, status, PQerrorMessage(imp_dbh->conn));
-			if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_execute (error: begin failed)\n", THEADER);
+			if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_execute (error: begin failed)\n", THEADER_slow);
 			return -2;
 		}
 		imp_dbh->done_begin = DBDPG_TRUE;
@@ -2960,7 +2960,7 @@ int dbd_st_execute (SV * sth, imp_sth_t * imp_sth)
 			if (PGRES_COMMAND_OK != status) {
 				TRACE_PQERRORMESSAGE;
 				pg_error(aTHX_ sth, status, PQerrorMessage(imp_dbh->conn));
-				if (TEND) TRC(DBILOGFP, "%sEnd pg_quickexec (error: set transaction read only failed)\n", THEADER);
+				if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_quickexec (error: set transaction read only failed)\n", THEADER_slow);
 				return -2;
 			}
 		}
@@ -3064,9 +3064,9 @@ int dbd_st_execute (SV * sth, imp_sth_t * imp_sth)
 	   OR
 	   6b. All placeholders are bound (and "pg_server_prepare" is 2)
 	*/
-	if (TRACE4) TRC(DBILOGFP,
+	if (TRACE4_slow) TRC(DBILOGFP,
 					"%sPQexec* decision: dml=%d direct=%d server_prepare=%d numbound=%d numphs=%d default=%d current=%d\n",
-					THEADER, 
+					THEADER_slow, 
 					imp_sth->is_dml,
 					imp_sth->direct,
 					imp_sth->server_prepare,
@@ -3085,36 +3085,36 @@ int dbd_st_execute (SV * sth, imp_sth_t * imp_sth)
 			|| (imp_sth->numbound == imp_sth->numphs))
 		){
 	
-		if (TRACE4) TRC(DBILOGFP, "%sPQexecPrepared\n", THEADER);
+		if (TRACE4_slow) TRC(DBILOGFP, "%sPQexecPrepared\n", THEADER_slow);
 
 		/* Prepare if it has not already been prepared (or it needs repreparing) */
 		if (NULL == imp_sth->prepare_name) {
 			if (imp_sth->prepared_by_us) {
-				if (TRACE5) TRC(DBILOGFP, "%sRe-preparing statement\n", THEADER);
+				if (TRACE5_slow) TRC(DBILOGFP, "%sRe-preparing statement\n", THEADER_slow);
 			}
 			if (pg_st_prepare_statement(aTHX_ sth, imp_sth)!=0) {
-				if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_execute (error)\n", THEADER);
+				if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_execute (error)\n", THEADER_slow);
 				return -2;
 			}
 		}
 		else {
-			if (TRACE5) TRC(DBILOGFP, "%sUsing previously prepared statement (%s)\n",
-							THEADER, imp_sth->prepare_name);
+			if (TRACE5_slow) TRC(DBILOGFP, "%sUsing previously prepared statement (%s)\n",
+							THEADER_slow, imp_sth->prepare_name);
 		}
 		
-		if (TRACE7) {
+		if (TRACE7_slow) {
 			for (x=0,currph=imp_sth->ph; NULL != currph; currph=currph->nextph,x++) {
-				TRC(DBILOGFP, "%sPQexecPrepared item #%d\n", THEADER, (int)x);
+				TRC(DBILOGFP, "%sPQexecPrepared item #%d\n", THEADER_slow, (int)x);
 				TRC(DBILOGFP, "%s-> Value: (%s)\n",
-					THEADER, (imp_sth->PQfmts && imp_sth->PQfmts[x]==1) ? "(binary, not shown)" 
+					THEADER_slow, (imp_sth->PQfmts && imp_sth->PQfmts[x]==1) ? "(binary, not shown)" 
 									: imp_sth->PQvals[x]);
-				TRC(DBILOGFP, "%s-> Length: (%d)\n", THEADER, imp_sth->PQlens ? imp_sth->PQlens[x] : 0);
-				TRC(DBILOGFP, "%s-> Format: (%d)\n", THEADER, imp_sth->PQfmts ? imp_sth->PQfmts[x] : 0);
+				TRC(DBILOGFP, "%s-> Length: (%d)\n", THEADER_slow, imp_sth->PQlens ? imp_sth->PQlens[x] : 0);
+				TRC(DBILOGFP, "%s-> Format: (%d)\n", THEADER_slow, imp_sth->PQfmts ? imp_sth->PQfmts[x] : 0);
 			}
 		}
 		
-		if (TRACE5) TRC(DBILOGFP, "%sRunning PQexecPrepared with (%s)\n",
-						THEADER, imp_sth->prepare_name);
+		if (TRACE5_slow) TRC(DBILOGFP, "%sRunning PQexecPrepared with (%s)\n",
+						THEADER_slow, imp_sth->prepare_name);
 		if (TSQL) {
 			TRC(DBILOGFP, "EXECUTE %s (\n", imp_sth->prepare_name);
 			for (x=0,currph=imp_sth->ph; NULL != currph; currph=currph->nextph,x++) {
@@ -3148,7 +3148,7 @@ int dbd_st_execute (SV * sth, imp_sth_t * imp_sth)
 			&& 1 == imp_sth->server_prepare
 			) {
 
-			if (TRACE5) TRC(DBILOGFP, "%sPQexecParams\n", THEADER);
+			if (TRACE5_slow) TRC(DBILOGFP, "%sPQexecParams\n", THEADER_slow);
 
 			/* Figure out how big the statement plus placeholders will be */
 			for (currseg=imp_sth->seg; NULL != currseg; currseg=currseg->nextseg) {
@@ -3183,13 +3183,13 @@ int dbd_st_execute (SV * sth, imp_sth_t * imp_sth)
 				imp_sth->PQoids[x++] = (currph->defaultval) ? 0 : (Oid)currph->bind_type->type_id;
 			}
 		
-			if (TRACE7) {
+			if (TRACE7_slow) {
 				for (x=0,currph=imp_sth->ph; NULL != currph; currph=currph->nextph,x++) {
-					TRC(DBILOGFP, "%sPQexecParams item #%d\n", THEADER, (int)x);
-					TRC(DBILOGFP, "%s-> Type: (%d)\n", THEADER, imp_sth->PQoids[x]);
-					TRC(DBILOGFP, "%s-> Value: (%s)\n", THEADER, imp_sth->PQvals[x]);
-					TRC(DBILOGFP, "%s-> Length: (%d)\n", THEADER, imp_sth->PQlens ? imp_sth->PQlens[x] : 0);
-					TRC(DBILOGFP, "%s-> Format: (%d)\n", THEADER, imp_sth->PQfmts ? imp_sth->PQfmts[x] : 0);
+					TRC(DBILOGFP, "%sPQexecParams item #%d\n", THEADER_slow, (int)x);
+					TRC(DBILOGFP, "%s-> Type: (%d)\n", THEADER_slow, imp_sth->PQoids[x]);
+					TRC(DBILOGFP, "%s-> Value: (%s)\n", THEADER_slow, imp_sth->PQvals[x]);
+					TRC(DBILOGFP, "%s-> Length: (%d)\n", THEADER_slow, imp_sth->PQlens ? imp_sth->PQlens[x] : 0);
+					TRC(DBILOGFP, "%s-> Format: (%d)\n", THEADER_slow, imp_sth->PQfmts ? imp_sth->PQfmts[x] : 0);
 				}
 			}
 
@@ -3201,7 +3201,7 @@ int dbd_st_execute (SV * sth, imp_sth_t * imp_sth)
 				TRC(DBILOGFP, ");\n\n");
 			}
 
-			if (TRACE5) TRC(DBILOGFP, "%sRunning PQexecParams with (%s)\n", THEADER, statement);
+			if (TRACE5_slow) TRC(DBILOGFP, "%sRunning PQexecParams with (%s)\n", THEADER_slow, statement);
 			if (imp_sth->async_flag & PG_ASYNC) {
 				TRACE_PQSENDQUERYPARAMS;
 				ret = PQsendQueryParams
@@ -3218,7 +3218,7 @@ int dbd_st_execute (SV * sth, imp_sth_t * imp_sth)
 
 		else {
 
-			if (TRACE5) TRC(DBILOGFP, "%sPQexec\n", THEADER);
+			if (TRACE5_slow) TRC(DBILOGFP, "%sPQexec\n", THEADER_slow);
 
 			/* Go through and quote each value, then turn into a giant statement */
 			for (currseg=imp_sth->seg; NULL != currseg; currseg=currseg->nextseg) {
@@ -3236,8 +3236,8 @@ int dbd_st_execute (SV * sth, imp_sth_t * imp_sth)
 			}
 			statement[execsize] = '\0';
 
-			if (TRACE5) TRC(DBILOGFP, "%sRunning %s with (%s)\n", 
-							THEADER, imp_sth->async_flag & 1 ? "PQsendQuery" : "PQexec", statement);
+			if (TRACE5_slow) TRC(DBILOGFP, "%sRunning %s with (%s)\n", 
+							THEADER_slow, imp_sth->async_flag & 1 ? "PQsendQuery" : "PQexec", statement);
 			
 			if (TSQL)
 				TRC(DBILOGFP, "%s;\n\n", statement);
@@ -3261,11 +3261,11 @@ int dbd_st_execute (SV * sth, imp_sth_t * imp_sth)
 
 	/* If running asynchronously, we don't stick around for the result */
 	if (imp_sth->async_flag & PG_ASYNC) {
-		if (TRACEWARN) TRC(DBILOGFP, "%sEarly return for async query", THEADER);
+		if (TRACEWARN_slow) TRC(DBILOGFP, "%sEarly return for async query", THEADER_slow);
 		imp_dbh->async_status = 1;
 		imp_sth->async_status = 1;
 		imp_dbh->async_sth = imp_sth;
-		if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_execute (async)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_execute (async)\n", THEADER_slow);
 		return 0;
 	}
 
@@ -3280,17 +3280,17 @@ int dbd_st_execute (SV * sth, imp_sth_t * imp_sth)
 		DBIc_ACTIVE_on(imp_sth);
 		TRACE_PQNTUPLES;
 		ret = PQntuples(imp_sth->result);
-		if (TRACE5) TRC(DBILOGFP,
+		if (TRACE5_slow) TRC(DBILOGFP,
 						"%sStatus was PGRES_TUPLES_OK, fields=%d, tuples=%d\n",
-						THEADER, num_fields, ret);
+						THEADER_slow, num_fields, ret);
 	}
 	else if (PGRES_COMMAND_OK == status) {
 		/* non-select statement */
 		char *cmdStatus = NULL;
 		bool gotrows = DBDPG_FALSE;
 
-		if (TRACE5)
-			TRC(DBILOGFP, "%sStatus was PGRES_COMMAND_OK\n", THEADER);
+		if (TRACE5_slow)
+			TRC(DBILOGFP, "%sStatus was PGRES_COMMAND_OK\n", THEADER_slow);
 
 		if (imp_sth->result) {
 			TRACE_PQCMDSTATUS;
@@ -3323,24 +3323,24 @@ int dbd_st_execute (SV * sth, imp_sth_t * imp_sth)
 					DBIc_set(imp_dbh, DBIcf_BegunWork, 0);
 				}
 			}
-			if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_execute (OK, no rows)\n", THEADER);
+			if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_execute (OK, no rows)\n", THEADER_slow);
 			return 0;
 		}
 	}
 	else if (PGRES_COPY_OUT == status || PGRES_COPY_IN == status) {
-		if (TRACE5)
+		if (TRACE5_slow)
 			TRC(DBILOGFP, "%sStatus was PGRES_COPY_%s\n",
-				THEADER, PGRES_COPY_OUT == status ? "OUT" : "IN");
+				THEADER_slow, PGRES_COPY_OUT == status ? "OUT" : "IN");
 		/* Copy Out/In data transfer in progress */
 		imp_dbh->copystate = status;
-		if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_execute (COPY)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_execute (COPY)\n", THEADER_slow);
 		return -1;
 	}
 	else {
-		if (TRACE5) TRC(DBILOGFP, "%sInvalid status returned (%d)\n", THEADER, status);
+		if (TRACE5_slow) TRC(DBILOGFP, "%sInvalid status returned (%d)\n", THEADER_slow, status);
 		TRACE_PQERRORMESSAGE;
 		pg_error(aTHX_ sth, status, PQerrorMessage(imp_dbh->conn));
-		if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_execute (error: bad status)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_execute (error: bad status)\n", THEADER_slow);
 		return -2;
 	}
 	
@@ -3348,7 +3348,7 @@ int dbd_st_execute (SV * sth, imp_sth_t * imp_sth)
 	
 	imp_sth->rows = ret;
 
-	if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_execute (rows: %d)\n", THEADER, ret);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_execute (rows: %d)\n", THEADER_slow, ret);
 	return ret;
 
 } /* end of dbd_st_execute */
@@ -3357,7 +3357,7 @@ int dbd_st_execute (SV * sth, imp_sth_t * imp_sth)
 /* ================================================================== */
 static int is_high_bit_set(pTHX_ const unsigned char * val, STRLEN size)
 {
-	if (TSTART) TRC(DBILOGFP, "%sBegin is_high_bit_set\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin is_high_bit_set\n", THEADER_slow);
 	while (*val && size--)
 		if (*val++ & 0x80) return 1;
 	return 0;
@@ -3379,22 +3379,22 @@ AV * dbd_st_fetch (SV * sth, imp_sth_t * imp_sth)
 	STRLEN            len;
 	AV *              av;
 	
-	if (TSTART) TRC(DBILOGFP, "%sBegin dbd_st_fetch\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin dbd_st_fetch\n", THEADER_slow);
 
 	/* Check that execute() was executed successfully */
 	if ( !DBIc_ACTIVE(imp_sth) ) {
 		pg_error(aTHX_ sth, PGRES_NONFATAL_ERROR, "no statement executing\n");	
-		if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_fetch (error: no statement)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_fetch (error: no statement)\n", THEADER_slow);
 		return Nullav;
 	}
 	
 	TRACE_PQNTUPLES;
 	if (imp_sth->cur_tuple == imp_sth->rows) {
-		if (TRACE5)
-			TRC(DBILOGFP, "%sFetched the last tuple (%d)\n", THEADER, imp_sth->cur_tuple);
+		if (TRACE5_slow)
+			TRC(DBILOGFP, "%sFetched the last tuple (%d)\n", THEADER_slow, imp_sth->cur_tuple);
 		imp_sth->cur_tuple = 0;
 		DBIc_ACTIVE_off(imp_sth);
-		if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_fetch (last tuple)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_fetch (last tuple)\n", THEADER_slow);
 		return Nullav; /* we reached the last tuple */
 	}
 
@@ -3410,10 +3410,10 @@ AV * dbd_st_fetch (SV * sth, imp_sth_t * imp_sth)
 			TRACE_PQFTYPE;
 			imp_sth->type_info[i] = pg_type_data((int)PQftype(imp_sth->result, i));
 			if (imp_sth->type_info[i] == NULL) {
-				if (TRACEWARN) {
+				if (TRACEWARN_slow) {
 					TRACE_PQFTYPE;
 					TRC(DBILOGFP, "%sUnknown type returned by Postgres: %d. Setting to UNKNOWN\n",
-						THEADER, PQftype(imp_sth->result, i));
+						THEADER_slow, PQftype(imp_sth->result, i));
 				}
 				imp_sth->type_info[i] = pg_type_data(PG_UNKNOWN);
 			}
@@ -3423,8 +3423,8 @@ AV * dbd_st_fetch (SV * sth, imp_sth_t * imp_sth)
 	for (i = 0; i < num_fields; ++i) {
 		SV *sv;
 
-		if (TRACE5)
-			TRC(DBILOGFP, "%sFetching field #%d\n", THEADER, i);
+		if (TRACE5_slow)
+			TRC(DBILOGFP, "%sFetching field #%d\n", THEADER_slow, i);
 
 		sv = AvARRAY(av)[i];
 
@@ -3521,7 +3521,7 @@ AV * dbd_st_fetch (SV * sth, imp_sth_t * imp_sth)
 		}
 	}
 
-	if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_fetch\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_fetch\n", THEADER_slow);
 	return av;
 
 } /* end of dbd_st_fetch */
@@ -3535,7 +3535,7 @@ static void pg_db_free_savepoints_to (pTHX_ imp_dbh_t * imp_dbh, const char *sav
 {
 	I32 i;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_free_savepoints_to\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_free_savepoints_to\n", THEADER_slow);
 
 	for (i = av_len(imp_dbh->savepoints); i >= 0; i--) {
 		SV * const elem = av_pop(imp_dbh->savepoints);
@@ -3546,7 +3546,7 @@ static void pg_db_free_savepoints_to (pTHX_ imp_dbh_t * imp_dbh, const char *sav
 		sv_2mortal(elem);
 	}
 
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_db_free_savepoints_to\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_free_savepoints_to\n", THEADER_slow);
 }
 
 
@@ -3555,7 +3555,7 @@ int dbd_st_rows (SV * sth, imp_sth_t * imp_sth)
 {
 	dTHX;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin dbd_st_rows\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin dbd_st_rows\n", THEADER_slow);
 
 	return imp_sth->rows;
 
@@ -3568,8 +3568,8 @@ int dbd_st_finish (SV * sth, imp_sth_t * imp_sth)
 	dTHX;
 	D_imp_dbh_from_sth;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin dbdpg_finish (async: %d)\n",
-					THEADER, imp_dbh->async_status);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin dbdpg_finish (async: %d)\n",
+					THEADER_slow, imp_dbh->async_status);
 	
 	if (DBIc_ACTIVE(imp_sth) && imp_sth->result) {
 		TRACE_PQCLEAR;
@@ -3589,7 +3589,7 @@ int dbd_st_finish (SV * sth, imp_sth_t * imp_sth)
 	imp_dbh->async_sth = NULL;
 
 	DBIc_ACTIVE_off(imp_sth);
-	if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_finish\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_finish\n", THEADER_slow);
 	return 1;
 
 } /* end of dbd_st_finish */
@@ -3604,10 +3604,10 @@ static int pg_st_deallocate_statement (pTHX_ SV * sth, imp_sth_t * imp_sth)
 	int                     status;
 	PGTransactionStatusType tstatus;
 	
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_st_deallocate_statement\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_st_deallocate_statement\n", THEADER_slow);
 
 	if (NULL == imp_dbh->conn || NULL == imp_sth->prepare_name) {
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_st_deallocate_statement (0)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_st_deallocate_statement (0)\n", THEADER_slow);
 		return 0;
 	}
 	
@@ -3615,13 +3615,13 @@ static int pg_st_deallocate_statement (pTHX_ SV * sth, imp_sth_t * imp_sth)
 
 	/* What is our status? */
 	tstatus = pg_db_txn_status(aTHX_ imp_dbh);
-	if (TRACE5)
-		TRC(DBILOGFP, "%stxn_status is %d\n", THEADER, tstatus);
+	if (TRACE5_slow)
+		TRC(DBILOGFP, "%stxn_status is %d\n", THEADER_slow, tstatus);
 
 	/* If we are in a failed transaction, rollback before deallocating */
 	if (PQTRANS_INERROR == tstatus) {
-		if (TRACE4)
-			TRC(DBILOGFP, "%sIssuing rollback before deallocate\n", THEADER);
+		if (TRACE4_slow)
+			TRC(DBILOGFP, "%sIssuing rollback before deallocate\n", THEADER_slow);
 		{
 			/* If a savepoint has been set, rollback to the last savepoint instead of the entire transaction */
 			I32	alen = av_len(imp_dbh->savepoints);
@@ -3629,8 +3629,8 @@ static int pg_st_deallocate_statement (pTHX_ SV * sth, imp_sth_t * imp_sth)
 				char	*cmd;
 				SV * const sp = *av_fetch(imp_dbh->savepoints, alen, 0);
 				New(0, cmd, SvLEN(sp) + 13, char); /* Freed below */
-				if (TRACE4)
-					TRC(DBILOGFP, "%sRolling back to savepoint %s\n", THEADER, SvPV_nolen(sp));
+				if (TRACE4_slow)
+					TRC(DBILOGFP, "%sRolling back to savepoint %s\n", THEADER_slow, SvPV_nolen(sp));
 				sprintf(cmd, "rollback to %s", SvPV_nolen(sp));
 				strncpy(tempsqlstate, imp_dbh->sqlstate, strlen(imp_dbh->sqlstate)+1);
 				status = _result(aTHX_ imp_dbh, cmd);
@@ -3643,8 +3643,8 @@ static int pg_st_deallocate_statement (pTHX_ SV * sth, imp_sth_t * imp_sth)
 		}
 		if (PGRES_COMMAND_OK != status) {
 			/* This is not fatal, it just means we cannot deallocate */
-			if (TRACEWARN) TRC(DBILOGFP, "%sRollback failed, so no deallocate\n", THEADER);
-			if (TEND) TRC(DBILOGFP, "%sEnd pg_st_deallocate_statement (cannot deallocate)\n", THEADER);
+			if (TRACEWARN_slow) TRC(DBILOGFP, "%sRollback failed, so no deallocate\n", THEADER_slow);
+			if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_st_deallocate_statement (cannot deallocate)\n", THEADER_slow);
 			return 1;
 		}
 	}
@@ -3653,15 +3653,15 @@ static int pg_st_deallocate_statement (pTHX_ SV * sth, imp_sth_t * imp_sth)
 
 	sprintf(stmt, "DEALLOCATE %s", imp_sth->prepare_name);
 
-	if (TRACE5)
-		TRC(DBILOGFP, "%sDeallocating (%s)\n", THEADER, imp_sth->prepare_name);
+	if (TRACE5_slow)
+		TRC(DBILOGFP, "%sDeallocating (%s)\n", THEADER_slow, imp_sth->prepare_name);
 
 	status = _result(aTHX_ imp_dbh, stmt);
 	Safefree(stmt);
 	if (PGRES_COMMAND_OK != status) {
 		TRACE_PQERRORMESSAGE;
 		pg_error(aTHX_ sth, status, PQerrorMessage(imp_dbh->conn));
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_st_deallocate_statement (error: status not OK)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_st_deallocate_statement (error: status not OK)\n", THEADER_slow);
 		return 2;
 	}
 
@@ -3671,7 +3671,7 @@ static int pg_st_deallocate_statement (pTHX_ SV * sth, imp_sth_t * imp_sth)
 		strncpy(imp_dbh->sqlstate, tempsqlstate, strlen(tempsqlstate)+1);
 	}
 
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_st_deallocate_statement\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_st_deallocate_statement\n", THEADER_slow);
 	return 0;
 
 } /* end of pg_st_deallocate_statement */
@@ -3687,18 +3687,18 @@ void dbd_st_destroy (SV * sth, imp_sth_t * imp_sth)
 	ph_t *  currph;
 	ph_t *  nextph;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin dbd_st_destroy\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin dbd_st_destroy\n", THEADER_slow);
 
 	if (NULL == imp_sth->seg) /* Already been destroyed! */
 		croak("dbd_st_destroy called twice!");
 
 	/* If the InactiveDestroy flag has been set, we go no further */
 	if (DBIc_IADESTROY(imp_dbh)) {
-		if (TRACE4) {
-			TRC(DBILOGFP, "%sskipping sth destroy due to InactiveDestroy\n", THEADER);
+		if (TRACE4_slow) {
+			TRC(DBILOGFP, "%sskipping sth destroy due to InactiveDestroy\n", THEADER_slow);
 		}
 		DBIc_IMPSET_off(imp_sth); /* let DBI know we've done it */
-		if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_destroy (InactiveDestroy set)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_destroy (InactiveDestroy set)\n", THEADER_slow);
 		return;
 	}
 
@@ -3710,8 +3710,8 @@ void dbd_st_destroy (SV * sth, imp_sth_t * imp_sth)
 	/* On rare occasions, dbd_db_destroy is called first and we can no longer rely on imp_dbh */
 	if (imp_sth->prepared_by_us && DBIc_ACTIVE(imp_dbh)) {
 		if (pg_st_deallocate_statement(aTHX_ sth, imp_sth)!=0) {
-			if (TRACEWARN)
-				TRC(DBILOGFP, "%sCould not deallocate\n", THEADER);
+			if (TRACEWARN_slow)
+				TRC(DBILOGFP, "%sCould not deallocate\n", THEADER_slow);
 		}
 	}
 
@@ -3758,7 +3758,7 @@ void dbd_st_destroy (SV * sth, imp_sth_t * imp_sth)
 
 	DBIc_IMPSET_off(imp_sth); /* let DBI know we've done it */
 
-	if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_destroy\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_destroy\n", THEADER_slow);
 
 } /* end of dbd_st_destroy */
 
@@ -3770,7 +3770,7 @@ int pg_db_putline (SV * dbh, const char * buffer)
 	D_imp_dbh(dbh);
 	int copystatus;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_putline\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_putline\n", THEADER_slow);
 
 	/* We must be in COPY IN state */
 	if (PGRES_COPY_IN != imp_dbh->copystate)
@@ -3781,14 +3781,14 @@ int pg_db_putline (SV * dbh, const char * buffer)
 	if (-1 == copystatus) {
 		TRACE_PQERRORMESSAGE;
 		pg_error(aTHX_ dbh, PGRES_FATAL_ERROR, PQerrorMessage(imp_dbh->conn));
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_putline (error: copystatus not -1)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_putline (error: copystatus not -1)\n", THEADER_slow);
 		return 0;
 	}
 	else if (1 != copystatus) {
 		croak("PQputCopyData gave a value of %d\n", copystatus);
 	}
 
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_db_putline\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_putline\n", THEADER_slow);
 	return 0;
 
 } /* end of pg_db_putline */
@@ -3805,7 +3805,7 @@ int pg_db_getline (SV * dbh, SV * svbuf, int length)
 
 	buffer = SvPV_nolen(svbuf);
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_getline\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_getline\n", THEADER_slow);
 
 	tempbuf = NULL;
 
@@ -3822,7 +3822,7 @@ int pg_db_getline (SV * dbh, SV * svbuf, int length)
 		imp_dbh->copystate=0;
 		TRACE_PQENDCOPY;
 		PQendcopy(imp_dbh->conn); /* Can't hurt */
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_getline (-1)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_getline (-1)\n", THEADER_slow);
 		return -1;
 	}
 	else if (copystatus < 1) {
@@ -3834,7 +3834,7 @@ int pg_db_getline (SV * dbh, SV * svbuf, int length)
 		TRACE_PQFREEMEM;
 		PQfreemem(tempbuf);
 	}
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_db_getline (0)\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_getline (0)\n", THEADER_slow);
 	return 0;
 
 } /* end of pg_db_getline */
@@ -3848,7 +3848,7 @@ int pg_db_getcopydata (SV * dbh, SV * dataline, int async)
 	int    copystatus;
 	char * tempbuf;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_getcopydata\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_getcopydata\n", THEADER_slow);
 
 	/* We must be in COPY OUT state */
 	if (PGRES_COPY_OUT != imp_dbh->copystate)
@@ -3873,7 +3873,7 @@ int pg_db_getcopydata (SV * dbh, SV * dataline, int async)
 		if (!PQconsumeInput(imp_dbh->conn)) {
 			TRACE_PQERRORMESSAGE;
 			pg_error(aTHX_ dbh, PGRES_FATAL_ERROR, PQerrorMessage(imp_dbh->conn));
-			if (TEND) TRC(DBILOGFP, "%sEnd pg_db_getcopydata (error: async in progress)\n", THEADER);
+			if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_getcopydata (error: async in progress)\n", THEADER_slow);
 			return -2;
 		}
 	}
@@ -3900,7 +3900,7 @@ int pg_db_getcopydata (SV * dbh, SV * dataline, int async)
 		pg_error(aTHX_ dbh, PGRES_FATAL_ERROR, PQerrorMessage(imp_dbh->conn));
 	}
 
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_db_getcopydata\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_getcopydata\n", THEADER_slow);
 	return copystatus;
 
 } /* end of pg_db_getcopydata */
@@ -3913,7 +3913,7 @@ int pg_db_putcopydata (SV * dbh, SV * dataline)
 	D_imp_dbh(dbh);
 	int copystatus;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_putcopydata\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_putcopydata\n", THEADER_slow);
 
 	/* We must be in COPY IN state */
 	if (PGRES_COPY_IN != imp_dbh->copystate)
@@ -3936,7 +3936,7 @@ int pg_db_putcopydata (SV * dbh, SV * dataline)
 		pg_error(aTHX_ dbh, PGRES_FATAL_ERROR, PQerrorMessage(imp_dbh->conn));
 	}
 
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_db_putcopydata\n", THEADER);	
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_putcopydata\n", THEADER_slow);	
 	return copystatus == 1 ? 1 : 0;
 
 } /* end of pg_db_putcopydata */
@@ -3953,17 +3953,17 @@ int pg_db_putcopyend (SV * dbh)
 	D_imp_dbh(dbh);
 	int copystatus;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_putcopyend\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_putcopyend\n", THEADER_slow);
 
 	if (0 == imp_dbh->copystate) {
 		warn("pg_putcopyend cannot be called until a COPY is issued");
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_putcopyend (warning: copystate is 0)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_putcopyend (warning: copystate is 0)\n", THEADER_slow);
 		return 0;
 	}
 
 	if (PGRES_COPY_OUT == imp_dbh->copystate) {
 		warn("PQputcopyend does not need to be called when using PGgetcopydata");
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_putcopyend (warning: copy state is OUT)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_putcopyend (warning: copy state is OUT)\n", THEADER_slow);
 		return 0;
 	}
 
@@ -3987,20 +3987,20 @@ int pg_db_putcopyend (SV * dbh)
 		if (PGRES_COMMAND_OK != status) {
 			TRACE_PQERRORMESSAGE;
 			pg_error(aTHX_ dbh, status, PQerrorMessage(imp_dbh->conn));
-			if (TEND) TRC(DBILOGFP, "%sEnd pg_db_putcopyend (error: status not OK)\n", THEADER);
+			if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_putcopyend (error: status not OK)\n", THEADER_slow);
 			return 0;
 		}
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_putcopyend (1)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_putcopyend (1)\n", THEADER_slow);
 		return 1;
 	}
 	else if (0 == copystatus) { /* non-blocking mode only */
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_putcopyend (0)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_putcopyend (0)\n", THEADER_slow);
 		return 0;
 	}
 	else {
 		TRACE_PQERRORMESSAGE;
 		pg_error(aTHX_ dbh, PGRES_FATAL_ERROR, PQerrorMessage(imp_dbh->conn));
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_putcopyend (error: copystatus unknown)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_putcopyend (error: copystatus unknown)\n", THEADER_slow);
 		return 0;
 	}
 
@@ -4016,7 +4016,7 @@ int pg_db_endcopy (SV * dbh)
 	PGresult *     result;
 	ExecStatusType status;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_endcopy\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_endcopy\n", THEADER_slow);
 
 	if (0==imp_dbh->copystate)
 		croak("pg_endcopy cannot be called until a COPY is issued");
@@ -4027,7 +4027,7 @@ int pg_db_endcopy (SV * dbh)
 		if (-1 == copystatus) {
 			TRACE_PQERRORMESSAGE;
 			pg_error(aTHX_ dbh, PGRES_FATAL_ERROR, PQerrorMessage(imp_dbh->conn));
-			if (TEND) TRC(DBILOGFP, "%sEnd pg_db_endcopy (error)\n", THEADER);
+			if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_endcopy (error)\n", THEADER_slow);
 			return 1;
 		}
 		else if (1 != copystatus)
@@ -4041,7 +4041,7 @@ int pg_db_endcopy (SV * dbh)
 		if (PGRES_COMMAND_OK != status) {
 			TRACE_PQERRORMESSAGE;
 			pg_error(aTHX_ dbh, status, PQerrorMessage(imp_dbh->conn));
-			if (TEND) TRC(DBILOGFP, "%sEnd pg_db_endcopy (error: status not OK)\n", THEADER);
+			if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_endcopy (error: status not OK)\n", THEADER_slow);
 			return 1;
 		}
 		copystatus = 0;
@@ -4052,7 +4052,7 @@ int pg_db_endcopy (SV * dbh)
 	}
 
 	imp_dbh->copystate = 0;
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_db_endcopy\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_endcopy\n", THEADER_slow);
 	return copystatus;
 
 } /* end of pg_db_endcopy */
@@ -4064,12 +4064,12 @@ void pg_db_pg_server_trace (SV * dbh, FILE * fh)
 	dTHX;
 	D_imp_dbh(dbh);
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_pg_server_trace\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_pg_server_trace\n", THEADER_slow);
 
 	TRACE_PQTRACE;
 	PQtrace(imp_dbh->conn, fh);
 
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_db_pg_server_trace\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_pg_server_trace\n", THEADER_slow);
 
 } /* end of pg_db_pg_server_trace */
 
@@ -4080,12 +4080,12 @@ void pg_db_pg_server_untrace (SV * dbh)
 	dTHX;
 	D_imp_dbh(dbh);
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_pg_server_untrace\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_pg_server_untrace\n", THEADER_slow);
 
 	TRACE_PQUNTRACE;
 	PQuntrace(imp_dbh->conn);
 
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_db_pg_server_untrace\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_pg_server_untrace\n", THEADER_slow);
 
 } /* end of pg_db_pg_server_untrace */
 
@@ -4097,14 +4097,14 @@ int pg_db_savepoint (SV * dbh, imp_dbh_t * imp_dbh, char * savepoint)
 	int    status;
 	char * action;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_savepoint (name: %s)\n", THEADER, savepoint);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_savepoint (name: %s)\n", THEADER_slow, savepoint);
 
 	if (imp_dbh->pg_server_version < 80000)
 		croak("Savepoints are only supported on server version 8.0 or higher");
 
 	/* no action if AutoCommit = on or the connection is invalid */
 	if ((NULL == imp_dbh->conn) || (DBIc_has(imp_dbh, DBIcf_AutoCommit))) {
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_savepoint (0)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_savepoint (0)\n", THEADER_slow);
 		return 0;
 	}
 
@@ -4114,7 +4114,7 @@ int pg_db_savepoint (SV * dbh, imp_dbh_t * imp_dbh, char * savepoint)
 		if (PGRES_COMMAND_OK != status) {
 			TRACE_PQERRORMESSAGE;
 			pg_error(aTHX_ dbh, status, PQerrorMessage(imp_dbh->conn));
-			if (TEND) TRC(DBILOGFP, "%sEnd pg_db_savepoint (error: status not OK for begin)\n", THEADER);
+			if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_savepoint (error: status not OK for begin)\n", THEADER_slow);
 			return -2;
 		}
 		imp_dbh->done_begin = DBDPG_TRUE;
@@ -4128,12 +4128,12 @@ int pg_db_savepoint (SV * dbh, imp_dbh_t * imp_dbh, char * savepoint)
 	if (PGRES_COMMAND_OK != status) {
 		TRACE_PQERRORMESSAGE;
 		pg_error(aTHX_ dbh, status, PQerrorMessage(imp_dbh->conn));
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_savepoint (error: status not OK for savepoint)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_savepoint (error: status not OK for savepoint)\n", THEADER_slow);
 		return 0;
 	}
 
 	av_push(imp_dbh->savepoints, newSVpv(savepoint,0));
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_db_savepoint\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_savepoint\n", THEADER_slow);
 	return 1;
 
 } /* end of pg_db_savepoint */
@@ -4146,14 +4146,14 @@ int pg_db_rollback_to (SV * dbh, imp_dbh_t * imp_dbh, const char *savepoint)
 	int    status;
 	char * action;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_rollback_to (name: %s)\n", THEADER, savepoint);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_rollback_to (name: %s)\n", THEADER_slow, savepoint);
 
 	if (imp_dbh->pg_server_version < 80000)
 		croak("Savepoints are only supported on server version 8.0 or higher");
 
 	/* no action if AutoCommit = on or the connection is invalid */
 	if ((NULL == imp_dbh->conn) || (DBIc_has(imp_dbh, DBIcf_AutoCommit))) {
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_rollback_to (0)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_rollback_to (0)\n", THEADER_slow);
 		return 0;
 	}
 
@@ -4165,12 +4165,12 @@ int pg_db_rollback_to (SV * dbh, imp_dbh_t * imp_dbh, const char *savepoint)
 	if (PGRES_COMMAND_OK != status) {
 		TRACE_PQERRORMESSAGE;
 		pg_error(aTHX_ dbh, status, PQerrorMessage(imp_dbh->conn));
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_rollback_to (error: status not OK for rollback)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_rollback_to (error: status not OK for rollback)\n", THEADER_slow);
 		return 0;
 	}
 
 	pg_db_free_savepoints_to(aTHX_ imp_dbh, savepoint);
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_db_rollback_to\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_rollback_to\n", THEADER_slow);
 	return 1;
 
 } /* end of pg_db_rollback_to */
@@ -4183,14 +4183,14 @@ int pg_db_release (SV * dbh, imp_dbh_t * imp_dbh, char * savepoint)
 	int    status;
 	char * action;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_release (name: %s)\n", THEADER, savepoint);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_release (name: %s)\n", THEADER_slow, savepoint);
 
 	if (imp_dbh->pg_server_version < 80000)
 		croak("Savepoints are only supported on server version 8.0 or higher");
 
 	/* no action if AutoCommit = on or the connection is invalid */
 	if ((NULL == imp_dbh->conn) || (DBIc_has(imp_dbh, DBIcf_AutoCommit))) {
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_release (0)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_release (0)\n", THEADER_slow);
 		return 0;
 	}
 
@@ -4202,12 +4202,12 @@ int pg_db_release (SV * dbh, imp_dbh_t * imp_dbh, char * savepoint)
 	if (PGRES_COMMAND_OK != status) {
 		TRACE_PQERRORMESSAGE;
 		pg_error(aTHX_ dbh, status, PQerrorMessage(imp_dbh->conn));
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_release (error: status not OK for release)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_release (error: status not OK for release)\n", THEADER_slow);
 		return 0;
 	}
 
 	pg_db_free_savepoints_to(aTHX_ imp_dbh, savepoint);
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_db_release\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_release\n", THEADER_slow);
 	return 1;
 
 } /* end of pg_db_release */
@@ -4221,7 +4221,7 @@ static int pg_db_start_txn (pTHX_ SV * dbh, imp_dbh_t * imp_dbh)
 {
 	int status = -1;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_start_txn\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_start_txn\n", THEADER_slow);
 
 	/* If not autocommit, start a new transaction */
 	if (!imp_dbh->done_begin) {
@@ -4229,12 +4229,12 @@ static int pg_db_start_txn (pTHX_ SV * dbh, imp_dbh_t * imp_dbh)
 		if (PGRES_COMMAND_OK != status) {
 			TRACE_PQERRORMESSAGE;
 			pg_error(aTHX_ dbh, status, PQerrorMessage(imp_dbh->conn));
-			if (TEND) TRC(DBILOGFP, "%sEnd pg_db_start_txn (error: status not OK for begin)\n", THEADER);
+			if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_start_txn (error: status not OK for begin)\n", THEADER_slow);
 			return 0;
 		}
 		imp_dbh->done_begin = DBDPG_TRUE;
 	}
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_db_start_txn\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_start_txn\n", THEADER_slow);
 
 	return 1;
 
@@ -4250,20 +4250,20 @@ static int pg_db_end_txn (pTHX_ SV * dbh, imp_dbh_t * imp_dbh, int commit)
 {
 	int status = -1;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_end_txn with %s\n",
-					THEADER, commit ? "commit" : "rollback");
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_end_txn with %s\n",
+					THEADER_slow, commit ? "commit" : "rollback");
 
 	status = _result(aTHX_ imp_dbh, commit ? "commit" : "rollback");
 	imp_dbh->done_begin = DBDPG_FALSE;
 	if (PGRES_COMMAND_OK != status) {
 		TRACE_PQERRORMESSAGE;
 		pg_error(aTHX_ dbh, status, PQerrorMessage(imp_dbh->conn));
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_end_txn (error: status not OK for %s)\n",
-					  THEADER, commit ? "commit" : "rollback");
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_end_txn (error: status not OK for %s)\n",
+					  THEADER_slow, commit ? "commit" : "rollback");
 		return 0;
 	}
 
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_db_end_txn\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_end_txn\n", THEADER_slow);
 
 	return 1;
 
@@ -4278,7 +4278,7 @@ unsigned int pg_db_lo_creat (SV * dbh, int mode)
 	dTHX;
 	D_imp_dbh(dbh);
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_pg_lo_creat (mode: %d)\n", THEADER, mode);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_pg_lo_creat (mode: %d)\n", THEADER_slow, mode);
 
 	if (DBIc_has(imp_dbh, DBIcf_AutoCommit)) {
 		croak("Cannot call pg_lo_creat when AutoCommit is on");
@@ -4288,8 +4288,8 @@ unsigned int pg_db_lo_creat (SV * dbh, int mode)
 		return 0; /* No other option, because lo_creat returns an Oid */
 	}
 
-	if (TLIBPQ) {
-		TRC(DBILOGFP, "%slo_creat\n", THEADER);
+	if (TLIBPQ_slow) {
+		TRC(DBILOGFP, "%slo_creat\n", THEADER_slow);
 	}
 
 	return lo_creat(imp_dbh->conn, mode); /* 0 on error */
@@ -4303,8 +4303,8 @@ int pg_db_lo_open (SV * dbh, unsigned int lobjId, int mode)
 	dTHX;
 	D_imp_dbh(dbh);
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_pg_lo_open (mode: %d objectid: %d)\n",
-					THEADER, mode, lobjId);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_pg_lo_open (mode: %d objectid: %d)\n",
+					THEADER_slow, mode, lobjId);
 
 	if (DBIc_has(imp_dbh, DBIcf_AutoCommit)) {
 		croak("Cannot call pg_lo_open when AutoCommit is on");
@@ -4313,8 +4313,8 @@ int pg_db_lo_open (SV * dbh, unsigned int lobjId, int mode)
 	if (!pg_db_start_txn(aTHX_ dbh,imp_dbh))
 		return -2;
 
-	if (TLIBPQ) {
-		TRC(DBILOGFP, "%slo_open\n", THEADER);
+	if (TLIBPQ_slow) {
+		TRC(DBILOGFP, "%slo_open\n", THEADER_slow);
 	}
 
 	return lo_open(imp_dbh->conn, lobjId, mode); /* -1 on error */
@@ -4328,7 +4328,7 @@ int pg_db_lo_close (SV * dbh, int fd)
 	dTHX;
 	D_imp_dbh(dbh);
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_lo_close (fd: %d)\n", THEADER, fd);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_lo_close (fd: %d)\n", THEADER_slow, fd);
 
 	if (DBIc_has(imp_dbh, DBIcf_AutoCommit)) {
 		croak("Cannot call pg_lo_close when AutoCommit is on");
@@ -4337,8 +4337,8 @@ int pg_db_lo_close (SV * dbh, int fd)
 	if (!pg_db_start_txn(aTHX_ dbh,imp_dbh))
 		return -1;
 
-	if (TLIBPQ) {
-		TRC(DBILOGFP, "%slo_close\n", THEADER);
+	if (TLIBPQ_slow) {
+		TRC(DBILOGFP, "%slo_close\n", THEADER_slow);
 	}
 
 	return lo_close(imp_dbh->conn, fd); /* <0 on error, 0 if ok */
@@ -4352,8 +4352,8 @@ int pg_db_lo_read (SV * dbh, int fd, char * buf, size_t len)
 	dTHX;
 	D_imp_dbh(dbh);
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_lo_read (fd: %d length: %d)\n",
-					THEADER, fd, (int)len);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_lo_read (fd: %d length: %d)\n",
+					THEADER_slow, fd, (int)len);
 
 	if (DBIc_has(imp_dbh, DBIcf_AutoCommit)) {
 		croak("Cannot call pg_lo_read when AutoCommit is on");
@@ -4362,8 +4362,8 @@ int pg_db_lo_read (SV * dbh, int fd, char * buf, size_t len)
 	if (!pg_db_start_txn(aTHX_ dbh,imp_dbh))
 		return -1;
 
-	if (TLIBPQ) {
-		TRC(DBILOGFP, "%slo_read\n", THEADER);
+	if (TLIBPQ_slow) {
+		TRC(DBILOGFP, "%slo_read\n", THEADER_slow);
 	}
 
 	return lo_read(imp_dbh->conn, fd, buf, len); /* bytes read, <0 on error */
@@ -4377,8 +4377,8 @@ int pg_db_lo_write (SV * dbh, int fd, char * buf, size_t len)
 	dTHX;
 	D_imp_dbh(dbh);
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_lo_write (fd: %d length: %d)\n",
-					THEADER, fd, (int)len);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_lo_write (fd: %d length: %d)\n",
+					THEADER_slow, fd, (int)len);
 
 	if (DBIc_has(imp_dbh, DBIcf_AutoCommit)) {
 		croak("Cannot call pg_lo_write when AutoCommit is on");
@@ -4387,8 +4387,8 @@ int pg_db_lo_write (SV * dbh, int fd, char * buf, size_t len)
 	if (!pg_db_start_txn(aTHX_ dbh,imp_dbh))
 		return -1;
 
-	if (TLIBPQ) {
-		TRC(DBILOGFP, "%slo_write\n", THEADER);
+	if (TLIBPQ_slow) {
+		TRC(DBILOGFP, "%slo_write\n", THEADER_slow);
 	}
 
 	return lo_write(imp_dbh->conn, fd, buf, len); /* bytes written, <0 on error */
@@ -4402,8 +4402,8 @@ int pg_db_lo_lseek (SV * dbh, int fd, int offset, int whence)
 	dTHX;
 	D_imp_dbh(dbh);
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_lo_lseek (fd: %d offset: %d whence: %d)\n",
-					THEADER, fd, offset, whence);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_lo_lseek (fd: %d offset: %d whence: %d)\n",
+					THEADER_slow, fd, offset, whence);
 
 	if (DBIc_has(imp_dbh, DBIcf_AutoCommit)) {
 		croak("Cannot call pg_lo_lseek when AutoCommit is on");
@@ -4412,8 +4412,8 @@ int pg_db_lo_lseek (SV * dbh, int fd, int offset, int whence)
 	if (!pg_db_start_txn(aTHX_ dbh,imp_dbh))
 		return -1;
 
-	if (TLIBPQ) {
-		TRC(DBILOGFP, "%slo_lseek\n", THEADER);
+	if (TLIBPQ_slow) {
+		TRC(DBILOGFP, "%slo_lseek\n", THEADER_slow);
 	}
 
 	return lo_lseek(imp_dbh->conn, fd, offset, whence); /* new position, -1 on error */
@@ -4427,7 +4427,7 @@ int pg_db_lo_tell (SV * dbh, int fd)
 	dTHX;
 	D_imp_dbh(dbh);
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_lo_tell (fd: %d)\n", THEADER, fd);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_lo_tell (fd: %d)\n", THEADER_slow, fd);
 
 	if (DBIc_has(imp_dbh, DBIcf_AutoCommit)) {
 		croak("Cannot call pg_lo_tell when AutoCommit is on");
@@ -4436,8 +4436,8 @@ int pg_db_lo_tell (SV * dbh, int fd)
 	if (!pg_db_start_txn(aTHX_ dbh,imp_dbh))
 		return -1;
 
-	if (TLIBPQ) {
-		TRC(DBILOGFP, "%slo_tell\n", THEADER);
+	if (TLIBPQ_slow) {
+		TRC(DBILOGFP, "%slo_tell\n", THEADER_slow);
 	}
 
 	return lo_tell(imp_dbh->conn, fd); /* current position, <0 on error */
@@ -4451,7 +4451,7 @@ int pg_db_lo_unlink (SV * dbh, unsigned int lobjId)
 	dTHX;
 	D_imp_dbh(dbh);
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_lo_unlink (objectid: %d)\n", THEADER, lobjId);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_lo_unlink (objectid: %d)\n", THEADER_slow, lobjId);
 
 	if (DBIc_has(imp_dbh, DBIcf_AutoCommit)) {
 		croak("Cannot call pg_lo_unlink when AutoCommit is on");
@@ -4460,8 +4460,8 @@ int pg_db_lo_unlink (SV * dbh, unsigned int lobjId)
 	if (!pg_db_start_txn(aTHX_ dbh,imp_dbh))
 		return -1;
 
-	if (TLIBPQ) {
-		TRC(DBILOGFP, "%slo_unlink\n", THEADER);
+	if (TLIBPQ_slow) {
+		TRC(DBILOGFP, "%slo_unlink\n", THEADER_slow);
 	}
 
 	return lo_unlink(imp_dbh->conn, lobjId); /* 1 on success, -1 on failure */
@@ -4476,13 +4476,13 @@ unsigned int pg_db_lo_import (SV * dbh, char * filename)
 	dTHX;
 	D_imp_dbh(dbh);
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_lo_import (filename: %s)\n", THEADER, filename);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_lo_import (filename: %s)\n", THEADER_slow, filename);
 
 	if (!pg_db_start_txn(aTHX_ dbh,imp_dbh))
 		return 0; /* No other option, because lo_import returns an Oid */
 
-	if (TLIBPQ) {
-		TRC(DBILOGFP, "%slo_import\n", THEADER);
+	if (TLIBPQ_slow) {
+		TRC(DBILOGFP, "%slo_import\n", THEADER_slow);
 	}
 	loid = lo_import(imp_dbh->conn, filename); /* 0 on error */
 
@@ -4503,14 +4503,14 @@ unsigned int pg_db_lo_import_with_oid (SV * dbh, char * filename, unsigned int l
 	dTHX;
 	D_imp_dbh(dbh);
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_lo_import_with_oid (filename: %s, oid: %d)\n",
-					THEADER, filename, lobjId);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_lo_import_with_oid (filename: %s, oid: %d)\n",
+					THEADER_slow, filename, lobjId);
 
 	if (!pg_db_start_txn(aTHX_ dbh,imp_dbh))
 		return 0; /* No other option, because lo_import* returns an Oid */
 
-	if (TLIBPQ) {
-		TRC(DBILOGFP, "%slo_import_with_oid\n", THEADER);
+	if (TLIBPQ_slow) {
+		TRC(DBILOGFP, "%slo_import_with_oid\n", THEADER_slow);
 	}
 	loid = lo_import_with_oid(imp_dbh->conn, filename, lobjId); /* 0 on error */
 
@@ -4531,14 +4531,14 @@ int pg_db_lo_export (SV * dbh, unsigned int lobjId, char * filename)
 	dTHX;
 	D_imp_dbh(dbh);
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_lo_export (objectid: %d filename: %s)\n",
-					THEADER, lobjId, filename);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_lo_export (objectid: %d filename: %s)\n",
+					THEADER_slow, lobjId, filename);
 
 	if (!pg_db_start_txn(aTHX_ dbh,imp_dbh))
 		return -2;
 
-	if (TLIBPQ) {
-		TRC(DBILOGFP, "%slo_export\n", THEADER);
+	if (TLIBPQ_slow) {
+		TRC(DBILOGFP, "%slo_export\n", THEADER_slow);
 	}
 	loid = lo_export(imp_dbh->conn, lobjId, filename); /* 1 on success, -1 on failure */
 	if (DBIc_has(imp_dbh, DBIcf_AutoCommit)) {
@@ -4561,8 +4561,8 @@ int dbd_st_blob_read (SV * sth, imp_sth_t * imp_sth, int lobjId, long offset, lo
 	SV *   bufsv;
 	char * tmp;
 	
-	if (TSTART) TRC(DBILOGFP, "%sBegin dbd_st_blob_read (objectid: %d offset: %ld length: %ld)\n",
-					THEADER, lobjId, offset, len);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin dbd_st_blob_read (objectid: %d offset: %ld length: %ld)\n",
+					THEADER_slow, lobjId, offset, len);
 
 	/* safety checks */
 	if (lobjId <= 0) {
@@ -4597,7 +4597,7 @@ int dbd_st_blob_read (SV * sth, imp_sth_t * imp_sth, int lobjId, long offset, lo
 	if (lobj_fd < 0) {
 		TRACE_PQERRORMESSAGE;
 		pg_error(aTHX_ sth, PGRES_FATAL_ERROR, PQerrorMessage(imp_dbh->conn));
-		if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_blob_read (error: open failed)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_blob_read (error: open failed)\n", THEADER_slow);
 		return 0;
 	}
 	
@@ -4607,7 +4607,7 @@ int dbd_st_blob_read (SV * sth, imp_sth_t * imp_sth, int lobjId, long offset, lo
 		if (ret < 0) {
 			TRACE_PQERRORMESSAGE;
 			pg_error(aTHX_ sth, PGRES_FATAL_ERROR, PQerrorMessage(imp_dbh->conn));
-			if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_blob_read (error: bad seek)\n", THEADER);
+			if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_blob_read (error: bad seek)\n", THEADER_slow);
 			return 0;
 		}
 	}
@@ -4636,11 +4636,11 @@ int dbd_st_blob_read (SV * sth, imp_sth_t * imp_sth, int lobjId, long offset, lo
 	if (ret < 0) {
 		TRACE_PQERRORMESSAGE;
 		pg_error(aTHX_ sth, PGRES_FATAL_ERROR, PQerrorMessage(imp_dbh->conn));
-		if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_blob_read (error: close failed)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_blob_read (error: close failed)\n", THEADER_slow);
 		return 0;
 	}
 	
-	if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_blob_read (bytes: %d)\n", THEADER, (int)nread);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_blob_read (bytes: %d)\n", THEADER_slow, (int)nread);
 	return (int)nread;
 
 } /* end of dbd_st_blob_read */
@@ -4658,11 +4658,11 @@ int pg_db_result (SV *h, imp_dbh_t *imp_dbh)
 	int rows = 0;
 	char *cmdStatus = NULL;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_result\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_result\n", THEADER_slow);
 
 	if (1 != imp_dbh->async_status) {
 		pg_error(aTHX_ h, PGRES_FATAL_ERROR, "No asynchronous query is running\n");
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_result (error: no async)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_result (error: no async)\n", THEADER_slow);
 		return -2;
 	}	
 
@@ -4743,7 +4743,7 @@ int pg_db_result (SV *h, imp_dbh_t *imp_dbh)
 		imp_dbh->async_sth->async_status = 0;
 	}
 	imp_dbh->async_status = 0;
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_db_result (rows: %d)\n", THEADER, rows);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_result (rows: %d)\n", THEADER_slow, rows);
 	return rows;
 
 } /* end of pg_db_result */
@@ -4763,12 +4763,12 @@ int pg_db_ready(SV *h, imp_dbh_t *imp_dbh)
 {
 	dTHX;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_ready (async status: %d)\n",
-					THEADER, imp_dbh->async_status);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_ready (async status: %d)\n",
+					THEADER_slow, imp_dbh->async_status);
 
 	if (0 == imp_dbh->async_status) {
 		pg_error(aTHX_ h, PGRES_FATAL_ERROR, "No asynchronous query is running\n");
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_ready (error: no async)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_ready (error: no async)\n", THEADER_slow);
 		return -1;
 	}	
 
@@ -4776,11 +4776,11 @@ int pg_db_ready(SV *h, imp_dbh_t *imp_dbh)
 	if (!PQconsumeInput(imp_dbh->conn)) {
 		TRACE_PQERRORMESSAGE;
 		pg_error(aTHX_ h, PGRES_FATAL_ERROR, PQerrorMessage(imp_dbh->conn));
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_ready (error: consume failed)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_ready (error: consume failed)\n", THEADER_slow);
 		return -2;
 	}
 
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_db_ready\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_ready\n", THEADER_slow);
 	TRACE_PQISBUSY;
 	return PQisBusy(imp_dbh->conn) ? 0 : 1;
 
@@ -4802,18 +4802,18 @@ int pg_db_cancel(SV *h, imp_dbh_t *imp_dbh)
 	PGresult *result;
 	ExecStatusType status;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_cancel (async status: %d)\n",
-					THEADER, imp_dbh->async_status);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_cancel (async status: %d)\n",
+					THEADER_slow, imp_dbh->async_status);
 
 	if (0 == imp_dbh->async_status) {
 		pg_error(aTHX_ h, PGRES_FATAL_ERROR, "No asynchronous query is running");
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_cancel (error: no async)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_cancel (error: no async)\n", THEADER_slow);
 		return DBDPG_FALSE;
 	}
 
 	if (-1 == imp_dbh->async_status) {
 		pg_error(aTHX_ h, PGRES_FATAL_ERROR, "Asychronous query has already been cancelled");
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_cancel (error: async cancelled)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_cancel (error: async cancelled)\n", THEADER_slow);
 		return DBDPG_FALSE;
 	}
 
@@ -4826,9 +4826,9 @@ int pg_db_cancel(SV *h, imp_dbh_t *imp_dbh)
 	if (! PQcancel(cancel,errbuf,sizeof(errbuf))) {
 		TRACE_PQFREECANCEL;
 		PQfreeCancel(cancel);
-		if (TRACEWARN) { TRC(DBILOGFP, "%sPQcancel failed: %s\n", THEADER, errbuf); }
+		if (TRACEWARN_slow) { TRC(DBILOGFP, "%sPQcancel failed: %s\n", THEADER_slow, errbuf); }
 		pg_error(aTHX_ h, PGRES_FATAL_ERROR, "PQcancel failed");
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_cancel (error: cancel failed)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_cancel (error: cancel failed)\n", THEADER_slow);
 		return DBDPG_FALSE;
 	}
 	TRACE_PQFREECANCEL;
@@ -4844,7 +4844,7 @@ int pg_db_cancel(SV *h, imp_dbh_t *imp_dbh)
 	result = PQgetResult(imp_dbh->conn);
 	if (!result) {
 		pg_error(aTHX_ h, PGRES_FATAL_ERROR, "Failed to get a result after PQcancel");
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_cancel (error: no result)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_cancel (error: no result)\n", THEADER_slow);
 		return DBDPG_FALSE;
 	}
 
@@ -4855,19 +4855,19 @@ int pg_db_cancel(SV *h, imp_dbh_t *imp_dbh)
 
 	/* If we actually cancelled a running query, just return true - the caller must rollback if needed */
 	if (0 == strncmp(imp_dbh->sqlstate, "57014", 5)) {
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_cancel\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_cancel\n", THEADER_slow);
 		return DBDPG_TRUE;
 	}
 
 	/* If we got any other error, make sure we report it */
 	if (0 != strncmp(imp_dbh->sqlstate, "00000", 5)) {
-		if (TRACEWARN) TRC(DBILOGFP,
-						   "%sQuery was not cancelled: was already finished\n", THEADER);
+		if (TRACEWARN_slow) TRC(DBILOGFP,
+						   "%sQuery was not cancelled: was already finished\n", THEADER_slow);
 		TRACE_PQERRORMESSAGE;
 		pg_error(aTHX_ h, status, PQerrorMessage(imp_dbh->conn));
-		if (TEND) TRC(DBILOGFP, "%sEnd pg_db_cancel (error)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_cancel (error)\n", THEADER_slow);
 	}
-	else if (TEND) TRC(DBILOGFP, "%sEnd pg_db_cancel\n", THEADER);
+	else if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_cancel\n", THEADER_slow);
 	return DBDPG_FALSE;
 					
 } /* end of pg_db_cancel */
@@ -4880,14 +4880,14 @@ int pg_db_cancel_sth(SV *sth, imp_sth_t *imp_sth)
 	D_imp_dbh_from_sth;
 	bool cancel_result;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin pg_db_cancel_sth (async status: %d)\n",
-					THEADER, imp_dbh->async_status);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin pg_db_cancel_sth (async status: %d)\n",
+					THEADER_slow, imp_dbh->async_status);
 
 	cancel_result = pg_db_cancel(sth, imp_dbh);
 
 	dbd_st_finish(sth, imp_sth);
 
-	if (TEND) TRC(DBILOGFP, "%sEnd pg_db_cancel_sth\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd pg_db_cancel_sth\n", THEADER_slow);
 	return cancel_result;
 
 } /* end of pg_db_cancel_sth */
@@ -4903,25 +4903,25 @@ static int handle_old_async(pTHX_ SV * handle, imp_dbh_t * imp_dbh, const int as
 	PGresult *result;
 	ExecStatusType status;
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin handle_old_sync (flag: %d)\n", THEADER, asyncflag);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin handle_old_sync (flag: %d)\n", THEADER_slow, asyncflag);
 
 	if (asyncflag & PG_OLDQUERY_CANCEL) {
 		/* Cancel the outstanding query */
-		if (TRACE3) { TRC(DBILOGFP, "%sCancelling old async command\n", THEADER); }
+		if (TRACE3_slow) { TRC(DBILOGFP, "%sCancelling old async command\n", THEADER_slow); }
 		TRACE_PQISBUSY;
 		if (PQisBusy(imp_dbh->conn)) {
 			PGcancel *cancel;
 			char errbuf[256];
 			int cresult;
-			if (TRACE3) TRC(DBILOGFP, "%sAttempting to cancel query\n", THEADER);
+			if (TRACE3_slow) TRC(DBILOGFP, "%sAttempting to cancel query\n", THEADER_slow);
 			TRACE_PQGETCANCEL;
 			cancel = PQgetCancel(imp_dbh->conn);
 			TRACE_PQCANCEL;
 			cresult = PQcancel(cancel,errbuf,255);
 			if (! cresult) {
-				if (TRACEWARN) { TRC(DBILOGFP, "%sPQcancel failed: %s\n", THEADER, errbuf); }
+				if (TRACEWARN_slow) { TRC(DBILOGFP, "%sPQcancel failed: %s\n", THEADER_slow, errbuf); }
 				pg_error(aTHX_ handle, PGRES_FATAL_ERROR, "Could not cancel previous command");
-				if (TEND) TRC(DBILOGFP, "%sEnd handle_old_async (error: could not cancel)\n", THEADER);
+				if (TEND_slow) TRC(DBILOGFP, "%sEnd handle_old_async (error: could not cancel)\n", THEADER_slow);
 				return -2;
 			}
 			TRACE_PQFREECANCEL;
@@ -4940,7 +4940,7 @@ static int handle_old_async(pTHX_ SV * handle, imp_dbh_t * imp_dbh, const int as
 	}
 	else if (asyncflag & PG_OLDQUERY_WAIT || imp_dbh->async_status == -1) {
 		/* Finish up the outstanding query and throw out the result, unless an error */
-		if (TRACE3) { TRC(DBILOGFP, "%sWaiting for old async command to finish\n", THEADER); }
+		if (TRACE3_slow) { TRC(DBILOGFP, "%sWaiting for old async command to finish\n", THEADER_slow); }
 		TRACE_PQGETRESULT;
 		while ((result = PQgetResult(imp_dbh->conn)) != NULL) {
 			status = _sqlstate(aTHX_ imp_dbh, result);
@@ -4951,13 +4951,13 @@ static int handle_old_async(pTHX_ SV * handle, imp_dbh_t * imp_dbh, const int as
 				if (-1 == PQputCopyEnd(imp_dbh->conn, NULL)) {
 					TRACE_PQERRORMESSAGE;
 					pg_error(aTHX_ handle, PGRES_FATAL_ERROR, PQerrorMessage(imp_dbh->conn));
-					if (TEND) TRC(DBILOGFP, "%sEnd handle_old_async (error: PQputCopyEnd)\n", THEADER);
+					if (TEND_slow) TRC(DBILOGFP, "%sEnd handle_old_async (error: PQputCopyEnd)\n", THEADER_slow);
 					return -2;
 				}
 			}
 			else if (status == PGRES_COPY_OUT) { /* Won't be as nice with this one */
 				pg_error(aTHX_ handle, PGRES_FATAL_ERROR, "Must finish copying first");
-				if (TEND) TRC(DBILOGFP, "%sEnd handle_old_async (error: COPY_OUT status)\n", THEADER);
+				if (TEND_slow) TRC(DBILOGFP, "%sEnd handle_old_async (error: COPY_OUT status)\n", THEADER_slow);
 				return -2;
 			}
 			else if (status != PGRES_EMPTY_QUERY
@@ -4965,14 +4965,14 @@ static int handle_old_async(pTHX_ SV * handle, imp_dbh_t * imp_dbh, const int as
 					 && status != PGRES_TUPLES_OK) {
 				TRACE_PQERRORMESSAGE;
 				pg_error(aTHX_ handle, status, PQerrorMessage(imp_dbh->conn));
-				if (TEND) TRC(DBILOGFP, "%sEnd handle_old_async (error: bad status)\n", THEADER);
+				if (TEND_slow) TRC(DBILOGFP, "%sEnd handle_old_async (error: bad status)\n", THEADER_slow);
 				return -2;
 			}
 		}
 	}
 	else {
 		pg_error(aTHX_ handle, PGRES_FATAL_ERROR, "Cannot execute until previous async query has finished");
-		if (TEND) TRC(DBILOGFP, "%sEnd handle_old_async (error: unfinished)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd handle_old_async (error: unfinished)\n", THEADER_slow);
 		return -2;
 	}
 
@@ -4981,7 +4981,7 @@ static int handle_old_async(pTHX_ SV * handle, imp_dbh_t * imp_dbh, const int as
 	if (imp_dbh->async_sth)
 		imp_dbh->async_sth->async_status = 0;
 
-	if (TEND) TRC(DBILOGFP, "%sEnd handle_old_async\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd handle_old_async\n", THEADER_slow);
 	return 0;
 
 } /* end of handle_old_async */
@@ -4999,7 +4999,7 @@ int dbd_st_cancel(SV *sth, imp_sth_t *imp_sth)
 	PGcancel *cancel;
 	char errbuf[256];
 
-	if (TSTART) TRC(DBILOGFP, "%sBegin dbd_st_cancel\n", THEADER);
+	if (TSTART_slow) TRC(DBILOGFP, "%sBegin dbd_st_cancel\n", THEADER_slow);
 
 	/* Get the cancel structure */
 	TRACE_PQGETCANCEL;
@@ -5010,15 +5010,15 @@ int dbd_st_cancel(SV *sth, imp_sth_t *imp_sth)
 	if (!PQcancel(cancel, errbuf, sizeof(errbuf))) {
 		TRACE_PQFREECANCEL;
 		PQfreeCancel(cancel);
-		if (TRACEWARN) TRC(DBILOGFP, "%sPQcancel failed: %s\n", THEADER, errbuf);
+		if (TRACEWARN_slow) TRC(DBILOGFP, "%sPQcancel failed: %s\n", THEADER_slow, errbuf);
 		pg_error(aTHX_ sth, PGRES_FATAL_ERROR, "PQcancel failed");
-		if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_cancel (error: cancel failed)\n", THEADER);
+		if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_cancel (error: cancel failed)\n", THEADER_slow);
 		return DBDPG_FALSE;
 	}
 	TRACE_PQFREECANCEL;
 	PQfreeCancel(cancel);
 
-	if (TEND) TRC(DBILOGFP, "%sEnd dbd_st_cancel\n", THEADER);
+	if (TEND_slow) TRC(DBILOGFP, "%sEnd dbd_st_cancel\n", THEADER_slow);
 	return DBDPG_TRUE;
 
 } /* end of dbd_st_cancel */
-- 
1.7.1




nntp.perl.org: Perl Programming lists via nntp and http.
Comments to Ask Bjørn Hansen at ask@perl.org | Group listing | About