pgbench.c File Reference

#include "postgres_fe.h"
#include <ctype.h>
#include <float.h>
#include <limits.h>
#include <math.h>
#include <signal.h>
#include <time.h>
#include <sys/resource.h>
#include <sys/select.h>
#include "common/int.h"
#include "common/logging.h"
#include "common/pg_prng.h"
#include "common/string.h"
#include "common/username.h"
#include "fe_utils/cancel.h"
#include "fe_utils/conditional.h"
#include "fe_utils/option_utils.h"
#include "fe_utils/string_utils.h"
#include "getopt_long.h"
#include "libpq-fe.h"
#include "pgbench.h"
#include "port/pg_bitutils.h"
#include "portability/instr_time.h"
#include "port/pg_pthread.h"

Include dependency graph for pgbench.c:

Go to the source code of this file.

Data Structures
struct	socket_set
struct	Variable
struct	Variables
struct	SimpleStats
struct	StatsData
struct	CState
struct	TState
struct	Command
struct	ParsedScript
struct	BuiltinScript

Macros
#define	POLL_USING_SELECT
#define	M_PI   3.14159265358979323846
#define	ERRCODE_T_R_SERIALIZATION_FAILURE   "40001"
#define	ERRCODE_T_R_DEADLOCK_DETECTED   "40P01"
#define	ERRCODE_UNDEFINED_TABLE   "42P01"
#define	FNV_PRIME   UINT64CONST(0x100000001b3)
#define	FNV_OFFSET_BASIS   UINT64CONST(0xcbf29ce484222325)
#define	MM2_MUL   UINT64CONST(0xc6a4a7935bd1e995)
#define	MM2_MUL_TIMES_8   UINT64CONST(0x35253c9ade8f4ca8)
#define	MM2_ROT   47
#define	SOCKET_WAIT_METHOD   "select"
#define	THREAD_T   pthread_t
#define	THREAD_FUNC_RETURN_TYPE   void *
#define	THREAD_FUNC_RETURN   return NULL
#define	THREAD_FUNC_CC
#define	THREAD_CREATE(handle, function, arg)    pthread_create((handle), NULL, (function), (arg))
#define	THREAD_JOIN(handle)    pthread_join((handle), NULL)
#define	THREAD_BARRIER_T   pthread_barrier_t
#define	THREAD_BARRIER_INIT(barrier, n)    pthread_barrier_init((barrier), NULL, (n))
#define	THREAD_BARRIER_WAIT(barrier)   pthread_barrier_wait((barrier))
#define	THREAD_BARRIER_DESTROY(barrier)   pthread_barrier_destroy((barrier))
#define	DEFAULT_INIT_STEPS   "dtgvp" /* default -I setting */
#define	ALL_INIT_STEPS   "dtgGvpf" /* all possible steps */
#define	LOG_STEP_SECONDS   5 /* seconds between log messages */
#define	DEFAULT_NXACTS   10 /* default nxacts */
#define	MIN_GAUSSIAN_PARAM   2.0 /* minimum parameter for gauss */
#define	MIN_ZIPFIAN_PARAM   1.001 /* minimum parameter for zipfian */
#define	MAX_ZIPFIAN_PARAM   1000.0 /* maximum parameter for zipfian */
#define	nbranches
#define	ntellers   10
#define	naccounts   100000
#define	SCALE_32BIT_THRESHOLD   20000
#define	WSEP   '@' /* weight separator */
#define	VARIABLES_ALLOC_MARGIN   8
#define	MAX_SCRIPTS   128 /* max number of SQL scripts allowed */
#define	SHELL_COMMAND_SIZE   256 /* maximum size allowed for shell command */
#define	SQL_COMMAND   1
#define	META_COMMAND   2
#define	MAX_ARGS   256
#define	PG_TIME_GET_DOUBLE(t)   (0.000001 * (t))
#define	PARAMS_ARRAY_SIZE   7
#define	MAX_FARGS   16
#define	COMMANDS_ALLOC_NUM   128

Typedefs
typedef struct socket_set	socket_set
typedef struct SimpleStats	SimpleStats
typedef int64	pg_time_usec_t
typedef struct StatsData	StatsData
typedef enum EStatus	EStatus
typedef enum TStatus	TStatus
typedef enum MetaCommand	MetaCommand
typedef enum QueryMode	QueryMode
typedef struct Command	Command
typedef struct ParsedScript	ParsedScript
typedef struct BuiltinScript	BuiltinScript
typedef void(*	initRowMethod) (PQExpBufferData *sql, int64 curr)

Enumerations
enum	partition_method_t { PART_NONE , PART_RANGE , PART_HASH }
enum	EStatus {   ESTATUS_NO_ERROR = 0 , ESTATUS_META_COMMAND_ERROR , ESTATUS_SERIALIZATION_ERROR , ESTATUS_DEADLOCK_ERROR ,   ESTATUS_OTHER_SQL_ERROR }
enum	TStatus { TSTATUS_IDLE , TSTATUS_IN_BLOCK , TSTATUS_CONN_ERROR , TSTATUS_OTHER_ERROR }
enum	ConnectionStateEnum {   CSTATE_CHOOSE_SCRIPT , CSTATE_START_TX , CSTATE_PREPARE_THROTTLE , CSTATE_THROTTLE ,   CSTATE_START_COMMAND , CSTATE_WAIT_RESULT , CSTATE_SLEEP , CSTATE_END_COMMAND ,   CSTATE_SKIP_COMMAND , CSTATE_ERROR , CSTATE_WAIT_ROLLBACK_RESULT , CSTATE_RETRY ,   CSTATE_FAILURE , CSTATE_END_TX , CSTATE_ABORTED , CSTATE_FINISHED }
enum	MetaCommand {   META_NONE , META_SET , META_SETSHELL , META_SHELL ,   META_SLEEP , META_GSET , META_ASET , META_IF ,   META_ELIF , META_ELSE , META_ENDIF , META_STARTPIPELINE ,   META_SYNCPIPELINE , META_ENDPIPELINE }
enum	QueryMode { QUERY_SIMPLE , QUERY_EXTENDED , QUERY_PREPARED , NUM_QUERYMODE }

Functions
static void	setNullValue (PgBenchValue *pv)
static void	setBoolValue (PgBenchValue *pv, bool bval)
static void	setIntValue (PgBenchValue *pv, int64 ival)
static void	setDoubleValue (PgBenchValue *pv, double dval)
static bool	evaluateExpr (CState *st, PgBenchExpr *expr, PgBenchValue *retval)
static ConnectionStateEnum	executeMetaCommand (CState *st, pg_time_usec_t *now)
static void	doLog (TState *thread, CState *st, StatsData *agg, bool skipped, double latency, double lag)
static void	processXactStats (TState *thread, CState *st, pg_time_usec_t *now, bool skipped, StatsData *agg)
static void	addScript (const ParsedScript *script)
static THREAD_FUNC_RETURN_TYPE THREAD_FUNC_CC	threadRun (void *arg)
static void	finishCon (CState *st)
static void	setalarm (int seconds)
static socket_set *	alloc_socket_set (int count)
static void	free_socket_set (socket_set *sa)
static void	clear_socket_set (socket_set *sa)
static void	add_socket_to_set (socket_set *sa, int fd, int idx)
static int	wait_on_socket_set (socket_set *sa, int64 usecs)
static bool	socket_has_input (socket_set *sa, int fd, int idx)
static pg_time_usec_t	pg_time_now (void)
static void	pg_time_now_lazy (pg_time_usec_t *now)
static void	usage (void)
static bool	is_an_int (const char *str)
bool	strtoint64 (const char *str, bool errorOK, int64 *result)
bool	strtodouble (const char *str, bool errorOK, double *dv)
static void	initRandomState (pg_prng_state *state)
static int64	getrand (pg_prng_state *state, int64 min, int64 max)
static int64	getExponentialRand (pg_prng_state *state, int64 min, int64 max, double parameter)
static int64	getGaussianRand (pg_prng_state *state, int64 min, int64 max, double parameter)
static int64	getPoissonRand (pg_prng_state *state, double center)
static int64	computeIterativeZipfian (pg_prng_state *state, int64 n, double s)
static int64	getZipfianRand (pg_prng_state *state, int64 min, int64 max, double s)
static int64	getHashFnv1a (int64 val, uint64 seed)
static int64	getHashMurmur2 (int64 val, uint64 seed)
static int64	permute (const int64 val, const int64 isize, const int64 seed)
static void	initSimpleStats (SimpleStats *ss)
static void	addToSimpleStats (SimpleStats *ss, double val)
static void	mergeSimpleStats (SimpleStats *acc, SimpleStats *ss)
static void	initStats (StatsData *sd, pg_time_usec_t start)
static void	accumStats (StatsData *stats, bool skipped, double lat, double lag, EStatus estatus, int64 tries)
static void	executeStatement (PGconn *con, const char *sql)
static void	tryExecuteStatement (PGconn *con, const char *sql)
static PGconn *	doConnect (void)
static int	compareVariableNames (const void *v1, const void *v2)
static Variable *	lookupVariable (Variables *variables, char *name)
static char *	getVariable (Variables *variables, char *name)
static bool	makeVariableValue (Variable *var)
static bool	valid_variable_name (const char *name)
static void	enlargeVariables (Variables *variables, int needed)
static Variable *	lookupCreateVariable (Variables *variables, const char *context, char *name)
static bool	putVariable (Variables *variables, const char *context, char *name, const char *value)
static bool	putVariableValue (Variables *variables, const char *context, char *name, const PgBenchValue *value)
static bool	putVariableInt (Variables *variables, const char *context, char *name, int64 value)
static char *	parseVariable (const char *sql, int *eaten)
static char *	replaceVariable (char **sql, char *param, int len, char *value)
static char *	assignVariables (Variables *variables, char *sql)
static void	getQueryParams (Variables *variables, const Command *command, const char **params)
static char *	valueTypeName (PgBenchValue *pval)
static bool	coerceToBool (PgBenchValue *pval, bool *bval)
static bool	valueTruth (PgBenchValue *pval)
static bool	coerceToInt (PgBenchValue *pval, int64 *ival)
static bool	coerceToDouble (PgBenchValue *pval, double *dval)
static bool	isLazyFunc (PgBenchFunction func)
static bool	evalLazyFunc (CState *st, PgBenchFunction func, PgBenchExprLink *args, PgBenchValue *retval)
static bool	evalStandardFunc (CState *st, PgBenchFunction func, PgBenchExprLink *args, PgBenchValue *retval)
static bool	evalFunc (CState *st, PgBenchFunction func, PgBenchExprLink *args, PgBenchValue *retval)
static MetaCommand	getMetaCommand (const char *cmd)
static bool	runShellCommand (Variables *variables, char *variable, char **argv, int argc)
static void	commandFailed (CState *st, const char *cmd, const char *message)
static void	commandError (CState *st, const char *message)
static int	chooseScript (TState *thread)
static void	allocCStatePrepared (CState *st)
static void	prepareCommand (CState *st, int command_num)
static void	prepareCommandsInPipeline (CState *st)
static bool	sendCommand (CState *st, Command *command)
static EStatus	getSQLErrorStatus (const char *sqlState)
static bool	canRetryError (EStatus estatus)
static bool	readCommandResponse (CState *st, MetaCommand meta, char *varprefix)
static bool	evaluateSleep (Variables *variables, int argc, char **argv, int *usecs)
static bool	doRetry (CState *st, pg_time_usec_t *now)
static int	discardUntilSync (CState *st)
static TStatus	getTransactionStatus (PGconn *con)
static void	printVerboseErrorMessages (CState *st, pg_time_usec_t *now, bool is_retry)
static void	advanceConnectionState (TState *thread, CState *st, StatsData *agg)
static int64	getFailures (const StatsData *stats)
static const char *	getResultString (bool skipped, EStatus estatus)
static void	disconnect_all (CState *state, int length)
static void	initDropTables (PGconn *con)
static void	createPartitions (PGconn *con)
static void	initCreateTables (PGconn *con)
static void	initTruncateTables (PGconn *con)
static void	initBranch (PQExpBufferData *sql, int64 curr)
static void	initTeller (PQExpBufferData *sql, int64 curr)
static void	initAccount (PQExpBufferData *sql, int64 curr)
static void	initPopulateTable (PGconn *con, const char *table, int64 base, initRowMethod init_row)
static void	initGenerateDataClientSide (PGconn *con)
static void	initGenerateDataServerSide (PGconn *con)
static void	initVacuum (PGconn *con)
static void	initCreatePKeys (PGconn *con)
static void	initCreateFKeys (PGconn *con)
static void	checkInitSteps (const char *initialize_steps)
static void	runInitSteps (const char *initialize_steps)
static void	GetTableInfo (PGconn *con, bool scale_given)
static bool	parseQuery (Command *cmd)
void	syntax_error (const char *source, int lineno, const char *line, const char *command, const char *msg, const char *more, int column)
static char *	skip_sql_comments (char *sql_command)
static Command *	create_sql_command (PQExpBuffer buf, const char *source)
static void	free_command (Command *command)
static void	postprocess_sql_command (Command *my_command)
static Command *	process_backslash_command (PsqlScanState sstate, const char *source)
static void	ConditionError (const char *desc, int cmdn, const char *msg)
static void	CheckConditional (const ParsedScript *ps)
static void	ParseScript (const char *script, const char *desc, int weight)
static char *	read_file_contents (FILE *fd)
static void	process_file (const char *filename, int weight)
static void	process_builtin (const BuiltinScript *bi, int weight)
static void	listAvailableScripts (void)
static const BuiltinScript *	findBuiltin (const char *name)
static int	parseScriptWeight (const char *option, char **script)
static void	printProgressReport (TState *threads, int64 test_start, pg_time_usec_t now, StatsData *last, int64 *last_report)
static void	printSimpleStats (const char *prefix, SimpleStats *ss)
static void	printVersion (PGconn *con)
static void	printResults (StatsData *total, pg_time_usec_t total_duration, pg_time_usec_t conn_total_duration, pg_time_usec_t conn_elapsed_duration, int64 latency_late)
static bool	set_random_seed (const char *seed)
int	main (int argc, char **argv)
static void	handle_sig_alarm (SIGNAL_ARGS)

Variables
static int	nxacts = 0
static int	duration = 0
static int64	end_time = 0
static int	scale = 1
static int	fillfactor = 100
static bool	unlogged_tables = false
static double	sample_rate = 0.0
static double	throttle_delay = 0
static int64	latency_limit = 0
static char *	tablespace = NULL
static char *	index_tablespace = NULL
static int	partitions = 0
static partition_method_t	partition_method = PART_NONE
static const char *const	PARTITION_METHOD [] = {"none", "range", "hash"}
static int64	random_seed = -1
static bool	use_log
static bool	use_quiet
static int	agg_interval
static bool	per_script_stats = false
static int	progress = 0
static bool	progress_timestamp = false
static int	nclients = 1
static int	nthreads = 1
static bool	is_connect
static bool	report_per_command = false
static int	main_pid
static uint32	max_tries = 1
static bool	failures_detailed = false
static const char *	pghost = NULL
static const char *	pgport = NULL
static const char *	username = NULL
static const char *	dbName = NULL
static char *	logfile_prefix = NULL
static const char *	progname
static volatile sig_atomic_t	timer_exceeded = false
static pg_time_usec_t	epoch_shift
static pg_prng_state	base_random_sequence
static THREAD_BARRIER_T	barrier
static QueryMode	querymode = QUERY_SIMPLE
static const char *const	QUERYMODE [] = {"simple", "extended", "prepared"}
static ParsedScript	sql_script [MAX_SCRIPTS]
static int	num_scripts
static int64	total_weight = 0
static bool	verbose_errors = false
static bool	exit_on_abort = false
static const BuiltinScript	builtin_script []
static const PsqlScanCallbacks	pgbench_callbacks

Macro Definition Documentation

ALL_INIT_STEPS

#define ALL_INIT_STEPS   "dtgGvpf" /* all possible steps */

Definition at line 163 of file pgbench.c.

COMMANDS_ALLOC_NUM

#define COMMANDS_ALLOC_NUM   128

DEFAULT_INIT_STEPS

#define DEFAULT_INIT_STEPS   "dtgvp" /* default -I setting */

Definition at line 162 of file pgbench.c.

DEFAULT_NXACTS

#define DEFAULT_NXACTS   10 /* default nxacts */

Definition at line 166 of file pgbench.c.

ERRCODE_T_R_DEADLOCK_DETECTED

#define ERRCODE_T_R_DEADLOCK_DETECTED   "40P01"

Definition at line 77 of file pgbench.c.

ERRCODE_T_R_SERIALIZATION_FAILURE

#define ERRCODE_T_R_SERIALIZATION_FAILURE   "40001"

Definition at line 76 of file pgbench.c.

ERRCODE_UNDEFINED_TABLE

#define ERRCODE_UNDEFINED_TABLE   "42P01"

Definition at line 78 of file pgbench.c.

FNV_OFFSET_BASIS

#define FNV_OFFSET_BASIS   UINT64CONST(0xcbf29ce484222325)

Definition at line 84 of file pgbench.c.

FNV_PRIME

#define FNV_PRIME   UINT64CONST(0x100000001b3)

Definition at line 83 of file pgbench.c.

LOG_STEP_SECONDS

#define LOG_STEP_SECONDS   5 /* seconds between log messages */

Definition at line 165 of file pgbench.c.

M_PI

#define M_PI   3.14159265358979323846

Definition at line 73 of file pgbench.c.

MAX_ARGS

#define MAX_ARGS   256

Definition at line 685 of file pgbench.c.

MAX_FARGS

#define MAX_FARGS   16

Definition at line 2242 of file pgbench.c.

MAX_SCRIPTS

#define MAX_SCRIPTS   128 /* max number of SQL scripts allowed */

Definition at line 347 of file pgbench.c.

MAX_ZIPFIAN_PARAM

#define MAX_ZIPFIAN_PARAM   1000.0 /* maximum parameter for zipfian */

Definition at line 171 of file pgbench.c.

META_COMMAND

#define META_COMMAND   2

Definition at line 679 of file pgbench.c.

MIN_GAUSSIAN_PARAM

#define MIN_GAUSSIAN_PARAM   2.0 /* minimum parameter for gauss */

Definition at line 168 of file pgbench.c.

MIN_ZIPFIAN_PARAM

#define MIN_ZIPFIAN_PARAM   1.001 /* minimum parameter for zipfian */

Definition at line 170 of file pgbench.c.

MM2_MUL

#define MM2_MUL   UINT64CONST(0xc6a4a7935bd1e995)

Definition at line 85 of file pgbench.c.

MM2_MUL_TIMES_8

#define MM2_MUL_TIMES_8   UINT64CONST(0x35253c9ade8f4ca8)

Definition at line 86 of file pgbench.c.

MM2_ROT

#define MM2_ROT   47

Definition at line 87 of file pgbench.c.

naccounts

#define naccounts   100000

Definition at line 245 of file pgbench.c.

nbranches

#define nbranches

Value:

                                 1          /* Makes little sense to change this.  Change
                                 * -s instead */

Definition at line 243 of file pgbench.c.

ntellers

#define ntellers   10

Definition at line 244 of file pgbench.c.

PARAMS_ARRAY_SIZE

#define PARAMS_ARRAY_SIZE   7

PG_TIME_GET_DOUBLE

#define PG_TIME_GET_DOUBLE

(

t

)

(0.000001 * (t))

Definition at line 867 of file pgbench.c.

POLL_USING_SELECT

#define POLL_USING_SELECT

Definition at line 52 of file pgbench.c.

SCALE_32BIT_THRESHOLD

#define SCALE_32BIT_THRESHOLD   20000

Definition at line 254 of file pgbench.c.

SHELL_COMMAND_SIZE

#define SHELL_COMMAND_SIZE   256 /* maximum size allowed for shell command */

Definition at line 348 of file pgbench.c.

SOCKET_WAIT_METHOD

#define SOCKET_WAIT_METHOD   "select"

Definition at line 106 of file pgbench.c.

SQL_COMMAND

#define SQL_COMMAND   1

Definition at line 678 of file pgbench.c.

THREAD_BARRIER_DESTROY

#define THREAD_BARRIER_DESTROY

(

barrier

)

pthread_barrier_destroy((barrier))

Definition at line 155 of file pgbench.c.

THREAD_BARRIER_INIT

#define THREAD_BARRIER_INIT	(		barrier,
			n
	)		pthread_barrier_init((barrier), NULL, (n))

Definition at line 152 of file pgbench.c.

THREAD_BARRIER_T

#define THREAD_BARRIER_T   pthread_barrier_t

Definition at line 151 of file pgbench.c.

THREAD_BARRIER_WAIT

#define THREAD_BARRIER_WAIT

(

barrier

)

pthread_barrier_wait((barrier))

Definition at line 154 of file pgbench.c.

THREAD_CREATE

#define THREAD_CREATE	(		handle,
			function,
			arg
	)		pthread_create((handle), NULL, (function), (arg))

Definition at line 147 of file pgbench.c.

THREAD_FUNC_CC

#define THREAD_FUNC_CC

Definition at line 146 of file pgbench.c.

THREAD_FUNC_RETURN

#define THREAD_FUNC_RETURN   return NULL

Definition at line 145 of file pgbench.c.

THREAD_FUNC_RETURN_TYPE

#define THREAD_FUNC_RETURN_TYPE   void *

Definition at line 144 of file pgbench.c.

THREAD_JOIN

#define THREAD_JOIN

(

handle

)

pthread_join((handle), NULL)

Definition at line 149 of file pgbench.c.

THREAD_T

#define THREAD_T   pthread_t

Definition at line 143 of file pgbench.c.

VARIABLES_ALLOC_MARGIN

#define VARIABLES_ALLOC_MARGIN   8

Definition at line 310 of file pgbench.c.

WSEP

#define WSEP   '@' /* weight separator */

Definition at line 301 of file pgbench.c.

Typedef Documentation

BuiltinScript

typedef struct BuiltinScript BuiltinScript

Command

typedef struct Command Command

EStatus

typedef enum EStatus EStatus

initRowMethod

typedef void(* initRowMethod) (PQExpBufferData *sql, int64 curr)

Definition at line 843 of file pgbench.c.

MetaCommand

typedef enum MetaCommand MetaCommand

ParsedScript

typedef struct ParsedScript ParsedScript

pg_time_usec_t

typedef int64 pg_time_usec_t

Definition at line 370 of file pgbench.c.

QueryMode

typedef enum QueryMode QueryMode

SimpleStats

typedef struct SimpleStats SimpleStats

socket_set

typedef struct socket_set socket_set

StatsData

typedef struct StatsData StatsData

TStatus

typedef enum TStatus TStatus

Enumeration Type Documentation

ConnectionStateEnum

enum ConnectionStateEnum

Enumerator
CSTATE_CHOOSE_SCRIPT
CSTATE_START_TX
CSTATE_PREPARE_THROTTLE
CSTATE_THROTTLE
CSTATE_START_COMMAND
CSTATE_WAIT_RESULT
CSTATE_SLEEP
CSTATE_END_COMMAND
CSTATE_SKIP_COMMAND
CSTATE_ERROR
CSTATE_WAIT_ROLLBACK_RESULT
CSTATE_RETRY
CSTATE_FAILURE
CSTATE_END_TX
CSTATE_ABORTED
CSTATE_FINISHED

Definition at line 485 of file pgbench.c.

{
    /*
     * The client must first choose a script to execute.  Once chosen, it can
     * either be throttled (state CSTATE_PREPARE_THROTTLE under --rate), start
     * right away (state CSTATE_START_TX) or not start at all if the timer was
     * exceeded (state CSTATE_FINISHED).
     */
    CSTATE_CHOOSE_SCRIPT,
 
    /*
     * CSTATE_START_TX performs start-of-transaction processing.  Establishes
     * a new connection for the transaction in --connect mode, records the
     * transaction start time, and proceed to the first command.
     *
     * Note: once a script is started, it will either error or run till its
     * end, where it may be interrupted. It is not interrupted while running,
     * so pgbench --time is to be understood as tx are allowed to start in
     * that time, and will finish when their work is completed.
     */
    CSTATE_START_TX,
 
    /*
     * In CSTATE_PREPARE_THROTTLE state, we calculate when to begin the next
     * transaction, and advance to CSTATE_THROTTLE.  CSTATE_THROTTLE state
     * sleeps until that moment, then advances to CSTATE_START_TX, or
     * CSTATE_FINISHED if the next transaction would start beyond the end of
     * the run.
     */
    CSTATE_PREPARE_THROTTLE,
    CSTATE_THROTTLE,
 
    /*
     * We loop through these states, to process each command in the script:
     *
     * CSTATE_START_COMMAND starts the execution of a command.  On a SQL
     * command, the command is sent to the server, and we move to
     * CSTATE_WAIT_RESULT state unless in pipeline mode. On a \sleep
     * meta-command, the timer is set, and we enter the CSTATE_SLEEP state to
     * wait for it to expire. Other meta-commands are executed immediately. If
     * the command about to start is actually beyond the end of the script,
     * advance to CSTATE_END_TX.
     *
     * CSTATE_WAIT_RESULT waits until we get a result set back from the server
     * for the current command.
     *
     * CSTATE_SLEEP waits until the end of \sleep.
     *
     * CSTATE_END_COMMAND records the end-of-command timestamp, increments the
     * command counter, and loops back to CSTATE_START_COMMAND state.
     *
     * CSTATE_SKIP_COMMAND is used by conditional branches which are not
     * executed. It quickly skip commands that do not need any evaluation.
     * This state can move forward several commands, till there is something
     * to do or the end of the script.
     */
    CSTATE_START_COMMAND,
    CSTATE_WAIT_RESULT,
    CSTATE_SLEEP,
    CSTATE_END_COMMAND,
    CSTATE_SKIP_COMMAND,
 
    /*
     * States for failed commands.
     *
     * If the SQL/meta command fails, in CSTATE_ERROR clean up after an error:
     * (1) clear the conditional stack; (2) if we have an unterminated
     * (possibly failed) transaction block, send the rollback command to the
     * server and wait for the result in CSTATE_WAIT_ROLLBACK_RESULT.  If
     * something goes wrong with rolling back, go to CSTATE_ABORTED.
     *
     * But if everything is ok we are ready for future transactions: if this
     * is a serialization or deadlock error and we can re-execute the
     * transaction from the very beginning, go to CSTATE_RETRY; otherwise go
     * to CSTATE_FAILURE.
     *
     * In CSTATE_RETRY report an error, set the same parameters for the
     * transaction execution as in the previous tries and process the first
     * transaction command in CSTATE_START_COMMAND.
     *
     * In CSTATE_FAILURE report a failure, set the parameters for the
     * transaction execution as they were before the first run of this
     * transaction (except for a random state) and go to CSTATE_END_TX to
     * complete this transaction.
     */
    CSTATE_ERROR,
    CSTATE_WAIT_ROLLBACK_RESULT,
    CSTATE_RETRY,
    CSTATE_FAILURE,
 
    /*
     * CSTATE_END_TX performs end-of-transaction processing.  It calculates
     * latency, and logs the transaction.  In --connect mode, it closes the
     * current connection.
     *
     * Then either starts over in CSTATE_CHOOSE_SCRIPT, or enters
     * CSTATE_FINISHED if we have no more work to do.
     */
    CSTATE_END_TX,
 
    /*
     * Final states.  CSTATE_ABORTED means that the script execution was
     * aborted because a command failed, CSTATE_FINISHED means success.
     */
    CSTATE_ABORTED,
    CSTATE_FINISHED,

EStatus

enum EStatus

Enumerator
ESTATUS_NO_ERROR
ESTATUS_META_COMMAND_ERROR
ESTATUS_SERIALIZATION_ERROR
ESTATUS_DEADLOCK_ERROR
ESTATUS_OTHER_SQL_ERROR

Definition at line 454 of file pgbench.c.

{
    ESTATUS_NO_ERROR = 0,
    ESTATUS_META_COMMAND_ERROR,
 
    /* SQL errors */
    ESTATUS_SERIALIZATION_ERROR,
    ESTATUS_DEADLOCK_ERROR,
    ESTATUS_OTHER_SQL_ERROR,

MetaCommand

enum MetaCommand

Enumerator
META_NONE
META_SET
META_SETSHELL
META_SHELL
META_SLEEP
META_GSET
META_ASET
META_IF
META_ELIF
META_ELSE
META_ENDIF
META_STARTPIPELINE
META_SYNCPIPELINE
META_ENDPIPELINE

Definition at line 687 of file pgbench.c.

{
    META_NONE,                  /* not a known meta-command */
    META_SET,                   /* \set */
    META_SETSHELL,              /* \setshell */
    META_SHELL,                 /* \shell */
    META_SLEEP,                 /* \sleep */
    META_GSET,                  /* \gset */
    META_ASET,                  /* \aset */
    META_IF,                    /* \if */
    META_ELIF,                  /* \elif */
    META_ELSE,                  /* \else */
    META_ENDIF,                 /* \endif */
    META_STARTPIPELINE,         /* \startpipeline */
    META_SYNCPIPELINE,          /* \syncpipeline */
    META_ENDPIPELINE,           /* \endpipeline */

partition_method_t

enum partition_method_t

Enumerator
PART_NONE
PART_RANGE
PART_HASH

Definition at line 226 of file pgbench.c.

{
    PART_NONE,                  /* no partitioning */
    PART_RANGE,                 /* range partitioning */
    PART_HASH,                  /* hash partitioning */
} partition_method_t;

QueryMode

enum QueryMode

Enumerator
QUERY_SIMPLE
QUERY_EXTENDED
QUERY_PREPARED
NUM_QUERYMODE

Definition at line 705 of file pgbench.c.

{
    QUERY_SIMPLE,               /* simple query */
    QUERY_EXTENDED,             /* extended query */
    QUERY_PREPARED,             /* extended query with prepared statements */
    NUM_QUERYMODE

TStatus

enum TStatus

Enumerator
TSTATUS_IDLE
TSTATUS_IN_BLOCK
TSTATUS_CONN_ERROR
TSTATUS_OTHER_ERROR

Definition at line 468 of file pgbench.c.

{
    TSTATUS_IDLE,
    TSTATUS_IN_BLOCK,
    TSTATUS_CONN_ERROR,
    TSTATUS_OTHER_ERROR,

Function Documentation

accumStats()

static void accumStats ( StatsData *  stats, bool  skipped, double  lat, double  lag, EStatus  estatus, int64  tries  )

static

Definition at line 1451 of file pgbench.c.

{
    /* Record the skipped transaction */
    if (skipped)
    {
        /* no latency to record on skipped transactions */
        stats->skipped++;
        return;
    }
 
    /*
     * Record the number of retries regardless of whether the transaction was
     * successful or failed.
     */
    if (tries > 1)
    {
        stats->retries += (tries - 1);
        stats->retried++;
    }
 
    switch (estatus)
    {
            /* Record the successful transaction */
        case ESTATUS_NO_ERROR:
            stats->cnt++;
 
            addToSimpleStats(&stats->latency, lat);
 
            /* and possibly the same for schedule lag */
            if (throttle_delay)
                addToSimpleStats(&stats->lag, lag);
            break;
 
            /* Record the failed transaction */
        case ESTATUS_SERIALIZATION_ERROR:
            stats->serialization_failures++;
            break;
        case ESTATUS_DEADLOCK_ERROR:
            stats->deadlock_failures++;
            break;
        default:
            /* internal error which should never occur */
            pg_fatal("unexpected error status: %d", estatus);
    }

References addToSimpleStats(), StatsData::cnt, StatsData::deadlock_failures, ESTATUS_DEADLOCK_ERROR, ESTATUS_NO_ERROR, ESTATUS_SERIALIZATION_ERROR, StatsData::lag, StatsData::latency, pg_fatal, StatsData::retried, StatsData::retries, StatsData::serialization_failures, StatsData::skipped, and throttle_delay.

Referenced by doLog(), and processXactStats().

add_socket_to_set()

static void add_socket_to_set ( socket_set *  sa, int  fd, int  idx  )

static

Definition at line 7879 of file pgbench.c.

{
    /* See connect_slot() for background on this code. */
#ifdef WIN32
    if (sa->fds.fd_count + 1 >= FD_SETSIZE)
    {
        pg_log_error("too many concurrent database clients for this platform: %d",
                     sa->fds.fd_count + 1);
        exit(1);
    }
#else
    if (fd < 0 || fd >= FD_SETSIZE)
    {
        pg_log_error("socket file descriptor out of range for select(): %d",
                     fd);
        pg_log_error_hint("Try fewer concurrent database clients.");
        exit(1);
    }
#endif
    FD_SET(fd, &sa->fds);
    if (fd > sa->maxfd)
        sa->maxfd = fd;

References exit(), fd(), pg_log_error, and pg_log_error_hint.

Referenced by threadRun().

addScript()

static void addScript ( const ParsedScript *  script )

static

Definition at line 6193 of file pgbench.c.

{
    if (script->commands == NULL || script->commands[0] == NULL)
        pg_fatal("empty command list for script \"%s\"", script->desc);
 
    if (num_scripts >= MAX_SCRIPTS)
        pg_fatal("at most %d SQL scripts are allowed", MAX_SCRIPTS);
 
    CheckConditional(script);
 
    sql_script[num_scripts] = *script;
    num_scripts++;

References CheckConditional(), ParsedScript::commands, ParsedScript::desc, MAX_SCRIPTS, num_scripts, pg_fatal, and sql_script.

Referenced by ParseScript().

addToSimpleStats()

static void addToSimpleStats ( SimpleStats *  ss, double  val  )

static

Definition at line 1403 of file pgbench.c.

{
    if (ss->count == 0 || val < ss->min)
        ss->min = val;
    if (ss->count == 0 || val > ss->max)
        ss->max = val;
    ss->count++;
    ss->sum += val;
    ss->sum2 += val * val;

References SimpleStats::count, SimpleStats::max, SimpleStats::min, SimpleStats::sum, SimpleStats::sum2, and val.

Referenced by accumStats(), and advanceConnectionState().

advanceConnectionState()

static void advanceConnectionState ( TState *  thread, CState *  st, StatsData *  agg  )

static

Definition at line 3589 of file pgbench.c.

{
 
    /*
     * gettimeofday() isn't free, so we get the current timestamp lazily the
     * first time it's needed, and reuse the same value throughout this
     * function after that.  This also ensures that e.g. the calculated
     * latency reported in the log file and in the totals are the same. Zero
     * means "not set yet".  Reset "now" when we execute shell commands or
     * expressions, which might take a non-negligible amount of time, though.
     */
    pg_time_usec_t now = 0;
 
    /*
     * Loop in the state machine, until we have to wait for a result from the
     * server or have to sleep for throttling or \sleep.
     *
     * Note: In the switch-statement below, 'break' will loop back here,
     * meaning "continue in the state machine".  Return is used to return to
     * the caller, giving the thread the opportunity to advance another
     * client.
     */
    for (;;)
    {
        Command    *command;
 
        switch (st->state)
        {
                /* Select transaction (script) to run.  */
            case CSTATE_CHOOSE_SCRIPT:
                st->use_file = chooseScript(thread);
                Assert(conditional_stack_empty(st->cstack));
 
                /* reset transaction variables to default values */
                st->estatus = ESTATUS_NO_ERROR;
                st->tries = 1;
 
                pg_log_debug("client %d executing script \"%s\"",
                             st->id, sql_script[st->use_file].desc);
 
                /*
                 * If time is over, we're done; otherwise, get ready to start
                 * a new transaction, or to get throttled if that's requested.
                 */
                st->state = timer_exceeded ? CSTATE_FINISHED :
                    throttle_delay > 0 ? CSTATE_PREPARE_THROTTLE : CSTATE_START_TX;
                break;
 
                /* Start new transaction (script) */
            case CSTATE_START_TX:
                pg_time_now_lazy(&now);
 
                /* establish connection if needed, i.e. under --connect */
                if (st->con == NULL)
                {
                    pg_time_usec_t start = now;
 
                    if ((st->con = doConnect()) == NULL)
                    {
                        /*
                         * as the bench is already running, we do not abort
                         * the process
                         */
                        pg_log_error("client %d aborted while establishing connection", st->id);
                        st->state = CSTATE_ABORTED;
                        break;
                    }
 
                    /* reset now after connection */
                    now = pg_time_now();
 
                    thread->conn_duration += now - start;
 
                    /* Reset session-local state */
                    pg_free(st->prepared);
                    st->prepared = NULL;
                }
 
                /*
                 * It is the first try to run this transaction. Remember the
                 * random state: maybe it will get an error and we will need
                 * to run it again.
                 */
                st->random_state = st->cs_func_rs;
 
                /* record transaction start time */
                st->txn_begin = now;
 
                /*
                 * When not throttling, this is also the transaction's
                 * scheduled start time.
                 */
                if (!throttle_delay)
                    st->txn_scheduled = now;
 
                /* Begin with the first command */
                st->state = CSTATE_START_COMMAND;
                st->command = 0;
                break;
 
                /*
                 * Handle throttling once per transaction by sleeping.
                 */
            case CSTATE_PREPARE_THROTTLE:
 
                /*
                 * Generate a delay such that the series of delays will
                 * approximate a Poisson distribution centered on the
                 * throttle_delay time.
                 *
                 * If transactions are too slow or a given wait is shorter
                 * than a transaction, the next transaction will start right
                 * away.
                 */
                Assert(throttle_delay > 0);
 
                thread->throttle_trigger +=
                    getPoissonRand(&thread->ts_throttle_rs, throttle_delay);
                st->txn_scheduled = thread->throttle_trigger;
 
                /*
                 * If --latency-limit is used, and this slot is already late
                 * so that the transaction will miss the latency limit even if
                 * it completed immediately, skip this time slot and loop to
                 * reschedule.
                 */
                if (latency_limit)
                {
                    pg_time_now_lazy(&now);
 
                    if (thread->throttle_trigger < now - latency_limit)
                    {
                        processXactStats(thread, st, &now, true, agg);
 
                        /*
                         * Finish client if -T or -t was exceeded.
                         *
                         * Stop counting skipped transactions under -T as soon
                         * as the timer is exceeded. Because otherwise it can
                         * take a very long time to count all of them
                         * especially when quite a lot of them happen with
                         * unrealistically high rate setting in -R, which
                         * would prevent pgbench from ending immediately.
                         * Because of this behavior, note that there is no
                         * guarantee that all skipped transactions are counted
                         * under -T though there is under -t. This is OK in
                         * practice because it's very unlikely to happen with
                         * realistic setting.
                         */
                        if (timer_exceeded || (nxacts > 0 && st->cnt >= nxacts))
                            st->state = CSTATE_FINISHED;
 
                        /* Go back to top of loop with CSTATE_PREPARE_THROTTLE */
                        break;
                    }
                }
 
                /*
                 * stop client if next transaction is beyond pgbench end of
                 * execution; otherwise, throttle it.
                 */
                st->state = end_time > 0 && st->txn_scheduled > end_time ?
                    CSTATE_FINISHED : CSTATE_THROTTLE;
                break;
 
                /*
                 * Wait until it's time to start next transaction.
                 */
            case CSTATE_THROTTLE:
                pg_time_now_lazy(&now);
 
                if (now < st->txn_scheduled)
                    return;     /* still sleeping, nothing to do here */
 
                /* done sleeping, but don't start transaction if we're done */
                st->state = timer_exceeded ? CSTATE_FINISHED : CSTATE_START_TX;
                break;
 
                /*
                 * Send a command to server (or execute a meta-command)
                 */
            case CSTATE_START_COMMAND:
                command = sql_script[st->use_file].commands[st->command];
 
                /*
                 * Transition to script end processing if done, but close up
                 * shop if a pipeline is open at this point.
                 */
                if (command == NULL)
                {
                    if (PQpipelineStatus(st->con) == PQ_PIPELINE_OFF)
                        st->state = CSTATE_END_TX;
                    else
                    {
                        pg_log_error("client %d aborted: end of script reached with pipeline open",
                                     st->id);
                        st->state = CSTATE_ABORTED;
                    }
 
                    break;
                }
 
                /* record begin time of next command, and initiate it */
                if (report_per_command)
                {
                    pg_time_now_lazy(&now);
                    st->stmt_begin = now;
                }
 
                /* Execute the command */
                if (command->type == SQL_COMMAND)
                {
                    /* disallow \aset and \gset in pipeline mode */
                    if (PQpipelineStatus(st->con) != PQ_PIPELINE_OFF)
                    {
                        if (command->meta == META_GSET)
                        {
                            commandFailed(st, "gset", "\\gset is not allowed in pipeline mode");
                            st->state = CSTATE_ABORTED;
                            break;
                        }
                        else if (command->meta == META_ASET)
                        {
                            commandFailed(st, "aset", "\\aset is not allowed in pipeline mode");
                            st->state = CSTATE_ABORTED;
                            break;
                        }
                    }
 
                    if (!sendCommand(st, command))
                    {
                        commandFailed(st, "SQL", "SQL command send failed");
                        st->state = CSTATE_ABORTED;
                    }
                    else
                    {
                        /* Wait for results, unless in pipeline mode */
                        if (PQpipelineStatus(st->con) == PQ_PIPELINE_OFF)
                            st->state = CSTATE_WAIT_RESULT;
                        else
                            st->state = CSTATE_END_COMMAND;
                    }
                }
                else if (command->type == META_COMMAND)
                {
                    /*-----
                     * Possible state changes when executing meta commands:
                     * - on errors CSTATE_ABORTED
                     * - on sleep CSTATE_SLEEP
                     * - else CSTATE_END_COMMAND
                     */
                    st->state = executeMetaCommand(st, &now);
                    if (st->state == CSTATE_ABORTED)
                        st->estatus = ESTATUS_META_COMMAND_ERROR;
                }
 
                /*
                 * We're now waiting for an SQL command to complete, or
                 * finished processing a metacommand, or need to sleep, or
                 * something bad happened.
                 */
                Assert(st->state == CSTATE_WAIT_RESULT ||
                       st->state == CSTATE_END_COMMAND ||
                       st->state == CSTATE_SLEEP ||
                       st->state == CSTATE_ABORTED);
                break;
 
                /*
                 * non executed conditional branch
                 */
            case CSTATE_SKIP_COMMAND:
                Assert(!conditional_active(st->cstack));
                /* quickly skip commands until something to do... */
                while (true)
                {
                    command = sql_script[st->use_file].commands[st->command];
 
                    /* cannot reach end of script in that state */
                    Assert(command != NULL);
 
                    /*
                     * if this is conditional related, update conditional
                     * state
                     */
                    if (command->type == META_COMMAND &&
                        (command->meta == META_IF ||
                         command->meta == META_ELIF ||
                         command->meta == META_ELSE ||
                         command->meta == META_ENDIF))
                    {
                        switch (conditional_stack_peek(st->cstack))
                        {
                            case IFSTATE_FALSE:
                                if (command->meta == META_IF ||
                                    command->meta == META_ELIF)
                                {
                                    /* we must evaluate the condition */
                                    st->state = CSTATE_START_COMMAND;
                                }
                                else if (command->meta == META_ELSE)
                                {
                                    /* we must execute next command */
                                    conditional_stack_poke(st->cstack,
                                                           IFSTATE_ELSE_TRUE);
                                    st->state = CSTATE_START_COMMAND;
                                    st->command++;
                                }
                                else if (command->meta == META_ENDIF)
                                {
                                    Assert(!conditional_stack_empty(st->cstack));
                                    conditional_stack_pop(st->cstack);
                                    if (conditional_active(st->cstack))
                                        st->state = CSTATE_START_COMMAND;
 
                                    /*
                                     * else state remains in
                                     * CSTATE_SKIP_COMMAND
                                     */
                                    st->command++;
                                }
                                break;
 
                            case IFSTATE_IGNORED:
                            case IFSTATE_ELSE_FALSE:
                                if (command->meta == META_IF)
                                    conditional_stack_push(st->cstack,
                                                           IFSTATE_IGNORED);
                                else if (command->meta == META_ENDIF)
                                {
                                    Assert(!conditional_stack_empty(st->cstack));
                                    conditional_stack_pop(st->cstack);
                                    if (conditional_active(st->cstack))
                                        st->state = CSTATE_START_COMMAND;
                                }
                                /* could detect "else" & "elif" after "else" */
                                st->command++;
                                break;
 
                            case IFSTATE_NONE:
                            case IFSTATE_TRUE:
                            case IFSTATE_ELSE_TRUE:
                            default:
 
                                /*
                                 * inconsistent if inactive, unreachable dead
                                 * code
                                 */
                                Assert(false);
                        }
                    }
                    else
                    {
                        /* skip and consider next */
                        st->command++;
                    }
 
                    if (st->state != CSTATE_SKIP_COMMAND)
                        /* out of quick skip command loop */
                        break;
                }
                break;
 
                /*
                 * Wait for the current SQL command to complete
                 */
            case CSTATE_WAIT_RESULT:
                pg_log_debug("client %d receiving", st->id);
 
                /*
                 * Only check for new network data if we processed all data
                 * fetched prior. Otherwise we end up doing a syscall for each
                 * individual pipelined query, which has a measurable
                 * performance impact.
                 */
                if (PQisBusy(st->con) && !PQconsumeInput(st->con))
                {
                    /* there's something wrong */
                    commandFailed(st, "SQL", "perhaps the backend died while processing");
                    st->state = CSTATE_ABORTED;
                    break;
                }
                if (PQisBusy(st->con))
                    return;     /* don't have the whole result yet */
 
                /* store or discard the query results */
                if (readCommandResponse(st,
                                        sql_script[st->use_file].commands[st->command]->meta,
                                        sql_script[st->use_file].commands[st->command]->varprefix))
                {
                    /*
                     * outside of pipeline mode: stop reading results.
                     * pipeline mode: continue reading results until an
                     * end-of-pipeline response.
                     */
                    if (PQpipelineStatus(st->con) != PQ_PIPELINE_ON)
                        st->state = CSTATE_END_COMMAND;
                }
                else if (canRetryError(st->estatus))
                    st->state = CSTATE_ERROR;
                else
                    st->state = CSTATE_ABORTED;
                break;
 
                /*
                 * Wait until sleep is done. This state is entered after a
                 * \sleep metacommand. The behavior is similar to
                 * CSTATE_THROTTLE, but proceeds to CSTATE_START_COMMAND
                 * instead of CSTATE_START_TX.
                 */
            case CSTATE_SLEEP:
                pg_time_now_lazy(&now);
                if (now < st->sleep_until)
                    return;     /* still sleeping, nothing to do here */
                /* Else done sleeping. */
                st->state = CSTATE_END_COMMAND;
                break;
 
                /*
                 * End of command: record stats and proceed to next command.
                 */
            case CSTATE_END_COMMAND:
 
                /*
                 * command completed: accumulate per-command execution times
                 * in thread-local data structure, if per-command latencies
                 * are requested.
                 */
                if (report_per_command)
                {
                    pg_time_now_lazy(&now);
 
                    command = sql_script[st->use_file].commands[st->command];
                    /* XXX could use a mutex here, but we choose not to */
                    addToSimpleStats(&command->stats,
                                     PG_TIME_GET_DOUBLE(now - st->stmt_begin));
                }
 
                /* Go ahead with next command, to be executed or skipped */
                st->command++;
                st->state = conditional_active(st->cstack) ?
                    CSTATE_START_COMMAND : CSTATE_SKIP_COMMAND;
                break;
 
                /*
                 * Clean up after an error.
                 */
            case CSTATE_ERROR:
                {
                    TStatus     tstatus;
 
                    Assert(st->estatus != ESTATUS_NO_ERROR);
 
                    /* Clear the conditional stack */
                    conditional_stack_reset(st->cstack);
 
                    /* Read and discard until a sync point in pipeline mode */
                    if (PQpipelineStatus(st->con) != PQ_PIPELINE_OFF)
                    {
                        if (!discardUntilSync(st))
                        {
                            st->state = CSTATE_ABORTED;
                            break;
                        }
                    }
 
                    /*
                     * Check if we have a (failed) transaction block or not,
                     * and roll it back if any.
                     */
                    tstatus = getTransactionStatus(st->con);
                    if (tstatus == TSTATUS_IN_BLOCK)
                    {
                        /* Try to rollback a (failed) transaction block. */
                        if (!PQsendQuery(st->con, "ROLLBACK"))
                        {
                            pg_log_error("client %d aborted: failed to send sql command for rolling back the failed transaction",
                                         st->id);
                            st->state = CSTATE_ABORTED;
                        }
                        else
                            st->state = CSTATE_WAIT_ROLLBACK_RESULT;
                    }
                    else if (tstatus == TSTATUS_IDLE)
                    {
                        /*
                         * If time is over, we're done; otherwise, check if we
                         * can retry the error.
                         */
                        st->state = timer_exceeded ? CSTATE_FINISHED :
                            doRetry(st, &now) ? CSTATE_RETRY : CSTATE_FAILURE;
                    }
                    else
                    {
                        if (tstatus == TSTATUS_CONN_ERROR)
                            pg_log_error("perhaps the backend died while processing");
 
                        pg_log_error("client %d aborted while receiving the transaction status", st->id);
                        st->state = CSTATE_ABORTED;
                    }
                    break;
                }
 
                /*
                 * Wait for the rollback command to complete
                 */
            case CSTATE_WAIT_ROLLBACK_RESULT:
                {
                    PGresult   *res;
 
                    pg_log_debug("client %d receiving", st->id);
                    if (!PQconsumeInput(st->con))
                    {
                        pg_log_error("client %d aborted while rolling back the transaction after an error; perhaps the backend died while processing",
                                     st->id);
                        st->state = CSTATE_ABORTED;
                        break;
                    }
                    if (PQisBusy(st->con))
                        return; /* don't have the whole result yet */
 
                    /*
                     * Read and discard the query result;
                     */
                    res = PQgetResult(st->con);
                    switch (PQresultStatus(res))
                    {
                        case PGRES_COMMAND_OK:
                            /* OK */
                            PQclear(res);
                            /* null must be returned */
                            res = PQgetResult(st->con);
                            Assert(res == NULL);
 
                            /*
                             * If time is over, we're done; otherwise, check
                             * if we can retry the error.
                             */
                            st->state = timer_exceeded ? CSTATE_FINISHED :
                                doRetry(st, &now) ? CSTATE_RETRY : CSTATE_FAILURE;
                            break;
                        default:
                            pg_log_error("client %d aborted while rolling back the transaction after an error; %s",
                                         st->id, PQerrorMessage(st->con));
                            PQclear(res);
                            st->state = CSTATE_ABORTED;
                            break;
                    }
                    break;
                }
 
                /*
                 * Retry the transaction after an error.
                 */
            case CSTATE_RETRY:
                command = sql_script[st->use_file].commands[st->command];
 
                /*
                 * Inform that the transaction will be retried after the
                 * error.
                 */
                if (verbose_errors)
                    printVerboseErrorMessages(st, &now, true);
 
                /* Count tries and retries */
                st->tries++;
                command->retries++;
 
                /*
                 * Reset the random state as they were at the beginning of the
                 * transaction.
                 */
                st->cs_func_rs = st->random_state;
 
                /* Process the first transaction command. */
                st->command = 0;
                st->estatus = ESTATUS_NO_ERROR;
                st->state = CSTATE_START_COMMAND;
                break;
 
                /*
                 * Record a failed transaction.
                 */
            case CSTATE_FAILURE:
                command = sql_script[st->use_file].commands[st->command];
 
                /* Accumulate the failure. */
                command->failures++;
 
                /*
                 * Inform that the failed transaction will not be retried.
                 */
                if (verbose_errors)
                    printVerboseErrorMessages(st, &now, false);
 
                /* End the failed transaction. */
                st->state = CSTATE_END_TX;
                break;
 
                /*
                 * End of transaction (end of script, really).
                 */
            case CSTATE_END_TX:
                {
                    TStatus     tstatus;
 
                    /* transaction finished: calculate latency and do log */
                    processXactStats(thread, st, &now, false, agg);
 
                    /*
                     * missing \endif... cannot happen if CheckConditional was
                     * okay
                     */
                    Assert(conditional_stack_empty(st->cstack));
 
                    /*
                     * We must complete all the transaction blocks that were
                     * started in this script.
                     */
                    tstatus = getTransactionStatus(st->con);
                    if (tstatus == TSTATUS_IN_BLOCK)
                    {
                        pg_log_error("client %d aborted: end of script reached without completing the last transaction",
                                     st->id);
                        st->state = CSTATE_ABORTED;
                        break;
                    }
                    else if (tstatus != TSTATUS_IDLE)
                    {
                        if (tstatus == TSTATUS_CONN_ERROR)
                            pg_log_error("perhaps the backend died while processing");
 
                        pg_log_error("client %d aborted while receiving the transaction status", st->id);
                        st->state = CSTATE_ABORTED;
                        break;
                    }
 
                    if (is_connect)
                    {
                        pg_time_usec_t start = now;
 
                        pg_time_now_lazy(&start);
                        finishCon(st);
                        now = pg_time_now();
                        thread->conn_duration += now - start;
                    }
 
                    if ((st->cnt >= nxacts && duration <= 0) || timer_exceeded)
                    {
                        /* script completed */
                        st->state = CSTATE_FINISHED;
                        break;
                    }
 
                    /* next transaction (script) */
                    st->state = CSTATE_CHOOSE_SCRIPT;
 
                    /*
                     * Ensure that we always return on this point, so as to
                     * avoid an infinite loop if the script only contains meta
                     * commands.
                     */
                    return;
                }
 
                /*
                 * Final states.  Close the connection if it's still open.
                 */
            case CSTATE_ABORTED:
            case CSTATE_FINISHED:
 
                /*
                 * Don't measure the disconnection delays here even if in
                 * CSTATE_FINISHED and -C/--connect option is specified.
                 * Because in this case all the connections that this thread
                 * established are closed at the end of transactions and the
                 * disconnection delays should have already been measured at
                 * that moment.
                 *
                 * In CSTATE_ABORTED state, the measurement is no longer
                 * necessary because we cannot report complete results anyways
                 * in this case.
                 */
                finishCon(st);
                return;
        }
    }

References addToSimpleStats(), Assert, canRetryError(), chooseScript(), CState::cnt, CState::command, commandFailed(), ParsedScript::commands, CState::con, conditional_active(), conditional_stack_empty(), conditional_stack_peek(), conditional_stack_poke(), conditional_stack_pop(), conditional_stack_push(), conditional_stack_reset(), TState::conn_duration, CState::cs_func_rs, CState::cstack, CSTATE_ABORTED, CSTATE_CHOOSE_SCRIPT, CSTATE_END_COMMAND, CSTATE_END_TX, CSTATE_ERROR, CSTATE_FAILURE, CSTATE_FINISHED, CSTATE_PREPARE_THROTTLE, CSTATE_RETRY, CSTATE_SKIP_COMMAND, CSTATE_SLEEP, CSTATE_START_COMMAND, CSTATE_START_TX, CSTATE_THROTTLE, CSTATE_WAIT_RESULT, CSTATE_WAIT_ROLLBACK_RESULT, ParsedScript::desc, discardUntilSync(), doConnect(), doRetry(), duration, end_time, CState::estatus, ESTATUS_META_COMMAND_ERROR, ESTATUS_NO_ERROR, executeMetaCommand(), Command::failures, finishCon(), getPoissonRand(), getTransactionStatus(), CState::id, IFSTATE_ELSE_FALSE, IFSTATE_ELSE_TRUE, IFSTATE_FALSE, IFSTATE_IGNORED, IFSTATE_NONE, IFSTATE_TRUE, is_connect, latency_limit, Command::meta, META_ASET, META_COMMAND, META_ELIF, META_ELSE, META_ENDIF, META_GSET, META_IF, now(), nxacts, pg_free(), pg_log_debug, pg_log_error, PG_TIME_GET_DOUBLE, pg_time_now(), pg_time_now_lazy(), PGRES_COMMAND_OK, PQ_PIPELINE_OFF, PQ_PIPELINE_ON, PQclear(), PQconsumeInput(), PQerrorMessage(), PQgetResult(), PQisBusy(), PQpipelineStatus(), PQresultStatus(), PQsendQuery(), CState::prepared, printVerboseErrorMessages(), processXactStats(), CState::random_state, readCommandResponse(), report_per_command, res, Command::retries, sendCommand(), SQL_COMMAND, sql_script, start, CState::state, Command::stats, CState::stmt_begin, throttle_delay, TState::throttle_trigger, timer_exceeded, CState::tries, TState::ts_throttle_rs, TSTATUS_CONN_ERROR, TSTATUS_IDLE, TSTATUS_IN_BLOCK, CState::txn_begin, CState::txn_scheduled, Command::type, CState::use_file, Command::varprefix, and verbose_errors.

Referenced by threadRun().

alloc_socket_set()

static socket_set * alloc_socket_set ( int  count )

static

Definition at line 7860 of file pgbench.c.

{
    return (socket_set *) pg_malloc0(sizeof(socket_set));

References pg_malloc0().

Referenced by threadRun().

allocCStatePrepared()

static void allocCStatePrepared ( CState *  st )

static

Definition at line 3069 of file pgbench.c.

{
    Assert(st->prepared == NULL);
 
    st->prepared = pg_malloc(sizeof(bool *) * num_scripts);
    for (int i = 0; i < num_scripts; i++)
    {
        ParsedScript *script = &sql_script[i];
        int         numcmds;
 
        for (numcmds = 0; script->commands[numcmds] != NULL; numcmds++)
            ;
        st->prepared[i] = pg_malloc0(sizeof(bool) * numcmds);
    }

References Assert, ParsedScript::commands, i, num_scripts, pg_malloc(), pg_malloc0(), CState::prepared, and sql_script.

Referenced by prepareCommand(), and prepareCommandsInPipeline().

assignVariables()

static char* assignVariables ( Variables *  variables, char *  sql  )

static

Definition at line 1936 of file pgbench.c.

{
    char       *p,
               *name,
               *val;
 
    p = sql;
    while ((p = strchr(p, ':')) != NULL)
    {
        int         eaten;
 
        name = parseVariable(p, &eaten);
        if (name == NULL)
        {
            while (*p == ':')
            {
                p++;
            }
            continue;
        }
 
        val = getVariable(variables, name);
        free(name);
        if (val == NULL)
        {
            p++;
            continue;
        }
 
        p = replaceVariable(&sql, p, eaten, val);
    }
 
    return sql;

References free, getVariable(), name, parseVariable(), replaceVariable(), and val.

Referenced by sendCommand().

canRetryError()

static bool canRetryError ( EStatus  estatus )

static

Definition at line 3225 of file pgbench.c.

{
    return (estatus == ESTATUS_SERIALIZATION_ERROR ||
            estatus == ESTATUS_DEADLOCK_ERROR);

References ESTATUS_DEADLOCK_ERROR, and ESTATUS_SERIALIZATION_ERROR.

Referenced by advanceConnectionState(), doRetry(), and readCommandResponse().

CheckConditional()

static void CheckConditional ( const ParsedScript *  ps )

static

Definition at line 5855 of file pgbench.c.

{
    /* statically check conditional structure */
    ConditionalStack cs = conditional_stack_create();
    int         i;
 
    for (i = 0; ps->commands[i] != NULL; i++)
    {
        Command    *cmd = ps->commands[i];
 
        if (cmd->type == META_COMMAND)
        {
            switch (cmd->meta)
            {
                case META_IF:
                    conditional_stack_push(cs, IFSTATE_FALSE);
                    break;
                case META_ELIF:
                    if (conditional_stack_empty(cs))
                        ConditionError(ps->desc, i + 1, "\\elif without matching \\if");
                    if (conditional_stack_peek(cs) == IFSTATE_ELSE_FALSE)
                        ConditionError(ps->desc, i + 1, "\\elif after \\else");
                    break;
                case META_ELSE:
                    if (conditional_stack_empty(cs))
                        ConditionError(ps->desc, i + 1, "\\else without matching \\if");
                    if (conditional_stack_peek(cs) == IFSTATE_ELSE_FALSE)
                        ConditionError(ps->desc, i + 1, "\\else after \\else");
                    conditional_stack_poke(cs, IFSTATE_ELSE_FALSE);
                    break;
                case META_ENDIF:
                    if (!conditional_stack_pop(cs))
                        ConditionError(ps->desc, i + 1, "\\endif without matching \\if");
                    break;
                default:
                    /* ignore anything else... */
                    break;
            }
        }
    }
    if (!conditional_stack_empty(cs))
        ConditionError(ps->desc, i + 1, "\\if without matching \\endif");
    conditional_stack_destroy(cs);

References conditional_stack_create(), conditional_stack_destroy(), conditional_stack_empty(), conditional_stack_peek(), conditional_stack_poke(), conditional_stack_pop(), conditional_stack_push(), ConditionError(), i, IFSTATE_ELSE_FALSE, IFSTATE_FALSE, Command::meta, META_COMMAND, META_ELIF, META_ELSE, META_ENDIF, META_IF, ps, and Command::type.

Referenced by addScript().

checkInitSteps()

static void checkInitSteps ( const char *  initialize_steps )

static

Definition at line 5203 of file pgbench.c.

{
    if (initialize_steps[0] == '\0')
        pg_fatal("no initialization steps specified");
 
    for (const char *step = initialize_steps; *step != '\0'; step++)
    {
        if (strchr(ALL_INIT_STEPS " ", *step) == NULL)
        {
            pg_log_error("unrecognized initialization step \"%c\"", *step);
            pg_log_error_detail("Allowed step characters are: \"" ALL_INIT_STEPS "\".");
            exit(1);
        }
    }

References ALL_INIT_STEPS, exit(), pg_fatal, pg_log_error, and pg_log_error_detail.

Referenced by main().

chooseScript()

static int chooseScript ( TState *  thread )

static

Definition at line 3047 of file pgbench.c.

{
    int         i = 0;
    int64       w;
 
    if (num_scripts == 1)
        return 0;
 
    w = getrand(&thread->ts_choose_rs, 0, total_weight - 1);
    do
    {
        w -= sql_script[i++].weight;
    } while (w >= 0);
 
    return i - 1;

References getrand(), i, num_scripts, sql_script, total_weight, TState::ts_choose_rs, and ParsedScript::weight.

Referenced by advanceConnectionState().

clear_socket_set()

static void clear_socket_set ( socket_set *  sa )

static

Definition at line 7872 of file pgbench.c.

{
    FD_ZERO(&sa->fds);
    sa->maxfd = -1;

Referenced by threadRun().

coerceToBool()

static bool coerceToBool ( PgBenchValue *  pval, bool *  bval  )

static

Definition at line 2004 of file pgbench.c.

{
    if (pval->type == PGBT_BOOLEAN)
    {
        *bval = pval->u.bval;
        return true;
    }
    else                        /* NULL, INT or DOUBLE */
    {
        pg_log_error("cannot coerce %s to boolean", valueTypeName(pval));
        *bval = false;          /* suppress uninitialized-variable warnings */
        return false;
    }

References PgBenchValue::bval, pg_log_error, PGBT_BOOLEAN, PgBenchValue::type, PgBenchValue::u, and valueTypeName().

Referenced by evalLazyFunc(), and evalStandardFunc().

coerceToDouble()

static bool coerceToDouble ( PgBenchValue *  pval, double *  dval  )

static

Definition at line 2073 of file pgbench.c.

{
    if (pval->type == PGBT_DOUBLE)
    {
        *dval = pval->u.dval;
        return true;
    }
    else if (pval->type == PGBT_INT)
    {
        *dval = (double) pval->u.ival;
        return true;
    }
    else                        /* BOOLEAN or NULL */
    {
        pg_log_error("cannot coerce %s to double", valueTypeName(pval));
        return false;
    }

References PgBenchValue::dval, PgBenchValue::ival, pg_log_error, PGBT_DOUBLE, PGBT_INT, PgBenchValue::type, PgBenchValue::u, and valueTypeName().

Referenced by evalStandardFunc().

coerceToInt()

static bool coerceToInt ( PgBenchValue *  pval, int64 *  ival  )

static

Definition at line 2045 of file pgbench.c.

{
    if (pval->type == PGBT_INT)
    {
        *ival = pval->u.ival;
        return true;
    }
    else if (pval->type == PGBT_DOUBLE)
    {
        double      dval = rint(pval->u.dval);
 
        if (isnan(dval) || !FLOAT8_FITS_IN_INT64(dval))
        {
            pg_log_error("double to int overflow for %f", dval);
            return false;
        }
        *ival = (int64) dval;
        return true;
    }
    else                        /* BOOLEAN or NULL */
    {
        pg_log_error("cannot coerce %s to int", valueTypeName(pval));
        return false;
    }

References PgBenchValue::dval, FLOAT8_FITS_IN_INT64, PgBenchValue::ival, pg_log_error, PGBT_DOUBLE, PGBT_INT, PgBenchValue::type, PgBenchValue::u, and valueTypeName().

Referenced by evalStandardFunc().

commandError()

static void commandError ( CState *  st, const char *  message  )

static

Definition at line 3038 of file pgbench.c.

{
    Assert(sql_script[st->use_file].commands[st->command]->type == SQL_COMMAND);
    pg_log_info("client %d got an error in command %d (SQL) of script %d; %s",
                st->id, st->command, st->use_file, message);

References Assert, CState::command, ParsedScript::commands, CState::id, pg_log_info, SQL_COMMAND, sql_script, Command::type, and CState::use_file.

Referenced by readCommandResponse().

commandFailed()

static void commandFailed ( CState *  st, const char *  cmd, const char *  message  )

static

Definition at line 3028 of file pgbench.c.

{
    pg_log_error("client %d aborted in command %d (%s) of script %d; %s",
                 st->id, st->command, cmd, st->use_file, message);

References CState::command, CState::id, pg_log_error, and CState::use_file.

Referenced by advanceConnectionState(), and executeMetaCommand().

compareVariableNames()

static int compareVariableNames ( const void *  v1, const void *  v2  )

static

Definition at line 1596 of file pgbench.c.

{
    return strcmp(((const Variable *) v1)->name,
                  ((const Variable *) v2)->name);

References name.

Referenced by lookupVariable().

computeIterativeZipfian()

static int64 computeIterativeZipfian ( pg_prng_state *  state, int64  n, double  s  )

static

Definition at line 1201 of file pgbench.c.

{
    double      b = pow(2.0, s - 1.0);
    double      x,
                t,
                u,
                v;
 
    /* Ensure n is sane */
    if (n <= 1)
        return 1;
 
    while (true)
    {
        /* random variates */
        u = pg_prng_double(state);
        v = pg_prng_double(state);
 
        x = floor(pow(u, -1.0 / (s - 1.0)));
 
        t = pow(1.0 + 1.0 / x, s - 1.0);
        /* reject if too large or out of bound */
        if (v * x * (t - 1.0) / (b - 1.0) <= t / b && x <= n)
            break;
    }
    return (int64) x;

References b, pg_prng_double(), and x.

Referenced by getZipfianRand().

ConditionError()

static void ConditionError ( const char *  desc, int  cmdn, const char *  msg  )

static

Definition at line 5845 of file pgbench.c.

{
    pg_fatal("condition error in script \"%s\" command %d: %s",
             desc, cmdn, msg);

References pg_fatal.

Referenced by CheckConditional().

create_sql_command()

static Command* create_sql_command ( PQExpBuffer  buf, const char *  source  )

static

Definition at line 5549 of file pgbench.c.

{
    Command    *my_command;
    char       *p = skip_sql_comments(buf->data);
 
    if (p == NULL)
        return NULL;
 
    /* Allocate and initialize Command structure */
    my_command = (Command *) pg_malloc(sizeof(Command));
    initPQExpBuffer(&my_command->lines);
    appendPQExpBufferStr(&my_command->lines, p);
    my_command->first_line = NULL;  /* this is set later */
    my_command->type = SQL_COMMAND;
    my_command->meta = META_NONE;
    my_command->argc = 0;
    my_command->retries = 0;
    my_command->failures = 0;
    memset(my_command->argv, 0, sizeof(my_command->argv));
    my_command->varprefix = NULL;   /* allocated later, if needed */
    my_command->expr = NULL;
    initSimpleStats(&my_command->stats);
    my_command->prepname = NULL;    /* set later, if needed */
 
    return my_command;

References appendPQExpBufferStr(), Command::argc, Command::argv, buf, Command::expr, Command::failures, Command::first_line, initPQExpBuffer(), initSimpleStats(), Command::lines, Command::meta, META_NONE, pg_malloc(), Command::prepname, Command::retries, skip_sql_comments(), SQL_COMMAND, Command::stats, Command::type, and Command::varprefix.

Referenced by ParseScript().

createPartitions()

static void createPartitions ( PGconn *  con )

static

Definition at line 4739 of file pgbench.c.

{
    PQExpBufferData query;
 
    /* we must have to create some partitions */
    Assert(partitions > 0);
 
    fprintf(stderr, "creating %d partitions...\n", partitions);
 
    initPQExpBuffer(&query);
 
    for (int p = 1; p <= partitions; p++)
    {
        if (partition_method == PART_RANGE)
        {
            int64       part_size = (naccounts * (int64) scale + partitions - 1) / partitions;
 
            printfPQExpBuffer(&query,
                              "create%s table pgbench_accounts_%d\n"
                              "  partition of pgbench_accounts\n"
                              "  for values from (",
                              unlogged_tables ? " unlogged" : "", p);
 
            /*
             * For RANGE, we use open-ended partitions at the beginning and
             * end to allow any valid value for the primary key.  Although the
             * actual minimum and maximum values can be derived from the
             * scale, it is more generic and the performance is better.
             */
            if (p == 1)
                appendPQExpBufferStr(&query, "minvalue");
            else
                appendPQExpBuffer(&query, INT64_FORMAT, (p - 1) * part_size + 1);
 
            appendPQExpBufferStr(&query, ") to (");
 
            if (p < partitions)
                appendPQExpBuffer(&query, INT64_FORMAT, p * part_size + 1);
            else
                appendPQExpBufferStr(&query, "maxvalue");
 
            appendPQExpBufferChar(&query, ')');
        }
        else if (partition_method == PART_HASH)
            printfPQExpBuffer(&query,
                              "create%s table pgbench_accounts_%d\n"
                              "  partition of pgbench_accounts\n"
                              "  for values with (modulus %d, remainder %d)",
                              unlogged_tables ? " unlogged" : "", p,
                              partitions, p - 1);
        else                    /* cannot get there */
            Assert(0);
 
        /*
         * Per ddlinfo in initCreateTables, fillfactor is needed on table
         * pgbench_accounts.
         */
        appendPQExpBuffer(&query, " with (fillfactor=%d)", fillfactor);
 
        executeStatement(con, query.data);
    }
 
    termPQExpBuffer(&query);

References appendPQExpBuffer(), appendPQExpBufferChar(), appendPQExpBufferStr(), Assert, PQExpBufferData::data, executeStatement(), fillfactor, fprintf, initPQExpBuffer(), INT64_FORMAT, naccounts, PART_HASH, PART_RANGE, partition_method, partitions, printfPQExpBuffer(), scale, termPQExpBuffer(), and unlogged_tables.

Referenced by initCreateTables().

discardUntilSync()

static int discardUntilSync ( CState *  st )

static

Definition at line 3474 of file pgbench.c.

{
    /* send a sync */
    if (!PQpipelineSync(st->con))
    {
        pg_log_error("client %d aborted: failed to send a pipeline sync",
                     st->id);
        return 0;
    }
 
    /* receive PGRES_PIPELINE_SYNC and null following it */
    for (;;)
    {
        PGresult   *res = PQgetResult(st->con);
 
        if (PQresultStatus(res) == PGRES_PIPELINE_SYNC)
        {
            PQclear(res);
            res = PQgetResult(st->con);
            Assert(res == NULL);
            break;
        }
        PQclear(res);
    }
 
    /* exit pipeline */
    if (PQexitPipelineMode(st->con) != 1)
    {
        pg_log_error("client %d aborted: failed to exit pipeline mode for rolling back the failed transaction",
                     st->id);
        return 0;
    }
    return 1;

References Assert, CState::con, CState::id, pg_log_error, PGRES_PIPELINE_SYNC, PQclear(), PQexitPipelineMode(), PQgetResult(), PQpipelineSync(), PQresultStatus(), and res.

Referenced by advanceConnectionState().

disconnect_all()

static void disconnect_all ( CState *  state, int  length  )

static

Definition at line 4705 of file pgbench.c.

{
    int         i;
 
    for (i = 0; i < length; i++)
        finishCon(&state[i]);

References finishCon(), and i.

Referenced by main(), and threadRun().

doConnect()

static PGconn* doConnect ( void  )

static

Definition at line 1531 of file pgbench.c.

{
    PGconn     *conn;
    bool        new_pass;
    static char *password = NULL;
 
    /*
     * Start the connection.  Loop until we have a password if requested by
     * backend.
     */
    do
    {
#define PARAMS_ARRAY_SIZE   7
 
        const char *keywords[PARAMS_ARRAY_SIZE];
        const char *values[PARAMS_ARRAY_SIZE];
 
        keywords[0] = "host";
        values[0] = pghost;
        keywords[1] = "port";
        values[1] = pgport;
        keywords[2] = "user";
        values[2] = username;
        keywords[3] = "password";
        values[3] = password;
        keywords[4] = "dbname";
        values[4] = dbName;
        keywords[5] = "fallback_application_name";
        values[5] = progname;
        keywords[6] = NULL;
        values[6] = NULL;
 
        new_pass = false;
 
        conn = PQconnectdbParams(keywords, values, true);
 
        if (!conn)
        {
            pg_log_error("connection to database \"%s\" failed", dbName);
            return NULL;
        }
 
        if (PQstatus(conn) == CONNECTION_BAD &&
            PQconnectionNeedsPassword(conn) &&
            !password)
        {
            PQfinish(conn);
            password = simple_prompt("Password: ", false);
            new_pass = true;
        }
    } while (new_pass);
 
    /* check to see that the backend connection was successfully made */
    if (PQstatus(conn) == CONNECTION_BAD)
    {
        pg_log_error("%s", PQerrorMessage(conn));
        PQfinish(conn);
        return NULL;
    }
 
    return conn;

References conn, CONNECTION_BAD, dbName, PARAMS_ARRAY_SIZE, password, pg_log_error, pghost, pgport, PQconnectdbParams(), PQconnectionNeedsPassword(), PQerrorMessage(), PQfinish(), PQstatus(), progname, simple_prompt(), username, and values.

Referenced by advanceConnectionState(), main(), runInitSteps(), and threadRun().

doLog()

static void doLog ( TState *  thread, CState *  st, StatsData *  agg, bool  skipped, double  latency, double  lag  )

static

Definition at line 4546 of file pgbench.c.

{
    FILE       *logfile = thread->logfile;
    pg_time_usec_t now = pg_time_now() + epoch_shift;
 
    Assert(use_log);
 
    /*
     * Skip the log entry if sampling is enabled and this row doesn't belong
     * to the random sample.
     */
    if (sample_rate != 0.0 &&
        pg_prng_double(&thread->ts_sample_rs) > sample_rate)
        return;
 
    /* should we aggregate the results or not? */
    if (agg_interval > 0)
    {
        pg_time_usec_t next;
 
        /*
         * Loop until we reach the interval of the current moment, and print
         * any empty intervals in between (this may happen with very low tps,
         * e.g. --rate=0.1).
         */
 
        while ((next = agg->start_time + agg_interval * INT64CONST(1000000)) <= now)
        {
            double      lag_sum = 0.0;
            double      lag_sum2 = 0.0;
            double      lag_min = 0.0;
            double      lag_max = 0.0;
            int64       skipped = 0;
            int64       serialization_failures = 0;
            int64       deadlock_failures = 0;
            int64       retried = 0;
            int64       retries = 0;
 
            /* print aggregated report to logfile */
            fprintf(logfile, INT64_FORMAT " " INT64_FORMAT " %.0f %.0f %.0f %.0f",
                    agg->start_time / 1000000,  /* seconds since Unix epoch */
                    agg->cnt,
                    agg->latency.sum,
                    agg->latency.sum2,
                    agg->latency.min,
                    agg->latency.max);
 
            if (throttle_delay)
            {
                lag_sum = agg->lag.sum;
                lag_sum2 = agg->lag.sum2;
                lag_min = agg->lag.min;
                lag_max = agg->lag.max;
            }
            fprintf(logfile, " %.0f %.0f %.0f %.0f",
                    lag_sum,
                    lag_sum2,
                    lag_min,
                    lag_max);
 
            if (latency_limit)
                skipped = agg->skipped;
            fprintf(logfile, " " INT64_FORMAT, skipped);
 
            if (max_tries != 1)
            {
                retried = agg->retried;
                retries = agg->retries;
            }
            fprintf(logfile, " " INT64_FORMAT " " INT64_FORMAT, retried, retries);
 
            if (failures_detailed)
            {
                serialization_failures = agg->serialization_failures;
                deadlock_failures = agg->deadlock_failures;
            }
            fprintf(logfile, " " INT64_FORMAT " " INT64_FORMAT,
                    serialization_failures,
                    deadlock_failures);
 
            fputc('\n', logfile);
 
            /* reset data and move to next interval */
            initStats(agg, next);
        }
 
        /* accumulate the current transaction */
        accumStats(agg, skipped, latency, lag, st->estatus, st->tries);
    }
    else
    {
        /* no, print raw transactions */
        if (!skipped && st->estatus == ESTATUS_NO_ERROR)
            fprintf(logfile, "%d " INT64_FORMAT " %.0f %d " INT64_FORMAT " "
                    INT64_FORMAT,
                    st->id, st->cnt, latency, st->use_file,
                    now / 1000000, now % 1000000);
        else
            fprintf(logfile, "%d " INT64_FORMAT " %s %d " INT64_FORMAT " "
                    INT64_FORMAT,
                    st->id, st->cnt, getResultString(skipped, st->estatus),
                    st->use_file, now / 1000000, now % 1000000);
 
        if (throttle_delay)
            fprintf(logfile, " %.0f", lag);
        if (max_tries != 1)
            fprintf(logfile, " %u", st->tries - 1);
        fputc('\n', logfile);
    }

References accumStats(), agg_interval, Assert, StatsData::cnt, CState::cnt, StatsData::deadlock_failures, epoch_shift, CState::estatus, ESTATUS_NO_ERROR, failures_detailed, fprintf, getResultString(), CState::id, initStats(), INT64_FORMAT, StatsData::lag, StatsData::latency, latency_limit, TState::logfile, logfile, SimpleStats::max, max_tries, SimpleStats::min, next, now(), pg_prng_double(), pg_time_now(), StatsData::retried, StatsData::retries, sample_rate, StatsData::serialization_failures, StatsData::skipped, StatsData::start_time, SimpleStats::sum, SimpleStats::sum2, throttle_delay, CState::tries, TState::ts_sample_rs, CState::use_file, and use_log.

Referenced by processXactStats(), and threadRun().

doRetry()

static bool doRetry ( CState *  st, pg_time_usec_t *  now  )

static

Definition at line 3428 of file pgbench.c.

{
    Assert(st->estatus != ESTATUS_NO_ERROR);
 
    /* We can only retry serialization or deadlock errors. */
    if (!canRetryError(st->estatus))
        return false;
 
    /*
     * We must have at least one option to limit the retrying of transactions
     * that got an error.
     */
    Assert(max_tries || latency_limit || duration > 0);
 
    /*
     * We cannot retry the error if we have reached the maximum number of
     * tries.
     */
    if (max_tries && st->tries >= max_tries)
        return false;
 
    /*
     * We cannot retry the error if we spent too much time on this
     * transaction.
     */
    if (latency_limit)
    {
        pg_time_now_lazy(now);
        if (*now - st->txn_scheduled > latency_limit)
            return false;
    }
 
    /*
     * We cannot retry the error if the benchmark duration is over.
     */
    if (timer_exceeded)
        return false;
 
    /* OK */
    return true;

References Assert, canRetryError(), duration, CState::estatus, ESTATUS_NO_ERROR, latency_limit, max_tries, now(), pg_time_now_lazy(), timer_exceeded, CState::tries, and CState::txn_scheduled.

Referenced by advanceConnectionState().

enlargeVariables()

static void enlargeVariables ( Variables *  variables, int  needed  )

static

Definition at line 1773 of file pgbench.c.

{
    /* total number of variables required now */
    needed += variables->nvars;
 
    if (variables->max_vars < needed)
    {
        variables->max_vars = needed + VARIABLES_ALLOC_MARGIN;
        variables->vars = (Variable *)
            pg_realloc(variables->vars, variables->max_vars * sizeof(Variable));
    }

References Variables::max_vars, Variables::nvars, pg_realloc(), VARIABLES_ALLOC_MARGIN, and Variables::vars.

Referenced by lookupCreateVariable().

evalFunc()

static bool evalFunc ( CState *  st, PgBenchFunction  func, PgBenchExprLink *  args, PgBenchValue *  retval  )

static

Definition at line 2821 of file pgbench.c.

{
    if (isLazyFunc(func))
        return evalLazyFunc(st, func, args, retval);
    else
        return evalStandardFunc(st, func, args, retval);

References generate_unaccent_rules::args, evalLazyFunc(), evalStandardFunc(), and isLazyFunc().

Referenced by evaluateExpr().

evalLazyFunc()

static bool evalLazyFunc ( CState *  st, PgBenchFunction  func, PgBenchExprLink *  args, PgBenchValue *  retval  )

static

Definition at line 2132 of file pgbench.c.

{
    PgBenchValue a1,
                a2;
    bool        ba1,
                ba2;
 
    Assert(isLazyFunc(func) && args != NULL && args->next != NULL);
 
    /* args points to first condition */
    if (!evaluateExpr(st, args->expr, &a1))
        return false;
 
    /* second condition for AND/OR and corresponding branch for CASE */
    args = args->next;
 
    switch (func)
    {
        case PGBENCH_AND:
            if (a1.type == PGBT_NULL)
            {
                setNullValue(retval);
                return true;
            }
 
            if (!coerceToBool(&a1, &ba1))
                return false;
 
            if (!ba1)
            {
                setBoolValue(retval, false);
                return true;
            }
 
            if (!evaluateExpr(st, args->expr, &a2))
                return false;
 
            if (a2.type == PGBT_NULL)
            {
                setNullValue(retval);
                return true;
            }
            else if (!coerceToBool(&a2, &ba2))
                return false;
            else
            {
                setBoolValue(retval, ba2);
                return true;
            }
 
            return true;
 
        case PGBENCH_OR:
 
            if (a1.type == PGBT_NULL)
            {
                setNullValue(retval);
                return true;
            }
 
            if (!coerceToBool(&a1, &ba1))
                return false;
 
            if (ba1)
            {
                setBoolValue(retval, true);
                return true;
            }
 
            if (!evaluateExpr(st, args->expr, &a2))
                return false;
 
            if (a2.type == PGBT_NULL)
            {
                setNullValue(retval);
                return true;
            }
            else if (!coerceToBool(&a2, &ba2))
                return false;
            else
            {
                setBoolValue(retval, ba2);
                return true;
            }
 
        case PGBENCH_CASE:
            /* when true, execute branch */
            if (valueTruth(&a1))
                return evaluateExpr(st, args->expr, retval);
 
            /* now args contains next condition or final else expression */
            args = args->next;
 
            /* final else case? */
            if (args->next == NULL)
                return evaluateExpr(st, args->expr, retval);
 
            /* no, another when, proceed */
            return evalLazyFunc(st, PGBENCH_CASE, args, retval);
 
        default:
            /* internal error, cannot get here */
            Assert(0);
            break;
    }
    return false;

References a1, a2, generate_unaccent_rules::args, Assert, coerceToBool(), evaluateExpr(), isLazyFunc(), PGBENCH_AND, PGBENCH_CASE, PGBENCH_OR, PGBT_NULL, setBoolValue(), setNullValue(), and valueTruth().

Referenced by evalFunc().

evalStandardFunc()

static bool evalStandardFunc ( CState *  st, PgBenchFunction  func, PgBenchExprLink *  args, PgBenchValue *  retval  )

static

Definition at line 2249 of file pgbench.c.

{
    /* evaluate all function arguments */
    int         nargs = 0;
    PgBenchExprLink *l = args;
    bool        has_null = false;
 
    /*
     * This value is double braced to workaround GCC bug 53119, which seems to
     * exist at least on gcc (Debian 4.7.2-5) 4.7.2, 32-bit.
     */
    PgBenchValue vargs[MAX_FARGS] = {{0}};
 
    for (nargs = 0; nargs < MAX_FARGS && l != NULL; nargs++, l = l->next)
    {
        if (!evaluateExpr(st, l->expr, &vargs[nargs]))
            return false;
        has_null |= vargs[nargs].type == PGBT_NULL;
    }
 
    if (l != NULL)
    {
        pg_log_error("too many function arguments, maximum is %d", MAX_FARGS);
        return false;
    }
 
    /* NULL arguments */
    if (has_null && func != PGBENCH_IS && func != PGBENCH_DEBUG)
    {
        setNullValue(retval);
        return true;
    }
 
    /* then evaluate function */
    switch (func)
    {
            /* overloaded operators */
        case PGBENCH_ADD:
        case PGBENCH_SUB:
        case PGBENCH_MUL:
        case PGBENCH_DIV:
        case PGBENCH_MOD:
        case PGBENCH_EQ:
        case PGBENCH_NE:
        case PGBENCH_LE:
        case PGBENCH_LT:
            {
                PgBenchValue *lval = &vargs[0],
                           *rval = &vargs[1];
 
                Assert(nargs == 2);
 
                /* overloaded type management, double if some double */
                if ((lval->type == PGBT_DOUBLE ||
                     rval->type == PGBT_DOUBLE) && func != PGBENCH_MOD)
                {
                    double      ld,
                                rd;
 
                    if (!coerceToDouble(lval, &ld) ||
                        !coerceToDouble(rval, &rd))
                        return false;
 
                    switch (func)
                    {
                        case PGBENCH_ADD:
                            setDoubleValue(retval, ld + rd);
                            return true;
 
                        case PGBENCH_SUB:
                            setDoubleValue(retval, ld - rd);
                            return true;
 
                        case PGBENCH_MUL:
                            setDoubleValue(retval, ld * rd);
                            return true;
 
                        case PGBENCH_DIV:
                            setDoubleValue(retval, ld / rd);
                            return true;
 
                        case PGBENCH_EQ:
                            setBoolValue(retval, ld == rd);
                            return true;
 
                        case PGBENCH_NE:
                            setBoolValue(retval, ld != rd);
                            return true;
 
                        case PGBENCH_LE:
                            setBoolValue(retval, ld <= rd);
                            return true;
 
                        case PGBENCH_LT:
                            setBoolValue(retval, ld < rd);
                            return true;
 
                        default:
                            /* cannot get here */
                            Assert(0);
                    }
                }
                else            /* we have integer operands, or % */
                {
                    int64       li,
                                ri,
                                res;
 
                    if (!coerceToInt(lval, &li) ||
                        !coerceToInt(rval, &ri))
                        return false;
 
                    switch (func)
                    {
                        case PGBENCH_ADD:
                            if (pg_add_s64_overflow(li, ri, &res))
                            {
                                pg_log_error("bigint add out of range");
                                return false;
                            }
                            setIntValue(retval, res);
                            return true;
 
                        case PGBENCH_SUB:
                            if (pg_sub_s64_overflow(li, ri, &res))
                            {
                                pg_log_error("bigint sub out of range");
                                return false;
                            }
                            setIntValue(retval, res);
                            return true;
 
                        case PGBENCH_MUL:
                            if (pg_mul_s64_overflow(li, ri, &res))
                            {
                                pg_log_error("bigint mul out of range");
                                return false;
                            }
                            setIntValue(retval, res);
                            return true;
 
                        case PGBENCH_EQ:
                            setBoolValue(retval, li == ri);
                            return true;
 
                        case PGBENCH_NE:
                            setBoolValue(retval, li != ri);
                            return true;
 
                        case PGBENCH_LE:
                            setBoolValue(retval, li <= ri);
                            return true;
 
                        case PGBENCH_LT:
                            setBoolValue(retval, li < ri);
                            return true;
 
                        case PGBENCH_DIV:
                        case PGBENCH_MOD:
                            if (ri == 0)
                            {
                                pg_log_error("division by zero");
                                return false;
                            }
                            /* special handling of -1 divisor */
                            if (ri == -1)
                            {
                                if (func == PGBENCH_DIV)
                                {
                                    /* overflow check (needed for INT64_MIN) */
                                    if (li == PG_INT64_MIN)
                                    {
                                        pg_log_error("bigint div out of range");
                                        return false;
                                    }
                                    else
                                        setIntValue(retval, -li);
                                }
                                else
                                    setIntValue(retval, 0);
                                return true;
                            }
                            /* else divisor is not -1 */
                            if (func == PGBENCH_DIV)
                                setIntValue(retval, li / ri);
                            else    /* func == PGBENCH_MOD */
                                setIntValue(retval, li % ri);
 
                            return true;
 
                        default:
                            /* cannot get here */
                            Assert(0);
                    }
                }
 
                Assert(0);
                return false;   /* NOTREACHED */
            }
 
            /* integer bitwise operators */
        case PGBENCH_BITAND:
        case PGBENCH_BITOR:
        case PGBENCH_BITXOR:
        case PGBENCH_LSHIFT:
        case PGBENCH_RSHIFT:
            {
                int64       li,
                            ri;
 
                if (!coerceToInt(&vargs[0], &li) || !coerceToInt(&vargs[1], &ri))
                    return false;
 
                if (func == PGBENCH_BITAND)
                    setIntValue(retval, li & ri);
                else if (func == PGBENCH_BITOR)
                    setIntValue(retval, li | ri);
                else if (func == PGBENCH_BITXOR)
                    setIntValue(retval, li ^ ri);
                else if (func == PGBENCH_LSHIFT)
                    setIntValue(retval, li << ri);
                else if (func == PGBENCH_RSHIFT)
                    setIntValue(retval, li >> ri);
                else            /* cannot get here */
                    Assert(0);
 
                return true;
            }
 
            /* logical operators */
        case PGBENCH_NOT:
            {
                bool        b;
 
                if (!coerceToBool(&vargs[0], &b))
                    return false;
 
                setBoolValue(retval, !b);
                return true;
            }
 
            /* no arguments */
        case PGBENCH_PI:
            setDoubleValue(retval, M_PI);
            return true;
 
            /* 1 overloaded argument */
        case PGBENCH_ABS:
            {
                PgBenchValue *varg = &vargs[0];
 
                Assert(nargs == 1);
 
                if (varg->type == PGBT_INT)
                {
                    int64       i = varg->u.ival;
 
                    setIntValue(retval, i < 0 ? -i : i);
                }
                else
                {
                    double      d = varg->u.dval;
 
                    Assert(varg->type == PGBT_DOUBLE);
                    setDoubleValue(retval, d < 0.0 ? -d : d);
                }
 
                return true;
            }
 
        case PGBENCH_DEBUG:
            {
                PgBenchValue *varg = &vargs[0];
 
                Assert(nargs == 1);
 
                fprintf(stderr, "debug(script=%d,command=%d): ",
                        st->use_file, st->command + 1);
 
                if (varg->type == PGBT_NULL)
                    fprintf(stderr, "null\n");
                else if (varg->type == PGBT_BOOLEAN)
                    fprintf(stderr, "boolean %s\n", varg->u.bval ? "true" : "false");
                else if (varg->type == PGBT_INT)
                    fprintf(stderr, "int " INT64_FORMAT "\n", varg->u.ival);
                else if (varg->type == PGBT_DOUBLE)
                    fprintf(stderr, "double %.*g\n", DBL_DIG, varg->u.dval);
                else            /* internal error, unexpected type */
                    Assert(0);
 
                *retval = *varg;
 
                return true;
            }
 
            /* 1 double argument */
        case PGBENCH_DOUBLE:
        case PGBENCH_SQRT:
        case PGBENCH_LN:
        case PGBENCH_EXP:
            {
                double      dval;
 
                Assert(nargs == 1);
 
                if (!coerceToDouble(&vargs[0], &dval))
                    return false;
 
                if (func == PGBENCH_SQRT)
                    dval = sqrt(dval);
                else if (func == PGBENCH_LN)
                    dval = log(dval);
                else if (func == PGBENCH_EXP)
                    dval = exp(dval);
                /* else is cast: do nothing */
 
                setDoubleValue(retval, dval);
                return true;
            }
 
            /* 1 int argument */
        case PGBENCH_INT:
            {
                int64       ival;
 
                Assert(nargs == 1);
 
                if (!coerceToInt(&vargs[0], &ival))
                    return false;
 
                setIntValue(retval, ival);
                return true;
            }
 
            /* variable number of arguments */
        case PGBENCH_LEAST:
        case PGBENCH_GREATEST:
            {
                bool        havedouble;
                int         i;
 
                Assert(nargs >= 1);
 
                /* need double result if any input is double */
                havedouble = false;
                for (i = 0; i < nargs; i++)
                {
                    if (vargs[i].type == PGBT_DOUBLE)
                    {
                        havedouble = true;
                        break;
                    }
                }
                if (havedouble)
                {
                    double      extremum;
 
                    if (!coerceToDouble(&vargs[0], &extremum))
                        return false;
                    for (i = 1; i < nargs; i++)
                    {
                        double      dval;
 
                        if (!coerceToDouble(&vargs[i], &dval))
                            return false;
                        if (func == PGBENCH_LEAST)
                            extremum = Min(extremum, dval);
                        else
                            extremum = Max(extremum, dval);
                    }
                    setDoubleValue(retval, extremum);
                }
                else
                {
                    int64       extremum;
 
                    if (!coerceToInt(&vargs[0], &extremum))
                        return false;
                    for (i = 1; i < nargs; i++)
                    {
                        int64       ival;
 
                        if (!coerceToInt(&vargs[i], &ival))
                            return false;
                        if (func == PGBENCH_LEAST)
                            extremum = Min(extremum, ival);
                        else
                            extremum = Max(extremum, ival);
                    }
                    setIntValue(retval, extremum);
                }
                return true;
            }
 
            /* random functions */
        case PGBENCH_RANDOM:
        case PGBENCH_RANDOM_EXPONENTIAL:
        case PGBENCH_RANDOM_GAUSSIAN:
        case PGBENCH_RANDOM_ZIPFIAN:
            {
                int64       imin,
                            imax,
                            delta;
 
                Assert(nargs >= 2);
 
                if (!coerceToInt(&vargs[0], &imin) ||
                    !coerceToInt(&vargs[1], &imax))
                    return false;
 
                /* check random range */
                if (unlikely(imin > imax))
                {
                    pg_log_error("empty range given to random");
                    return false;
                }
                else if (unlikely(pg_sub_s64_overflow(imax, imin, &delta) ||
                                  pg_add_s64_overflow(delta, 1, &delta)))
                {
                    /* prevent int overflows in random functions */
                    pg_log_error("random range is too large");
                    return false;
                }
 
                if (func == PGBENCH_RANDOM)
                {
                    Assert(nargs == 2);
                    setIntValue(retval, getrand(&st->cs_func_rs, imin, imax));
                }
                else            /* gaussian & exponential */
                {
                    double      param;
 
                    Assert(nargs == 3);
 
                    if (!coerceToDouble(&vargs[2], &param))
                        return false;
 
                    if (func == PGBENCH_RANDOM_GAUSSIAN)
                    {
                        if (param < MIN_GAUSSIAN_PARAM)
                        {
                            pg_log_error("gaussian parameter must be at least %f (not %f)",
                                         MIN_GAUSSIAN_PARAM, param);
                            return false;
                        }
 
                        setIntValue(retval,
                                    getGaussianRand(&st->cs_func_rs,
                                                    imin, imax, param));
                    }
                    else if (func == PGBENCH_RANDOM_ZIPFIAN)
                    {
                        if (param < MIN_ZIPFIAN_PARAM || param > MAX_ZIPFIAN_PARAM)
                        {
                            pg_log_error("zipfian parameter must be in range [%.3f, %.0f] (not %f)",
                                         MIN_ZIPFIAN_PARAM, MAX_ZIPFIAN_PARAM, param);
                            return false;
                        }
 
                        setIntValue(retval,
                                    getZipfianRand(&st->cs_func_rs, imin, imax, param));
                    }
                    else        /* exponential */
                    {
                        if (param <= 0.0)
                        {
                            pg_log_error("exponential parameter must be greater than zero (not %f)",
                                         param);
                            return false;
                        }
 
                        setIntValue(retval,
                                    getExponentialRand(&st->cs_func_rs,
                                                       imin, imax, param));
                    }
                }
 
                return true;
            }
 
        case PGBENCH_POW:
            {
                PgBenchValue *lval = &vargs[0];
                PgBenchValue *rval = &vargs[1];
                double      ld,
                            rd;
 
                Assert(nargs == 2);
 
                if (!coerceToDouble(lval, &ld) ||
                    !coerceToDouble(rval, &rd))
                    return false;
 
                setDoubleValue(retval, pow(ld, rd));
 
                return true;
            }
 
        case PGBENCH_IS:
            {
                Assert(nargs == 2);
 
                /*
                 * note: this simple implementation is more permissive than
                 * SQL
                 */
                setBoolValue(retval,
                             vargs[0].type == vargs[1].type &&
                             vargs[0].u.bval == vargs[1].u.bval);
                return true;
            }
 
            /* hashing */
        case PGBENCH_HASH_FNV1A:
        case PGBENCH_HASH_MURMUR2:
            {
                int64       val,
                            seed;
 
                Assert(nargs == 2);
 
                if (!coerceToInt(&vargs[0], &val) ||
                    !coerceToInt(&vargs[1], &seed))
                    return false;
 
                if (func == PGBENCH_HASH_MURMUR2)
                    setIntValue(retval, getHashMurmur2(val, seed));
                else if (func == PGBENCH_HASH_FNV1A)
                    setIntValue(retval, getHashFnv1a(val, seed));
                else
                    /* cannot get here */
                    Assert(0);
 
                return true;
            }
 
        case PGBENCH_PERMUTE:
            {
                int64       val,
                            size,
                            seed;
 
                Assert(nargs == 3);
 
                if (!coerceToInt(&vargs[0], &val) ||
                    !coerceToInt(&vargs[1], &size) ||
                    !coerceToInt(&vargs[2], &seed))
                    return false;
 
                if (size <= 0)
                {
                    pg_log_error("permute size parameter must be greater than zero");
                    return false;
                }
 
                setIntValue(retval, permute(val, size, seed));
                return true;
            }
 
        default:
            /* cannot get here */
            Assert(0);
            /* dead code to avoid a compiler warning */
            return false;
    }

References generate_unaccent_rules::args, Assert, b, PgBenchValue::bval, coerceToBool(), coerceToDouble(), coerceToInt(), CState::command, CState::cs_func_rs, PgBenchValue::dval, evaluateExpr(), PgBenchExprLink::expr, fprintf, getExponentialRand(), getGaussianRand(), getHashFnv1a(), getHashMurmur2(), getrand(), getZipfianRand(), i, INT64_FORMAT, PgBenchValue::ival, M_PI, Max, MAX_FARGS, MAX_ZIPFIAN_PARAM, Min, MIN_GAUSSIAN_PARAM, MIN_ZIPFIAN_PARAM, PgBenchExprLink::next, permute(), pg_add_s64_overflow(), PG_INT64_MIN, pg_log_error, pg_mul_s64_overflow(), pg_sub_s64_overflow(), PGBENCH_ABS, PGBENCH_ADD, PGBENCH_BITAND, PGBENCH_BITOR, PGBENCH_BITXOR, PGBENCH_DEBUG, PGBENCH_DIV, PGBENCH_DOUBLE, PGBENCH_EQ, PGBENCH_EXP, PGBENCH_GREATEST, PGBENCH_HASH_FNV1A, PGBENCH_HASH_MURMUR2, PGBENCH_INT, PGBENCH_IS, PGBENCH_LE, PGBENCH_LEAST, PGBENCH_LN, PGBENCH_LSHIFT, PGBENCH_LT, PGBENCH_MOD, PGBENCH_MUL, PGBENCH_NE, PGBENCH_NOT, PGBENCH_PERMUTE, PGBENCH_PI, PGBENCH_POW, PGBENCH_RANDOM, PGBENCH_RANDOM_EXPONENTIAL, PGBENCH_RANDOM_GAUSSIAN, PGBENCH_RANDOM_ZIPFIAN, PGBENCH_RSHIFT, PGBENCH_SQRT, PGBENCH_SUB, PGBT_BOOLEAN, PGBT_DOUBLE, PGBT_INT, PGBT_NULL, res, setBoolValue(), setDoubleValue(), setIntValue(), setNullValue(), size, type, PgBenchValue::type, PgBenchValue::u, unlikely, CState::use_file, and val.

Referenced by evalFunc().

evaluateExpr()

static bool evaluateExpr ( CState *  st, PgBenchExpr *  expr, PgBenchValue *  retval  )

static

Definition at line 2837 of file pgbench.c.

{
    switch (expr->etype)
    {
        case ENODE_CONSTANT:
            {
                *retval = expr->u.constant;
                return true;
            }
 
        case ENODE_VARIABLE:
            {
                Variable   *var;
 
                if ((var = lookupVariable(&st->variables, expr->u.variable.varname)) == NULL)
                {
                    pg_log_error("undefined variable \"%s\"", expr->u.variable.varname);
                    return false;
                }
 
                if (!makeVariableValue(var))
                    return false;
 
                *retval = var->value;
                return true;
            }
 
        case ENODE_FUNCTION:
            return evalFunc(st,
                            expr->u.function.function,
                            expr->u.function.args,
                            retval);
 
        default:
            /* internal error which should never occur */
            pg_fatal("unexpected enode type in evaluation: %d", expr->etype);
    }

References PgBenchExpr::constant, ENODE_CONSTANT, ENODE_FUNCTION, ENODE_VARIABLE, PgBenchExpr::etype, evalFunc(), PgBenchExpr::function, lookupVariable(), makeVariableValue(), pg_fatal, pg_log_error, PgBenchExpr::u, Variable::value, PgBenchExpr::variable, and CState::variables.

Referenced by evalLazyFunc(), evalStandardFunc(), and executeMetaCommand().

evaluateSleep()

static bool evaluateSleep ( Variables *  variables, int  argc, char **  argv, int *  usecs  )

static

Definition at line 3383 of file pgbench.c.

{
    char       *var;
    int         usec;
 
    if (*argv[1] == ':')
    {
        if ((var = getVariable(variables, argv[1] + 1)) == NULL)
        {
            pg_log_error("%s: undefined variable \"%s\"", argv[0], argv[1] + 1);
            return false;
        }
 
        usec = atoi(var);
 
        /* Raise an error if the value of a variable is not a number */
        if (usec == 0 && !isdigit((unsigned char) *var))
        {
            pg_log_error("%s: invalid sleep time \"%s\" for variable \"%s\"",
                         argv[0], var, argv[1] + 1);
            return false;
        }
    }
    else
        usec = atoi(argv[1]);
 
    if (argc > 2)
    {
        if (pg_strcasecmp(argv[2], "ms") == 0)
            usec *= 1000;
        else if (pg_strcasecmp(argv[2], "s") == 0)
            usec *= 1000000;
    }
    else
        usec *= 1000000;
 
    *usecs = usec;
    return true;

References getVariable(), pg_log_error, and pg_strcasecmp().

Referenced by executeMetaCommand().

executeMetaCommand()

static ConnectionStateEnum executeMetaCommand ( CState *  st, pg_time_usec_t *  now  )

static

Definition at line 4285 of file pgbench.c.

{
    Command    *command = sql_script[st->use_file].commands[st->command];
    int         argc;
    char      **argv;
 
    Assert(command != NULL && command->type == META_COMMAND);
 
    argc = command->argc;
    argv = command->argv;
 
    if (unlikely(__pg_log_level <= PG_LOG_DEBUG))
    {
        PQExpBufferData buf;
 
        initPQExpBuffer(&buf);
 
        printfPQExpBuffer(&buf, "client %d executing \\%s", st->id, argv[0]);
        for (int i = 1; i < argc; i++)
            appendPQExpBuffer(&buf, " %s", argv[i]);
 
        pg_log_debug("%s", buf.data);
 
        termPQExpBuffer(&buf);
    }
 
    if (command->meta == META_SLEEP)
    {
        int         usec;
 
        /*
         * A \sleep doesn't execute anything, we just get the delay from the
         * argument, and enter the CSTATE_SLEEP state.  (The per-command
         * latency will be recorded in CSTATE_SLEEP state, not here, after the
         * delay has elapsed.)
         */
        if (!evaluateSleep(&st->variables, argc, argv, &usec))
        {
            commandFailed(st, "sleep", "execution of meta-command failed");
            return CSTATE_ABORTED;
        }
 
        pg_time_now_lazy(now);
        st->sleep_until = (*now) + usec;
        return CSTATE_SLEEP;
    }
    else if (command->meta == META_SET)
    {
        PgBenchExpr *expr = command->expr;
        PgBenchValue result;
 
        if (!evaluateExpr(st, expr, &result))
        {
            commandFailed(st, argv[0], "evaluation of meta-command failed");
            return CSTATE_ABORTED;
        }
 
        if (!putVariableValue(&st->variables, argv[0], argv[1], &result))
        {
            commandFailed(st, "set", "assignment of meta-command failed");
            return CSTATE_ABORTED;
        }
    }
    else if (command->meta == META_IF)
    {
        /* backslash commands with an expression to evaluate */
        PgBenchExpr *expr = command->expr;
        PgBenchValue result;
        bool        cond;
 
        if (!evaluateExpr(st, expr, &result))
        {
            commandFailed(st, argv[0], "evaluation of meta-command failed");
            return CSTATE_ABORTED;
        }
 
        cond = valueTruth(&result);
        conditional_stack_push(st->cstack, cond ? IFSTATE_TRUE : IFSTATE_FALSE);
    }
    else if (command->meta == META_ELIF)
    {
        /* backslash commands with an expression to evaluate */
        PgBenchExpr *expr = command->expr;
        PgBenchValue result;
        bool        cond;
 
        if (conditional_stack_peek(st->cstack) == IFSTATE_TRUE)
        {
            /* elif after executed block, skip eval and wait for endif. */
            conditional_stack_poke(st->cstack, IFSTATE_IGNORED);
            return CSTATE_END_COMMAND;
        }
 
        if (!evaluateExpr(st, expr, &result))
        {
            commandFailed(st, argv[0], "evaluation of meta-command failed");
            return CSTATE_ABORTED;
        }
 
        cond = valueTruth(&result);
        Assert(conditional_stack_peek(st->cstack) == IFSTATE_FALSE);
        conditional_stack_poke(st->cstack, cond ? IFSTATE_TRUE : IFSTATE_FALSE);
    }
    else if (command->meta == META_ELSE)
    {
        switch (conditional_stack_peek(st->cstack))
        {
            case IFSTATE_TRUE:
                conditional_stack_poke(st->cstack, IFSTATE_ELSE_FALSE);
                break;
            case IFSTATE_FALSE: /* inconsistent if active */
            case IFSTATE_IGNORED:   /* inconsistent if active */
            case IFSTATE_NONE:  /* else without if */
            case IFSTATE_ELSE_TRUE: /* else after else */
            case IFSTATE_ELSE_FALSE:    /* else after else */
            default:
                /* dead code if conditional check is ok */
                Assert(false);
        }
    }
    else if (command->meta == META_ENDIF)
    {
        Assert(!conditional_stack_empty(st->cstack));
        conditional_stack_pop(st->cstack);
    }
    else if (command->meta == META_SETSHELL)
    {
        if (!runShellCommand(&st->variables, argv[1], argv + 2, argc - 2))
        {
            commandFailed(st, "setshell", "execution of meta-command failed");
            return CSTATE_ABORTED;
        }
    }
    else if (command->meta == META_SHELL)
    {
        if (!runShellCommand(&st->variables, NULL, argv + 1, argc - 1))
        {
            commandFailed(st, "shell", "execution of meta-command failed");
            return CSTATE_ABORTED;
        }
    }
    else if (command->meta == META_STARTPIPELINE)
    {
        /*
         * In pipeline mode, we use a workflow based on libpq pipeline
         * functions.
         */
        if (querymode == QUERY_SIMPLE)
        {
            commandFailed(st, "startpipeline", "cannot use pipeline mode with the simple query protocol");
            return CSTATE_ABORTED;
        }
 
        /*
         * If we're in prepared-query mode, we need to prepare all the
         * commands that are inside the pipeline before we actually start the
         * pipeline itself.  This solves the problem that running BEGIN
         * ISOLATION LEVEL SERIALIZABLE in a pipeline would fail due to a
         * snapshot having been acquired by the prepare within the pipeline.
         */
        if (querymode == QUERY_PREPARED)
            prepareCommandsInPipeline(st);
 
        if (PQpipelineStatus(st->con) != PQ_PIPELINE_OFF)
        {
            commandFailed(st, "startpipeline", "already in pipeline mode");
            return CSTATE_ABORTED;
        }
        if (PQenterPipelineMode(st->con) == 0)
        {
            commandFailed(st, "startpipeline", "failed to enter pipeline mode");
            return CSTATE_ABORTED;
        }
    }
    else if (command->meta == META_SYNCPIPELINE)
    {
        if (PQpipelineStatus(st->con) != PQ_PIPELINE_ON)
        {
            commandFailed(st, "syncpipeline", "not in pipeline mode");
            return CSTATE_ABORTED;
        }
        if (PQsendPipelineSync(st->con) == 0)
        {
            commandFailed(st, "syncpipeline", "failed to send a pipeline sync");
            return CSTATE_ABORTED;
        }
        st->num_syncs++;
    }
    else if (command->meta == META_ENDPIPELINE)
    {
        if (PQpipelineStatus(st->con) != PQ_PIPELINE_ON)
        {
            commandFailed(st, "endpipeline", "not in pipeline mode");
            return CSTATE_ABORTED;
        }
        if (!PQpipelineSync(st->con))
        {
            commandFailed(st, "endpipeline", "failed to send a pipeline sync");
            return CSTATE_ABORTED;
        }
        st->num_syncs++;
        /* Now wait for the PGRES_PIPELINE_SYNC and exit pipeline mode there */
        /* collect pending results before getting out of pipeline mode */
        return CSTATE_WAIT_RESULT;
    }
 
    /*
     * executing the expression or shell command might have taken a
     * non-negligible amount of time, so reset 'now'
     */
    *now = 0;
 
    return CSTATE_END_COMMAND;

References __pg_log_level, appendPQExpBuffer(), Command::argc, Command::argv, Assert, buf, CState::command, commandFailed(), ParsedScript::commands, CState::con, conditional_stack_empty(), conditional_stack_peek(), conditional_stack_poke(), conditional_stack_pop(), conditional_stack_push(), CState::cstack, CSTATE_ABORTED, CSTATE_END_COMMAND, CSTATE_SLEEP, CSTATE_WAIT_RESULT, evaluateExpr(), evaluateSleep(), Command::expr, i, CState::id, IFSTATE_ELSE_FALSE, IFSTATE_ELSE_TRUE, IFSTATE_FALSE, IFSTATE_IGNORED, IFSTATE_NONE, IFSTATE_TRUE, initPQExpBuffer(), Command::meta, META_COMMAND, META_ELIF, META_ELSE, META_ENDIF, META_ENDPIPELINE, META_IF, META_SET, META_SETSHELL, META_SHELL, META_SLEEP, META_STARTPIPELINE, META_SYNCPIPELINE, now(), CState::num_syncs, PG_LOG_DEBUG, pg_log_debug, pg_time_now_lazy(), PQ_PIPELINE_OFF, PQ_PIPELINE_ON, PQenterPipelineMode(), PQpipelineStatus(), PQpipelineSync(), PQsendPipelineSync(), prepareCommandsInPipeline(), printfPQExpBuffer(), putVariableValue(), QUERY_PREPARED, QUERY_SIMPLE, querymode, runShellCommand(), CState::sleep_until, sql_script, termPQExpBuffer(), Command::type, unlikely, CState::use_file, valueTruth(), and CState::variables.

Referenced by advanceConnectionState().

executeStatement()

static void executeStatement ( PGconn *  con, const char *  sql  )

static

Definition at line 1500 of file pgbench.c.

{
    PGresult   *res;
 
    res = PQexec(con, sql);
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
    {
        pg_log_error("query failed: %s", PQerrorMessage(con));
        pg_log_error_detail("Query was: %s", sql);
        exit(1);
    }
    PQclear(res);

References exit(), pg_log_error, pg_log_error_detail, PGRES_COMMAND_OK, PQclear(), PQerrorMessage(), PQexec(), PQresultStatus(), and res.

Referenced by createPartitions(), initCreateFKeys(), initCreatePKeys(), initCreateTables(), initDropTables(), initGenerateDataClientSide(), initGenerateDataServerSide(), initTruncateTables(), and initVacuum().

findBuiltin()

static const BuiltinScript* findBuiltin ( const char *  name )

static

Definition at line 6120 of file pgbench.c.

{
    int         i,
                found = 0,
                len = strlen(name);
    const BuiltinScript *result = NULL;
 
    for (i = 0; i < lengthof(builtin_script); i++)
    {
        if (strncmp(builtin_script[i].name, name, len) == 0)
        {
            result = &builtin_script[i];
            found++;
        }
    }
 
    /* ok, unambiguous result */
    if (found == 1)
        return result;
 
    /* error cases */
    if (found == 0)
        pg_log_error("no builtin script found for name \"%s\"", name);
    else                        /* found > 1 */
        pg_log_error("ambiguous builtin name: %d builtin scripts found for prefix \"%s\"", found, name);
 
    listAvailableScripts();
    exit(1);

References builtin_script, exit(), i, len, lengthof, listAvailableScripts(), name, and pg_log_error.

Referenced by main().

finishCon()

static void finishCon ( CState *  st )

static

Definition at line 7695 of file pgbench.c.

{
    if (st->con != NULL)
    {
        PQfinish(st->con);
        st->con = NULL;
    }

References CState::con, and PQfinish().

Referenced by advanceConnectionState(), and disconnect_all().

free_command()

static void free_command ( Command *  command )

static

Definition at line 5578 of file pgbench.c.

{
    termPQExpBuffer(&command->lines);
    pg_free(command->first_line);
    for (int i = 0; i < command->argc; i++)
        pg_free(command->argv[i]);
    pg_free(command->varprefix);
 
    /*
     * It should also free expr recursively, but this is currently not needed
     * as only gset commands (which do not have an expression) are freed.
     */
    pg_free(command);

References Command::argc, Command::argv, Command::first_line, i, Command::lines, pg_free(), termPQExpBuffer(), and Command::varprefix.

Referenced by ParseScript().

free_socket_set()

static void free_socket_set ( socket_set *  sa )

static

Definition at line 7866 of file pgbench.c.

{
    pg_free(sa);

References pg_free().

Referenced by threadRun().

getExponentialRand()

static int64 getExponentialRand ( pg_prng_state *  state, int64  min, int64  max, double  parameter  )

static

Definition at line 1113 of file pgbench.c.

{
    double      cut,
                uniform,
                rand;
 
    /* abort if wrong parameter, but must really be checked beforehand */
    Assert(parameter > 0.0);
    cut = exp(-parameter);
    /* pg_prng_double value in [0, 1), uniform in (0, 1] */
    uniform = 1.0 - pg_prng_double(state);
 
    /*
     * inner expression in (cut, 1] (if parameter > 0), rand in [0, 1)
     */
    Assert((1.0 - cut) != 0.0);
    rand = -log(cut + (1.0 - cut) * uniform) / parameter;
    /* return int64 random number within between min and max */
    return min + (int64) ((max - min + 1) * rand);

References Assert, and pg_prng_double().

Referenced by evalStandardFunc().

getFailures()

static int64 getFailures ( const StatsData *  stats )

static

Definition at line 4504 of file pgbench.c.

{
    return (stats->serialization_failures +
            stats->deadlock_failures);

References StatsData::deadlock_failures, and StatsData::serialization_failures.

Referenced by printProgressReport(), and printResults().

getGaussianRand()

static int64 getGaussianRand ( pg_prng_state *  state, int64  min, int64  max, double  parameter  )

static

Definition at line 1137 of file pgbench.c.

{
    double      stdev;
    double      rand;
 
    /* abort if parameter is too low, but must really be checked beforehand */
    Assert(parameter >= MIN_GAUSSIAN_PARAM);
 
    /*
     * Get normally-distributed random number in the range -parameter <= stdev
     * < parameter.
     *
     * This loop is executed until the number is in the expected range.
     *
     * As the minimum parameter is 2.0, the probability of looping is low:
     * sqrt(-2 ln(r)) <= 2 => r >= e^{-2} ~ 0.135, then when taking the
     * average sinus multiplier as 2/pi, we have a 8.6% looping probability in
     * the worst case. For a parameter value of 5.0, the looping probability
     * is about e^{-5} * 2 / pi ~ 0.43%.
     */
    do
    {
        stdev = pg_prng_double_normal(state);
    }
    while (stdev < -parameter || stdev >= parameter);
 
    /* stdev is in [-parameter, parameter), normalization to [0,1) */
    rand = (stdev + parameter) / (parameter * 2.0);
 
    /* return int64 random number within between min and max */
    return min + (int64) ((max - min + 1) * rand);

References Assert, MIN_GAUSSIAN_PARAM, and pg_prng_double_normal().

Referenced by evalStandardFunc().

getHashFnv1a()

static int64 getHashFnv1a ( int64  val, uint64  seed  )

static

Definition at line 1245 of file pgbench.c.

{
    int64       result;
    int         i;
 
    result = FNV_OFFSET_BASIS ^ seed;
    for (i = 0; i < 8; ++i)
    {
        int32       octet = val & 0xff;
 
        val = val >> 8;
        result = result ^ octet;
        result = result * FNV_PRIME;
    }
 
    return result;

References FNV_OFFSET_BASIS, FNV_PRIME, i, and val.

Referenced by evalStandardFunc().

getHashMurmur2()

static int64 getHashMurmur2 ( int64  val, uint64  seed  )

static

Definition at line 1270 of file pgbench.c.

{
    uint64      result = seed ^ MM2_MUL_TIMES_8;    /* sizeof(int64) */
    uint64      k = (uint64) val;
 
    k *= MM2_MUL;
    k ^= k >> MM2_ROT;
    k *= MM2_MUL;
 
    result ^= k;
    result *= MM2_MUL;
 
    result ^= result >> MM2_ROT;
    result *= MM2_MUL;
    result ^= result >> MM2_ROT;
 
    return (int64) result;

References MM2_MUL, MM2_MUL_TIMES_8, MM2_ROT, and val.

Referenced by evalStandardFunc().

getMetaCommand()

static MetaCommand getMetaCommand ( const char *  cmd )

static

Definition at line 2880 of file pgbench.c.

{
    MetaCommand mc;
 
    if (cmd == NULL)
        mc = META_NONE;
    else if (pg_strcasecmp(cmd, "set") == 0)
        mc = META_SET;
    else if (pg_strcasecmp(cmd, "setshell") == 0)
        mc = META_SETSHELL;
    else if (pg_strcasecmp(cmd, "shell") == 0)
        mc = META_SHELL;
    else if (pg_strcasecmp(cmd, "sleep") == 0)
        mc = META_SLEEP;
    else if (pg_strcasecmp(cmd, "if") == 0)
        mc = META_IF;
    else if (pg_strcasecmp(cmd, "elif") == 0)
        mc = META_ELIF;
    else if (pg_strcasecmp(cmd, "else") == 0)
        mc = META_ELSE;
    else if (pg_strcasecmp(cmd, "endif") == 0)
        mc = META_ENDIF;
    else if (pg_strcasecmp(cmd, "gset") == 0)
        mc = META_GSET;
    else if (pg_strcasecmp(cmd, "aset") == 0)
        mc = META_ASET;
    else if (pg_strcasecmp(cmd, "startpipeline") == 0)
        mc = META_STARTPIPELINE;
    else if (pg_strcasecmp(cmd, "syncpipeline") == 0)
        mc = META_SYNCPIPELINE;
    else if (pg_strcasecmp(cmd, "endpipeline") == 0)
        mc = META_ENDPIPELINE;
    else
        mc = META_NONE;
    return mc;

References META_ASET, META_ELIF, META_ELSE, META_ENDIF, META_ENDPIPELINE, META_GSET, META_IF, META_NONE, META_SET, META_SETSHELL, META_SHELL, META_SLEEP, META_STARTPIPELINE, META_SYNCPIPELINE, and pg_strcasecmp().

Referenced by process_backslash_command().

getPoissonRand()

static int64 getPoissonRand ( pg_prng_state *  state, double  center  )

static

Definition at line 1179 of file pgbench.c.

{
    /*
     * Use inverse transform sampling to generate a value > 0, such that the
     * expected (i.e. average) value is the given argument.
     */
    double      uniform;
 
    /* pg_prng_double value in [0, 1), uniform in (0, 1] */
    uniform = 1.0 - pg_prng_double(state);
 
    return (int64) (-log(uniform) * center + 0.5);

References pg_prng_double().

Referenced by advanceConnectionState().

getQueryParams()

static void getQueryParams ( Variables *  variables, const Command *  command, const char **  params  )

static

Definition at line 1972 of file pgbench.c.

{
    int         i;
 
    for (i = 0; i < command->argc - 1; i++)
        params[i] = getVariable(variables, command->argv[i + 1]);

References Command::argc, Command::argv, getVariable(), and i.

Referenced by sendCommand().

getrand()

static int64 getrand ( pg_prng_state *  state, int64  min, int64  max  )

static

Definition at line 1102 of file pgbench.c.

{
    return min + (int64) pg_prng_uint64_range(state, 0, max - min);

References pg_prng_uint64_range().

Referenced by chooseScript(), and evalStandardFunc().

getResultString()

static const char* getResultString ( bool  skipped, EStatus  estatus  )

static

Definition at line 4515 of file pgbench.c.

{
    if (skipped)
        return "skipped";
    else if (failures_detailed)
    {
        switch (estatus)
        {
            case ESTATUS_SERIALIZATION_ERROR:
                return "serialization";
            case ESTATUS_DEADLOCK_ERROR:
                return "deadlock";
            default:
                /* internal error which should never occur */
                pg_fatal("unexpected error status: %d", estatus);
        }
    }
    else
        return "failed";

References ESTATUS_DEADLOCK_ERROR, ESTATUS_SERIALIZATION_ERROR, failures_detailed, and pg_fatal.

Referenced by doLog().

getSQLErrorStatus()

static EStatus getSQLErrorStatus ( const char *  sqlState )

static

Definition at line 3208 of file pgbench.c.

{
    if (sqlState != NULL)
    {
        if (strcmp(sqlState, ERRCODE_T_R_SERIALIZATION_FAILURE) == 0)
            return ESTATUS_SERIALIZATION_ERROR;
        else if (strcmp(sqlState, ERRCODE_T_R_DEADLOCK_DETECTED) == 0)
            return ESTATUS_DEADLOCK_ERROR;
    }
 
    return ESTATUS_OTHER_SQL_ERROR;

References ERRCODE_T_R_DEADLOCK_DETECTED, ERRCODE_T_R_SERIALIZATION_FAILURE, ESTATUS_DEADLOCK_ERROR, ESTATUS_OTHER_SQL_ERROR, and ESTATUS_SERIALIZATION_ERROR.

Referenced by readCommandResponse().

GetTableInfo()

static void GetTableInfo ( PGconn *  con, bool  scale_given  )

static

Definition at line 5308 of file pgbench.c.

{
    PGresult   *res;
 
    /*
     * get the scaling factor that should be same as count(*) from
     * pgbench_branches if this is not a custom query
     */
    res = PQexec(con, "select count(*) from pgbench_branches");
    if (PQresultStatus(res) != PGRES_TUPLES_OK)
    {
        char       *sqlState = PQresultErrorField(res, PG_DIAG_SQLSTATE);
 
        pg_log_error("could not count number of branches: %s", PQerrorMessage(con));
 
        if (sqlState && strcmp(sqlState, ERRCODE_UNDEFINED_TABLE) == 0)
            pg_log_error_hint("Perhaps you need to do initialization (\"pgbench -i\") in database \"%s\".",
                              PQdb(con));
 
        exit(1);
    }
    scale = atoi(PQgetvalue(res, 0, 0));
    if (scale < 0)
        pg_fatal("invalid count(*) from pgbench_branches: \"%s\"",
                 PQgetvalue(res, 0, 0));
    PQclear(res);
 
    /* warn if we override user-given -s switch */
    if (scale_given)
        pg_log_warning("scale option ignored, using count from pgbench_branches table (%d)",
                       scale);
 
    /*
     * Get the partition information for the first "pgbench_accounts" table
     * found in search_path.
     *
     * The result is empty if no "pgbench_accounts" is found.
     *
     * Otherwise, it always returns one row even if the table is not
     * partitioned (in which case the partition strategy is NULL).
     *
     * The number of partitions can be 0 even for partitioned tables, if no
     * partition is attached.
     *
     * We assume no partitioning on any failure, so as to avoid failing on an
     * old version without "pg_partitioned_table".
     */
    res = PQexec(con,
                 "select o.n, p.partstrat, pg_catalog.count(i.inhparent) "
                 "from pg_catalog.pg_class as c "
                 "join pg_catalog.pg_namespace as n on (n.oid = c.relnamespace) "
                 "cross join lateral (select pg_catalog.array_position(pg_catalog.current_schemas(true), n.nspname)) as o(n) "
                 "left join pg_catalog.pg_partitioned_table as p on (p.partrelid = c.oid) "
                 "left join pg_catalog.pg_inherits as i on (c.oid = i.inhparent) "
                 "where c.relname = 'pgbench_accounts' and o.n is not null "
                 "group by 1, 2 "
                 "order by 1 asc "
                 "limit 1");
 
    if (PQresultStatus(res) != PGRES_TUPLES_OK)
    {
        /* probably an older version, coldly assume no partitioning */
        partition_method = PART_NONE;
        partitions = 0;
    }
    else if (PQntuples(res) == 0)
    {
        /*
         * This case is unlikely as pgbench already found "pgbench_branches"
         * above to compute the scale.
         */
        pg_log_error("no pgbench_accounts table found in \"search_path\"");
        pg_log_error_hint("Perhaps you need to do initialization (\"pgbench -i\") in database \"%s\".", PQdb(con));
        exit(1);
    }
    else                        /* PQntuples(res) == 1 */
    {
        /* normal case, extract partition information */
        if (PQgetisnull(res, 0, 1))
            partition_method = PART_NONE;
        else
        {
            char       *ps = PQgetvalue(res, 0, 1);
 
            /* column must be there */
            Assert(ps != NULL);
 
            if (strcmp(ps, "r") == 0)
                partition_method = PART_RANGE;
            else if (strcmp(ps, "h") == 0)
                partition_method = PART_HASH;
            else
            {
                /* possibly a newer version with new partition method */
                pg_fatal("unexpected partition method: \"%s\"", ps);
            }
        }
 
        partitions = atoi(PQgetvalue(res, 0, 2));
    }
 
    PQclear(res);

References Assert, ERRCODE_UNDEFINED_TABLE, exit(), PART_HASH, PART_NONE, PART_RANGE, partition_method, partitions, PG_DIAG_SQLSTATE, pg_fatal, pg_log_error, pg_log_error_hint, pg_log_warning, PGRES_TUPLES_OK, PQclear(), PQdb(), PQerrorMessage(), PQexec(), PQgetisnull(), PQgetvalue(), PQntuples(), PQresultErrorField(), PQresultStatus(), ps, res, and scale.

Referenced by main().

getTransactionStatus()

static TStatus getTransactionStatus ( PGconn *  con )

static

Definition at line 3514 of file pgbench.c.

{
    PGTransactionStatusType tx_status;
 
    tx_status = PQtransactionStatus(con);
    switch (tx_status)
    {
        case PQTRANS_IDLE:
            return TSTATUS_IDLE;
        case PQTRANS_INTRANS:
        case PQTRANS_INERROR:
            return TSTATUS_IN_BLOCK;
        case PQTRANS_UNKNOWN:
            /* PQTRANS_UNKNOWN is expected given a broken connection */
            if (PQstatus(con) == CONNECTION_BAD)
                return TSTATUS_CONN_ERROR;
            /* fall through */
        case PQTRANS_ACTIVE:
        default:
 
            /*
             * We cannot find out whether we are in a transaction block or
             * not. Internal error which should never occur.
             */
            pg_log_error("unexpected transaction status %d", tx_status);
            return TSTATUS_OTHER_ERROR;
    }
 
    /* not reached */
    Assert(false);
    return TSTATUS_OTHER_ERROR;

References Assert, CONNECTION_BAD, pg_log_error, PQstatus(), PQTRANS_ACTIVE, PQTRANS_IDLE, PQTRANS_INERROR, PQTRANS_INTRANS, PQTRANS_UNKNOWN, PQtransactionStatus(), TSTATUS_CONN_ERROR, TSTATUS_IDLE, TSTATUS_IN_BLOCK, and TSTATUS_OTHER_ERROR.

Referenced by advanceConnectionState().

getVariable()

static char* getVariable ( Variables *  variables, char *  name  )

static

Definition at line 1631 of file pgbench.c.

{
    Variable   *var;
    char        stringform[64];
 
    var = lookupVariable(variables, name);
    if (var == NULL)
        return NULL;            /* not found */
 
    if (var->svalue)
        return var->svalue;     /* we have it in string form */
 
    /* We need to produce a string equivalent of the value */
    Assert(var->value.type != PGBT_NO_VALUE);
    if (var->value.type == PGBT_NULL)
        snprintf(stringform, sizeof(stringform), "NULL");
    else if (var->value.type == PGBT_BOOLEAN)
        snprintf(stringform, sizeof(stringform),
                 "%s", var->value.u.bval ? "true" : "false");
    else if (var->value.type == PGBT_INT)
        snprintf(stringform, sizeof(stringform),
                 INT64_FORMAT, var->value.u.ival);
    else if (var->value.type == PGBT_DOUBLE)
        snprintf(stringform, sizeof(stringform),
                 "%.*g", DBL_DIG, var->value.u.dval);
    else                        /* internal error, unexpected type */
        Assert(0);
    var->svalue = pg_strdup(stringform);
    return var->svalue;

References Assert, PgBenchValue::bval, PgBenchValue::dval, INT64_FORMAT, PgBenchValue::ival, lookupVariable(), name, pg_strdup(), PGBT_BOOLEAN, PGBT_DOUBLE, PGBT_INT, PGBT_NO_VALUE, PGBT_NULL, snprintf, Variable::svalue, PgBenchValue::type, PgBenchValue::u, and Variable::value.

Referenced by assignVariables(), evaluateSleep(), getQueryParams(), and runShellCommand().

getZipfianRand()

static int64 getZipfianRand ( pg_prng_state *  state, int64  min, int64  max, double  s  )

static

Definition at line 1231 of file pgbench.c.

{
    int64       n = max - min + 1;
 
    /* abort if parameter is invalid */
    Assert(MIN_ZIPFIAN_PARAM <= s && s <= MAX_ZIPFIAN_PARAM);
 
    return min - 1 + computeIterativeZipfian(state, n, s);

References Assert, computeIterativeZipfian(), MAX_ZIPFIAN_PARAM, and MIN_ZIPFIAN_PARAM.

Referenced by evalStandardFunc().

handle_sig_alarm()

static void handle_sig_alarm ( SIGNAL_ARGS  )

static

Definition at line 7711 of file pgbench.c.

{
    timer_exceeded = true;

References timer_exceeded.

Referenced by setalarm().

initAccount()

static void initAccount ( PQExpBufferData *  sql, int64  curr  )

static

Definition at line 4931 of file pgbench.c.

{
    /* "filler" column defaults to blank padded empty string */
    printfPQExpBuffer(sql,
                      INT64_FORMAT "\t" INT64_FORMAT "\t0\t\n",
                      curr + 1, curr / naccounts + 1);

References INT64_FORMAT, naccounts, and printfPQExpBuffer().

Referenced by initGenerateDataClientSide().

initBranch()

static void initBranch ( PQExpBufferData *  sql, int64  curr  )

static

Definition at line 4913 of file pgbench.c.

{
    /* "filler" column uses NULL */
    printfPQExpBuffer(sql,
                      INT64_FORMAT "\t0\t\\N\n",
                      curr + 1);

References INT64_FORMAT, and printfPQExpBuffer().

Referenced by initGenerateDataClientSide().

initCreateFKeys()

static void initCreateFKeys ( PGconn *  con )

static

Definition at line 5177 of file pgbench.c.

{
    static const char *const DDLKEYs[] = {
        "alter table pgbench_tellers add constraint pgbench_tellers_bid_fkey foreign key (bid) references pgbench_branches",
        "alter table pgbench_accounts add constraint pgbench_accounts_bid_fkey foreign key (bid) references pgbench_branches",
        "alter table pgbench_history add constraint pgbench_history_bid_fkey foreign key (bid) references pgbench_branches",
        "alter table pgbench_history add constraint pgbench_history_tid_fkey foreign key (tid) references pgbench_tellers",
        "alter table pgbench_history add constraint pgbench_history_aid_fkey foreign key (aid) references pgbench_accounts"
    };
    int         i;
 
    fprintf(stderr, "creating foreign keys...\n");
    for (i = 0; i < lengthof(DDLKEYs); i++)
    {
        executeStatement(con, DDLKEYs[i]);
    }

References executeStatement(), fprintf, i, and lengthof.

Referenced by runInitSteps().

initCreatePKeys()

static void initCreatePKeys ( PGconn *  con )

static

Definition at line 5139 of file pgbench.c.

{
    static const char *const DDLINDEXes[] = {
        "alter table pgbench_branches add primary key (bid)",
        "alter table pgbench_tellers add primary key (tid)",
        "alter table pgbench_accounts add primary key (aid)"
    };
    int         i;
    PQExpBufferData query;
 
    fprintf(stderr, "creating primary keys...\n");
    initPQExpBuffer(&query);
 
    for (i = 0; i < lengthof(DDLINDEXes); i++)
    {
        resetPQExpBuffer(&query);
        appendPQExpBufferStr(&query, DDLINDEXes[i]);
 
        if (index_tablespace != NULL)
        {
            char       *escape_tablespace;
 
            escape_tablespace = PQescapeIdentifier(con, index_tablespace,
                                                   strlen(index_tablespace));
            appendPQExpBuffer(&query, " using index tablespace %s", escape_tablespace);
            PQfreemem(escape_tablespace);
        }
 
        executeStatement(con, query.data);
    }
 
    termPQExpBuffer(&query);

References appendPQExpBuffer(), appendPQExpBufferStr(), PQExpBufferData::data, executeStatement(), fprintf, i, index_tablespace, initPQExpBuffer(), lengthof, PQescapeIdentifier(), PQfreemem(), resetPQExpBuffer(), and termPQExpBuffer().

Referenced by runInitSteps().

initCreateTables()

static void initCreateTables ( PGconn *  con )

static

Definition at line 4808 of file pgbench.c.

{
    /*
     * Note: TPC-B requires at least 100 bytes per row, and the "filler"
     * fields in these table declarations were intended to comply with that.
     * The pgbench_accounts table complies with that because the "filler"
     * column is set to blank-padded empty string. But for all other tables
     * the columns default to NULL and so don't actually take any space.  We
     * could fix that by giving them non-null default values.  However, that
     * would completely break comparability of pgbench results with prior
     * versions. Since pgbench has never pretended to be fully TPC-B compliant
     * anyway, we stick with the historical behavior.
     */
    struct ddlinfo
    {
        const char *table;      /* table name */
        const char *smcols;     /* column decls if accountIDs are 32 bits */
        const char *bigcols;    /* column decls if accountIDs are 64 bits */
        int         declare_fillfactor;
    };
    static const struct ddlinfo DDLs[] = {
        {
            "pgbench_history",
            "tid int,bid int,aid    int,delta int,mtime timestamp,filler char(22)",
            "tid int,bid int,aid bigint,delta int,mtime timestamp,filler char(22)",
            0
        },
        {
            "pgbench_tellers",
            "tid int not null,bid int,tbalance int,filler char(84)",
            "tid int not null,bid int,tbalance int,filler char(84)",
            1
        },
        {
            "pgbench_accounts",
            "aid    int not null,bid int,abalance int,filler char(84)",
            "aid bigint not null,bid int,abalance int,filler char(84)",
            1
        },
        {
            "pgbench_branches",
            "bid int not null,bbalance int,filler char(88)",
            "bid int not null,bbalance int,filler char(88)",
            1
        }
    };
    int         i;
    PQExpBufferData query;
 
    fprintf(stderr, "creating tables...\n");
 
    initPQExpBuffer(&query);
 
    for (i = 0; i < lengthof(DDLs); i++)
    {
        const struct ddlinfo *ddl = &DDLs[i];
 
        /* Construct new create table statement. */
        printfPQExpBuffer(&query, "create%s table %s(%s)",
                          unlogged_tables ? " unlogged" : "",
                          ddl->table,
                          (scale >= SCALE_32BIT_THRESHOLD) ? ddl->bigcols : ddl->smcols);
 
        /* Partition pgbench_accounts table */
        if (partition_method != PART_NONE && strcmp(ddl->table, "pgbench_accounts") == 0)
            appendPQExpBuffer(&query,
                              " partition by %s (aid)", PARTITION_METHOD[partition_method]);
        else if (ddl->declare_fillfactor)
        {
            /* fillfactor is only expected on actual tables */
            appendPQExpBuffer(&query, " with (fillfactor=%d)", fillfactor);
        }
 
        if (tablespace != NULL)
        {
            char       *escape_tablespace;
 
            escape_tablespace = PQescapeIdentifier(con, tablespace, strlen(tablespace));
            appendPQExpBuffer(&query, " tablespace %s", escape_tablespace);
            PQfreemem(escape_tablespace);
        }
 
        executeStatement(con, query.data);
    }
 
    termPQExpBuffer(&query);
 
    if (partition_method != PART_NONE)
        createPartitions(con);

References appendPQExpBuffer(), createPartitions(), PQExpBufferData::data, executeStatement(), fillfactor, fprintf, i, initPQExpBuffer(), lengthof, PART_NONE, partition_method, PARTITION_METHOD, PQescapeIdentifier(), PQfreemem(), printfPQExpBuffer(), scale, SCALE_32BIT_THRESHOLD, tablespace, termPQExpBuffer(), and unlogged_tables.

Referenced by runInitSteps().

initDropTables()

static void initDropTables ( PGconn *  con )

static

Definition at line 4717 of file pgbench.c.

{
    fprintf(stderr, "dropping old tables...\n");
 
    /*
     * We drop all the tables in one command, so that whether there are
     * foreign key dependencies or not doesn't matter.
     */
    executeStatement(con, "drop table if exists "
                     "pgbench_accounts, "
                     "pgbench_branches, "
                     "pgbench_history, "
                     "pgbench_tellers");

References executeStatement(), and fprintf.

Referenced by runInitSteps().

initGenerateDataClientSide()

static void initGenerateDataClientSide ( PGconn *  con )

static

Definition at line 5049 of file pgbench.c.

{
    fprintf(stderr, "generating data (client-side)...\n");
 
    /*
     * we do all of this in one transaction to enable the backend's
     * data-loading optimizations
     */
    executeStatement(con, "begin");
 
    /* truncate away any old data */
    initTruncateTables(con);
 
    /*
     * fill branches, tellers, accounts in that order in case foreign keys
     * already exist
     */
    initPopulateTable(con, "pgbench_branches", nbranches, initBranch);
    initPopulateTable(con, "pgbench_tellers", ntellers, initTeller);
    initPopulateTable(con, "pgbench_accounts", naccounts, initAccount);
 
    executeStatement(con, "commit");

References executeStatement(), fprintf, initAccount(), initBranch(), initPopulateTable(), initTeller(), initTruncateTables(), naccounts, nbranches, and ntellers.

Referenced by runInitSteps().

initGenerateDataServerSide()

static void initGenerateDataServerSide ( PGconn *  con )

static

Definition at line 5081 of file pgbench.