libpq-be-fe-helpers.h File Reference

#include "libpq/libpq-be-fe.h"
#include "miscadmin.h"
#include "storage/fd.h"
#include "storage/latch.h"
#include "utils/timestamp.h"
#include "utils/wait_event.h"

Include dependency graph for libpq-be-fe-helpers.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	PGresult   libpqsrv_PGresult
#define	PQresultErrorMessage   libpqsrv_PQresultErrorMessage

Functions
static void	libpqsrv_connect_prepare (void)
static void	libpqsrv_connect_complete (PGconn *conn, uint32 wait_event_info)
static PGresult *	libpqsrv_get_result_last (PGconn *conn, uint32 wait_event_info)
static PGresult *	libpqsrv_get_result (PGconn *conn, uint32 wait_event_info)
static PGconn *	libpqsrv_connect_start (const char *conninfo)
static PGconn *	libpqsrv_connect (const char *conninfo, uint32 wait_event_info)
static PGconn *	libpqsrv_connect_params_start (const char *const *keywords, const char *const *values, int expand_dbname)
static PGconn *	libpqsrv_connect_params (const char *const *keywords, const char *const *values, int expand_dbname, uint32 wait_event_info)
static void	libpqsrv_disconnect (PGconn *conn)
static PGresult *	libpqsrv_exec (PGconn *conn, const char *query, uint32 wait_event_info)
static PGresult *	libpqsrv_exec_params (PGconn *conn, const char *command, int nParams, const Oid *paramTypes, const char *const *paramValues, const int *paramLengths, const int *paramFormats, int resultFormat, uint32 wait_event_info)
static const char *	libpqsrv_cancel (PGconn *conn, TimestampTz endtime)
static void	libpqsrv_notice_receiver (void *arg, const PGresult *res)

Macro Definition Documentation

PGresult

#define PGresult   libpqsrv_PGresult

Definition at line 505 of file libpq-be-fe-helpers.h.

PQresultErrorMessage

#define PQresultErrorMessage   libpqsrv_PQresultErrorMessage

Definition at line 506 of file libpq-be-fe-helpers.h.

Function Documentation

libpqsrv_cancel()

static const char * libpqsrv_cancel ( PGconn *  conn, TimestampTz  endtime  )

inlinestatic

Definition at line 396 of file libpq-be-fe-helpers.h.

{
    PGcancelConn *cancel_conn;
    const char *error = NULL;
 
    cancel_conn = PQcancelCreate(conn);
    if (cancel_conn == NULL)
        return "out of memory";
 
    /* In what follows, do not leak any PGcancelConn on any errors. */
 
    PG_TRY();
    {
        if (!PQcancelStart(cancel_conn))
        {
            error = pchomp(PQcancelErrorMessage(cancel_conn));
            goto exit;
        }
 
        for (;;)
        {
            PostgresPollingStatusType pollres;
            TimestampTz now;
            long        cur_timeout;
            int         waitEvents = WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH;
 
            pollres = PQcancelPoll(cancel_conn);
            if (pollres == PGRES_POLLING_OK)
                break;          /* success! */
 
            /* If timeout has expired, give up, else get sleep time. */
            now = GetCurrentTimestamp();
            cur_timeout = TimestampDifferenceMilliseconds(now, endtime);
            if (cur_timeout <= 0)
            {
                error = "cancel request timed out";
                break;
            }
 
            switch (pollres)
            {
                case PGRES_POLLING_READING:
                    waitEvents |= WL_SOCKET_READABLE;
                    break;
                case PGRES_POLLING_WRITING:
                    waitEvents |= WL_SOCKET_WRITEABLE;
                    break;
                default:
                    error = pchomp(PQcancelErrorMessage(cancel_conn));
                    goto exit;
            }
 
            /* Sleep until there's something to do */
            WaitLatchOrSocket(MyLatch, waitEvents, PQcancelSocket(cancel_conn),
                              cur_timeout, PG_WAIT_CLIENT);
 
            ResetLatch(MyLatch);
 
            CHECK_FOR_INTERRUPTS();
        }
exit:   ;
    }
    PG_FINALLY();
    {
        PQcancelFinish(cancel_conn);
    }
    PG_END_TRY();
 
    return error;
}

References CHECK_FOR_INTERRUPTS, conn, error(), fb(), GetCurrentTimestamp(), MyLatch, now(), pchomp(), PG_END_TRY, PG_FINALLY, PG_TRY, PG_WAIT_CLIENT, PGRES_POLLING_OK, PGRES_POLLING_READING, PGRES_POLLING_WRITING, PQcancelCreate(), PQcancelErrorMessage(), PQcancelFinish(), PQcancelPoll(), PQcancelSocket(), PQcancelStart(), ResetLatch(), TimestampDifferenceMilliseconds(), WaitLatchOrSocket(), WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, WL_SOCKET_READABLE, WL_SOCKET_WRITEABLE, and WL_TIMEOUT.

Referenced by dblink_cancel_query(), pgfdw_cancel_query_begin(), and pgfdw_get_cleanup_result().

libpqsrv_connect()

static PGconn * libpqsrv_connect ( const char *  conninfo, uint32  wait_event_info  )

inlinestatic

Definition at line 74 of file libpq-be-fe-helpers.h.

{
    PGconn     *conn;
 
    conn = libpqsrv_connect_start(conninfo);
 
    libpqsrv_connect_complete(conn, wait_event_info);
 
    return conn;
}

References conn, libpqsrv_connect_complete(), and libpqsrv_connect_start().

libpqsrv_connect_complete()

static void libpqsrv_connect_complete ( PGconn *  conn, uint32  wait_event_info  )

inlinestatic

Definition at line 181 of file libpq-be-fe-helpers.h.

{
    /*
     * With conn == NULL libpqsrv_disconnect() wouldn't release the FD. So do
     * that here.
     */
    if (conn == NULL)
    {
        ReleaseExternalFD();
        return;
    }
 
    /*
     * Can't wait without a socket. Note that we don't want to close the libpq
     * connection yet, so callers can emit a useful error.
     */
    if (PQstatus(conn) == CONNECTION_BAD)
        return;
 
    /*
     * WaitLatchOrSocket() can conceivably fail, handle that case here instead
     * of requiring all callers to do so.
     */
    PG_TRY();
    {
        PostgresPollingStatusType status;
 
        /*
         * Poll connection until we have OK or FAILED status.
         *
         * Per spec for PQconnectPoll, first wait till socket is write-ready.
         */
        status = PGRES_POLLING_WRITING;
        while (status != PGRES_POLLING_OK && status != PGRES_POLLING_FAILED)
        {
            int         io_flag;
            int         rc;
 
            if (status == PGRES_POLLING_READING)
                io_flag = WL_SOCKET_READABLE;
#ifdef WIN32
 
            /*
             * Windows needs a different test while waiting for
             * connection-made
             */
            else if (PQstatus(conn) == CONNECTION_STARTED)
                io_flag = WL_SOCKET_CONNECTED;
#endif
            else
                io_flag = WL_SOCKET_WRITEABLE;
 
            rc = WaitLatchOrSocket(MyLatch,
                                   WL_EXIT_ON_PM_DEATH | WL_LATCH_SET | io_flag,
                                   PQsocket(conn),
                                   0,
                                   wait_event_info);
 
            /* Interrupted? */
            if (rc & WL_LATCH_SET)
            {
                ResetLatch(MyLatch);
                CHECK_FOR_INTERRUPTS();
            }
 
            /* If socket is ready, advance the libpq state machine */
            if (rc & io_flag)
                status = PQconnectPoll(conn);
        }
    }
    PG_CATCH();
    {
        /*
         * If an error is thrown here, the callers won't call
         * libpqsrv_disconnect() with a conn, so release resources
         * immediately.
         */
        ReleaseExternalFD();
        PQfinish(conn);
 
        PG_RE_THROW();
    }
    PG_END_TRY();
}

References CHECK_FOR_INTERRUPTS, conn, CONNECTION_BAD, CONNECTION_STARTED, fb(), MyLatch, PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, PGRES_POLLING_FAILED, PGRES_POLLING_OK, PGRES_POLLING_READING, PGRES_POLLING_WRITING, PQconnectPoll(), PQfinish(), PQsocket(), PQstatus(), ReleaseExternalFD(), ResetLatch(), WaitLatchOrSocket(), WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, WL_SOCKET_CONNECTED, WL_SOCKET_READABLE, and WL_SOCKET_WRITEABLE.

Referenced by connect_pg_server(), dblink_connect(), dblink_get_conn(), libpqrcv_connect(), libpqsrv_connect(), and libpqsrv_connect_params().

libpqsrv_connect_params()

static PGconn * libpqsrv_connect_params ( const char *const *  keywords, const char *const *  values, int  expand_dbname, uint32  wait_event_info  )

inlinestatic

Definition at line 105 of file libpq-be-fe-helpers.h.

{
    PGconn     *conn;
 
    conn = libpqsrv_connect_params_start(keywords, values, expand_dbname);
 
    libpqsrv_connect_complete(conn, wait_event_info);
 
    return conn;
}

References conn, fb(), keywords, libpqsrv_connect_complete(), libpqsrv_connect_params_start(), and values.

libpqsrv_connect_params_start()

static PGconn * libpqsrv_connect_params_start ( const char *const *  keywords, const char *const *  values, int  expand_dbname  )

inlinestatic

Definition at line 91 of file libpq-be-fe-helpers.h.

{
    libpqsrv_connect_prepare();
 
    return PQconnectStartParams(keywords, values, expand_dbname);
}

References fb(), keywords, libpqsrv_connect_prepare(), PQconnectStartParams(), and values.

Referenced by connect_pg_server(), libpqrcv_connect(), and libpqsrv_connect_params().

libpqsrv_connect_prepare()

static void libpqsrv_connect_prepare ( void  )

inlinestatic

Definition at line 151 of file libpq-be-fe-helpers.h.

{
    /*
     * We must obey fd.c's limit on non-virtual file descriptors.  Assume that
     * a PGconn represents one long-lived FD.  (Doing this here also ensures
     * that VFDs are closed if needed to make room.)
     */
    if (!AcquireExternalFD())
    {
#ifndef WIN32                   /* can't write #if within ereport() macro */
        ereport(ERROR,
                (errcode(ERRCODE_SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION),
                 errmsg("could not establish connection"),
                 errdetail("There are too many open files on the local server."),
                 errhint("Raise the server's \"max_files_per_process\" and/or \"ulimit -n\" limits.")));
#else
        ereport(ERROR,
                (errcode(ERRCODE_SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION),
                 errmsg("could not establish connection"),
                 errdetail("There are too many open files on the local server."),
                 errhint("Raise the server's \"max_files_per_process\" setting.")));
#endif
    }
}

References AcquireExternalFD(), ereport, errcode(), errdetail(), errhint(), errmsg, ERROR, and fb().

Referenced by libpqsrv_connect_params_start(), and libpqsrv_connect_start().

libpqsrv_connect_start()

static PGconn * libpqsrv_connect_start ( const char *  conninfo )

inlinestatic

Definition at line 58 of file libpq-be-fe-helpers.h.

{
    libpqsrv_connect_prepare();
 
    return PQconnectStart(conninfo);
}

References libpqsrv_connect_prepare(), and PQconnectStart().

Referenced by dblink_connect(), dblink_get_conn(), and libpqsrv_connect().

libpqsrv_disconnect()

static void libpqsrv_disconnect ( PGconn *  conn )

inlinestatic

Definition at line 127 of file libpq-be-fe-helpers.h.

{
    /*
     * If no connection was established, we haven't reserved an FD for it (or
     * already released it). This rule makes it easier to write PG_CATCH()
     * handlers for this facility's users.
     *
     * See also libpqsrv_connect_complete().
     */
    if (conn == NULL)
        return;
 
    ReleaseExternalFD();
    PQfinish(conn);
}

References conn, fb(), PQfinish(), and ReleaseExternalFD().

Referenced by connect_pg_server(), dblink_connect(), dblink_disconnect(), dblink_exec(), dblink_get_conn(), dblink_record_internal(), dblink_security_check(), disconnect_pg_server(), libpqrcv_connect(), and libpqrcv_disconnect().

libpqsrv_exec()

static PGresult * libpqsrv_exec ( PGconn *  conn, const char *  query, uint32  wait_event_info  )

inlinestatic

Definition at line 277 of file libpq-be-fe-helpers.h.

{
    if (!PQsendQuery(conn, query))
        return NULL;
    return libpqsrv_get_result_last(conn, wait_event_info);
}

References conn, fb(), libpqsrv_get_result_last(), and PQsendQuery().

Referenced by dblink_close(), dblink_exec(), dblink_fetch(), dblink_open(), libpqrcv_alter_slot(), libpqrcv_connect(), libpqrcv_create_slot(), libpqrcv_exec(), libpqrcv_identify_system(), libpqrcv_readtimelinehistoryfile(), and libpqrcv_startstreaming().

libpqsrv_exec_params()

static PGresult * libpqsrv_exec_params ( PGconn *  conn, const char *  command, int  nParams, const Oid *  paramTypes, const char *const *  paramValues, const int *  paramLengths, const int *  paramFormats, int  resultFormat, uint32  wait_event_info  )

inlinestatic

Definition at line 290 of file libpq-be-fe-helpers.h.

{
    if (!PQsendQueryParams(conn, command, nParams, paramTypes, paramValues,
                           paramLengths, paramFormats, resultFormat))
        return NULL;
    return libpqsrv_get_result_last(conn, wait_event_info);
}

References conn, fb(), libpqsrv_get_result_last(), and PQsendQueryParams().

libpqsrv_get_result()

static PGresult * libpqsrv_get_result ( PGconn *  conn, uint32  wait_event_info  )

inlinestatic

Definition at line 344 of file libpq-be-fe-helpers.h.

{
    /*
     * Collect data until PQgetResult is ready to get the result without
     * blocking.
     */
    while (PQisBusy(conn))
    {
        int         rc;
 
        rc = WaitLatchOrSocket(MyLatch,
                               WL_EXIT_ON_PM_DEATH | WL_LATCH_SET |
                               WL_SOCKET_READABLE,
                               PQsocket(conn),
                               0,
                               wait_event_info);
 
        /* Interrupted? */
        if (rc & WL_LATCH_SET)
        {
            ResetLatch(MyLatch);
            CHECK_FOR_INTERRUPTS();
        }
 
        /* Consume whatever data is available from the socket */
        if (PQconsumeInput(conn) == 0)
        {
            /* trouble; expect PQgetResult() to return NULL */
            break;
        }
    }
 
    /* Now we can collect and return the next PGresult */
    return PQgetResult(conn);
}

References CHECK_FOR_INTERRUPTS, conn, MyLatch, PQconsumeInput(), PQgetResult, PQisBusy(), PQsocket(), ResetLatch(), WaitLatchOrSocket(), WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, and WL_SOCKET_READABLE.

Referenced by dblink_record_internal(), libpqrcv_endstreaming(), libpqrcv_receive(), libpqsrv_get_result_last(), materializeQueryResult(), and storeQueryResult().

libpqsrv_get_result_last()

static PGresult * libpqsrv_get_result_last ( PGconn *  conn, uint32  wait_event_info  )

inlinestatic

Definition at line 311 of file libpq-be-fe-helpers.h.

{
    PGresult   *lastResult = NULL;
 
    for (;;)
    {
        /* Wait for, and collect, the next PGresult. */
        PGresult   *result;
 
        result = libpqsrv_get_result(conn, wait_event_info);
        if (result == NULL)
            break;              /* query is complete, or failure */
 
        /*
         * Emulate PQexec()'s behavior of returning the last result when there
         * are many.
         */
        PQclear(lastResult);
        lastResult = result;
 
        if (PQresultStatus(lastResult) == PGRES_COPY_IN ||
            PQresultStatus(lastResult) == PGRES_COPY_OUT ||
            PQresultStatus(lastResult) == PGRES_COPY_BOTH ||
            PQstatus(conn) == CONNECTION_BAD)
            break;
    }
    return lastResult;
}

References conn, CONNECTION_BAD, fb(), libpqsrv_get_result(), PGRES_COPY_BOTH, PGRES_COPY_IN, PGRES_COPY_OUT, PQclear, PQresultStatus, PQstatus(), and result.

Referenced by libpqsrv_exec(), libpqsrv_exec_params(), and pgfdw_get_result().

libpqsrv_notice_receiver()

static void libpqsrv_notice_receiver ( void *  arg, const PGresult *  res  )

inlinestatic

Definition at line 485 of file libpq-be-fe-helpers.h.

{
    const char *message;
    int         len;
    const char *prefix = (const char *) arg;
 
    /*
     * Trim the trailing newline from the message text returned from
     * PQresultErrorMessage(), as it always includes one, to produce cleaner
     * log output.
     */
    message = PQresultErrorMessage(res);
    len = strlen(message);
    if (len > 0 && message[len - 1] == '\n')
        len--;
 
    ereport(LOG,
            errmsg_internal("%s: %.*s", prefix, len, message));
}

References arg, ereport, errmsg_internal(), fb(), len, LOG, and PQresultErrorMessage.

Referenced by connect_pg_server(), dblink_connect(), dblink_get_conn(), and libpqrcv_connect().