fe-trace.c File Reference

#include "postgres_fe.h"
#include <ctype.h>
#include <limits.h>
#include <sys/time.h>
#include <unistd.h>
#include "libpq-fe.h"
#include "libpq-int.h"
#include "port/pg_bswap.h"

Include dependency graph for fe-trace.c:

Go to the source code of this file.

Functions
void	PQtrace (PGconn *conn, FILE *debug_port)
void	PQuntrace (PGconn *conn)
void	PQsetTraceFlags (PGconn *conn, int flags)
static void	pqTraceFormatTimestamp (char *timestr, size_t ts_len)
static void	pqTraceOutputByte1 (FILE *pfdebug, const char *data, int *cursor)
static int	pqTraceOutputInt16 (FILE *pfdebug, const char *data, int *cursor)
static int	pqTraceOutputInt32 (FILE *pfdebug, const char *data, int *cursor, bool suppress)
static void	pqTraceOutputString (FILE *pfdebug, const char *data, int *cursor, bool suppress)
static void	pqTraceOutputNchar (FILE *pfdebug, int len, const char *data, int *cursor)
static void	pqTraceOutputA (FILE *f, const char *message, int *cursor, bool regress)
static void	pqTraceOutputB (FILE *f, const char *message, int *cursor)
static void	pqTraceOutputC (FILE *f, bool toServer, const char *message, int *cursor)
static void	pqTraceOutputD (FILE *f, bool toServer, const char *message, int *cursor)
static void	pqTraceOutputNR (FILE *f, const char *type, const char *message, int *cursor, bool regress)
static void	pqTraceOutputE (FILE *f, bool toServer, const char *message, int *cursor, bool regress)
static void	pqTraceOutputf (FILE *f, const char *message, int *cursor)
static void	pqTraceOutputF (FILE *f, const char *message, int *cursor, bool regress)
static void	pqTraceOutputG (FILE *f, const char *message, int *cursor)
static void	pqTraceOutputH (FILE *f, const char *message, int *cursor)
static void	pqTraceOutputK (FILE *f, const char *message, int *cursor, bool regress)
static void	pqTraceOutputP (FILE *f, const char *message, int *cursor, bool regress)
static void	pqTraceOutputQ (FILE *f, const char *message, int *cursor)
static void	pqTraceOutputR (FILE *f, const char *message, int *cursor)
static void	pqTraceOutputS (FILE *f, const char *message, int *cursor)
static void	pqTraceOutputt (FILE *f, const char *message, int *cursor, bool regress)
static void	pqTraceOutputT (FILE *f, const char *message, int *cursor, bool regress)
static void	pqTraceOutputv (FILE *f, const char *message, int *cursor)
static void	pqTraceOutputV (FILE *f, const char *message, int *cursor)
static void	pqTraceOutputW (FILE *f, const char *message, int *cursor, int length)
static void	pqTraceOutputZ (FILE *f, const char *message, int *cursor)
void	pqTraceOutputMessage (PGconn *conn, const char *message, bool toServer)
void	pqTraceOutputNoTypeByteMessage (PGconn *conn, const char *message)

Function Documentation

PQsetTraceFlags()

void PQsetTraceFlags	(	PGconn *	conn,
		int	flags
	)

Definition at line 64 of file fe-trace.c.

{
    if (conn == NULL)
        return;
    /* If PQtrace() failed, do nothing. */
    if (conn->Pfdebug == NULL)
        return;
    conn->traceFlags = flags;
}

References conn, pg_conn::Pfdebug, and pg_conn::traceFlags.

Referenced by main().

PQtrace()

void PQtrace	(	PGconn *	conn,
		FILE *	debug_port
	)

Definition at line 35 of file fe-trace.c.

{
    if (conn == NULL)
        return;
    PQuntrace(conn);
    if (debug_port == NULL)
        return;
 
    conn->Pfdebug = debug_port;
    conn->traceFlags = 0;
}

References conn, pg_conn::Pfdebug, PQuntrace(), and pg_conn::traceFlags.

Referenced by main().

pqTraceFormatTimestamp()

static void pqTraceFormatTimestamp ( char *  timestr, size_t  ts_len  )

static

Definition at line 80 of file fe-trace.c.

{
    struct timeval tval;
    time_t      now;
 
    gettimeofday(&tval, NULL);
 
    /*
     * MSVC's implementation of timeval uses a long for tv_sec, however,
     * localtime() expects a time_t pointer.  Here we'll assign tv_sec to a
     * local time_t variable so that we pass localtime() the correct pointer
     * type.
     */
    now = tval.tv_sec;
    strftime(timestr, ts_len,
             "%Y-%m-%d %H:%M:%S",
             localtime(&now));
    /* append microseconds */
    snprintf(timestr + strlen(timestr), ts_len - strlen(timestr),
             ".%06u", (unsigned int) (tval.tv_usec));
}

References gettimeofday(), now(), and snprintf.

Referenced by pqTraceOutputMessage(), and pqTraceOutputNoTypeByteMessage().

pqTraceOutputA()

static void pqTraceOutputA ( FILE *  f, const char *  message, int *  cursor, bool  regress  )

static

Definition at line 220 of file fe-trace.c.

{
    fprintf(f, "NotificationResponse\t");
    pqTraceOutputInt32(f, message, cursor, regress);
    pqTraceOutputString(f, message, cursor, false);
    pqTraceOutputString(f, message, cursor, false);
}

References fprintf, pqTraceOutputInt32(), and pqTraceOutputString().

Referenced by pqTraceOutputMessage().

pqTraceOutputB()

static void pqTraceOutputB ( FILE *  f, const char *  message, int *  cursor  )

static

Definition at line 230 of file fe-trace.c.

{
    int         nparams;
 
    fprintf(f, "Bind\t");
    pqTraceOutputString(f, message, cursor, false);
    pqTraceOutputString(f, message, cursor, false);
    nparams = pqTraceOutputInt16(f, message, cursor);
 
    for (int i = 0; i < nparams; i++)
        pqTraceOutputInt16(f, message, cursor);
 
    nparams = pqTraceOutputInt16(f, message, cursor);
 
    for (int i = 0; i < nparams; i++)
    {
        int         nbytes;
 
        nbytes = pqTraceOutputInt32(f, message, cursor, false);
        if (nbytes == -1)
            continue;
        pqTraceOutputNchar(f, nbytes, message, cursor);
    }
 
    nparams = pqTraceOutputInt16(f, message, cursor);
    for (int i = 0; i < nparams; i++)
        pqTraceOutputInt16(f, message, cursor);
}

References fprintf, i, pqTraceOutputInt16(), pqTraceOutputInt32(), pqTraceOutputNchar(), and pqTraceOutputString().

Referenced by pqTraceOutputMessage().

pqTraceOutputByte1()

static void pqTraceOutputByte1 ( FILE *  pfdebug, const char *  data, int *  cursor  )

static

Definition at line 106 of file fe-trace.c.

{
    const char *v = data + *cursor;
 
    /*
     * Show non-printable data in hex format, including the terminating \0
     * that completes ErrorResponse and NoticeResponse messages.
     */
    if (!isprint((unsigned char) *v))
        fprintf(pfdebug, " \\x%02x", *v);
    else
        fprintf(pfdebug, " %c", *v);
    *cursor += 1;
}

References data, and fprintf.

Referenced by pqTraceOutputC(), pqTraceOutputD(), pqTraceOutputG(), pqTraceOutputH(), pqTraceOutputNR(), pqTraceOutputW(), and pqTraceOutputZ().

pqTraceOutputC()

static void pqTraceOutputC ( FILE *  f, bool  toServer, const char *  message, int *  cursor  )

static

Definition at line 261 of file fe-trace.c.

{
    if (toServer)
    {
        fprintf(f, "Close\t");
        pqTraceOutputByte1(f, message, cursor);
        pqTraceOutputString(f, message, cursor, false);
    }
    else
    {
        fprintf(f, "CommandComplete\t");
        pqTraceOutputString(f, message, cursor, false);
    }
}

References fprintf, pqTraceOutputByte1(), and pqTraceOutputString().

Referenced by pqTraceOutputMessage().

pqTraceOutputD()

static void pqTraceOutputD ( FILE *  f, bool  toServer, const char *  message, int *  cursor  )

static

Definition at line 278 of file fe-trace.c.

{
    if (toServer)
    {
        fprintf(f, "Describe\t");
        pqTraceOutputByte1(f, message, cursor);
        pqTraceOutputString(f, message, cursor, false);
    }
    else
    {
        int         nfields;
        int         len;
        int         i;
 
        fprintf(f, "DataRow\t");
        nfields = pqTraceOutputInt16(f, message, cursor);
        for (i = 0; i < nfields; i++)
        {
            len = pqTraceOutputInt32(f, message, cursor, false);
            if (len == -1)
                continue;
            pqTraceOutputNchar(f, len, message, cursor);
        }
    }
}

References fprintf, i, len, pqTraceOutputByte1(), pqTraceOutputInt16(), pqTraceOutputInt32(), pqTraceOutputNchar(), and pqTraceOutputString().

Referenced by pqTraceOutputMessage().

pqTraceOutputE()

static void pqTraceOutputE ( FILE *  f, bool  toServer, const char *  message, int *  cursor, bool  regress  )

static

Definition at line 327 of file fe-trace.c.

{
    if (toServer)
    {
        fprintf(f, "Execute\t");
        pqTraceOutputString(f, message, cursor, false);
        pqTraceOutputInt32(f, message, cursor, false);
    }
    else
        pqTraceOutputNR(f, "ErrorResponse", message, cursor, regress);
}

References fprintf, pqTraceOutputInt32(), pqTraceOutputNR(), and pqTraceOutputString().

Referenced by pqTraceOutputMessage().

pqTraceOutputf()

static void pqTraceOutputf ( FILE *  f, const char *  message, int *  cursor  )

static

Definition at line 341 of file fe-trace.c.

{
    fprintf(f, "CopyFail\t");
    pqTraceOutputString(f, message, cursor, false);
}

References fprintf, and pqTraceOutputString().

Referenced by pqTraceOutputMessage().

pqTraceOutputF()

static void pqTraceOutputF ( FILE *  f, const char *  message, int *  cursor, bool  regress  )

static

Definition at line 349 of file fe-trace.c.

{
    int         nfields;
    int         nbytes;
 
    fprintf(f, "FunctionCall\t");
    pqTraceOutputInt32(f, message, cursor, regress);
    nfields = pqTraceOutputInt16(f, message, cursor);
 
    for (int i = 0; i < nfields; i++)
        pqTraceOutputInt16(f, message, cursor);
 
    nfields = pqTraceOutputInt16(f, message, cursor);
 
    for (int i = 0; i < nfields; i++)
    {
        nbytes = pqTraceOutputInt32(f, message, cursor, false);
        if (nbytes == -1)
            continue;
        pqTraceOutputNchar(f, nbytes, message, cursor);
    }
 
    pqTraceOutputInt16(f, message, cursor);
}

References fprintf, i, pqTraceOutputInt16(), pqTraceOutputInt32(), and pqTraceOutputNchar().

Referenced by pqTraceOutputMessage().

pqTraceOutputG()

static void pqTraceOutputG ( FILE *  f, const char *  message, int *  cursor  )

static

Definition at line 376 of file fe-trace.c.

{
    int         nfields;
 
    fprintf(f, "CopyInResponse\t");
    pqTraceOutputByte1(f, message, cursor);
    nfields = pqTraceOutputInt16(f, message, cursor);
 
    for (int i = 0; i < nfields; i++)
        pqTraceOutputInt16(f, message, cursor);
}

References fprintf, i, pqTraceOutputByte1(), and pqTraceOutputInt16().

Referenced by pqTraceOutputMessage().

pqTraceOutputH()

static void pqTraceOutputH ( FILE *  f, const char *  message, int *  cursor  )

static

Definition at line 390 of file fe-trace.c.

{
    int         nfields;
 
    fprintf(f, "CopyOutResponse\t");
    pqTraceOutputByte1(f, message, cursor);
    nfields = pqTraceOutputInt16(f, message, cursor);
 
    for (int i = 0; i < nfields; i++)
        pqTraceOutputInt16(f, message, cursor);
}

References fprintf, i, pqTraceOutputByte1(), and pqTraceOutputInt16().

Referenced by pqTraceOutputMessage().

pqTraceOutputInt16()

static int pqTraceOutputInt16 ( FILE *  pfdebug, const char *  data, int *  cursor  )

static

Definition at line 125 of file fe-trace.c.

{
    uint16      tmp;
    int         result;
 
    memcpy(&tmp, data + *cursor, 2);
    *cursor += 2;
    result = (int) pg_ntoh16(tmp);
    fprintf(pfdebug, " %d", result);
 
    return result;
}

References data, fprintf, and pg_ntoh16.

Referenced by pqTraceOutputB(), pqTraceOutputD(), pqTraceOutputF(), pqTraceOutputG(), pqTraceOutputH(), pqTraceOutputP(), pqTraceOutputt(), pqTraceOutputT(), and pqTraceOutputW().

pqTraceOutputInt32()

static int pqTraceOutputInt32 ( FILE *  pfdebug, const char *  data, int *  cursor, bool  suppress  )

static

Definition at line 144 of file fe-trace.c.

{
    int         result;
 
    memcpy(&result, data + *cursor, 4);
    *cursor += 4;
    result = (int) pg_ntoh32(result);
    if (suppress)
        fprintf(pfdebug, " NNNN");
    else
        fprintf(pfdebug, " %d", result);
 
    return result;
}

References data, fprintf, and pg_ntoh32.

Referenced by pqTraceOutputA(), pqTraceOutputB(), pqTraceOutputD(), pqTraceOutputE(), pqTraceOutputF(), pqTraceOutputK(), pqTraceOutputNoTypeByteMessage(), pqTraceOutputP(), pqTraceOutputR(), pqTraceOutputt(), pqTraceOutputT(), pqTraceOutputv(), and pqTraceOutputV().

pqTraceOutputK()

static void pqTraceOutputK ( FILE *  f, const char *  message, int *  cursor, bool  regress  )

static

Definition at line 404 of file fe-trace.c.

{
    fprintf(f, "BackendKeyData\t");
    pqTraceOutputInt32(f, message, cursor, regress);
    pqTraceOutputInt32(f, message, cursor, regress);
}

References fprintf, and pqTraceOutputInt32().

Referenced by pqTraceOutputMessage().

pqTraceOutputMessage()

void pqTraceOutputMessage	(	PGconn *	conn,
		const char *	message,
		bool	toServer
	)

Definition at line 529 of file fe-trace.c.

{
    char        id;
    int         length;
    char       *prefix = toServer ? "F" : "B";
    int         logCursor = 0;
    bool        regress;
 
    if ((conn->traceFlags & PQTRACE_SUPPRESS_TIMESTAMPS) == 0)
    {
        char        timestr[128];
 
        pqTraceFormatTimestamp(timestr, sizeof(timestr));
        fprintf(conn->Pfdebug, "%s\t", timestr);
    }
    regress = (conn->traceFlags & PQTRACE_REGRESS_MODE) != 0;
 
    id = message[logCursor++];
 
    memcpy(&length, message + logCursor, 4);
    length = (int) pg_ntoh32(length);
    logCursor += 4;
 
    /*
     * In regress mode, suppress the length of ErrorResponse and
     * NoticeResponse.  The F (file name), L (line number) and R (routine
     * name) fields can change as server code is modified, and if their
     * lengths differ from the originals, that would break tests.
     */
    if (regress && !toServer && (id == 'E' || id == 'N'))
        fprintf(conn->Pfdebug, "%s\tNN\t", prefix);
    else
        fprintf(conn->Pfdebug, "%s\t%d\t", prefix, length);
 
    switch (id)
    {
        case '1':
            fprintf(conn->Pfdebug, "ParseComplete");
            /* No message content */
            break;
        case '2':
            fprintf(conn->Pfdebug, "BindComplete");
            /* No message content */
            break;
        case '3':
            fprintf(conn->Pfdebug, "CloseComplete");
            /* No message content */
            break;
        case 'A':               /* Notification Response */
            pqTraceOutputA(conn->Pfdebug, message, &logCursor, regress);
            break;
        case 'B':               /* Bind */
            pqTraceOutputB(conn->Pfdebug, message, &logCursor);
            break;
        case 'c':
            fprintf(conn->Pfdebug, "CopyDone");
            /* No message content */
            break;
        case 'C':               /* Close(F) or Command Complete(B) */
            pqTraceOutputC(conn->Pfdebug, toServer, message, &logCursor);
            break;
        case 'd':               /* Copy Data */
            /* Drop COPY data to reduce the overhead of logging. */
            break;
        case 'D':               /* Describe(F) or Data Row(B) */
            pqTraceOutputD(conn->Pfdebug, toServer, message, &logCursor);
            break;
        case 'E':               /* Execute(F) or Error Response(B) */
            pqTraceOutputE(conn->Pfdebug, toServer, message, &logCursor,
                           regress);
            break;
        case 'f':               /* Copy Fail */
            pqTraceOutputf(conn->Pfdebug, message, &logCursor);
            break;
        case 'F':               /* Function Call */
            pqTraceOutputF(conn->Pfdebug, message, &logCursor, regress);
            break;
        case 'G':               /* Start Copy In */
            pqTraceOutputG(conn->Pfdebug, message, &logCursor);
            break;
        case 'H':               /* Flush(F) or Start Copy Out(B) */
            if (!toServer)
                pqTraceOutputH(conn->Pfdebug, message, &logCursor);
            else
                fprintf(conn->Pfdebug, "Flush");    /* no message content */
            break;
        case 'I':
            fprintf(conn->Pfdebug, "EmptyQueryResponse");
            /* No message content */
            break;
        case 'K':               /* secret key data from the backend */
            pqTraceOutputK(conn->Pfdebug, message, &logCursor, regress);
            break;
        case 'n':
            fprintf(conn->Pfdebug, "NoData");
            /* No message content */
            break;
        case 'N':
            pqTraceOutputNR(conn->Pfdebug, "NoticeResponse", message,
                            &logCursor, regress);
            break;
        case 'P':               /* Parse */
            pqTraceOutputP(conn->Pfdebug, message, &logCursor, regress);
            break;
        case 'Q':               /* Query */
            pqTraceOutputQ(conn->Pfdebug, message, &logCursor);
            break;
        case 'R':               /* Authentication */
            pqTraceOutputR(conn->Pfdebug, message, &logCursor);
            break;
        case 's':
            fprintf(conn->Pfdebug, "PortalSuspended");
            /* No message content */
            break;
        case 'S':               /* Parameter Status(B) or Sync(F) */
            if (!toServer)
                pqTraceOutputS(conn->Pfdebug, message, &logCursor);
            else
                fprintf(conn->Pfdebug, "Sync"); /* no message content */
            break;
        case 't':               /* Parameter Description */
            pqTraceOutputt(conn->Pfdebug, message, &logCursor, regress);
            break;
        case 'T':               /* Row Description */
            pqTraceOutputT(conn->Pfdebug, message, &logCursor, regress);
            break;
        case 'v':               /* Negotiate Protocol Version */
            pqTraceOutputv(conn->Pfdebug, message, &logCursor);
            break;
        case 'V':               /* Function Call response */
            pqTraceOutputV(conn->Pfdebug, message, &logCursor);
            break;
        case 'W':               /* Start Copy Both */
            pqTraceOutputW(conn->Pfdebug, message, &logCursor, length);
            break;
        case 'X':
            fprintf(conn->Pfdebug, "Terminate");
            /* No message content */
            break;
        case 'Z':               /* Ready For Query */
            pqTraceOutputZ(conn->Pfdebug, message, &logCursor);
            break;
        default:
            fprintf(conn->Pfdebug, "Unknown message: %02x", id);
            break;
    }
 
    fputc('\n', conn->Pfdebug);
 
    /*
     * Verify the printing routine did it right.  Note that the one-byte
     * message identifier is not included in the length, but our cursor does
     * include it.
     */
    if (logCursor - 1 != length)
        fprintf(conn->Pfdebug,
                "mismatched message length: consumed %d, expected %d\n",
                logCursor - 1, length);
}

References conn, fprintf, pg_conn::Pfdebug, pg_ntoh32, PQTRACE_REGRESS_MODE, PQTRACE_SUPPRESS_TIMESTAMPS, pqTraceFormatTimestamp(), pqTraceOutputA(), pqTraceOutputB(), pqTraceOutputC(), pqTraceOutputD(), pqTraceOutputE(), pqTraceOutputf(), pqTraceOutputF(), pqTraceOutputG(), pqTraceOutputH(), pqTraceOutputK(), pqTraceOutputNR(), pqTraceOutputP(), pqTraceOutputQ(), pqTraceOutputR(), pqTraceOutputS(), pqTraceOutputt(), pqTraceOutputT(), pqTraceOutputv(), pqTraceOutputV(), pqTraceOutputW(), pqTraceOutputZ(), and pg_conn::traceFlags.

Referenced by getCopyDataMessage(), pqFunctionCall3(), pqParseInput3(), and pqPutMsgEnd().

pqTraceOutputNchar()

static void pqTraceOutputNchar ( FILE *  pfdebug, int  len, const char *  data, int *  cursor  )

static

Definition at line 188 of file fe-trace.c.

{
    int         i,
                next;           /* first char not yet printed */
    const char *v = data + *cursor;
 
    fprintf(pfdebug, " \'");
 
    for (next = i = 0; i < len; ++i)
    {
        if (isprint((unsigned char) v[i]))
            continue;
        else
        {
            fwrite(v + next, 1, i - next, pfdebug);
            fprintf(pfdebug, "\\x%02x", v[i]);
            next = i + 1;
        }
    }
    if (next < len)
        fwrite(v + next, 1, len - next, pfdebug);
 
    fprintf(pfdebug, "\'");
    *cursor += len;
}

References data, fprintf, i, len, and next.

Referenced by pqTraceOutputB(), pqTraceOutputD(), pqTraceOutputF(), and pqTraceOutputV().

pqTraceOutputNoTypeByteMessage()

void pqTraceOutputNoTypeByteMessage	(	PGconn *	conn,
		const char *	message
	)

Definition at line 694 of file fe-trace.c.

{
    int         length;
    int         logCursor = 0;
 
    if ((conn->traceFlags & PQTRACE_SUPPRESS_TIMESTAMPS) == 0)
    {
        char        timestr[128];
 
        pqTraceFormatTimestamp(timestr, sizeof(timestr));
        fprintf(conn->Pfdebug, "%s\t", timestr);
    }
 
    memcpy(&length, message + logCursor, 4);
    length = (int) pg_ntoh32(length);
    logCursor += 4;
 
    fprintf(conn->Pfdebug, "F\t%d\t", length);
 
    switch (length)
    {
        case 16:                /* CancelRequest */
            fprintf(conn->Pfdebug, "CancelRequest\t");
            pqTraceOutputInt32(conn->Pfdebug, message, &logCursor, false);
            pqTraceOutputInt32(conn->Pfdebug, message, &logCursor, false);
            pqTraceOutputInt32(conn->Pfdebug, message, &logCursor, false);
            break;
        case 8:                 /* GSSENCRequest or SSLRequest */
            /* These messages do not reach here. */
        default:
            fprintf(conn->Pfdebug, "Unknown message: length is %d", length);
            break;
    }
 
    fputc('\n', conn->Pfdebug);
}

References conn, fprintf, pg_conn::Pfdebug, pg_ntoh32, PQTRACE_SUPPRESS_TIMESTAMPS, pqTraceFormatTimestamp(), pqTraceOutputInt32(), and pg_conn::traceFlags.

Referenced by pqPutMsgEnd().

pqTraceOutputNR()

static void pqTraceOutputNR ( FILE *  f, const char *  type, const char *  message, int *  cursor, bool  regress  )

static

Definition at line 306 of file fe-trace.c.

{
    fprintf(f, "%s\t", type);
    for (;;)
    {
        char        field;
        bool        suppress;
 
        pqTraceOutputByte1(f, message, cursor);
        field = message[*cursor - 1];
        if (field == '\0')
            break;
 
        suppress = regress && (field == 'L' || field == 'F' || field == 'R');
        pqTraceOutputString(f, message, cursor, suppress);
    }
}

References fprintf, pqTraceOutputByte1(), pqTraceOutputString(), and generate_unaccent_rules::type.

Referenced by pqTraceOutputE(), and pqTraceOutputMessage().

pqTraceOutputP()

static void pqTraceOutputP ( FILE *  f, const char *  message, int *  cursor, bool  regress  )

static

Definition at line 413 of file fe-trace.c.

{
    int         nparams;
 
    fprintf(f, "Parse\t");
    pqTraceOutputString(f, message, cursor, false);
    pqTraceOutputString(f, message, cursor, false);
    nparams = pqTraceOutputInt16(f, message, cursor);
 
    for (int i = 0; i < nparams; i++)
        pqTraceOutputInt32(f, message, cursor, regress);
}

References fprintf, i, pqTraceOutputInt16(), pqTraceOutputInt32(), and pqTraceOutputString().

Referenced by pqTraceOutputMessage().

pqTraceOutputQ()

static void pqTraceOutputQ ( FILE *  f, const char *  message, int *  cursor  )

static

Definition at line 428 of file fe-trace.c.

{
    fprintf(f, "Query\t");
    pqTraceOutputString(f, message, cursor, false);
}

References fprintf, and pqTraceOutputString().

Referenced by pqTraceOutputMessage().

pqTraceOutputR()

static void pqTraceOutputR ( FILE *  f, const char *  message, int *  cursor  )

static

Definition at line 436 of file fe-trace.c.

{
    fprintf(f, "Authentication\t");
    pqTraceOutputInt32(f, message, cursor, false);
}

References fprintf, and pqTraceOutputInt32().

Referenced by pqTraceOutputMessage().

pqTraceOutputS()

static void pqTraceOutputS ( FILE *  f, const char *  message, int *  cursor  )

static

Definition at line 444 of file fe-trace.c.

{
    fprintf(f, "ParameterStatus\t");
    pqTraceOutputString(f, message, cursor, false);
    pqTraceOutputString(f, message, cursor, false);
}

References fprintf, and pqTraceOutputString().

Referenced by pqTraceOutputMessage().

pqTraceOutputString()

static void pqTraceOutputString ( FILE *  pfdebug, const char *  data, int *  cursor, bool  suppress  )

static

Definition at line 163 of file fe-trace.c.

{
    int         len;
 
    if (suppress)
    {
        fprintf(pfdebug, " \"SSSS\"");
        *cursor += strlen(data + *cursor) + 1;
    }
    else
    {
        len = fprintf(pfdebug, " \"%s\"", data + *cursor);
 
        /*
         * This is a null-terminated string. So add 1 after subtracting 3
         * which is the double quotes and space length from len.
         */
        *cursor += (len - 3 + 1);
    }
}

References data, fprintf, and len.

Referenced by pqTraceOutputA(), pqTraceOutputB(), pqTraceOutputC(), pqTraceOutputD(), pqTraceOutputE(), pqTraceOutputf(), pqTraceOutputNR(), pqTraceOutputP(), pqTraceOutputQ(), pqTraceOutputS(), and pqTraceOutputT().

pqTraceOutputt()

static void pqTraceOutputt ( FILE *  f, const char *  message, int *  cursor, bool  regress  )

static

Definition at line 453 of file fe-trace.c.

{
    int         nfields;
 
    fprintf(f, "ParameterDescription\t");
    nfields = pqTraceOutputInt16(f, message, cursor);
 
    for (int i = 0; i < nfields; i++)
        pqTraceOutputInt32(f, message, cursor, regress);
}

References fprintf, i, pqTraceOutputInt16(), and pqTraceOutputInt32().

Referenced by pqTraceOutputMessage().

pqTraceOutputT()

static void pqTraceOutputT ( FILE *  f, const char *  message, int *  cursor, bool  regress  )

static

Definition at line 466 of file fe-trace.c.

{
    int         nfields;
 
    fprintf(f, "RowDescription\t");
    nfields = pqTraceOutputInt16(f, message, cursor);
 
    for (int i = 0; i < nfields; i++)
    {
        pqTraceOutputString(f, message, cursor, false);
        pqTraceOutputInt32(f, message, cursor, regress);
        pqTraceOutputInt16(f, message, cursor);
        pqTraceOutputInt32(f, message, cursor, regress);
        pqTraceOutputInt16(f, message, cursor);
        pqTraceOutputInt32(f, message, cursor, false);
        pqTraceOutputInt16(f, message, cursor);
    }
}

References fprintf, i, pqTraceOutputInt16(), pqTraceOutputInt32(), and pqTraceOutputString().

Referenced by pqTraceOutputMessage().

pqTraceOutputv()

static void pqTraceOutputv ( FILE *  f, const char *  message, int *  cursor  )

static

Definition at line 487 of file fe-trace.c.

{
    fprintf(f, "NegotiateProtocolVersion\t");
    pqTraceOutputInt32(f, message, cursor, false);
    pqTraceOutputInt32(f, message, cursor, false);
}

References fprintf, and pqTraceOutputInt32().

Referenced by pqTraceOutputMessage().

pqTraceOutputV()

static void pqTraceOutputV ( FILE *  f, const char *  message, int *  cursor  )

static

Definition at line 496 of file fe-trace.c.

{
    int         len;
 
    fprintf(f, "FunctionCallResponse\t");
    len = pqTraceOutputInt32(f, message, cursor, false);
    if (len != -1)
        pqTraceOutputNchar(f, len, message, cursor);
}

References fprintf, len, pqTraceOutputInt32(), and pqTraceOutputNchar().

Referenced by pqTraceOutputMessage().

pqTraceOutputW()

static void pqTraceOutputW ( FILE *  f, const char *  message, int *  cursor, int  length  )

static

Definition at line 508 of file fe-trace.c.

{
    fprintf(f, "CopyBothResponse\t");
    pqTraceOutputByte1(f, message, cursor);
 
    while (length > *cursor)
        pqTraceOutputInt16(f, message, cursor);
}

References fprintf, pqTraceOutputByte1(), and pqTraceOutputInt16().

Referenced by pqTraceOutputMessage().

pqTraceOutputZ()

static void pqTraceOutputZ ( FILE *  f, const char *  message, int *  cursor  )

static

Definition at line 519 of file fe-trace.c.

{
    fprintf(f, "ReadyForQuery\t");
    pqTraceOutputByte1(f, message, cursor);
}

References fprintf, and pqTraceOutputByte1().

Referenced by pqTraceOutputMessage().

PQuntrace()

void PQuntrace

(

PGconn *

conn

)

Definition at line 49 of file fe-trace.c.

{
    if (conn == NULL)
        return;
    if (conn->Pfdebug)
    {
        fflush(conn->Pfdebug);
        conn->Pfdebug = NULL;
    }
 
    conn->traceFlags = 0;
}

References conn, fflush(), pg_conn::Pfdebug, and pg_conn::traceFlags.

Referenced by PQtrace().