/*-------------------------------------------------------------------------
 *
 * libpq_pipeline.c
 *		Verify libpq pipeline execution functionality
 *
 * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *		src/test/modules/libpq_pipeline/libpq_pipeline.c
 *
 *-------------------------------------------------------------------------
 */

#include "postgres_fe.h"

#include <sys/select.h>
#include <sys/time.h>

#include "catalog/pg_type_d.h"
#include "common/fe_memutils.h"
#include "libpq-fe.h"
#include "pg_getopt.h"
#include "portability/instr_time.h"


static void exit_nicely(PGconn *conn);
static void pg_attribute_noreturn() pg_fatal_impl(int line, const char *fmt,...)
			pg_attribute_printf(2, 3);
static bool process_result(PGconn *conn, PGresult *res, int results,
						   int numsent);

const char *const progname = "libpq_pipeline";

/* Options and defaults */
char	   *tracefile = NULL;	/* path to PQtrace() file */


#ifdef DEBUG_OUTPUT
#define	pg_debug(...)  do { fprintf(stderr, __VA_ARGS__); } while (0)
#else
#define pg_debug(...)
#endif

static const char *const drop_table_sql =
"DROP TABLE IF EXISTS pq_pipeline_demo";
static const char *const create_table_sql =
"CREATE UNLOGGED TABLE pq_pipeline_demo(id serial primary key, itemno integer,"
"int8filler int8);";
static const char *const insert_sql =
"INSERT INTO pq_pipeline_demo(itemno) VALUES ($1)";
static const char *const insert_sql2 =
"INSERT INTO pq_pipeline_demo(itemno,int8filler) VALUES ($1, $2)";

/* max char length of an int32/64, plus sign and null terminator */
#define MAXINTLEN 12
#define MAXINT8LEN 20

static void
exit_nicely(PGconn *conn)
{
	PQfinish(conn);
	exit(1);
}

/*
 * The following few functions are wrapped in macros to make the reported line
 * number in an error match the line number of the invocation.
 */

/*
 * Print an error to stderr and terminate the program.
 */
#define pg_fatal(...) pg_fatal_impl(__LINE__, __VA_ARGS__)
static void
pg_attribute_noreturn()
pg_fatal_impl(int line, const char *fmt,...)
{
	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);
}

/*
 * Check that the query on the given connection got canceled.
 */
#define confirm_query_canceled(conn) confirm_query_canceled_impl(__LINE__, conn)
static void
confirm_query_canceled_impl(int line, PGconn *conn)
{
	PGresult   *res = NULL;

	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal_impl(line, "PQgetResult returned null: %s",
					  PQerrorMessage(conn));
	if (PQresultStatus(res) != PGRES_FATAL_ERROR)
		pg_fatal_impl(line, "query did not fail when it was expected");
	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);
}

/*
 * Using monitorConn, query pg_stat_activity to see that the connection with
 * the given PID is either in the given state, or waiting on the given event
 * (only one of them can be given).
 */
static void
wait_for_connection_state(int line, PGconn *monitorConn, int procpid,
						  char *state, char *event)
{
	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);
}

#define send_cancellable_query(conn, monitorConn) \
	send_cancellable_query_impl(__LINE__, conn, monitorConn)
static void
send_cancellable_query_impl(int line, PGconn *conn, PGconn *monitorConn)
{
	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");
}

/*
 * Create a new connection with the same conninfo as the given one.
 */
static PGconn *
copy_connection(PGconn *conn)
{
	PGconn	   *copyConn;
	PQconninfoOption *opts = PQconninfo(conn);
	const char **keywords;
	const char **vals;
	int			nopts = 1;
	int			i = 0;

	for (PQconninfoOption *opt = opts; opt->keyword != NULL; ++opt)
		nopts++;

	keywords = pg_malloc(sizeof(char *) * nopts);
	vals = pg_malloc(sizeof(char *) * nopts);

	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));

	return copyConn;
}

/*
 * Test query cancellation routines
 */
static void
test_cancel(PGconn *conn)
{
	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);
	confirm_query_canceled(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);
	confirm_query_canceled(conn);

	PQfreeCancel(cancel);

	/* test PQrequestCancel */
	send_cancellable_query(conn, monitorConn);
	if (!PQrequestCancel(conn))
		pg_fatal("failed to run PQrequestCancel: %s", PQerrorMessage(conn));
	confirm_query_canceled(conn);

	/* test PQcancelBlocking */
	send_cancellable_query(conn, monitorConn);
	cancelConn = PQcancelCreate(conn);
	if (!PQcancelBlocking(cancelConn))
		pg_fatal("failed to run PQcancelBlocking: %s", PQcancelErrorMessage(cancelConn));
	confirm_query_canceled(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));
	confirm_query_canceled(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));
	confirm_query_canceled(conn);

	PQcancelFinish(cancelConn);

	fprintf(stderr, "ok\n");
}

static void
test_disallowed_in_pipeline(PGconn *conn)
{
	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));

	/* 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));

	fprintf(stderr, "ok\n");
}

static void
test_multi_pipelines(PGconn *conn)
{
	PGresult   *res = NULL;
	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 */

	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("PQgetResult returned null when there's a pipeline item: %s",
				 PQerrorMessage(conn));

	if (PQresultStatus(res) != PGRES_TUPLES_OK)
		pg_fatal("Unexpected result code %s from first pipeline item",
				 PQresStatus(PQresultStatus(res)));
	PQclear(res);
	res = NULL;

	if (PQgetResult(conn) != NULL)
		pg_fatal("PQgetResult returned something extra after first result");

	if (PQexitPipelineMode(conn) != 0)
		pg_fatal("exiting pipeline mode after query but before sync succeeded incorrectly");

	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("PQgetResult returned null when sync result expected: %s",
				 PQerrorMessage(conn));

	if (PQresultStatus(res) != PGRES_PIPELINE_SYNC)
		pg_fatal("Unexpected result code %s instead of sync result, error: %s",
				 PQresStatus(PQresultStatus(res)), PQerrorMessage(conn));
	PQclear(res);

	/* second pipeline */

	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("PQgetResult returned null when there's a pipeline item: %s",
				 PQerrorMessage(conn));

	if (PQresultStatus(res) != PGRES_TUPLES_OK)
		pg_fatal("Unexpected result code %s from second pipeline item",
				 PQresStatus(PQresultStatus(res)));
	PQclear(res);
	res = NULL;

	if (PQgetResult(conn) != NULL)
		pg_fatal("PQgetResult returned something extra after first result");

	if (PQexitPipelineMode(conn) != 0)
		pg_fatal("exiting pipeline mode after query but before sync succeeded incorrectly");

	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("PQgetResult returned null when sync result expected: %s",
				 PQerrorMessage(conn));

	if (PQresultStatus(res) != PGRES_PIPELINE_SYNC)
		pg_fatal("Unexpected result code %s instead of sync result, error: %s",
				 PQresStatus(PQresultStatus(res)), PQerrorMessage(conn));
	PQclear(res);

	/* third pipeline */

	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("PQgetResult returned null when there's a pipeline item: %s",
				 PQerrorMessage(conn));

	if (PQresultStatus(res) != PGRES_TUPLES_OK)
		pg_fatal("Unexpected result code %s from third pipeline item",
				 PQresStatus(PQresultStatus(res)));

	res = PQgetResult(conn);
	if (res != NULL)
		pg_fatal("Expected null result, got %s",
				 PQresStatus(PQresultStatus(res)));

	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("PQgetResult returned null when there's a pipeline item: %s",
				 PQerrorMessage(conn));

	if (PQresultStatus(res) != PGRES_PIPELINE_SYNC)
		pg_fatal("Unexpected result code %s from second pipeline sync",
				 PQresStatus(PQresultStatus(res)));

	/* 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");
}

/*
 * Test behavior when a pipeline dispatches a number of commands that are
 * not flushed by a sync point.
 */
static void
test_nosync(PGconn *conn)
{
	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 (;;)
	{
		PGresult   *res;

		res = PQgetResult(conn);

		/* NULL results are only expected after TUPLES_OK */
		if (res == NULL)
			pg_fatal("got unexpected NULL result after %d results", results);

		/* We expect exactly one TUPLES_OK result for each query we sent */
		if (PQresultStatus(res) == PGRES_TUPLES_OK)
		{
			PGresult   *res2;

			/* and one NULL result should follow each */
			res2 = PQgetResult(conn);
			if (res2 != NULL)
				pg_fatal("expected NULL, got %s",
						 PQresStatus(PQresultStatus(res2)));
			PQclear(res);
			results++;

			/* if we're done, we're done */
			if (results == numqueries)
				break;

			continue;
		}

		/* anything else is unexpected */
		pg_fatal("got unexpected %s\n", PQresStatus(PQresultStatus(res)));
	}

	fprintf(stderr, "ok\n");
}

/*
 * When an operation in a pipeline fails the rest of the pipeline is flushed. We
 * still have to get results for each pipeline item, but the item will just be
 * a PGRES_PIPELINE_ABORTED code.
 *
 * This intentionally doesn't use a transaction to wrap the pipeline. You should
 * usually use an xact, but in this case we want to observe the effects of each
 * statement.
 */
static void
test_pipeline_abort(PGconn *conn)
{
	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));

	res = PQexec(conn, create_table_sql);
	if (PQresultStatus(res) != PGRES_COMMAND_OK)
		pg_fatal("dispatching CREATE TABLE failed: %s", PQerrorMessage(conn));

	/*
	 * 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.
	 */
	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("Unexpected NULL result: %s", PQerrorMessage(conn));
	if (PQresultStatus(res) != PGRES_COMMAND_OK)
		pg_fatal("Unexpected result status %s: %s",
				 PQresStatus(PQresultStatus(res)),
				 PQresultErrorMessage(res));
	PQclear(res);

	/* NULL result to signal end-of-results for this command */
	if ((res = PQgetResult(conn)) != NULL)
		pg_fatal("Expected null result, got %s",
				 PQresStatus(PQresultStatus(res)));

	/* Second query caused error, so we expect an error next */
	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("Unexpected NULL result: %s", PQerrorMessage(conn));
	if (PQresultStatus(res) != PGRES_FATAL_ERROR)
		pg_fatal("Unexpected result code -- expected PGRES_FATAL_ERROR, got %s",
				 PQresStatus(PQresultStatus(res)));
	PQclear(res);

	/* NULL result to signal end-of-results for this command */
	if ((res = PQgetResult(conn)) != NULL)
		pg_fatal("Expected null result, got %s",
				 PQresStatus(PQresultStatus(res)));

	/*
	 * 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 */
	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("Unexpected NULL result: %s", PQerrorMessage(conn));
	if (PQresultStatus(res) != PGRES_PIPELINE_ABORTED)
		pg_fatal("Unexpected result code -- expected PGRES_PIPELINE_ABORTED, got %s",
				 PQresStatus(PQresultStatus(res)));
	PQclear(res);

	/* NULL result to signal end-of-results for this command */
	if ((res = PQgetResult(conn)) != NULL)
		pg_fatal("Expected null result, got %s", PQresStatus(PQresultStatus(res)));

	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.)
	 */
	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("Unexpected NULL result: %s", PQerrorMessage(conn));
	if (PQresultStatus(res) != PGRES_PIPELINE_SYNC)
		pg_fatal("Unexpected result code from first pipeline sync\n"
				 "Expected PGRES_PIPELINE_SYNC, got %s",
				 PQresStatus(PQresultStatus(res)));
	PQclear(res);

	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 */
	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("Unexpected NULL result: %s", PQerrorMessage(conn));
	if (PQresultStatus(res) != PGRES_COMMAND_OK)
		pg_fatal("Unexpected result code %s from first item in second pipeline",
				 PQresStatus(PQresultStatus(res)));
	PQclear(res);

	/* Read the NULL result at the end of the command */
	if ((res = PQgetResult(conn)) != NULL)
		pg_fatal("Expected null result, got %s", PQresStatus(PQresultStatus(res)));

	/* the second pipeline sync */
	if ((res = PQgetResult(conn)) == NULL)
		pg_fatal("Unexpected NULL result: %s", PQerrorMessage(conn));
	if (PQresultStatus(res) != PGRES_PIPELINE_SYNC)
		pg_fatal("Unexpected result code %s from second pipeline sync",
				 PQresStatus(PQresultStatus(res)));
	PQclear(res);

	if ((res = PQgetResult(conn)) != NULL)
		pg_fatal("Expected null result, got %s: %s",
				 PQresStatus(PQresultStatus(res)),
				 PQerrorMessage(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;
		}
	}
	if (!goterror)
		pg_fatal("did not get cannot-insert-multiple-commands error");
	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("got NULL result");
	if (PQresultStatus(res) != PGRES_PIPELINE_SYNC)
		pg_fatal("Unexpected result code %s from pipeline sync",
				 PQresStatus(PQresultStatus(res)));
	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 */
	if ((res = PQgetResult(conn)) == NULL)
		pg_fatal("Unexpected NULL result: %s", PQerrorMessage(conn));
	if (PQresultStatus(res) != PGRES_PIPELINE_SYNC)
		pg_fatal("Unexpected result code %s from third pipeline sync",
				 PQresStatus(PQresultStatus(res)));
	PQclear(res);

	/* 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");
}

/* State machine enum for test_pipelined_insert */
enum PipelineInsertStep
{
	BI_BEGIN_TX,
	BI_DROP_TABLE,
	BI_CREATE_TABLE,
	BI_PREPARE,
	BI_INSERT_ROWS,
	BI_COMMIT_TX,
	BI_SYNC,
	BI_DONE,
};

static void
test_pipelined_insert(PGconn *conn, int n_rows)
{
	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");
}

static void
test_prepared(PGconn *conn)
{
	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));

	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("PQgetResult returned null");
	if (PQresultStatus(res) != PGRES_COMMAND_OK)
		pg_fatal("expected COMMAND_OK, got %s", PQresStatus(PQresultStatus(res)));
	PQclear(res);
	res = PQgetResult(conn);
	if (res != NULL)
		pg_fatal("expected NULL result");

	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("PQgetResult returned NULL");
	if (PQresultStatus(res) != PGRES_COMMAND_OK)
		pg_fatal("expected COMMAND_OK, got %s", PQresStatus(PQresultStatus(res)));
	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);
	res = PQgetResult(conn);
	if (res != NULL)
		pg_fatal("expected NULL result");

	res = PQgetResult(conn);
	if (PQresultStatus(res) != PGRES_PIPELINE_SYNC)
		pg_fatal("expected PGRES_PIPELINE_SYNC, got %s", PQresStatus(PQresultStatus(res)));

	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));

	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("expected non-NULL result");
	if (PQresultStatus(res) != PGRES_COMMAND_OK)
		pg_fatal("expected COMMAND_OK, got %s", PQresStatus(PQresultStatus(res)));
	PQclear(res);
	res = PQgetResult(conn);
	if (res != NULL)
		pg_fatal("expected NULL result");
	res = PQgetResult(conn);
	if (PQresultStatus(res) != PGRES_PIPELINE_SYNC)
		pg_fatal("expected PGRES_PIPELINE_SYNC, got %s", PQresStatus(PQresultStatus(res)));

	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)));

	/*
	 * 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)));

	fprintf(stderr, "creating portal... ");
	PQexec(conn, "BEGIN");
	PQexec(conn, "DECLARE cursor_one CURSOR FOR SELECT 1");
	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 = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("PQgetResult returned null");
	if (PQresultStatus(res) != PGRES_COMMAND_OK)
		pg_fatal("expected COMMAND_OK, got %s", PQresStatus(PQresultStatus(res)));

	typ = PQftype(res, 0);
	if (typ != INT4OID)
		pg_fatal("portal: expected type %u, got %u",
				 INT4OID, typ);
	PQclear(res);
	res = PQgetResult(conn);
	if (res != NULL)
		pg_fatal("expected NULL result");
	res = PQgetResult(conn);
	if (PQresultStatus(res) != PGRES_PIPELINE_SYNC)
		pg_fatal("expected PGRES_PIPELINE_SYNC, got %s", PQresStatus(PQresultStatus(res)));

	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));

	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("expected non-NULL result");
	if (PQresultStatus(res) != PGRES_COMMAND_OK)
		pg_fatal("expected COMMAND_OK, got %s", PQresStatus(PQresultStatus(res)));
	PQclear(res);
	res = PQgetResult(conn);
	if (res != NULL)
		pg_fatal("expected NULL result");
	res = PQgetResult(conn);
	if (PQresultStatus(res) != PGRES_PIPELINE_SYNC)
		pg_fatal("expected PGRES_PIPELINE_SYNC, got %s", PQresStatus(PQresultStatus(res)));

	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)));

	/*
	 * 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)));

	fprintf(stderr, "ok\n");
}

/* Notice processor: print notices, and count how many we got */
static void
notice_processor(void *arg, const char *message)
{
	int		   *n_notices = (int *) arg;

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

/* Verify behavior in "idle" state */
static void
test_pipeline_idle(PGconn *conn)
{
	PGresult   *res;
	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);
	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("PQgetResult returned null when there's a pipeline item: %s",
				 PQerrorMessage(conn));
	if (PQresultStatus(res) != PGRES_TUPLES_OK)
		pg_fatal("unexpected result code %s from first pipeline item",
				 PQresStatus(PQresultStatus(res)));
	PQclear(res);
	res = PQgetResult(conn);
	if (res != NULL)
		pg_fatal("did not receive terminating NULL");
	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);
	res = PQgetResult(conn);
	if (PQresultStatus(res) != PGRES_TUPLES_OK)
		pg_fatal("unexpected result code %s from second pipeline item",
				 PQresStatus(PQresultStatus(res)));
	PQclear(res);
	res = PQgetResult(conn);
	if (res != NULL)
		pg_fatal("did not receive terminating NULL");
	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);
	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("unexpected NULL result received");
	if (PQresultStatus(res) != PGRES_TUPLES_OK)
		pg_fatal("unexpected result code %s", PQresStatus(PQresultStatus(res)));
	if (PQexitPipelineMode(conn) != 1)
		pg_fatal("failed to exit pipeline mode: %s", PQerrorMessage(conn));
	fprintf(stderr, "ok - 2\n");
}

static void
test_simple_pipeline(PGconn *conn)
{
	PGresult   *res = NULL;
	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));

	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("PQgetResult returned null when there's a pipeline item: %s",
				 PQerrorMessage(conn));

	if (PQresultStatus(res) != PGRES_TUPLES_OK)
		pg_fatal("Unexpected result code %s from first pipeline item",
				 PQresStatus(PQresultStatus(res)));

	PQclear(res);
	res = NULL;

	if (PQgetResult(conn) != NULL)
		pg_fatal("PQgetResult returned something extra after first query result.");

	/*
	 * 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");

	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("PQgetResult returned null when sync result PGRES_PIPELINE_SYNC expected: %s",
				 PQerrorMessage(conn));

	if (PQresultStatus(res) != PGRES_PIPELINE_SYNC)
		pg_fatal("Unexpected result code %s instead of PGRES_PIPELINE_SYNC, error: %s",
				 PQresStatus(PQresultStatus(res)), PQerrorMessage(conn));

	PQclear(res);
	res = NULL;

	if (PQgetResult(conn) != NULL)
		pg_fatal("PQgetResult returned something extra after pipeline end: %s",
				 PQresStatus(PQresultStatus(res)));

	/* 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");
}

static void
test_singlerowmode(PGconn *conn)
{
	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");
	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("unexpected NULL");
	if (PQresultStatus(res) != PGRES_SINGLE_TUPLE)
		pg_fatal("Expected PGRES_SINGLE_TUPLE, got %s",
				 PQresStatus(PQresultStatus(res)));
	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("unexpected NULL");
	if (PQresultStatus(res) != PGRES_TUPLES_OK)
		pg_fatal("Expected PGRES_TUPLES_OK, got %s",
				 PQresStatus(PQresultStatus(res)));
	if (PQgetResult(conn) != NULL)
		pg_fatal("expected NULL result");

	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");
	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("unexpected NULL");
	if (PQresultStatus(res) != PGRES_TUPLES_OK)
		pg_fatal("Expected PGRES_TUPLES_OK, got %s",
				 PQresStatus(PQresultStatus(res)));
	if (PQgetResult(conn) != NULL)
		pg_fatal("expected NULL result");

	/*
	 * 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 = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("unexpected NULL");
	if (PQresultStatus(res) != PGRES_TUPLES_CHUNK)
		pg_fatal("Expected PGRES_TUPLES_CHUNK, got %s: %s",
				 PQresStatus(PQresultStatus(res)),
				 PQerrorMessage(conn));
	if (PQntuples(res) != 3)
		pg_fatal("Expected 3 rows, got %d", PQntuples(res));
	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("unexpected NULL");
	if (PQresultStatus(res) != PGRES_TUPLES_CHUNK)
		pg_fatal("Expected PGRES_TUPLES_CHUNK, got %s",
				 PQresStatus(PQresultStatus(res)));
	if (PQntuples(res) != 2)
		pg_fatal("Expected 2 rows, got %d", PQntuples(res));
	res = PQgetResult(conn);
	if (res == NULL)
		pg_fatal("unexpected NULL");
	if (PQresultStatus(res) != PGRES_TUPLES_OK)
		pg_fatal("Expected PGRES_TUPLES_OK, got %s",
				 PQresStatus(PQresultStatus(res)));
	if (PQntuples(res) != 0)
		pg_fatal("Expected 0 rows, got %d", PQntuples(res));
	if (PQgetResult(conn) != NULL)
		pg_fatal("expected NULL result");

	if (PQexitPipelineMode(conn) != 1)
		pg_fatal("failed to end pipeline mode: %s", PQerrorMessage(conn));

	fprintf(stderr, "ok\n");
}

/*
 * Simple test to verify that a pipeline is discarded as a whole when there's
 * an error, ignoring transaction commands.
 */
static void
test_transaction(PGconn *conn)
{
	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;
	}
	if (PQgetResult(conn) != NULL)
		pg_fatal("returned something extra after all the syncs: %s",
				 PQresStatus(PQresultStatus(res)));

	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");
}

/*
 * In this test mode we send a stream of queries, with one in the middle
 * causing an error.  Verify that we can still send some more after the
 * error and have libpq work properly.
 */
static void
test_uniqviol(PGconn *conn)
{
	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));

	res = PQexec(conn, "begin");
	if (PQresultStatus(res) != PGRES_COMMAND_OK)
		pg_fatal("failed to begin transaction: %s", PQerrorMessage(conn));

	res = PQprepare(conn, "insertion",
					"insert into ppln_uniqviol values ($1, $2) returning id",
					2, paramTypes);
	if (res == NULL || PQresultStatus(res) != PGRES_COMMAND_OK)
		pg_fatal("failed to prepare query: %s", PQerrorMessage(conn));

	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");
}

/*
 * Subroutine for test_uniqviol; given a PGresult, print it out and consume
 * the expected NULL that should follow it.
 *
 * Returns true if we read a fatal error message, otherwise false.
 */
static bool
process_result(PGconn *conn, PGresult *res, int results, int numsent)
{
	PGresult   *res2;
	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);

			res2 = PQgetResult(conn);
			if (res2 != NULL)
				pg_fatal("expected NULL, got %s",
						 PQresStatus(PQresultStatus(res2)));
			break;

		case PGRES_TUPLES_OK:
			fprintf(stderr, "result %d/%d: %s\n", results, numsent, PQgetvalue(res, 0, 0));
			PQclear(res);

			res2 = PQgetResult(conn);
			if (res2 != NULL)
				pg_fatal("expected NULL, got %s",
						 PQresStatus(PQresultStatus(res2)));
			break;

		case PGRES_PIPELINE_ABORTED:
			fprintf(stderr, "result %d/%d: pipeline aborted\n", results, numsent);
			res2 = PQgetResult(conn);
			if (res2 != NULL)
				pg_fatal("expected NULL, got %s",
						 PQresStatus(PQresultStatus(res2)));
			break;

		default:
			pg_fatal("got unexpected %s", PQresStatus(PQresultStatus(res)));
	}

	return got_error;
}


static void
usage(const char *progname)
{
	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");
}

static void
print_test_list(void)
{
	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("simple_pipeline\n");
	printf("singlerow\n");
	printf("transaction\n");
	printf("uniqviol\n");
}

int
main(int argc, char **argv)
{
	const char *conninfo = "";
	PGconn	   *conn;
	FILE	   *trace;
	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));
	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));

	/* 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, "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);
	return 0;
}
