libpq_pipeline.c File Reference

#include "postgres_fe.h"
#include <sys/select.h>
#include <sys/time.h>
#include "catalog/pg_type_d.h"
#include "libpq-fe.h"
#include "pg_getopt.h"

Include dependency graph for libpq_pipeline.c:

Go to the source code of this file.

Macros
#define	pg_debug(...)
#define	MAXINTLEN   12
#define	MAXINT8LEN   20
#define	pg_fatal(...)   pg_fatal_impl(__LINE__, __VA_ARGS__)
#define	confirm_result_status(conn, status)   confirm_result_status_impl(__LINE__, conn, status)
#define	consume_result_status(conn, status)   consume_result_status_impl(__LINE__, conn, status)
#define	consume_null_result(conn)   consume_null_result_impl(__LINE__, conn)
#define	consume_query_cancel(conn)   consume_query_cancel_impl(__LINE__, conn)
#define	send_cancellable_query(conn, monitorConn)    send_cancellable_query_impl(__LINE__, conn, monitorConn)

Enumerations
enum	PipelineInsertStep {   BI_BEGIN_TX , BI_DROP_TABLE , BI_CREATE_TABLE , BI_PREPARE ,   BI_INSERT_ROWS , BI_COMMIT_TX , BI_SYNC , BI_DONE }

Functions
static void	exit_nicely (PGconn *conn)
static pg_noreturn void	pg_fatal_impl (int line, const char *fmt,...) pg_attribute_printf(2
static pg_noreturn void static bool	process_result (PGconn *conn, PGresult *res, int results, int numsent)
static PGresult *	confirm_result_status_impl (int line, PGconn *conn, ExecStatusType status)
static void	consume_result_status_impl (int line, PGconn *conn, ExecStatusType status)
static void	consume_null_result_impl (int line, PGconn *conn)
static void	consume_query_cancel_impl (int line, PGconn *conn)
static void	wait_for_connection_state (int line, PGconn *monitorConn, int procpid, char *state, char *event)
static void	send_cancellable_query_impl (int line, PGconn *conn, PGconn *monitorConn)
static PGconn *	copy_connection (PGconn *conn)
static void	test_cancel (PGconn *conn)
static void	test_disallowed_in_pipeline (PGconn *conn)
static void	test_multi_pipelines (PGconn *conn)
static void	test_nosync (PGconn *conn)
static void	test_pipeline_abort (PGconn *conn)
static void	test_pipelined_insert (PGconn *conn, int n_rows)
static void	test_prepared (PGconn *conn)
static void	test_protocol_version (PGconn *conn)
static void	notice_processor (void *arg, const char *message)
static void	test_pipeline_idle (PGconn *conn)
static void	test_simple_pipeline (PGconn *conn)
static void	test_singlerowmode (PGconn *conn)
static void	test_transaction (PGconn *conn)
static void	test_uniqviol (PGconn *conn)
static void	usage (const char *progname)
static void	print_test_list (void)
int	main (int argc, char **argv)

Variables
static const char *const	progname = "libpq_pipeline"
static char *	tracefile = NULL
static const char *const	drop_table_sql
static const char *const	create_table_sql
static const char *const	insert_sql
static const char *const	insert_sql2

Macro Definition Documentation

confirm_result_status

#define confirm_result_status	(		conn,
			status
	)		confirm_result_status_impl(__LINE__, conn, status)

Definition at line 94 of file libpq_pipeline.c.

consume_null_result

#define consume_null_result

(

conn

)

consume_null_result_impl(__LINE__, conn)

Definition at line 129 of file libpq_pipeline.c.

consume_query_cancel

#define consume_query_cancel

(

conn

)

consume_query_cancel_impl(__LINE__, conn)

Definition at line 145 of file libpq_pipeline.c.

consume_result_status

#define consume_result_status	(		conn,
			status
	)		consume_result_status_impl(__LINE__, conn, status)

Definition at line 116 of file libpq_pipeline.c.

MAXINT8LEN

#define MAXINT8LEN   20

Definition at line 56 of file libpq_pipeline.c.

MAXINTLEN

#define MAXINTLEN   12

Definition at line 55 of file libpq_pipeline.c.

pg_debug

#define pg_debug

(

...

)

Definition at line 41 of file libpq_pipeline.c.

pg_fatal

#define pg_fatal

(

...

)

pg_fatal_impl(__LINE__, __VA_ARGS__)

Definition at line 73 of file libpq_pipeline.c.

send_cancellable_query

#define send_cancellable_query	(		conn,
			monitorConn
	)		send_cancellable_query_impl(__LINE__, conn, monitorConn)

Definition at line 216 of file libpq_pipeline.c.

Enumeration Type Documentation

PipelineInsertStep

enum PipelineInsertStep

Enumerator
BI_BEGIN_TX
BI_DROP_TABLE
BI_CREATE_TABLE
BI_PREPARE
BI_INSERT_ROWS
BI_COMMIT_TX
BI_SYNC
BI_DONE

Definition at line 924 of file libpq_pipeline.c.

{
    BI_BEGIN_TX,
    BI_DROP_TABLE,
    BI_CREATE_TABLE,
    BI_PREPARE,
    BI_INSERT_ROWS,
    BI_COMMIT_TX,
    BI_SYNC,
    BI_DONE,
};

Function Documentation

confirm_result_status_impl()

static PGresult * confirm_result_status_impl ( int  line, PGconn *  conn, ExecStatusType  status  )

static

Definition at line 96 of file libpq_pipeline.c.

{
    PGresult   *res;
 
    res = PQgetResult(conn);
    if (res == NULL)
        pg_fatal_impl(line, "PQgetResult returned null unexpectedly: %s",
                      PQerrorMessage(conn));
    if (PQresultStatus(res) != status)
        pg_fatal_impl(line, "PQgetResult returned status %s, expected %s: %s",
                      PQresStatus(PQresultStatus(res)),
                      PQresStatus(status),
                      PQerrorMessage(conn));
    return res;
}

References conn, pg_fatal_impl(), PQerrorMessage(), PQgetResult, PQresStatus(), and PQresultStatus.

Referenced by consume_query_cancel_impl(), and consume_result_status_impl().

consume_null_result_impl()

static void consume_null_result_impl ( int  line, PGconn *  conn  )

static

Definition at line 131 of file libpq_pipeline.c.

{
    PGresult   *res;
 
    res = PQgetResult(conn);
    if (res != NULL)
        pg_fatal_impl(line, "expected NULL PGresult, got %s: %s",
                      PQresStatus(PQresultStatus(res)),
                      PQerrorMessage(conn));
}

References conn, pg_fatal_impl(), PQerrorMessage(), PQgetResult, PQresStatus(), and PQresultStatus.

consume_query_cancel_impl()

static void consume_query_cancel_impl ( int  line, PGconn *  conn  )

static

Definition at line 147 of file libpq_pipeline.c.

{
    PGresult   *res;
 
    res = confirm_result_status_impl(line, conn, PGRES_FATAL_ERROR);
    if (strcmp(PQresultErrorField(res, PG_DIAG_SQLSTATE), "57014") != 0)
        pg_fatal_impl(line, "query failed with a different error than cancellation: %s",
                      PQerrorMessage(conn));
    PQclear(res);
 
    while (PQisBusy(conn))
        PQconsumeInput(conn);
}

References confirm_result_status_impl(), conn, PG_DIAG_SQLSTATE, pg_fatal_impl(), PGRES_FATAL_ERROR, PQclear, PQconsumeInput(), PQerrorMessage(), PQisBusy(), and PQresultErrorField.

consume_result_status_impl()

static void consume_result_status_impl ( int  line, PGconn *  conn, ExecStatusType  status  )

static

Definition at line 118 of file libpq_pipeline.c.

{
    PGresult   *res;
 
    res = confirm_result_status_impl(line, conn, status);
    PQclear(res);
}

References confirm_result_status_impl(), conn, and PQclear.

copy_connection()

static PGconn * copy_connection ( PGconn *  conn )

static

Definition at line 250 of file libpq_pipeline.c.

{
    PGconn     *copyConn;
    PQconninfoOption *opts = PQconninfo(conn);
    const char **keywords;
    const char **vals;
    int         nopts = 0;
    int         i;
 
    for (PQconninfoOption *opt = opts; opt->keyword != NULL; ++opt)
        nopts++;
    nopts++;                    /* for the NULL terminator */
 
    keywords = pg_malloc(sizeof(char *) * nopts);
    vals = pg_malloc(sizeof(char *) * nopts);
 
    i = 0;
    for (PQconninfoOption *opt = opts; opt->keyword != NULL; ++opt)
    {
        if (opt->val)
        {
            keywords[i] = opt->keyword;
            vals[i] = opt->val;
            i++;
        }
    }
    keywords[i] = vals[i] = NULL;
 
    copyConn = PQconnectdbParams(keywords, vals, false);
 
    if (PQstatus(copyConn) != CONNECTION_OK)
        pg_fatal("Connection to database failed: %s",
                 PQerrorMessage(copyConn));
 
    pfree(keywords);
    pfree(vals);
    PQconninfoFree(opts);
 
    return copyConn;
}

References conn, CONNECTION_OK, i, JsonPathKeyword::keyword, keywords, opts, pfree(), pg_fatal, pg_malloc(), PQconnectdbParams(), PQconninfo(), PQconninfoFree(), PQerrorMessage(), and PQstatus().

Referenced by test_cancel().

exit_nicely()

static void exit_nicely ( PGconn *  conn )

static

Definition at line 59 of file libpq_pipeline.c.

{
    PQfinish(conn);
    exit(1);
}

References conn, and PQfinish().

Referenced by main(), test_nosync(), and test_pipelined_insert().

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 2117 of file libpq_pipeline.c.

{
    const char *conninfo = "";
    PGconn     *conn;
    FILE       *trace = NULL;
    char       *testname;
    int         numrows = 10000;
    PGresult   *res;
    int         c;
 
    while ((c = getopt(argc, argv, "r:t:")) != -1)
    {
        switch (c)
        {
            case 'r':           /* numrows */
                errno = 0;
                numrows = strtol(optarg, NULL, 10);
                if (errno != 0 || numrows <= 0)
                {
                    fprintf(stderr, "couldn't parse \"%s\" as a positive integer\n",
                            optarg);
                    exit(1);
                }
                break;
            case 't':           /* trace file */
                tracefile = pg_strdup(optarg);
                break;
        }
    }
 
    if (optind < argc)
    {
        testname = pg_strdup(argv[optind]);
        optind++;
    }
    else
    {
        usage(argv[0]);
        exit(1);
    }
 
    if (strcmp(testname, "tests") == 0)
    {
        print_test_list();
        exit(0);
    }
 
    if (optind < argc)
    {
        conninfo = pg_strdup(argv[optind]);
        optind++;
    }
 
    /* Make a connection to the database */
    conn = PQconnectdb(conninfo);
    if (PQstatus(conn) != CONNECTION_OK)
    {
        fprintf(stderr, "Connection to database failed: %s\n",
                PQerrorMessage(conn));
        exit_nicely(conn);
    }
 
    res = PQexec(conn, "SET lc_messages TO \"C\"");
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
        pg_fatal("failed to set \"lc_messages\": %s", PQerrorMessage(conn));
    PQclear(res);
    res = PQexec(conn, "SET debug_parallel_query = off");
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
        pg_fatal("failed to set \"debug_parallel_query\": %s", PQerrorMessage(conn));
    PQclear(res);
 
    /* Set the trace file, if requested */
    if (tracefile != NULL)
    {
        if (strcmp(tracefile, "-") == 0)
            trace = stdout;
        else
            trace = fopen(tracefile, "w");
        if (trace == NULL)
            pg_fatal("could not open file \"%s\": %m", tracefile);
 
        /* Make it line-buffered */
        setvbuf(trace, NULL, PG_IOLBF, 0);
 
        PQtrace(conn, trace);
        PQsetTraceFlags(conn,
                        PQTRACE_SUPPRESS_TIMESTAMPS | PQTRACE_REGRESS_MODE);
    }
 
    if (strcmp(testname, "cancel") == 0)
        test_cancel(conn);
    else if (strcmp(testname, "disallowed_in_pipeline") == 0)
        test_disallowed_in_pipeline(conn);
    else if (strcmp(testname, "multi_pipelines") == 0)
        test_multi_pipelines(conn);
    else if (strcmp(testname, "nosync") == 0)
        test_nosync(conn);
    else if (strcmp(testname, "pipeline_abort") == 0)
        test_pipeline_abort(conn);
    else if (strcmp(testname, "pipeline_idle") == 0)
        test_pipeline_idle(conn);
    else if (strcmp(testname, "pipelined_insert") == 0)
        test_pipelined_insert(conn, numrows);
    else if (strcmp(testname, "prepared") == 0)
        test_prepared(conn);
    else if (strcmp(testname, "protocol_version") == 0)
        test_protocol_version(conn);
    else if (strcmp(testname, "simple_pipeline") == 0)
        test_simple_pipeline(conn);
    else if (strcmp(testname, "singlerow") == 0)
        test_singlerowmode(conn);
    else if (strcmp(testname, "transaction") == 0)
        test_transaction(conn);
    else if (strcmp(testname, "uniqviol") == 0)
        test_uniqviol(conn);
    else
    {
        fprintf(stderr, "\"%s\" is not a recognized test name\n", testname);
        exit(1);
    }
 
    /* close the connection to the database and cleanup */
    PQfinish(conn);
 
    if (trace && trace != stdout)
        fclose(trace);
 
    return 0;
}

References conn, CONNECTION_OK, exit_nicely(), fprintf, getopt(), optarg, optind, pg_fatal, PG_IOLBF, pg_strdup(), PGRES_COMMAND_OK, PQclear, PQconnectdb(), PQerrorMessage(), PQexec(), PQfinish(), PQresultStatus, PQsetTraceFlags(), PQstatus(), PQtrace(), PQTRACE_REGRESS_MODE, PQTRACE_SUPPRESS_TIMESTAMPS, print_test_list(), generate_unaccent_rules::stdout, test_cancel(), test_disallowed_in_pipeline(), test_multi_pipelines(), test_nosync(), test_pipeline_abort(), test_pipeline_idle(), test_pipelined_insert(), test_prepared(), test_protocol_version(), test_simple_pipeline(), test_singlerowmode(), test_transaction(), test_uniqviol(), tracefile, and usage().

notice_processor()

static void notice_processor ( void *  arg, const char *  message  )

static

Definition at line 1430 of file libpq_pipeline.c.

{
    int        *n_notices = (int *) arg;
 
    (*n_notices)++;
    fprintf(stderr, "NOTICE %d: %s", *n_notices, message);
}

References arg, and fprintf.

Referenced by test_pipeline_idle().

pg_fatal_impl()

static pg_noreturn void pg_fatal_impl ( int  line, const char *  fmt,   ...  )

static

Definition at line 75 of file libpq_pipeline.c.

{
    va_list     args;
 
    fflush(stdout);
 
    fprintf(stderr, "\n%s:%d: ", progname, line);
    va_start(args, fmt);
    vfprintf(stderr, fmt, args);
    va_end(args);
    Assert(fmt[strlen(fmt) - 1] != '\n');
    fprintf(stderr, "\n");
    exit(1);
}

References generate_unaccent_rules::args, Assert(), fprintf, progname, generate_unaccent_rules::stdout, and vfprintf.

Referenced by confirm_result_status_impl(), consume_null_result_impl(), consume_query_cancel_impl(), send_cancellable_query_impl(), and wait_for_connection_state().

print_test_list()

static void print_test_list ( void  )

static

Definition at line 2099 of file libpq_pipeline.c.

{
    printf("cancel\n");
    printf("disallowed_in_pipeline\n");
    printf("multi_pipelines\n");
    printf("nosync\n");
    printf("pipeline_abort\n");
    printf("pipeline_idle\n");
    printf("pipelined_insert\n");
    printf("prepared\n");
    printf("protocol_version\n");
    printf("simple_pipeline\n");
    printf("singlerow\n");
    printf("transaction\n");
    printf("uniqviol\n");
}

References printf.

Referenced by main().

process_result()

static bool process_result ( PGconn *  conn, PGresult *  res, int  results, int  numsent  )

static

Definition at line 2050 of file libpq_pipeline.c.

{
    bool        got_error = false;
 
    if (res == NULL)
        pg_fatal("got unexpected NULL");
 
    switch (PQresultStatus(res))
    {
        case PGRES_FATAL_ERROR:
            got_error = true;
            fprintf(stderr, "result %d/%d (error): %s\n", results, numsent, PQerrorMessage(conn));
            PQclear(res);
            consume_null_result(conn);
            break;
 
        case PGRES_TUPLES_OK:
            fprintf(stderr, "result %d/%d: %s\n", results, numsent, PQgetvalue(res, 0, 0));
            PQclear(res);
            consume_null_result(conn);
            break;
 
        case PGRES_PIPELINE_ABORTED:
            fprintf(stderr, "result %d/%d: pipeline aborted\n", results, numsent);
            PQclear(res);
            consume_null_result(conn);
            break;
 
        default:
            pg_fatal("got unexpected %s", PQresStatus(PQresultStatus(res)));
    }
 
    return got_error;
}

References conn, consume_null_result, fprintf, pg_fatal, PGRES_FATAL_ERROR, PGRES_PIPELINE_ABORTED, PGRES_TUPLES_OK, PQclear, PQerrorMessage(), PQgetvalue, PQresStatus(), and PQresultStatus.

Referenced by test_uniqviol().

send_cancellable_query_impl()

static void send_cancellable_query_impl ( int  line, PGconn *  conn, PGconn *  monitorConn  )

static

Definition at line 219 of file libpq_pipeline.c.

{
    const char *env_wait;
    const Oid   paramTypes[1] = {INT4OID};
 
    /*
     * Wait for the connection to be idle, so that our check for an active
     * connection below is reliable, instead of possibly seeing an outdated
     * state.
     */
    wait_for_connection_state(line, monitorConn, PQbackendPID(conn), "idle", NULL);
 
    env_wait = getenv("PG_TEST_TIMEOUT_DEFAULT");
    if (env_wait == NULL)
        env_wait = "180";
 
    if (PQsendQueryParams(conn, "SELECT pg_sleep($1)", 1, paramTypes,
                          &env_wait, NULL, NULL, 0) != 1)
        pg_fatal_impl(line, "failed to send query: %s", PQerrorMessage(conn));
 
    /*
     * Wait for the sleep to be active, because if the query is not running
     * yet, the cancel request that we send won't have any effect.
     */
    wait_for_connection_state(line, monitorConn, PQbackendPID(conn), NULL, "PgSleep");
}

References conn, pg_fatal_impl(), PQbackendPID(), PQerrorMessage(), PQsendQueryParams(), and wait_for_connection_state().

test_cancel()

static void test_cancel ( PGconn *  conn )

static

Definition at line 295 of file libpq_pipeline.c.

{
    PGcancel   *cancel;
    PGcancelConn *cancelConn;
    PGconn     *monitorConn;
    char        errorbuf[256];
 
    fprintf(stderr, "test cancellations... ");
 
    if (PQsetnonblocking(conn, 1) != 0)
        pg_fatal("failed to set nonblocking mode: %s", PQerrorMessage(conn));
 
    /*
     * Make a separate connection to the database to monitor the query on the
     * main connection.
     */
    monitorConn = copy_connection(conn);
    Assert(PQstatus(monitorConn) == CONNECTION_OK);
 
    /* test PQcancel */
    send_cancellable_query(conn, monitorConn);
    cancel = PQgetCancel(conn);
    if (!PQcancel(cancel, errorbuf, sizeof(errorbuf)))
        pg_fatal("failed to run PQcancel: %s", errorbuf);
    consume_query_cancel(conn);
 
    /* PGcancel object can be reused for the next query */
    send_cancellable_query(conn, monitorConn);
    if (!PQcancel(cancel, errorbuf, sizeof(errorbuf)))
        pg_fatal("failed to run PQcancel: %s", errorbuf);
    consume_query_cancel(conn);
 
    PQfreeCancel(cancel);
 
    /* test PQrequestCancel */
    send_cancellable_query(conn, monitorConn);
    if (!PQrequestCancel(conn))
        pg_fatal("failed to run PQrequestCancel: %s", PQerrorMessage(conn));
    consume_query_cancel(conn);
 
    /* test PQcancelBlocking */
    send_cancellable_query(conn, monitorConn);
    cancelConn = PQcancelCreate(conn);
    if (!PQcancelBlocking(cancelConn))
        pg_fatal("failed to run PQcancelBlocking: %s", PQcancelErrorMessage(cancelConn));
    consume_query_cancel(conn);
    PQcancelFinish(cancelConn);
 
    /* test PQcancelCreate and then polling with PQcancelPoll */
    send_cancellable_query(conn, monitorConn);
    cancelConn = PQcancelCreate(conn);
    if (!PQcancelStart(cancelConn))
        pg_fatal("bad cancel connection: %s", PQcancelErrorMessage(cancelConn));
    while (true)
    {
        struct timeval tv;
        fd_set      input_mask;
        fd_set      output_mask;
        PostgresPollingStatusType pollres = PQcancelPoll(cancelConn);
        int         sock = PQcancelSocket(cancelConn);
 
        if (pollres == PGRES_POLLING_OK)
            break;
 
        FD_ZERO(&input_mask);
        FD_ZERO(&output_mask);
        switch (pollres)
        {
            case PGRES_POLLING_READING:
                pg_debug("polling for reads\n");
                FD_SET(sock, &input_mask);
                break;
            case PGRES_POLLING_WRITING:
                pg_debug("polling for writes\n");
                FD_SET(sock, &output_mask);
                break;
            default:
                pg_fatal("bad cancel connection: %s", PQcancelErrorMessage(cancelConn));
        }
 
        if (sock < 0)
            pg_fatal("sock did not exist: %s", PQcancelErrorMessage(cancelConn));
 
        tv.tv_sec = 3;
        tv.tv_usec = 0;
 
        while (true)
        {
            if (select(sock + 1, &input_mask, &output_mask, NULL, &tv) < 0)
            {
                if (errno == EINTR)
                    continue;
                pg_fatal("select() failed: %m");
            }
            break;
        }
    }
    if (PQcancelStatus(cancelConn) != CONNECTION_OK)
        pg_fatal("unexpected cancel connection status: %s", PQcancelErrorMessage(cancelConn));
    consume_query_cancel(conn);
 
    /*
     * test PQcancelReset works on the cancel connection and it can be reused
     * afterwards
     */
    PQcancelReset(cancelConn);
 
    send_cancellable_query(conn, monitorConn);
    if (!PQcancelStart(cancelConn))
        pg_fatal("bad cancel connection: %s", PQcancelErrorMessage(cancelConn));
    while (true)
    {
        struct timeval tv;
        fd_set      input_mask;
        fd_set      output_mask;
        PostgresPollingStatusType pollres = PQcancelPoll(cancelConn);
        int         sock = PQcancelSocket(cancelConn);
 
        if (pollres == PGRES_POLLING_OK)
            break;
 
        FD_ZERO(&input_mask);
        FD_ZERO(&output_mask);
        switch (pollres)
        {
            case PGRES_POLLING_READING:
                pg_debug("polling for reads\n");
                FD_SET(sock, &input_mask);
                break;
            case PGRES_POLLING_WRITING:
                pg_debug("polling for writes\n");
                FD_SET(sock, &output_mask);
                break;
            default:
                pg_fatal("bad cancel connection: %s", PQcancelErrorMessage(cancelConn));
        }
 
        if (sock < 0)
            pg_fatal("sock did not exist: %s", PQcancelErrorMessage(cancelConn));
 
        tv.tv_sec = 3;
        tv.tv_usec = 0;
 
        while (true)
        {
            if (select(sock + 1, &input_mask, &output_mask, NULL, &tv) < 0)
            {
                if (errno == EINTR)
                    continue;
                pg_fatal("select() failed: %m");
            }
            break;
        }
    }
    if (PQcancelStatus(cancelConn) != CONNECTION_OK)
        pg_fatal("unexpected cancel connection status: %s", PQcancelErrorMessage(cancelConn));
    consume_query_cancel(conn);
 
    PQcancelFinish(cancelConn);
    PQfinish(monitorConn);
 
    fprintf(stderr, "ok\n");
}

References Assert(), cancelConn, conn, CONNECTION_OK, consume_query_cancel, copy_connection(), EINTR, fprintf, pg_debug, pg_fatal, PGRES_POLLING_OK, PGRES_POLLING_READING, PGRES_POLLING_WRITING, PQcancel(), PQcancelBlocking(), PQcancelCreate(), PQcancelErrorMessage(), PQcancelFinish(), PQcancelPoll(), PQcancelReset(), PQcancelSocket(), PQcancelStart(), PQcancelStatus(), PQerrorMessage(), PQfinish(), PQfreeCancel(), PQgetCancel(), PQrequestCancel(), PQsetnonblocking(), PQstatus(), select, and send_cancellable_query.

Referenced by main().

test_disallowed_in_pipeline()

static void test_disallowed_in_pipeline ( PGconn *  conn )

static

Definition at line 460 of file libpq_pipeline.c.

{
    PGresult   *res = NULL;
 
    fprintf(stderr, "test error cases... ");
 
    if (PQisnonblocking(conn))
        pg_fatal("Expected blocking connection mode");
 
    if (PQenterPipelineMode(conn) != 1)
        pg_fatal("Unable to enter pipeline mode");
 
    if (PQpipelineStatus(conn) == PQ_PIPELINE_OFF)
        pg_fatal("Pipeline mode not activated properly");
 
    /* PQexec should fail in pipeline mode */
    res = PQexec(conn, "SELECT 1");
    if (PQresultStatus(res) != PGRES_FATAL_ERROR)
        pg_fatal("PQexec should fail in pipeline mode but succeeded");
    if (strcmp(PQerrorMessage(conn),
               "synchronous command execution functions are not allowed in pipeline mode\n") != 0)
        pg_fatal("did not get expected error message; got: \"%s\"",
                 PQerrorMessage(conn));
    PQclear(res);
 
    /* PQsendQuery should fail in pipeline mode */
    if (PQsendQuery(conn, "SELECT 1") != 0)
        pg_fatal("PQsendQuery should fail in pipeline mode but succeeded");
    if (strcmp(PQerrorMessage(conn),
               "PQsendQuery not allowed in pipeline mode\n") != 0)
        pg_fatal("did not get expected error message; got: \"%s\"",
                 PQerrorMessage(conn));
 
    /* Entering pipeline mode when already in pipeline mode is OK */
    if (PQenterPipelineMode(conn) != 1)
        pg_fatal("re-entering pipeline mode should be a no-op but failed");
 
    if (PQisBusy(conn) != 0)
        pg_fatal("PQisBusy should return 0 when idle in pipeline mode, returned 1");
 
    /* ok, back to normal command mode */
    if (PQexitPipelineMode(conn) != 1)
        pg_fatal("couldn't exit idle empty pipeline mode");
 
    if (PQpipelineStatus(conn) != PQ_PIPELINE_OFF)
        pg_fatal("Pipeline mode not terminated properly");
 
    /* exiting pipeline mode when not in pipeline mode should be a no-op */
    if (PQexitPipelineMode(conn) != 1)
        pg_fatal("pipeline mode exit when not in pipeline mode should succeed but failed");
 
    /* can now PQexec again */
    res = PQexec(conn, "SELECT 1");
    if (PQresultStatus(res) != PGRES_TUPLES_OK)
        pg_fatal("PQexec should succeed after exiting pipeline mode but failed with: %s",
                 PQerrorMessage(conn));
    PQclear(res);
 
    fprintf(stderr, "ok\n");
}

References conn, fprintf, pg_fatal, PGRES_FATAL_ERROR, PGRES_TUPLES_OK, PQ_PIPELINE_OFF, PQclear, PQenterPipelineMode(), PQerrorMessage(), PQexec(), PQexitPipelineMode(), PQisBusy(), PQisnonblocking(), PQpipelineStatus(), PQresultStatus, and PQsendQuery().

Referenced by main().

test_multi_pipelines()

static void test_multi_pipelines ( PGconn *  conn )

static

Definition at line 522 of file libpq_pipeline.c.

{
    const char *dummy_params[1] = {"1"};
    Oid         dummy_param_oids[1] = {INT4OID};
 
    fprintf(stderr, "multi pipeline... ");
 
    /*
     * Queue up a couple of small pipelines and process each without returning
     * to command mode first.
     */
    if (PQenterPipelineMode(conn) != 1)
        pg_fatal("failed to enter pipeline mode: %s", PQerrorMessage(conn));
 
    /* first pipeline */
    if (PQsendQueryParams(conn, "SELECT $1", 1, dummy_param_oids,
                          dummy_params, NULL, NULL, 0) != 1)
        pg_fatal("dispatching first SELECT failed: %s", PQerrorMessage(conn));
 
    if (PQpipelineSync(conn) != 1)
        pg_fatal("Pipeline sync failed: %s", PQerrorMessage(conn));
 
    /* second pipeline */
    if (PQsendQueryParams(conn, "SELECT $1", 1, dummy_param_oids,
                          dummy_params, NULL, NULL, 0) != 1)
        pg_fatal("dispatching second SELECT failed: %s", PQerrorMessage(conn));
 
    /* Skip flushing once. */
    if (PQsendPipelineSync(conn) != 1)
        pg_fatal("Pipeline sync failed: %s", PQerrorMessage(conn));
 
    /* third pipeline */
    if (PQsendQueryParams(conn, "SELECT $1", 1, dummy_param_oids,
                          dummy_params, NULL, NULL, 0) != 1)
        pg_fatal("dispatching third SELECT failed: %s", PQerrorMessage(conn));
 
    if (PQpipelineSync(conn) != 1)
        pg_fatal("pipeline sync failed: %s", PQerrorMessage(conn));
 
    /* OK, start processing the results */
 
    /* first pipeline */
    consume_result_status(conn, PGRES_TUPLES_OK);
 
    consume_null_result(conn);
 
    if (PQexitPipelineMode(conn) != 0)
        pg_fatal("exiting pipeline mode after query but before sync succeeded incorrectly");
 
    consume_result_status(conn, PGRES_PIPELINE_SYNC);
 
    /* second pipeline */
    consume_result_status(conn, PGRES_TUPLES_OK);
 
    consume_null_result(conn);
 
    if (PQexitPipelineMode(conn) != 0)
        pg_fatal("exiting pipeline mode after query but before sync succeeded incorrectly");
 
    consume_result_status(conn, PGRES_PIPELINE_SYNC);
 
    /* third pipeline */
    consume_result_status(conn, PGRES_TUPLES_OK);
 
    consume_null_result(conn);
 
    consume_result_status(conn, PGRES_PIPELINE_SYNC);
 
    /* We're still in pipeline mode ... */
    if (PQpipelineStatus(conn) == PQ_PIPELINE_OFF)
        pg_fatal("Fell out of pipeline mode somehow");
 
    /* until we end it, which we can safely do now */
    if (PQexitPipelineMode(conn) != 1)
        pg_fatal("attempt to exit pipeline mode failed when it should've succeeded: %s",
                 PQerrorMessage(conn));
 
    if (PQpipelineStatus(conn) != PQ_PIPELINE_OFF)
        pg_fatal("exiting pipeline mode didn't seem to work");
 
    fprintf(stderr, "ok\n");
}

References conn, consume_null_result, consume_result_status, fprintf, pg_fatal, PGRES_PIPELINE_SYNC, PGRES_TUPLES_OK, PQ_PIPELINE_OFF, PQenterPipelineMode(), PQerrorMessage(), PQexitPipelineMode(), PQpipelineStatus(), PQpipelineSync(), PQsendPipelineSync(), and PQsendQueryParams().

Referenced by main().

test_nosync()

static void test_nosync ( PGconn *  conn )

static

Definition at line 610 of file libpq_pipeline.c.

{
    int         numqueries = 10;
    int         results = 0;
    int         sock = PQsocket(conn);
 
    fprintf(stderr, "nosync... ");
 
    if (sock < 0)
        pg_fatal("invalid socket");
 
    if (PQenterPipelineMode(conn) != 1)
        pg_fatal("could not enter pipeline mode");
    for (int i = 0; i < numqueries; i++)
    {
        fd_set      input_mask;
        struct timeval tv;
 
        if (PQsendQueryParams(conn, "SELECT repeat('xyzxz', 12)",
                              0, NULL, NULL, NULL, NULL, 0) != 1)
            pg_fatal("error sending select: %s", PQerrorMessage(conn));
        PQflush(conn);
 
        /*
         * If the server has written anything to us, read (some of) it now.
         */
        FD_ZERO(&input_mask);
        FD_SET(sock, &input_mask);
        tv.tv_sec = 0;
        tv.tv_usec = 0;
        if (select(sock + 1, &input_mask, NULL, NULL, &tv) < 0)
        {
            fprintf(stderr, "select() failed: %m\n");
            exit_nicely(conn);
        }
        if (FD_ISSET(sock, &input_mask) && PQconsumeInput(conn) != 1)
            pg_fatal("failed to read from server: %s", PQerrorMessage(conn));
    }
 
    /* tell server to flush its output buffer */
    if (PQsendFlushRequest(conn) != 1)
        pg_fatal("failed to send flush request");
    PQflush(conn);
 
    /* Now read all results */
    for (;;)
    {
        /* We expect exactly one TUPLES_OK result for each query we sent */
        consume_result_status(conn, PGRES_TUPLES_OK);
 
        /* and one NULL result should follow each */
        consume_null_result(conn);
 
        results++;
 
        /* if we're done, we're done */
        if (results == numqueries)
            break;
    }
 
    fprintf(stderr, "ok\n");
}

References conn, consume_null_result, consume_result_status, exit_nicely(), fprintf, i, pg_fatal, PGRES_TUPLES_OK, PQconsumeInput(), PQenterPipelineMode(), PQerrorMessage(), PQflush(), PQsendFlushRequest(), PQsendQueryParams(), PQsocket(), and select.

Referenced by main().

test_pipeline_abort()

static void test_pipeline_abort ( PGconn *  conn )

static

Definition at line 683 of file libpq_pipeline.c.

{
    PGresult   *res = NULL;
    const char *dummy_params[1] = {"1"};
    Oid         dummy_param_oids[1] = {INT4OID};
    int         i;
    int         gotrows;
    bool        goterror;
 
    fprintf(stderr, "aborted pipeline... ");
 
    res = PQexec(conn, drop_table_sql);
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
        pg_fatal("dispatching DROP TABLE failed: %s", PQerrorMessage(conn));
    PQclear(res);
 
    res = PQexec(conn, create_table_sql);
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
        pg_fatal("dispatching CREATE TABLE failed: %s", PQerrorMessage(conn));
    PQclear(res);
 
    /*
     * Queue up a couple of small pipelines and process each without returning
     * to command mode first. Make sure the second operation in the first
     * pipeline ERRORs.
     */
    if (PQenterPipelineMode(conn) != 1)
        pg_fatal("failed to enter pipeline mode: %s", PQerrorMessage(conn));
 
    dummy_params[0] = "1";
    if (PQsendQueryParams(conn, insert_sql, 1, dummy_param_oids,
                          dummy_params, NULL, NULL, 0) != 1)
        pg_fatal("dispatching first insert failed: %s", PQerrorMessage(conn));
 
    if (PQsendQueryParams(conn, "SELECT no_such_function($1)",
                          1, dummy_param_oids, dummy_params,
                          NULL, NULL, 0) != 1)
        pg_fatal("dispatching error select failed: %s", PQerrorMessage(conn));
 
    dummy_params[0] = "2";
    if (PQsendQueryParams(conn, insert_sql, 1, dummy_param_oids,
                          dummy_params, NULL, NULL, 0) != 1)
        pg_fatal("dispatching second insert failed: %s", PQerrorMessage(conn));
 
    if (PQpipelineSync(conn) != 1)
        pg_fatal("pipeline sync failed: %s", PQerrorMessage(conn));
 
    dummy_params[0] = "3";
    if (PQsendQueryParams(conn, insert_sql, 1, dummy_param_oids,
                          dummy_params, NULL, NULL, 0) != 1)
        pg_fatal("dispatching second-pipeline insert failed: %s",
                 PQerrorMessage(conn));
 
    if (PQpipelineSync(conn) != 1)
        pg_fatal("pipeline sync failed: %s", PQerrorMessage(conn));
 
    /*
     * OK, start processing the pipeline results.
     *
     * We should get a command-ok for the first query, then a fatal error and
     * a pipeline aborted message for the second insert, a pipeline-end, then
     * a command-ok and a pipeline-ok for the second pipeline operation.
     */
    consume_result_status(conn, PGRES_COMMAND_OK);
 
    /* NULL result to signal end-of-results for this command */
    consume_null_result(conn);
 
    /* Second query caused error, so we expect an error next */
    consume_result_status(conn, PGRES_FATAL_ERROR);
 
    /* NULL result to signal end-of-results for this command */
    consume_null_result(conn);
 
    /*
     * pipeline should now be aborted.
     *
     * Note that we could still queue more queries at this point if we wanted;
     * they'd get added to a new third pipeline since we've already sent a
     * second. The aborted flag relates only to the pipeline being received.
     */
    if (PQpipelineStatus(conn) != PQ_PIPELINE_ABORTED)
        pg_fatal("pipeline should be flagged as aborted but isn't");
 
    /* third query in pipeline, the second insert */
    consume_result_status(conn, PGRES_PIPELINE_ABORTED);
 
    /* NULL result to signal end-of-results for this command */
    consume_null_result(conn);
 
    if (PQpipelineStatus(conn) != PQ_PIPELINE_ABORTED)
        pg_fatal("pipeline should be flagged as aborted but isn't");
 
    /* Ensure we're still in pipeline */
    if (PQpipelineStatus(conn) == PQ_PIPELINE_OFF)
        pg_fatal("Fell out of pipeline mode somehow");
 
    /*
     * The end of a failed pipeline is a PGRES_PIPELINE_SYNC.
     *
     * (This is so clients know to start processing results normally again and
     * can tell the difference between skipped commands and the sync.)
     */
    consume_result_status(conn, PGRES_PIPELINE_SYNC);
 
    if (PQpipelineStatus(conn) == PQ_PIPELINE_ABORTED)
        pg_fatal("sync should've cleared the aborted flag but didn't");
 
    /* We're still in pipeline mode... */
    if (PQpipelineStatus(conn) == PQ_PIPELINE_OFF)
        pg_fatal("Fell out of pipeline mode somehow");
 
    /* the insert from the second pipeline */
    consume_result_status(conn, PGRES_COMMAND_OK);
 
    /* Read the NULL result at the end of the command */
    consume_null_result(conn);
 
    /* the second pipeline sync */
    consume_result_status(conn, PGRES_PIPELINE_SYNC);
 
    /* Read the NULL result at the end of the command */
    consume_null_result(conn);
 
    /* Try to send two queries in one command */
    if (PQsendQueryParams(conn, "SELECT 1; SELECT 2", 0, NULL, NULL, NULL, NULL, 0) != 1)
        pg_fatal("failed to send query: %s", PQerrorMessage(conn));
    if (PQpipelineSync(conn) != 1)
        pg_fatal("pipeline sync failed: %s", PQerrorMessage(conn));
    goterror = false;
    while ((res = PQgetResult(conn)) != NULL)
    {
        switch (PQresultStatus(res))
        {
            case PGRES_FATAL_ERROR:
                if (strcmp(PQresultErrorField(res, PG_DIAG_SQLSTATE), "42601") != 0)
                    pg_fatal("expected error about multiple commands, got %s",
                             PQerrorMessage(conn));
                printf("got expected %s", PQerrorMessage(conn));
                goterror = true;
                break;
            default:
                pg_fatal("got unexpected status %s", PQresStatus(PQresultStatus(res)));
                break;
        }
        PQclear(res);
    }
    if (!goterror)
        pg_fatal("did not get cannot-insert-multiple-commands error");
 
    /* the second pipeline sync */
    consume_result_status(conn, PGRES_PIPELINE_SYNC);
 
    fprintf(stderr, "ok\n");
 
    /* Test single-row mode with an error partways */
    if (PQsendQueryParams(conn, "SELECT 1.0/g FROM generate_series(3, -1, -1) g",
                          0, NULL, NULL, NULL, NULL, 0) != 1)
        pg_fatal("failed to send query: %s", PQerrorMessage(conn));
    if (PQpipelineSync(conn) != 1)
        pg_fatal("pipeline sync failed: %s", PQerrorMessage(conn));
    PQsetSingleRowMode(conn);
    goterror = false;
    gotrows = 0;
    while ((res = PQgetResult(conn)) != NULL)
    {
        switch (PQresultStatus(res))
        {
            case PGRES_SINGLE_TUPLE:
                printf("got row: %s\n", PQgetvalue(res, 0, 0));
                gotrows++;
                break;
            case PGRES_FATAL_ERROR:
                if (strcmp(PQresultErrorField(res, PG_DIAG_SQLSTATE), "22012") != 0)
                    pg_fatal("expected division-by-zero, got: %s (%s)",
                             PQerrorMessage(conn),
                             PQresultErrorField(res, PG_DIAG_SQLSTATE));
                printf("got expected division-by-zero\n");
                goterror = true;
                break;
            default:
                pg_fatal("got unexpected result %s", PQresStatus(PQresultStatus(res)));
        }
        PQclear(res);
    }
    if (!goterror)
        pg_fatal("did not get division-by-zero error");
    if (gotrows != 3)
        pg_fatal("did not get three rows");
 
    /* the third pipeline sync */
    consume_result_status(conn, PGRES_PIPELINE_SYNC);
 
    /* We're still in pipeline mode... */
    if (PQpipelineStatus(conn) == PQ_PIPELINE_OFF)
        pg_fatal("Fell out of pipeline mode somehow");
 
    /* until we end it, which we can safely do now */
    if (PQexitPipelineMode(conn) != 1)
        pg_fatal("attempt to exit pipeline mode failed when it should've succeeded: %s",
                 PQerrorMessage(conn));
 
    if (PQpipelineStatus(conn) != PQ_PIPELINE_OFF)
        pg_fatal("exiting pipeline mode didn't seem to work");
 
    /*-
     * Since we fired the pipelines off without a surrounding xact, the results
     * should be:
     *
     * - Implicit xact started by server around 1st pipeline
     * - First insert applied
     * - Second statement aborted xact
     * - Third insert skipped
     * - Sync rolled back first implicit xact
     * - Implicit xact created by server around 2nd pipeline
     * - insert applied from 2nd pipeline
     * - Sync commits 2nd xact
     *
     * So we should only have the value 3 that we inserted.
     */
    res = PQexec(conn, "SELECT itemno FROM pq_pipeline_demo");
 
    if (PQresultStatus(res) != PGRES_TUPLES_OK)
        pg_fatal("Expected tuples, got %s: %s",
                 PQresStatus(PQresultStatus(res)), PQerrorMessage(conn));
    if (PQntuples(res) != 1)
        pg_fatal("expected 1 result, got %d", PQntuples(res));
    for (i = 0; i < PQntuples(res); i++)
    {
        const char *val = PQgetvalue(res, i, 0);
 
        if (strcmp(val, "3") != 0)
            pg_fatal("expected only insert with value 3, got %s", val);
    }
 
    PQclear(res);
 
    fprintf(stderr, "ok\n");
}

References conn, consume_null_result, consume_result_status, create_table_sql, drop_table_sql, fprintf, i, insert_sql, PG_DIAG_SQLSTATE, pg_fatal, PGRES_COMMAND_OK, PGRES_FATAL_ERROR, PGRES_PIPELINE_ABORTED, PGRES_PIPELINE_SYNC, PGRES_SINGLE_TUPLE, PGRES_TUPLES_OK, PQ_PIPELINE_ABORTED, PQ_PIPELINE_OFF, PQclear, PQenterPipelineMode(), PQerrorMessage(), PQexec(), PQexitPipelineMode(), PQgetResult, PQgetvalue, PQntuples, PQpipelineStatus(), PQpipelineSync(), PQresStatus(), PQresultErrorField, PQresultStatus, PQsendQueryParams(), PQsetSingleRowMode(), printf, and val.

Referenced by main().

test_pipeline_idle()

static void test_pipeline_idle ( PGconn *  conn )

static

Definition at line 1440 of file libpq_pipeline.c.

{
    int         n_notices = 0;
 
    fprintf(stderr, "\npipeline idle...\n");
 
    PQsetNoticeProcessor(conn, notice_processor, &n_notices);
 
    /* Try to exit pipeline mode in pipeline-idle state */
    if (PQenterPipelineMode(conn) != 1)
        pg_fatal("failed to enter pipeline mode: %s", PQerrorMessage(conn));
    if (PQsendQueryParams(conn, "SELECT 1", 0, NULL, NULL, NULL, NULL, 0) != 1)
        pg_fatal("failed to send query: %s", PQerrorMessage(conn));
    PQsendFlushRequest(conn);
 
    consume_result_status(conn, PGRES_TUPLES_OK);
 
    consume_null_result(conn);
 
    if (PQsendQueryParams(conn, "SELECT 2", 0, NULL, NULL, NULL, NULL, 0) != 1)
        pg_fatal("failed to send query: %s", PQerrorMessage(conn));
    if (PQexitPipelineMode(conn) == 1)
        pg_fatal("exiting pipeline succeeded when it shouldn't");
    if (strncmp(PQerrorMessage(conn), "cannot exit pipeline mode",
                strlen("cannot exit pipeline mode")) != 0)
        pg_fatal("did not get expected error; got: %s",
                 PQerrorMessage(conn));
    PQsendFlushRequest(conn);
 
    consume_result_status(conn, PGRES_TUPLES_OK);
 
    consume_null_result(conn);
 
    if (PQexitPipelineMode(conn) != 1)
        pg_fatal("exiting pipeline failed: %s", PQerrorMessage(conn));
 
    if (n_notices > 0)
        pg_fatal("got %d notice(s)", n_notices);
    fprintf(stderr, "ok - 1\n");
 
    /* Have a WARNING in the middle of a resultset */
    if (PQenterPipelineMode(conn) != 1)
        pg_fatal("entering pipeline mode failed: %s", PQerrorMessage(conn));
    if (PQsendQueryParams(conn, "SELECT pg_catalog.pg_advisory_unlock(1,1)", 0, NULL, NULL, NULL, NULL, 0) != 1)
        pg_fatal("failed to send query: %s", PQerrorMessage(conn));
    PQsendFlushRequest(conn);
 
    consume_result_status(conn, PGRES_TUPLES_OK);
 
    if (PQexitPipelineMode(conn) != 1)
        pg_fatal("failed to exit pipeline mode: %s", PQerrorMessage(conn));
    fprintf(stderr, "ok - 2\n");
}

References conn, consume_null_result, consume_result_status, fprintf, notice_processor(), pg_fatal, PGRES_TUPLES_OK, PQenterPipelineMode(), PQerrorMessage(), PQexitPipelineMode(), PQsendFlushRequest(), PQsendQueryParams(), and PQsetNoticeProcessor().

Referenced by main().

test_pipelined_insert()

static void test_pipelined_insert ( PGconn *  conn, int  n_rows  )

static

Definition at line 937 of file libpq_pipeline.c.

{
    Oid         insert_param_oids[2] = {INT4OID, INT8OID};
    const char *insert_params[2];
    char        insert_param_0[MAXINTLEN];
    char        insert_param_1[MAXINT8LEN];
    enum PipelineInsertStep send_step = BI_BEGIN_TX,
                recv_step = BI_BEGIN_TX;
    int         rows_to_send,
                rows_to_receive;
 
    insert_params[0] = insert_param_0;
    insert_params[1] = insert_param_1;
 
    rows_to_send = rows_to_receive = n_rows;
 
    /*
     * Do a pipelined insert into a table created at the start of the pipeline
     */
    if (PQenterPipelineMode(conn) != 1)
        pg_fatal("failed to enter pipeline mode: %s", PQerrorMessage(conn));
 
    while (send_step != BI_PREPARE)
    {
        const char *sql;
 
        switch (send_step)
        {
            case BI_BEGIN_TX:
                sql = "BEGIN TRANSACTION";
                send_step = BI_DROP_TABLE;
                break;
 
            case BI_DROP_TABLE:
                sql = drop_table_sql;
                send_step = BI_CREATE_TABLE;
                break;
 
            case BI_CREATE_TABLE:
                sql = create_table_sql;
                send_step = BI_PREPARE;
                break;
 
            default:
                pg_fatal("invalid state");
                sql = NULL;     /* keep compiler quiet */
        }
 
        pg_debug("sending: %s\n", sql);
        if (PQsendQueryParams(conn, sql,
                              0, NULL, NULL, NULL, NULL, 0) != 1)
            pg_fatal("dispatching %s failed: %s", sql, PQerrorMessage(conn));
    }
 
    Assert(send_step == BI_PREPARE);
    pg_debug("sending: %s\n", insert_sql2);
    if (PQsendPrepare(conn, "my_insert", insert_sql2, 2, insert_param_oids) != 1)
        pg_fatal("dispatching PREPARE failed: %s", PQerrorMessage(conn));
    send_step = BI_INSERT_ROWS;
 
    /*
     * Now we start inserting. We'll be sending enough data that we could fill
     * our output buffer, so to avoid deadlocking we need to enter nonblocking
     * mode and consume input while we send more output. As results of each
     * query are processed we should pop them to allow processing of the next
     * query. There's no need to finish the pipeline before processing
     * results.
     */
    if (PQsetnonblocking(conn, 1) != 0)
        pg_fatal("failed to set nonblocking mode: %s", PQerrorMessage(conn));
 
    while (recv_step != BI_DONE)
    {
        int         sock;
        fd_set      input_mask;
        fd_set      output_mask;
 
        sock = PQsocket(conn);
 
        if (sock < 0)
            break;              /* shouldn't happen */
 
        FD_ZERO(&input_mask);
        FD_SET(sock, &input_mask);
        FD_ZERO(&output_mask);
        FD_SET(sock, &output_mask);
 
        if (select(sock + 1, &input_mask, &output_mask, NULL, NULL) < 0)
        {
            fprintf(stderr, "select() failed: %m\n");
            exit_nicely(conn);
        }
 
        /*
         * Process any results, so we keep the server's output buffer free
         * flowing and it can continue to process input
         */
        if (FD_ISSET(sock, &input_mask))
        {
            PQconsumeInput(conn);
 
            /* Read until we'd block if we tried to read */
            while (!PQisBusy(conn) && recv_step < BI_DONE)
            {
                PGresult   *res;
                const char *cmdtag = "";
                const char *description = "";
                int         status;
 
                /*
                 * Read next result.  If no more results from this query,
                 * advance to the next query
                 */
                res = PQgetResult(conn);
                if (res == NULL)
                    continue;
 
                status = PGRES_COMMAND_OK;
                switch (recv_step)
                {
                    case BI_BEGIN_TX:
                        cmdtag = "BEGIN";
                        recv_step++;
                        break;
                    case BI_DROP_TABLE:
                        cmdtag = "DROP TABLE";
                        recv_step++;
                        break;
                    case BI_CREATE_TABLE:
                        cmdtag = "CREATE TABLE";
                        recv_step++;
                        break;
                    case BI_PREPARE:
                        cmdtag = "";
                        description = "PREPARE";
                        recv_step++;
                        break;
                    case BI_INSERT_ROWS:
                        cmdtag = "INSERT";
                        rows_to_receive--;
                        if (rows_to_receive == 0)
                            recv_step++;
                        break;
                    case BI_COMMIT_TX:
                        cmdtag = "COMMIT";
                        recv_step++;
                        break;
                    case BI_SYNC:
                        cmdtag = "";
                        description = "SYNC";
                        status = PGRES_PIPELINE_SYNC;
                        recv_step++;
                        break;
                    case BI_DONE:
                        /* unreachable */
                        pg_fatal("unreachable state");
                }
 
                if (PQresultStatus(res) != status)
                    pg_fatal("%s reported status %s, expected %s\n"
                             "Error message: \"%s\"",
                             description, PQresStatus(PQresultStatus(res)),
                             PQresStatus(status), PQerrorMessage(conn));
 
                if (strncmp(PQcmdStatus(res), cmdtag, strlen(cmdtag)) != 0)
                    pg_fatal("%s expected command tag '%s', got '%s'",
                             description, cmdtag, PQcmdStatus(res));
 
                pg_debug("Got %s OK\n", cmdtag[0] != '\0' ? cmdtag : description);
 
                PQclear(res);
            }
        }
 
        /* Write more rows and/or the end pipeline message, if needed */
        if (FD_ISSET(sock, &output_mask))
        {
            PQflush(conn);
 
            if (send_step == BI_INSERT_ROWS)
            {
                snprintf(insert_param_0, MAXINTLEN, "%d", rows_to_send);
                /* use up some buffer space with a wide value */
                snprintf(insert_param_1, MAXINT8LEN, "%lld", 1LL << 62);
 
                if (PQsendQueryPrepared(conn, "my_insert",
                                        2, insert_params, NULL, NULL, 0) == 1)
                {
                    pg_debug("sent row %d\n", rows_to_send);
 
                    rows_to_send--;
                    if (rows_to_send == 0)
                        send_step++;
                }
                else
                {
                    /*
                     * in nonblocking mode, so it's OK for an insert to fail
                     * to send
                     */
                    fprintf(stderr, "WARNING: failed to send insert #%d: %s\n",
                            rows_to_send, PQerrorMessage(conn));
                }
            }
            else if (send_step == BI_COMMIT_TX)
            {
                if (PQsendQueryParams(conn, "COMMIT",
                                      0, NULL, NULL, NULL, NULL, 0) == 1)
                {
                    pg_debug("sent COMMIT\n");
                    send_step++;
                }
                else
                {
                    fprintf(stderr, "WARNING: failed to send commit: %s\n",
                            PQerrorMessage(conn));
                }
            }
            else if (send_step == BI_SYNC)
            {
                if (PQpipelineSync(conn) == 1)
                {
                    fprintf(stdout, "pipeline sync sent\n");
                    send_step++;
                }
                else
                {
                    fprintf(stderr, "WARNING: pipeline sync failed: %s\n",
                            PQerrorMessage(conn));
                }
            }
        }
    }
 
    /* We've got the sync message and the pipeline should be done */
    if (PQexitPipelineMode(conn) != 1)
        pg_fatal("attempt to exit pipeline mode failed when it should've succeeded: %s",
                 PQerrorMessage(conn));
 
    if (PQsetnonblocking(conn, 0) != 0)
        pg_fatal("failed to clear nonblocking mode: %s", PQerrorMessage(conn));
 
    fprintf(stderr, "ok\n");
}

References Assert(), BI_BEGIN_TX, BI_COMMIT_TX, BI_CREATE_TABLE, BI_DONE, BI_DROP_TABLE, BI_INSERT_ROWS, BI_PREPARE, BI_SYNC, conn, create_table_sql, description, drop_table_sql, exit_nicely(), fprintf, insert_sql2, MAXINT8LEN, MAXINTLEN, pg_debug, pg_fatal, PGRES_COMMAND_OK, PGRES_PIPELINE_SYNC, PQclear, PQcmdStatus, PQconsumeInput(), PQenterPipelineMode(), PQerrorMessage(), PQexitPipelineMode(), PQflush(), PQgetResult, PQisBusy(), PQpipelineSync(), PQresStatus(), PQresultStatus, PQsendPrepare(), PQsendQueryParams(), PQsendQueryPrepared(), PQsetnonblocking(), PQsocket(), select, snprintf, and generate_unaccent_rules::stdout.

Referenced by main().

test_prepared()

static void test_prepared ( PGconn *  conn )

static

Definition at line 1183 of file libpq_pipeline.c.

{
    PGresult   *res = NULL;
    Oid         param_oids[1] = {INT4OID};
    Oid         expected_oids[4];
    Oid         typ;
 
    fprintf(stderr, "prepared... ");
 
    if (PQenterPipelineMode(conn) != 1)
        pg_fatal("failed to enter pipeline mode: %s", PQerrorMessage(conn));
    if (PQsendPrepare(conn, "select_one", "SELECT $1, '42', $1::numeric, "
                      "interval '1 sec'",
                      1, param_oids) != 1)
        pg_fatal("preparing query failed: %s", PQerrorMessage(conn));
    expected_oids[0] = INT4OID;
    expected_oids[1] = TEXTOID;
    expected_oids[2] = NUMERICOID;
    expected_oids[3] = INTERVALOID;
    if (PQsendDescribePrepared(conn, "select_one") != 1)
        pg_fatal("failed to send describePrepared: %s", PQerrorMessage(conn));
    if (PQpipelineSync(conn) != 1)
        pg_fatal("pipeline sync failed: %s", PQerrorMessage(conn));
 
    consume_result_status(conn, PGRES_COMMAND_OK);
 
    consume_null_result(conn);
 
    res = confirm_result_status(conn, PGRES_COMMAND_OK);
    if (PQnfields(res) != lengthof(expected_oids))
        pg_fatal("expected %zu columns, got %d",
                 lengthof(expected_oids), PQnfields(res));
    for (int i = 0; i < PQnfields(res); i++)
    {
        typ = PQftype(res, i);
        if (typ != expected_oids[i])
            pg_fatal("field %d: expected type %u, got %u",
                     i, expected_oids[i], typ);
    }
    PQclear(res);
 
    consume_null_result(conn);
 
    consume_result_status(conn, PGRES_PIPELINE_SYNC);
 
    fprintf(stderr, "closing statement..");
    if (PQsendClosePrepared(conn, "select_one") != 1)
        pg_fatal("PQsendClosePrepared failed: %s", PQerrorMessage(conn));
    if (PQpipelineSync(conn) != 1)
        pg_fatal("pipeline sync failed: %s", PQerrorMessage(conn));
 
    consume_result_status(conn, PGRES_COMMAND_OK);
 
    consume_null_result(conn);
 
    consume_result_status(conn, PGRES_PIPELINE_SYNC);
 
    if (PQexitPipelineMode(conn) != 1)
        pg_fatal("could not exit pipeline mode: %s", PQerrorMessage(conn));
 
    /* Now that it's closed we should get an error when describing */
    res = PQdescribePrepared(conn, "select_one");
    if (PQresultStatus(res) != PGRES_FATAL_ERROR)
        pg_fatal("expected FATAL_ERROR, got %s", PQresStatus(PQresultStatus(res)));
    PQclear(res);
 
    /*
     * Also test the blocking close, this should not fail since closing a
     * non-existent prepared statement is a no-op
     */
    res = PQclosePrepared(conn, "select_one");
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
        pg_fatal("expected COMMAND_OK, got %s", PQresStatus(PQresultStatus(res)));
    PQclear(res);
 
    fprintf(stderr, "creating portal... ");
 
    res = PQexec(conn, "BEGIN");
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
        pg_fatal("BEGIN failed: %s", PQerrorMessage(conn));
    PQclear(res);
 
    res = PQexec(conn, "DECLARE cursor_one CURSOR FOR SELECT 1");
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
        pg_fatal("DECLARE CURSOR failed: %s", PQerrorMessage(conn));
    PQclear(res);
 
    PQenterPipelineMode(conn);
    if (PQsendDescribePortal(conn, "cursor_one") != 1)
        pg_fatal("PQsendDescribePortal failed: %s", PQerrorMessage(conn));
    if (PQpipelineSync(conn) != 1)
        pg_fatal("pipeline sync failed: %s", PQerrorMessage(conn));
 
    res = confirm_result_status(conn, PGRES_COMMAND_OK);
    typ = PQftype(res, 0);
    if (typ != INT4OID)
        pg_fatal("portal: expected type %u, got %u",
                 INT4OID, typ);
    PQclear(res);
 
    consume_null_result(conn);
 
    consume_result_status(conn, PGRES_PIPELINE_SYNC);
 
    fprintf(stderr, "closing portal... ");
    if (PQsendClosePortal(conn, "cursor_one") != 1)
        pg_fatal("PQsendClosePortal failed: %s", PQerrorMessage(conn));
    if (PQpipelineSync(conn) != 1)
        pg_fatal("pipeline sync failed: %s", PQerrorMessage(conn));
 
    consume_result_status(conn, PGRES_COMMAND_OK);
 
    consume_null_result(conn);
 
    consume_result_status(conn, PGRES_PIPELINE_SYNC);
 
    if (PQexitPipelineMode(conn) != 1)
        pg_fatal("could not exit pipeline mode: %s", PQerrorMessage(conn));
 
    /* Now that it's closed we should get an error when describing */
    res = PQdescribePortal(conn, "cursor_one");
    if (PQresultStatus(res) != PGRES_FATAL_ERROR)
        pg_fatal("expected FATAL_ERROR, got %s", PQresStatus(PQresultStatus(res)));
    PQclear(res);
 
    /*
     * Also test the blocking close, this should not fail since closing a
     * non-existent portal is a no-op
     */
    res = PQclosePortal(conn, "cursor_one");
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
        pg_fatal("expected COMMAND_OK, got %s", PQresStatus(PQresultStatus(res)));
    PQclear(res);
 
    fprintf(stderr, "ok\n");
}

References confirm_result_status, conn, consume_null_result, consume_result_status, fprintf, i, lengthof, pg_fatal, PGRES_COMMAND_OK, PGRES_FATAL_ERROR, PGRES_PIPELINE_SYNC, PQclear, PQclosePortal(), PQclosePrepared(), PQdescribePortal(), PQdescribePrepared(), PQenterPipelineMode(), PQerrorMessage(), PQexec(), PQexitPipelineMode(), PQftype(), PQnfields, PQpipelineSync(), PQresStatus(), PQresultStatus, PQsendClosePortal(), PQsendClosePrepared(), PQsendDescribePortal(), PQsendDescribePrepared(), and PQsendPrepare().

Referenced by main().

test_protocol_version()

static void test_protocol_version ( PGconn *  conn )

static

Definition at line 1324 of file libpq_pipeline.c.

{
    const char **keywords;
    const char **vals;
    int         nopts;
    PQconninfoOption *opts = PQconninfo(conn);
    int         protocol_version;
    int         max_protocol_version_index;
    int         i;
 
    /*
     * Prepare keywords/vals arrays, copied from the existing connection, with
     * an extra slot for 'max_protocol_version'.
     */
    nopts = 0;
    for (PQconninfoOption *opt = opts; opt->keyword != NULL; ++opt)
        nopts++;
    nopts++;                    /* max_protocol_version */
    nopts++;                    /* NULL terminator */
 
    keywords = pg_malloc0(sizeof(char *) * nopts);
    vals = pg_malloc0(sizeof(char *) * nopts);
 
    i = 0;
    for (PQconninfoOption *opt = opts; opt->keyword != NULL; ++opt)
    {
        if (opt->val)
        {
            keywords[i] = opt->keyword;
            vals[i] = opt->val;
            i++;
        }
    }
 
    max_protocol_version_index = i;
    keywords[i] = "max_protocol_version";   /* value is filled in below */
    i++;
    keywords[i] = vals[i] = NULL;
 
    /*
     * Test max_protocol_version=3.0
     */
    vals[max_protocol_version_index] = "3.0";
    conn = PQconnectdbParams(keywords, vals, false);
 
    if (PQstatus(conn) != CONNECTION_OK)
        pg_fatal("Connection to database failed: %s",
                 PQerrorMessage(conn));
 
    protocol_version = PQfullProtocolVersion(conn);
    if (protocol_version != 30000)
        pg_fatal("expected 30000, got %d", protocol_version);
 
    PQfinish(conn);
 
    /*
     * Test max_protocol_version=3.1. It's not valid, we went straight from
     * 3.0 to 3.2.
     */
    vals[max_protocol_version_index] = "3.1";
    conn = PQconnectdbParams(keywords, vals, false);
 
    if (PQstatus(conn) != CONNECTION_BAD)
        pg_fatal("Connecting with max_protocol_version 3.1 should have failed.");
 
    PQfinish(conn);
 
    /*
     * Test max_protocol_version=3.2
     */
    vals[max_protocol_version_index] = "3.2";
    conn = PQconnectdbParams(keywords, vals, false);
 
    if (PQstatus(conn) != CONNECTION_OK)
        pg_fatal("Connection to database failed: %s",
                 PQerrorMessage(conn));
 
    protocol_version = PQfullProtocolVersion(conn);
    if (protocol_version != 30002)
        pg_fatal("expected 30002, got %d", protocol_version);
 
    PQfinish(conn);
 
    /*
     * Test max_protocol_version=latest. 'latest' currently means '3.2'.
     */
    vals[max_protocol_version_index] = "latest";
    conn = PQconnectdbParams(keywords, vals, false);
 
    if (PQstatus(conn) != CONNECTION_OK)
        pg_fatal("Connection to database failed: %s",
                 PQerrorMessage(conn));
 
    protocol_version = PQfullProtocolVersion(conn);
    if (protocol_version != 30002)
        pg_fatal("expected 30002, got %d", protocol_version);
 
    PQfinish(conn);
 
    pfree(keywords);
    pfree(vals);
    PQconninfoFree(opts);
}

References conn, CONNECTION_BAD, CONNECTION_OK, i, JsonPathKeyword::keyword, keywords, opts, pfree(), pg_fatal, pg_malloc0(), PQconnectdbParams(), PQconninfo(), PQconninfoFree(), PQerrorMessage(), PQfinish(), PQfullProtocolVersion(), and PQstatus().

Referenced by main().

test_simple_pipeline()

static void test_simple_pipeline ( PGconn *  conn )

static

Definition at line 1495 of file libpq_pipeline.c.

{
    const char *dummy_params[1] = {"1"};
    Oid         dummy_param_oids[1] = {INT4OID};
 
    fprintf(stderr, "simple pipeline... ");
 
    /*
     * Enter pipeline mode and dispatch a set of operations, which we'll then
     * process the results of as they come in.
     *
     * For a simple case we should be able to do this without interim
     * processing of results since our output buffer will give us enough slush
     * to work with and we won't block on sending. So blocking mode is fine.
     */
    if (PQisnonblocking(conn))
        pg_fatal("Expected blocking connection mode");
 
    if (PQenterPipelineMode(conn) != 1)
        pg_fatal("failed to enter pipeline mode: %s", PQerrorMessage(conn));
 
    if (PQsendQueryParams(conn, "SELECT $1",
                          1, dummy_param_oids, dummy_params,
                          NULL, NULL, 0) != 1)
        pg_fatal("dispatching SELECT failed: %s", PQerrorMessage(conn));
 
    if (PQexitPipelineMode(conn) != 0)
        pg_fatal("exiting pipeline mode with work in progress should fail, but succeeded");
 
    if (PQpipelineSync(conn) != 1)
        pg_fatal("pipeline sync failed: %s", PQerrorMessage(conn));
 
    consume_result_status(conn, PGRES_TUPLES_OK);
 
    consume_null_result(conn);
 
    /*
     * Even though we've processed the result there's still a sync to come and
     * we can't exit pipeline mode yet
     */
    if (PQexitPipelineMode(conn) != 0)
        pg_fatal("exiting pipeline mode after query but before sync succeeded incorrectly");
 
    consume_result_status(conn, PGRES_PIPELINE_SYNC);
 
    consume_null_result(conn);
 
    /* We're still in pipeline mode... */
    if (PQpipelineStatus(conn) == PQ_PIPELINE_OFF)
        pg_fatal("Fell out of pipeline mode somehow");
 
    /* ... until we end it, which we can safely do now */
    if (PQexitPipelineMode(conn) != 1)
        pg_fatal("attempt to exit pipeline mode failed when it should've succeeded: %s",
                 PQerrorMessage(conn));
 
    if (PQpipelineStatus(conn) != PQ_PIPELINE_OFF)
        pg_fatal("Exiting pipeline mode didn't seem to work");
 
    fprintf(stderr, "ok\n");
}

References conn, consume_null_result, consume_result_status, fprintf, pg_fatal, PGRES_PIPELINE_SYNC, PGRES_TUPLES_OK, PQ_PIPELINE_OFF, PQenterPipelineMode(), PQerrorMessage(), PQexitPipelineMode(), PQisnonblocking(), PQpipelineStatus(), PQpipelineSync(), and PQsendQueryParams().

Referenced by main().

test_singlerowmode()

static void test_singlerowmode ( PGconn *  conn )

static

Definition at line 1558 of file libpq_pipeline.c.

{
    PGresult   *res;
    int         i;
    bool        pipeline_ended = false;
 
    if (PQenterPipelineMode(conn) != 1)
        pg_fatal("failed to enter pipeline mode: %s",
                 PQerrorMessage(conn));
 
    /* One series of three commands, using single-row mode for the first two. */
    for (i = 0; i < 3; i++)
    {
        char       *param[1];
 
        param[0] = psprintf("%d", 44 + i);
 
        if (PQsendQueryParams(conn,
                              "SELECT generate_series(42, $1)",
                              1,
                              NULL,
                              (const char **) param,
                              NULL,
                              NULL,
                              0) != 1)
            pg_fatal("failed to send query: %s",
                     PQerrorMessage(conn));
        pfree(param[0]);
    }
    if (PQpipelineSync(conn) != 1)
        pg_fatal("pipeline sync failed: %s", PQerrorMessage(conn));
 
    for (i = 0; !pipeline_ended; i++)
    {
        bool        first = true;
        bool        saw_ending_tuplesok;
        bool        isSingleTuple = false;
 
        /* Set single row mode for only first 2 SELECT queries */
        if (i < 2)
        {
            if (PQsetSingleRowMode(conn) != 1)
                pg_fatal("PQsetSingleRowMode() failed for i=%d", i);
        }
 
        /* Consume rows for this query */
        saw_ending_tuplesok = false;
        while ((res = PQgetResult(conn)) != NULL)
        {
            ExecStatusType est = PQresultStatus(res);
 
            if (est == PGRES_PIPELINE_SYNC)
            {
                fprintf(stderr, "end of pipeline reached\n");
                pipeline_ended = true;
                PQclear(res);
                if (i != 3)
                    pg_fatal("Expected three results, got %d", i);
                break;
            }
 
            /* Expect SINGLE_TUPLE for queries 0 and 1, TUPLES_OK for 2 */
            if (first)
            {
                if (i <= 1 && est != PGRES_SINGLE_TUPLE)
                    pg_fatal("Expected PGRES_SINGLE_TUPLE for query %d, got %s",
                             i, PQresStatus(est));
                if (i >= 2 && est != PGRES_TUPLES_OK)
                    pg_fatal("Expected PGRES_TUPLES_OK for query %d, got %s",
                             i, PQresStatus(est));
                first = false;
            }
 
            fprintf(stderr, "Result status %s for query %d", PQresStatus(est), i);
            switch (est)
            {
                case PGRES_TUPLES_OK:
                    fprintf(stderr, ", tuples: %d\n", PQntuples(res));
                    saw_ending_tuplesok = true;
                    if (isSingleTuple)
                    {
                        if (PQntuples(res) == 0)
                            fprintf(stderr, "all tuples received in query %d\n", i);
                        else
                            pg_fatal("Expected to follow PGRES_SINGLE_TUPLE, but received PGRES_TUPLES_OK directly instead");
                    }
                    break;
 
                case PGRES_SINGLE_TUPLE:
                    isSingleTuple = true;
                    fprintf(stderr, ", %d tuple: %s\n", PQntuples(res), PQgetvalue(res, 0, 0));
                    break;
 
                default:
                    pg_fatal("unexpected");
            }
            PQclear(res);
        }
        if (!pipeline_ended && !saw_ending_tuplesok)
            pg_fatal("didn't get expected terminating TUPLES_OK");
    }
 
    /*
     * Now issue one command, get its results in with single-row mode, then
     * issue another command, and get its results in normal mode; make sure
     * the single-row mode flag is reset as expected.
     */
    if (PQsendQueryParams(conn, "SELECT generate_series(0, 0)",
                          0, NULL, NULL, NULL, NULL, 0) != 1)
        pg_fatal("failed to send query: %s",
                 PQerrorMessage(conn));
    if (PQsendFlushRequest(conn) != 1)
        pg_fatal("failed to send flush request");
    if (PQsetSingleRowMode(conn) != 1)
        pg_fatal("PQsetSingleRowMode() failed");
 
    consume_result_status(conn, PGRES_SINGLE_TUPLE);
 
    consume_result_status(conn, PGRES_TUPLES_OK);
 
    consume_null_result(conn);
 
    if (PQsendQueryParams(conn, "SELECT 1",
                          0, NULL, NULL, NULL, NULL, 0) != 1)
        pg_fatal("failed to send query: %s",
                 PQerrorMessage(conn));
    if (PQsendFlushRequest(conn) != 1)
        pg_fatal("failed to send flush request");
 
    consume_result_status(conn, PGRES_TUPLES_OK);
 
    consume_null_result(conn);
 
    /*
     * Try chunked mode as well; make sure that it correctly delivers a
     * partial final chunk.
     */
    if (PQsendQueryParams(conn, "SELECT generate_series(1, 5)",
                          0, NULL, NULL, NULL, NULL, 0) != 1)
        pg_fatal("failed to send query: %s",
                 PQerrorMessage(conn));
    if (PQsendFlushRequest(conn) != 1)
        pg_fatal("failed to send flush request");
    if (PQsetChunkedRowsMode(conn, 3) != 1)
        pg_fatal("PQsetChunkedRowsMode() failed");
 
    res = confirm_result_status(conn, PGRES_TUPLES_CHUNK);
    if (PQntuples(res) != 3)
        pg_fatal("Expected 3 rows, got %d", PQntuples(res));
    PQclear(res);
 
    res = confirm_result_status(conn, PGRES_TUPLES_CHUNK);
    if (PQntuples(res) != 2)
        pg_fatal("Expected 2 rows, got %d", PQntuples(res));
    PQclear(res);
 
    res = confirm_result_status(conn, PGRES_TUPLES_OK);
    if (PQntuples(res) != 0)
        pg_fatal("Expected 0 rows, got %d", PQntuples(res));
    PQclear(res);
 
    consume_null_result(conn);
 
    if (PQexitPipelineMode(conn) != 1)
        pg_fatal("failed to end pipeline mode: %s", PQerrorMessage(conn));
 
    fprintf(stderr, "ok\n");
}

References confirm_result_status, conn, consume_null_result, consume_result_status, fprintf, i, pfree(), pg_fatal, PGRES_PIPELINE_SYNC, PGRES_SINGLE_TUPLE, PGRES_TUPLES_CHUNK, PGRES_TUPLES_OK, PQclear, PQenterPipelineMode(), PQerrorMessage(), PQexitPipelineMode(), PQgetResult, PQgetvalue, PQntuples, PQpipelineSync(), PQresStatus(), PQresultStatus, PQsendFlushRequest(), PQsendQueryParams(), PQsetChunkedRowsMode(), PQsetSingleRowMode(), and psprintf().

Referenced by main().

test_transaction()

static void test_transaction ( PGconn *  conn )

static

Definition at line 1732 of file libpq_pipeline.c.

{
    PGresult   *res;
    bool        expect_null;
    int         num_syncs = 0;
 
    res = PQexec(conn, "DROP TABLE IF EXISTS pq_pipeline_tst;"
                 "CREATE TABLE pq_pipeline_tst (id int)");
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
        pg_fatal("failed to create test table: %s",
                 PQerrorMessage(conn));
    PQclear(res);
 
    if (PQenterPipelineMode(conn) != 1)
        pg_fatal("failed to enter pipeline mode: %s",
                 PQerrorMessage(conn));
    if (PQsendPrepare(conn, "rollback", "ROLLBACK", 0, NULL) != 1)
        pg_fatal("could not send prepare on pipeline: %s",
                 PQerrorMessage(conn));
 
    if (PQsendQueryParams(conn,
                          "BEGIN",
                          0, NULL, NULL, NULL, NULL, 0) != 1)
        pg_fatal("failed to send query: %s",
                 PQerrorMessage(conn));
    if (PQsendQueryParams(conn,
                          "SELECT 0/0",
                          0, NULL, NULL, NULL, NULL, 0) != 1)
        pg_fatal("failed to send query: %s",
                 PQerrorMessage(conn));
 
    /*
     * send a ROLLBACK using a prepared stmt. Doesn't work because we need to
     * get out of the pipeline-aborted state first.
     */
    if (PQsendQueryPrepared(conn, "rollback", 0, NULL, NULL, NULL, 1) != 1)
        pg_fatal("failed to execute prepared: %s",
                 PQerrorMessage(conn));
 
    /* This insert fails because we're in pipeline-aborted state */
    if (PQsendQueryParams(conn,
                          "INSERT INTO pq_pipeline_tst VALUES (1)",
                          0, NULL, NULL, NULL, NULL, 0) != 1)
        pg_fatal("failed to send query: %s",
                 PQerrorMessage(conn));
    if (PQpipelineSync(conn) != 1)
        pg_fatal("pipeline sync failed: %s", PQerrorMessage(conn));
    num_syncs++;
 
    /*
     * This insert fails even though the pipeline got a SYNC, because we're in
     * an aborted transaction
     */
    if (PQsendQueryParams(conn,
                          "INSERT INTO pq_pipeline_tst VALUES (2)",
                          0, NULL, NULL, NULL, NULL, 0) != 1)
        pg_fatal("failed to send query: %s",
                 PQerrorMessage(conn));
    if (PQpipelineSync(conn) != 1)
        pg_fatal("pipeline sync failed: %s", PQerrorMessage(conn));
    num_syncs++;
 
    /*
     * Send ROLLBACK using prepared stmt. This one works because we just did
     * PQpipelineSync above.
     */
    if (PQsendQueryPrepared(conn, "rollback", 0, NULL, NULL, NULL, 1) != 1)
        pg_fatal("failed to execute prepared: %s",
                 PQerrorMessage(conn));
 
    /*
     * Now that we're out of a transaction and in pipeline-good mode, this
     * insert works
     */
    if (PQsendQueryParams(conn,
                          "INSERT INTO pq_pipeline_tst VALUES (3)",
                          0, NULL, NULL, NULL, NULL, 0) != 1)
        pg_fatal("failed to send query: %s",
                 PQerrorMessage(conn));
    /* Send two syncs now -- match up to SYNC messages below */
    if (PQpipelineSync(conn) != 1)
        pg_fatal("pipeline sync failed: %s", PQerrorMessage(conn));
    num_syncs++;
    if (PQpipelineSync(conn) != 1)
        pg_fatal("pipeline sync failed: %s", PQerrorMessage(conn));
    num_syncs++;
 
    expect_null = false;
    for (int i = 0;; i++)
    {
        ExecStatusType restype;
 
        res = PQgetResult(conn);
        if (res == NULL)
        {
            printf("%d: got NULL result\n", i);
            if (!expect_null)
                pg_fatal("did not expect NULL here");
            expect_null = false;
            continue;
        }
        restype = PQresultStatus(res);
        printf("%d: got status %s", i, PQresStatus(restype));
        if (expect_null)
            pg_fatal("expected NULL");
        if (restype == PGRES_FATAL_ERROR)
            printf("; error: %s", PQerrorMessage(conn));
        else if (restype == PGRES_PIPELINE_ABORTED)
        {
            printf(": command didn't run because pipeline aborted\n");
        }
        else
            printf("\n");
        PQclear(res);
 
        if (restype == PGRES_PIPELINE_SYNC)
            num_syncs--;
        else
            expect_null = true;
        if (num_syncs <= 0)
            break;
    }
 
    consume_null_result(conn);
 
    if (PQexitPipelineMode(conn) != 1)
        pg_fatal("failed to end pipeline mode: %s", PQerrorMessage(conn));
 
    /* We expect to find one tuple containing the value "3" */
    res = PQexec(conn, "SELECT * FROM pq_pipeline_tst");
    if (PQresultStatus(res) != PGRES_TUPLES_OK)
        pg_fatal("failed to obtain result: %s", PQerrorMessage(conn));
    if (PQntuples(res) != 1)
        pg_fatal("did not get 1 tuple");
    if (strcmp(PQgetvalue(res, 0, 0), "3") != 0)
        pg_fatal("did not get expected tuple");
    PQclear(res);
 
    fprintf(stderr, "ok\n");
}

References conn, consume_null_result, fprintf, i, pg_fatal, PGRES_COMMAND_OK, PGRES_FATAL_ERROR, PGRES_PIPELINE_ABORTED, PGRES_PIPELINE_SYNC, PGRES_TUPLES_OK, PQclear, PQenterPipelineMode(), PQerrorMessage(), PQexec(), PQexitPipelineMode(), PQgetResult, PQgetvalue, PQntuples, PQpipelineSync(), PQresStatus(), PQresultStatus, PQsendPrepare(), PQsendQueryParams(), PQsendQueryPrepared(), and printf.

Referenced by main().

test_uniqviol()

static void test_uniqviol ( PGconn *  conn )

static

Definition at line 1879 of file libpq_pipeline.c.

{
    int         sock = PQsocket(conn);
    PGresult   *res;
    Oid         paramTypes[2] = {INT8OID, INT8OID};
    const char *paramValues[2];
    char        paramValue0[MAXINT8LEN];
    char        paramValue1[MAXINT8LEN];
    int         ctr = 0;
    int         numsent = 0;
    int         results = 0;
    bool        read_done = false;
    bool        write_done = false;
    bool        error_sent = false;
    bool        got_error = false;
    int         switched = 0;
    int         socketful = 0;
    fd_set      in_fds;
    fd_set      out_fds;
 
    fprintf(stderr, "uniqviol ...");
 
    PQsetnonblocking(conn, 1);
 
    paramValues[0] = paramValue0;
    paramValues[1] = paramValue1;
    sprintf(paramValue1, "42");
 
    res = PQexec(conn, "drop table if exists ppln_uniqviol;"
                 "create table ppln_uniqviol(id bigint primary key, idata bigint)");
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
        pg_fatal("failed to create table: %s", PQerrorMessage(conn));
    PQclear(res);
 
    res = PQexec(conn, "begin");
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
        pg_fatal("failed to begin transaction: %s", PQerrorMessage(conn));
    PQclear(res);
 
    res = PQprepare(conn, "insertion",
                    "insert into ppln_uniqviol values ($1, $2) returning id",
                    2, paramTypes);
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
        pg_fatal("failed to prepare query: %s", PQerrorMessage(conn));
    PQclear(res);
 
    if (PQenterPipelineMode(conn) != 1)
        pg_fatal("failed to enter pipeline mode");
 
    while (!read_done)
    {
        /*
         * Avoid deadlocks by reading everything the server has sent before
         * sending anything.  (Special precaution is needed here to process
         * PQisBusy before testing the socket for read-readiness, because the
         * socket does not turn read-ready after "sending" queries in aborted
         * pipeline mode.)
         */
        while (PQisBusy(conn) == 0)
        {
            bool        new_error;
 
            if (results >= numsent)
            {
                if (write_done)
                    read_done = true;
                break;
            }
 
            res = PQgetResult(conn);
            new_error = process_result(conn, res, results, numsent);
            if (new_error && got_error)
                pg_fatal("got two errors");
            got_error |= new_error;
            if (results++ >= numsent - 1)
            {
                if (write_done)
                    read_done = true;
                break;
            }
        }
 
        if (read_done)
            break;
 
        FD_ZERO(&out_fds);
        FD_SET(sock, &out_fds);
 
        FD_ZERO(&in_fds);
        FD_SET(sock, &in_fds);
 
        if (select(sock + 1, &in_fds, write_done ? NULL : &out_fds, NULL, NULL) == -1)
        {
            if (errno == EINTR)
                continue;
            pg_fatal("select() failed: %m");
        }
 
        if (FD_ISSET(sock, &in_fds) && PQconsumeInput(conn) == 0)
            pg_fatal("PQconsumeInput failed: %s", PQerrorMessage(conn));
 
        /*
         * If the socket is writable and we haven't finished sending queries,
         * send some.
         */
        if (!write_done && FD_ISSET(sock, &out_fds))
        {
            for (;;)
            {
                int         flush;
 
                /*
                 * provoke uniqueness violation exactly once after having
                 * switched to read mode.
                 */
                if (switched >= 1 && !error_sent && ctr % socketful >= socketful / 2)
                {
                    sprintf(paramValue0, "%d", numsent / 2);
                    fprintf(stderr, "E");
                    error_sent = true;
                }
                else
                {
                    fprintf(stderr, ".");
                    sprintf(paramValue0, "%d", ctr++);
                }
 
                if (PQsendQueryPrepared(conn, "insertion", 2, paramValues, NULL, NULL, 0) != 1)
                    pg_fatal("failed to execute prepared query: %s", PQerrorMessage(conn));
                numsent++;
 
                /* Are we done writing? */
                if (socketful != 0 && numsent % socketful == 42 && error_sent)
                {
                    if (PQsendFlushRequest(conn) != 1)
                        pg_fatal("failed to send flush request");
                    write_done = true;
                    fprintf(stderr, "\ndone writing\n");
                    PQflush(conn);
                    break;
                }
 
                /* is the outgoing socket full? */
                flush = PQflush(conn);
                if (flush == -1)
                    pg_fatal("failed to flush: %s", PQerrorMessage(conn));
                if (flush == 1)
                {
                    if (socketful == 0)
                        socketful = numsent;
                    fprintf(stderr, "\nswitch to reading\n");
                    switched++;
                    break;
                }
            }
        }
    }
 
    if (!got_error)
        pg_fatal("did not get expected error");
 
    fprintf(stderr, "ok\n");
}

References conn, EINTR, fprintf, MAXINT8LEN, pg_fatal, PGRES_COMMAND_OK, PQclear, PQconsumeInput(), PQenterPipelineMode(), PQerrorMessage(), PQexec(), PQflush(), PQgetResult, PQisBusy(), PQprepare(), PQresultStatus, PQsendFlushRequest(), PQsendQueryPrepared(), PQsetnonblocking(), PQsocket(), process_result(), select, and sprintf.

Referenced by main().

usage()

static void usage ( const char *  progname )

static

Definition at line 2087 of file libpq_pipeline.c.

{
    fprintf(stderr, "%s tests libpq's pipeline mode.\n\n", progname);
    fprintf(stderr, "Usage:\n");
    fprintf(stderr, "  %s [OPTION] tests\n", progname);
    fprintf(stderr, "  %s [OPTION] TESTNAME [CONNINFO]\n", progname);
    fprintf(stderr, "\nOptions:\n");
    fprintf(stderr, "  -t TRACEFILE       generate a libpq trace to TRACEFILE\n");
    fprintf(stderr, "  -r NUMROWS         use NUMROWS as the test size\n");
}

References fprintf, and progname.

Referenced by main().

wait_for_connection_state()

static void wait_for_connection_state ( int  line, PGconn *  monitorConn, int  procpid, char *  state, char *  event  )

static

Definition at line 167 of file libpq_pipeline.c.

{
    const Oid   paramTypes[] = {INT4OID, TEXTOID};
    const char *paramValues[2];
    char       *pidstr = psprintf("%d", procpid);
 
    Assert((state == NULL) ^ (event == NULL));
 
    paramValues[0] = pidstr;
    paramValues[1] = state ? state : event;
 
    while (true)
    {
        PGresult   *res;
        char       *value;
 
        if (state != NULL)
            res = PQexecParams(monitorConn,
                               "SELECT count(*) FROM pg_stat_activity WHERE "
                               "pid = $1 AND state = $2",
                               2, paramTypes, paramValues, NULL, NULL, 0);
        else
            res = PQexecParams(monitorConn,
                               "SELECT count(*) FROM pg_stat_activity WHERE "
                               "pid = $1 AND wait_event = $2",
                               2, paramTypes, paramValues, NULL, NULL, 0);
 
        if (PQresultStatus(res) != PGRES_TUPLES_OK)
            pg_fatal_impl(line, "could not query pg_stat_activity: %s", PQerrorMessage(monitorConn));
        if (PQntuples(res) != 1)
            pg_fatal_impl(line, "unexpected number of rows received: %d", PQntuples(res));
        if (PQnfields(res) != 1)
            pg_fatal_impl(line, "unexpected number of columns received: %d", PQnfields(res));
        value = PQgetvalue(res, 0, 0);
        if (strcmp(value, "0") != 0)
        {
            PQclear(res);
            break;
        }
        PQclear(res);
 
        /* wait 10ms before polling again */
        pg_usleep(10000);
    }
 
    pfree(pidstr);
}

References Assert(), pfree(), pg_fatal_impl(), pg_usleep(), PGRES_TUPLES_OK, PQclear, PQerrorMessage(), PQexecParams(), PQgetvalue, PQnfields, PQntuples, PQresultStatus, psprintf(), and value.

Referenced by send_cancellable_query_impl().

Variable Documentation

create_table_sql

const char* const create_table_sql

static

Initial value:

=
"CREATE UNLOGGED TABLE pq_pipeline_demo(id serial primary key, itemno integer,"
"int8filler int8);"

Definition at line 46 of file libpq_pipeline.c.

Referenced by test_pipeline_abort(), and test_pipelined_insert().

drop_table_sql

const char* const drop_table_sql

static

Initial value:

=
"DROP TABLE IF EXISTS pq_pipeline_demo"

Definition at line 44 of file libpq_pipeline.c.

Referenced by test_pipeline_abort(), and test_pipelined_insert().

insert_sql

const char* const insert_sql

static

Initial value:

=
"INSERT INTO pq_pipeline_demo(itemno) VALUES ($1)"

Definition at line 49 of file libpq_pipeline.c.

Referenced by test_pipeline_abort().

insert_sql2

const char* const insert_sql2

static

Initial value:

=
"INSERT INTO pq_pipeline_demo(itemno,int8filler) VALUES ($1, $2)"

Definition at line 51 of file libpq_pipeline.c.

Referenced by test_pipelined_insert().

progname

const char* const progname = "libpq_pipeline"

static

Definition at line 32 of file libpq_pipeline.c.

Referenced by pg_fatal_impl(), and usage().

tracefile

char* tracefile = NULL

static

Definition at line 35 of file libpq_pipeline.c.

Referenced by main().