#include "postgres_fe.h"
#include <ctype.h>
#include <float.h>
#include <limits.h>
#include <math.h>
#include <signal.h>
#include <time.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 dependency graph for pgbench.c:

Data Structures
struct	socket_set

struct	Variable

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_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 void *

#define	THREAD_FUNC_RETURN_TYPE void *

#define	THREAD_FUNC_RETURN return NULL

#define	THREAD_FUNC_CC

#define	THREAD_BARRIER_T int

#define	THREAD_BARRIER_INIT(barrier, n) (*(barrier) = 0)

#define	THREAD_BARRIER_WAIT(barrier)

#define	THREAD_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	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	MAX_PREPARE_NAME 32

#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 MetaCommand	MetaCommand

typedef enum QueryMode	QueryMode

typedef struct Command	Command

typedef struct ParsedScript	ParsedScript

typedef struct BuiltinScript	BuiltinScript

Enumerations
enum	partition_method_t { PART_NONE , PART_RANGE , PART_HASH }

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_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_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 (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)

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 (CState st, char name)

static char *	getVariable (CState st, char name)

static bool	makeVariableValue (Variable *var)

static bool	valid_variable_name (const char *name)

static Variable *	lookupCreateVariable (CState st, const char context, char *name)

static bool	putVariable (CState st, const char context, char name, const char value)

static bool	putVariableValue (CState st, const char context, char name, const PgBenchValue value)

static bool	putVariableInt (CState st, 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 (CState st, char sql)

static void	getQueryParams (CState st, 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 (CState st, char variable, char **argv, int argc)

static void	preparedStatementName (char *buffer, int file, int state)

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

static int	chooseScript (TState *thread)

static bool	sendCommand (CState st, Command command)

static bool	readCommandResponse (CState st, MetaCommand meta, char varprefix)

static bool	evaluateSleep (CState st, int argc, char argv, int usecs)

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

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	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 (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
int	nxacts = 0

int	duration = 0

int64	end_time = 0

int	scale = 1

int	fillfactor = 100

bool	unlogged_tables = false

double	sample_rate = 0.0

double	throttle_delay = 0

int64	latency_limit = 0

char *	tablespace = NULL

char *	index_tablespace = NULL

static int	partitions = 0

static partition_method_t	partition_method = PART_NONE

static const char *	PARTITION_METHOD [] = {"none", "range", "hash"}

int64	random_seed = -1

bool	use_log

bool	use_quiet

int	agg_interval

bool	per_script_stats = false

int	progress = 0

bool	progress_timestamp = false

int	nclients = 1

int	nthreads = 1

bool	is_connect

bool	report_per_command

int	main_pid

const char *	pghost = NULL

const char *	pgport = NULL

const char *	username = NULL

const char *	dbName = NULL

char *	logfile_prefix = NULL

const char *	progname

volatile bool	timer_exceeded = false

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 *	QUERYMODE [] = {"simple", "extended", "prepared"}

static ParsedScript	sql_script [MAX_SCRIPTS]

static int	num_scripts

static int64	total_weight = 0

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 174 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 173 of file pgbench.c.

◆ DEFAULT_NXACTS

#define DEFAULT_NXACTS 10 /* default nxacts */

Definition at line 177 of file pgbench.c.

◆ ERRCODE_UNDEFINED_TABLE

#define ERRCODE_UNDEFINED_TABLE "42P01"

Definition at line 79 of file pgbench.c.

◆ FNV_OFFSET_BASIS

#define FNV_OFFSET_BASIS UINT64CONST(0xcbf29ce484222325)

Definition at line 85 of file pgbench.c.

◆ FNV_PRIME

#define FNV_PRIME UINT64CONST(0x100000001b3)

Definition at line 84 of file pgbench.c.

◆ LOG_STEP_SECONDS

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

Definition at line 176 of file pgbench.c.

◆ M_PI

#define M_PI 3.14159265358979323846

Definition at line 76 of file pgbench.c.

◆ MAX_ARGS

#define MAX_ARGS 256

Definition at line 521 of file pgbench.c.

◆ MAX_FARGS

#define MAX_FARGS 16

Definition at line 2027 of file pgbench.c.

◆ MAX_PREPARE_NAME

#define MAX_PREPARE_NAME 32

Definition at line 2801 of file pgbench.c.

◆ MAX_SCRIPTS

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

Definition at line 308 of file pgbench.c.

◆ MAX_ZIPFIAN_PARAM

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

Definition at line 182 of file pgbench.c.

◆ META_COMMAND

#define META_COMMAND 2

Definition at line 515 of file pgbench.c.

◆ MIN_GAUSSIAN_PARAM

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

Definition at line 179 of file pgbench.c.

◆ MIN_ZIPFIAN_PARAM

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

Definition at line 181 of file pgbench.c.

◆ MM2_MUL

#define MM2_MUL UINT64CONST(0xc6a4a7935bd1e995)

Definition at line 86 of file pgbench.c.

◆ MM2_MUL_TIMES_8

#define MM2_MUL_TIMES_8 UINT64CONST(0x35253c9ade8f4ca8)

Definition at line 87 of file pgbench.c.

◆ MM2_ROT

#define MM2_ROT 47

Definition at line 88 of file pgbench.c.

◆ naccounts

#define naccounts 100000

Definition at line 256 of file pgbench.c.

◆ nbranches

#define nbranches

Value:

1 /* Makes little sense to change this. Change

* -s instead */

Definition at line 254 of file pgbench.c.

◆ ntellers

#define ntellers 10

Definition at line 255 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 689 of file pgbench.c.

◆ POLL_USING_SELECT

#define POLL_USING_SELECT

Definition at line 54 of file pgbench.c.

◆ SCALE_32BIT_THRESHOLD

#define SCALE_32BIT_THRESHOLD 20000

Definition at line 265 of file pgbench.c.

◆ SHELL_COMMAND_SIZE

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

Definition at line 309 of file pgbench.c.

◆ SOCKET_WAIT_METHOD

#define SOCKET_WAIT_METHOD "select"

Definition at line 107 of file pgbench.c.

◆ SQL_COMMAND

#define SQL_COMMAND 1

Definition at line 514 of file pgbench.c.

◆ THREAD_BARRIER_DESTROY

#define THREAD_BARRIER_DESTROY ( barrier )

Definition at line 166 of file pgbench.c.

◆ THREAD_BARRIER_INIT

#define THREAD_BARRIER_INIT	(	barrier,
		n
	)	(*(barrier) = 0)

Definition at line 164 of file pgbench.c.

◆ THREAD_BARRIER_T

#define THREAD_BARRIER_T int

Definition at line 163 of file pgbench.c.

◆ THREAD_BARRIER_WAIT

#define THREAD_BARRIER_WAIT ( barrier )

Definition at line 165 of file pgbench.c.

◆ THREAD_FUNC_CC

#define THREAD_FUNC_CC

Definition at line 162 of file pgbench.c.

◆ THREAD_FUNC_RETURN

#define THREAD_FUNC_RETURN return NULL

Definition at line 161 of file pgbench.c.

◆ THREAD_FUNC_RETURN_TYPE

#define THREAD_FUNC_RETURN_TYPE void *

Definition at line 160 of file pgbench.c.

◆ THREAD_T

#define THREAD_T void *

Definition at line 159 of file pgbench.c.

◆ WSEP

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

Definition at line 287 of file pgbench.c.

Typedef Documentation

◆ BuiltinScript

typedef struct BuiltinScript BuiltinScript

◆ Command

typedef struct Command Command

◆ MetaCommand

typedef enum MetaCommand MetaCommand

◆ ParsedScript

typedef struct ParsedScript ParsedScript

◆ pg_time_usec_t

typedef int64 pg_time_usec_t

Definition at line 331 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

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_END_TX
CSTATE_ABORTED
CSTATE_FINISHED

Definition at line 362 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,
  
     /*
      * 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

◆ 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_ENDPIPELINE

Definition at line 523 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_ENDPIPELINE            /* \endpipeline */

◆ partition_method_t

enum partition_method_t

Enumerator
PART_NONE
PART_RANGE
PART_HASH

Definition at line 237 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 540 of file pgbench.c.

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

Function Documentation

◆ accumStats()

static void accumStats	(	StatsData *	stats,
		bool	skipped,
		double	lat,
		double	lag
	)

static

Definition at line 1275 of file pgbench.c.

 {
     stats->cnt++;
  
     if (skipped)
     {
         /* no latency to record on skipped transactions */
         stats->skipped++;
     }
     else
     {
         addToSimpleStats(&stats->latency, lat);
  
         /* and possibly the same for schedule lag */
         if (throttle_delay)
             addToSimpleStats(&stats->lag, lag);
     }

References addToSimpleStats(), StatsData::cnt, StatsData::lag, StatsData::latency, 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 7042 of file pgbench.c.

 {
     if (fd < 0 || fd >= FD_SETSIZE)
     {
         /*
          * Doing a hard exit here is a bit grotty, but it doesn't seem worth
          * complicating the API to make it less grotty.
          */
         pg_log_fatal("too many client connections for select()");
         exit(1);
     }
     FD_SET(fd, &sa->fds);
     if (fd > sa->maxfd)
         sa->maxfd = fd;

References exit(), fd(), and pg_log_fatal.

Referenced by threadRun().

◆ addScript()

static void addScript ( ParsedScript script )

static

Definition at line 5409 of file pgbench.c.

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

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

Referenced by ParseScript().

◆ addToSimpleStats()

static void addToSimpleStats	(	SimpleStats *	ss,
		double	val
	)

static

Definition at line 1231 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 3101 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));
  
                 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 */
                     memset(st->prepared, 0, sizeof(st->prepared));
                 }
  
                 /* 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 */
                 if (command == NULL)
                 {
                     st->state = CSTATE_END_TX;
                     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);
                 }
  
                 /*
                  * 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    *command;
  
                     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
                     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)
                 {
                     Command    *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;
  
                 /*
                  * End of transaction (end of script, really).
                  */
             case CSTATE_END_TX:
  
                 /* 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));
  
                 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(), 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(), TState::conn_duration, CState::cstack, CSTATE_ABORTED, CSTATE_CHOOSE_SCRIPT, CSTATE_END_COMMAND, CSTATE_END_TX, CSTATE_FINISHED, CSTATE_PREPARE_THROTTLE, CSTATE_SKIP_COMMAND, CSTATE_SLEEP, CSTATE_START_COMMAND, CSTATE_START_TX, CSTATE_THROTTLE, CSTATE_WAIT_RESULT, ParsedScript::desc, doConnect(), duration, end_time, executeMetaCommand(), finishCon(), getPoissonRand(), 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_log_debug, pg_log_error, PG_TIME_GET_DOUBLE, pg_time_now(), pg_time_now_lazy(), PQ_PIPELINE_OFF, PQ_PIPELINE_ON, PQconsumeInput(), PQisBusy(), PQpipelineStatus(), CState::prepared, processXactStats(), readCommandResponse(), report_per_command, sendCommand(), SQL_COMMAND, sql_script, CState::state, Command::stats, CState::stmt_begin, throttle_delay, TState::throttle_trigger, timer_exceeded, TState::ts_throttle_rs, CState::txn_begin, CState::txn_scheduled, Command::type, CState::use_file, and Command::varprefix.

Referenced by threadRun().

◆ alloc_socket_set()

static socket_set * alloc_socket_set ( int count )

static

Definition at line 7023 of file pgbench.c.

7025 {

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

pg_malloc0

void * pg_malloc0(size_t size)

Definition: fe_memutils.c:53

socket_set

Definition: pgbench.c:110

References pg_malloc0().

Referenced by threadRun().

◆ assignVariables()

static char* assignVariables	(	CState *	st,
		char *	sql
	)

static

Definition at line 1722 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(st, 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().

◆ CheckConditional()

static void CheckConditional ( ParsedScript ps )

static

Definition at line 5059 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 ParsedScript::commands, conditional_stack_create(), conditional_stack_destroy(), conditional_stack_empty(), conditional_stack_peek(), conditional_stack_poke(), conditional_stack_pop(), conditional_stack_push(), ConditionError(), ParsedScript::desc, i, IFSTATE_ELSE_FALSE, IFSTATE_FALSE, Command::meta, META_COMMAND, META_ELIF, META_ELSE, META_ENDIF, META_IF, and Command::type.

Referenced by addScript().

◆ checkInitSteps()

static void checkInitSteps ( const char * initialize_steps )

static

Definition at line 4401 of file pgbench.c.

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

References ALL_INIT_STEPS, exit(), pg_log_fatal, and pg_log_info.

Referenced by main().

◆ chooseScript()

static int chooseScript ( TState * thread )

static

Definition at line 2817 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 7035 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 1789 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 1858 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 1830 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().

◆ commandFailed()

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

static

Definition at line 2809 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 1392 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 1029 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 5048 of file pgbench.c.

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

References exit(), and pg_log_fatal.

Referenced by CheckConditional().

◆ create_sql_command()

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

static

Definition at line 4757 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;
     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);
  
     return my_command;

References appendPQExpBufferStr(), Command::argc, Command::argv, buf, Command::expr, Command::first_line, initPQExpBuffer(), initSimpleStats(), Command::lines, Command::meta, META_NONE, pg_malloc(), 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 3954 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().

◆ disconnect_all()

static void disconnect_all	(	CState *	state,
		int	length
	)

static

Definition at line 3920 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 1327 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 3793 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)
         {
             /* 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)
             {
                 fprintf(logfile, " %.0f %.0f %.0f %.0f",
                         agg->lag.sum,
                         agg->lag.sum2,
                         agg->lag.min,
                         agg->lag.max);
                 if (latency_limit)
                     fprintf(logfile, " " INT64_FORMAT, agg->skipped);
             }
             fputc('\n', logfile);
  
             /* reset data and move to next interval */
             initStats(agg, next);
         }
  
         /* accumulate the current transaction */
         accumStats(agg, skipped, latency, lag);
     }
     else
     {
         /* no, print raw transactions */
         if (skipped)
             fprintf(logfile, "%d " INT64_FORMAT " skipped %d " INT64_FORMAT " "
                     INT64_FORMAT,
                     st->id, st->cnt, st->use_file, now / 1000000, now % 1000000);
         else
             fprintf(logfile, "%d " INT64_FORMAT " %.0f %d " INT64_FORMAT " "
                     INT64_FORMAT,
                     st->id, st->cnt, latency, st->use_file,
                     now / 1000000, now % 1000000);
         if (throttle_delay)
             fprintf(logfile, " %.0f", lag);
         fputc('\n', logfile);
     }

References accumStats(), agg_interval, Assert(), StatsData::cnt, CState::cnt, epoch_shift, fprintf, CState::id, initStats(), INT64_FORMAT, StatsData::lag, StatsData::latency, latency_limit, TState::logfile, logfile, SimpleStats::max, SimpleStats::min, next, now(), pg_prng_double(), pg_time_now(), sample_rate, StatsData::skipped, StatsData::start_time, SimpleStats::sum, SimpleStats::sum2, throttle_delay, TState::ts_sample_rs, CState::use_file, and use_log.

Referenced by processXactStats(), and threadRun().

◆ evalFunc()

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

static

Definition at line 2601 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 1917 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 2034 of file pgbench.c.

 {
     /* evaluate all function arguments */
     int         nargs = 0;
     PgBenchValue vargs[MAX_FARGS];
     PgBenchExprLink *l = args;
     bool        has_null = false;
  
     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(), generate_unaccent_rules::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 2617 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, 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_log_fatal("unexpected enode type in evaluation: %d", expr->etype);
             exit(1);
     }

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

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

◆ evaluateSleep()

static bool evaluateSleep	(	CState *	st,
		int	argc,
		char **	argv,
		int *	usecs
	)

static

Definition at line 3057 of file pgbench.c.

 {
     char       *var;
     int         usec;
  
     if (*argv[1] == ':')
     {
         if ((var = getVariable(st, 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 3593 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, 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, 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, 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, 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 (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_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;
         }
         /* 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, now(), PG_LOG_DEBUG, pg_log_debug, pg_time_now_lazy(), PQ_PIPELINE_OFF, PQ_PIPELINE_ON, PQenterPipelineMode(), PQpipelineStatus(), PQpipelineSync(), printfPQExpBuffer(), putVariableValue(), QUERY_SIMPLE, querymode, runShellCommand(), CState::sleep_until, sql_script, termPQExpBuffer(), Command::type, unlikely, CState::use_file, and valueTruth().

Referenced by advanceConnectionState().

◆ executeStatement()

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

static

Definition at line 1296 of file pgbench.c.

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

References exit(), pg_log_fatal, pg_log_info, 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 5330 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_fatal("no builtin script found for name \"%s\"", name);
     else                        /* found > 1 */
         pg_log_fatal("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_fatal.

Referenced by main().

◆ finishCon()

static void finishCon ( CState * st )

static

Definition at line 6855 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 4783 of file pgbench.c.

 {
     termPQExpBuffer(&command->lines);
     if (command->first_line)
         pg_free(command->first_line);
     for (int i = 0; i < command->argc; i++)
         pg_free(command->argv[i]);
     if (command->varprefix)
         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 7029 of file pgbench.c.

7031 {

7032 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 923 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().

◆ getGaussianRand()

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

static

Definition at line 947 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 user specified random number from this loop, with -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
     {
         /*
          * pg_prng_double generates [0, 1), but for the basic version of the
          * Box-Muller transform the two uniformly distributed random numbers
          * are expected to be in (0, 1] (see
          * https://en.wikipedia.org/wiki/Box-Muller_transform)
          */
         double      rand1 = 1.0 - pg_prng_double(state);
         double      rand2 = 1.0 - pg_prng_double(state);
  
         /* Box-Muller basic form transform */
         double      var_sqrt = sqrt(-2.0 * log(rand1));
  
         stdev = var_sqrt * sin(2.0 * M_PI * rand2);
  
         /*
          * we may try with cos, but there may be a bias induced if the
          * previous value fails the test. To be on the safe side, let us try
          * over.
          */
     }
     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(), M_PI, MIN_GAUSSIAN_PARAM, and pg_prng_double().

Referenced by evalStandardFunc().

◆ getHashFnv1a()

static int64 getHashFnv1a	(	int64	val,
		uint64	seed
	)

static

Definition at line 1073 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 1098 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 2661 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, "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, and pg_strcasecmp().

Referenced by process_backslash_command().

◆ getPoissonRand()

static int64 getPoissonRand	(	pg_prng_state *	state,
		double	center
	)

static

Definition at line 1007 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	(	CState *	st,
		const Command *	command,
		const char **	params
	)

static

Definition at line 1758 of file pgbench.c.

 {
     int         i;
  
     for (i = 0; i < command->argc - 1; i++)
         params[i] = getVariable(st, 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 912 of file pgbench.c.

914 {

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

pg_prng_uint64_range

uint64 pg_prng_uint64_range(pg_prng_state *state, uint64 rmin, uint64 rmax)

Definition: pg_prng.c:138

References pg_prng_uint64_range().

Referenced by chooseScript(), and evalStandardFunc().

◆ GetTableInfo()

static void GetTableInfo	(	PGconn *	con,
		bool	scale_given
	)

static

Definition at line 4512 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_fatal("could not count number of branches: %s", PQerrorMessage(con));
  
         if (sqlState && strcmp(sqlState, ERRCODE_UNDEFINED_TABLE) == 0)
             pg_log_info("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_log_fatal("invalid count(*) from pgbench_branches: \"%s\"",
                      PQgetvalue(res, 0, 0));
         exit(1);
     }
     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_fatal("no pgbench_accounts table found in search_path");
         pg_log_info("Perhaps you need to do initialization (\"pgbench -i\") in database \"%s\".", PQdb(con));
         exit(1);
     }
     else                        /* PQntupes(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_log_fatal("unexpected partition method: \"%s\"", ps);
                 exit(1);
             }
         }
  
         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_log_fatal, pg_log_info, pg_log_warning, PGRES_TUPLES_OK, PQclear(), PQdb(), PQerrorMessage(), PQexec(), PQgetisnull(), PQgetvalue(), PQntuples(), PQresultErrorField(), PQresultStatus(), res, and scale.

Referenced by main().

◆ getVariable()

static char* getVariable	(	CState *	st,
		char *	name
	)

static

Definition at line 1427 of file pgbench.c.

 {
     Variable   *var;
     char        stringform[64];
  
     var = lookupVariable(st, 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 1059 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 6871 of file pgbench.c.

6873 {

6874 timer_exceeded = true;

References timer_exceeded.

Referenced by setalarm().

◆ initCreateFKeys()

static void initCreateFKeys ( PGconn * con )

static

Definition at line 4375 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 4337 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 4023 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 3932 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 4131 of file pgbench.c.

 {
     PQExpBufferData sql;
     PGresult   *res;
     int         i;
     int64       k;
     char        *copy_statement;
  
     /* used to track elapsed time and estimate of the remaining time */
     pg_time_usec_t start;
     int         log_interval = 1;
  
     /* Stay on the same line if reporting to a terminal */
     char        eol = isatty(fileno(stderr)) ? '\r' : '\n';
  
     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);
  
     initPQExpBuffer(&sql);
  
     /*
      * fill branches, tellers, accounts in that order in case foreign keys
      * already exist
      */
     for (i = 0; i < nbranches * scale; i++)
     {
         /* "filler" column defaults to NULL */
         printfPQExpBuffer(&sql,
                           "insert into pgbench_branches(bid,bbalance) values(%d,0)",
                           i + 1);
         executeStatement(con, sql.data);
     }
  
     for (i = 0; i < ntellers * scale; i++)
     {
         /* "filler" column defaults to NULL */
         printfPQExpBuffer(&sql,
                           "insert into pgbench_tellers(tid,bid,tbalance) values (%d,%d,0)",
                           i + 1, i / ntellers + 1);
         executeStatement(con, sql.data);
     }
  
     /*
      * accounts is big enough to be worth using COPY and tracking runtime
      */
  
     /* use COPY with FREEZE on v14 and later without partioning */
     if (partitions == 0 && PQserverVersion(con) >= 140000)
         copy_statement = "copy pgbench_accounts from stdin with (freeze on)";
     else
         copy_statement = "copy pgbench_accounts from stdin";
  
     res = PQexec(con, copy_statement);
  
     if (PQresultStatus(res) != PGRES_COPY_IN)
     {
         pg_log_fatal("unexpected copy in result: %s", PQerrorMessage(con));
         exit(1);
     }
     PQclear(res);
  
     start = pg_time_now();
  
     for (k = 0; k < (int64) naccounts * scale; k++)
     {
         int64       j = k + 1;
  
         /* "filler" column defaults to blank padded empty string */
         printfPQExpBuffer(&sql,
                           INT64_FORMAT "\t" INT64_FORMAT "\t%d\t\n",
                           j, k / naccounts + 1, 0);
         if (PQputline(con, sql.data))
         {
             pg_log_fatal("PQputline failed");
             exit(1);
         }
  
         if (CancelRequested)
             break;
  
         /*
          * If we want to stick with the original logging, print a message each
          * 100k inserted rows.
          */
         if ((!use_quiet) && (j % 100000 == 0))
         {
             double      elapsed_sec = PG_TIME_GET_DOUBLE(pg_time_now() - start);
             double      remaining_sec = ((double) scale * naccounts - j) * elapsed_sec / j;
  
             fprintf(stderr, INT64_FORMAT " of " INT64_FORMAT " tuples (%d%%) done (elapsed %.2f s, remaining %.2f s)%c",
                     j, (int64) naccounts * scale,
                     (int) (((int64) j * 100) / (naccounts * (int64) scale)),
                     elapsed_sec, remaining_sec, eol);
         }
         /* let's not call the timing for each row, but only each 100 rows */
         else if (use_quiet && (j % 100 == 0))
         {
             double      elapsed_sec = PG_TIME_GET_DOUBLE(pg_time_now() - start);
             double      remaining_sec = ((double) scale * naccounts - j) * elapsed_sec / j;
  
             /* have we reached the next interval (or end)? */
             if ((j == scale * naccounts) || (elapsed_sec >= log_interval * LOG_STEP_SECONDS))
             {
                 fprintf(stderr, INT64_FORMAT " of " INT64_FORMAT " tuples (%d%%) done (elapsed %.2f s, remaining %.2f s)%c",
                         j, (int64) naccounts * scale,
                         (int) (((int64) j * 100) / (naccounts * (int64) scale)), elapsed_sec, remaining_sec, eol);
  
                 /* skip to the next interval */
                 log_interval = (int) ceil(elapsed_sec / LOG_STEP_SECONDS);
             }
         }
     }
  
     if (eol != '\n')
         fputc('\n', stderr);    /* Need to move to next line */
  
     if (PQputline(con, "\\.\n"))
     {
         pg_log_fatal("very last PQputline failed");
         exit(1);
     }
     if (PQendcopy(con))
     {
         pg_log_fatal("PQendcopy failed");
         exit(1);
     }
  
     termPQExpBuffer(&sql);
  
     executeStatement(con, "commit");

References CancelRequested, PQExpBufferData::data, executeStatement(), exit(), fprintf, i, initPQExpBuffer(), initTruncateTables(), INT64_FORMAT, j, LOG_STEP_SECONDS, naccounts, nbranches, ntellers, partitions, pg_log_fatal, PG_TIME_GET_DOUBLE, pg_time_now(), PGRES_COPY_IN, PQclear(), PQendcopy(), PQerrorMessage(), PQexec(), PQputline(), PQresultStatus(), PQserverVersion(), printfPQExpBuffer(), res, scale, termPQExpBuffer(), and use_quiet.

Referenced by runInitSteps().

◆ initGenerateDataServerSide()

static void initGenerateDataServerSide ( PGconn * con )

static

Definition at line 4279 of file pgbench.c.

 {
     PQExpBufferData sql;
  
     fprintf(stderr, "generating data (server-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);
  
     initPQExpBuffer(&sql);
  
     printfPQExpBuffer(&sql,
                       "insert into pgbench_branches(bid,bbalance) "
                       "select bid, 0 "
                       "from generate_series(1, %d) as bid", nbranches * scale);
     executeStatement(con, sql.data);
  
     printfPQExpBuffer(&sql,
                       "insert into pgbench_tellers(tid,bid,tbalance) "
                       "select tid, (tid - 1) / %d + 1, 0 "
                       "from generate_series(1, %d) as tid", ntellers, ntellers * scale);
     executeStatement(con, sql.data);
  
     printfPQExpBuffer(&sql,
                       "insert into pgbench_accounts(aid,bid,abalance,filler) "
                       "select aid, (aid - 1) / %d + 1, 0, '' "
                       "from generate_series(1, " INT64_FORMAT ") as aid",
                       naccounts, (int64) naccounts * scale);
     executeStatement(con, sql.data);
  
     termPQExpBuffer(&sql);
  
     executeStatement(con, "commit");

References PQExpBufferData::data, executeStatement(), fprintf, initPQExpBuffer(), initTruncateTables(), INT64_FORMAT, naccounts, nbranches, ntellers, printfPQExpBuffer(), scale, and termPQExpBuffer().

Referenced by runInitSteps().

◆ initRandomState()

static void initRandomState ( pg_prng_state * state )

static

Definition at line 898 of file pgbench.c.

900 {

901 pg_prng_seed(state, pg_prng_uint64(&base_random_sequence));

pg_prng_uint64

uint64 pg_prng_uint64(pg_prng_state *state)

Definition: pg_prng.c:128

pg_prng_seed

void pg_prng_seed(pg_prng_state *state, uint64 seed)

Definition: pg_prng.c:83

base_random_sequence

static pg_prng_state base_random_sequence

Definition: pgbench.c:354

References base_random_sequence, pg_prng_seed(), and pg_prng_uint64().

Referenced by main().

◆ initSimpleStats()

static void initSimpleStats ( SimpleStats * ss )

static

Definition at line 1222 of file pgbench.c.

1224 {

1225 memset(ss, 0, sizeof(SimpleStats));

SimpleStats

Definition: pgbench.c:318

Referenced by create_sql_command(), initStats(), and process_backslash_command().

◆ initStats()

static void initStats	(	StatsData *	sd,
		pg_time_usec_t	start
	)

static

Definition at line 1262 of file pgbench.c.

 {
     sd->start_time = start;
     sd->cnt = 0;
     sd->skipped = 0;
     initSimpleStats(&sd->latency);
     initSimpleStats(&sd->lag);

References StatsData::cnt, initSimpleStats(), StatsData::lag, StatsData::latency, StatsData::skipped, and StatsData::start_time.

Referenced by doLog(), main(), ParseScript(), printProgressReport(), and threadRun().

◆ initTruncateTables()

static void initTruncateTables ( PGconn * con )

static

Definition at line 4118 of file pgbench.c.

 {
     executeStatement(con, "truncate table "
                      "pgbench_accounts, "
                      "pgbench_branches, "
                      "pgbench_history, "
                      "pgbench_tellers");

References executeStatement().

Referenced by initGenerateDataClientSide(), and initGenerateDataServerSide().

◆ initVacuum()

static void initVacuum ( PGconn * con )

static

Definition at line 4324 of file pgbench.c.

 {
     fprintf(stderr, "vacuuming...\n");
     executeStatement(con, "vacuum analyze pgbench_branches");
     executeStatement(con, "vacuum analyze pgbench_tellers");
     executeStatement(con, "vacuum analyze pgbench_accounts");
     executeStatement(con, "vacuum analyze pgbench_history");

References executeStatement(), and fprintf.

Referenced by runInitSteps().

◆ is_an_int()

static bool is_an_int ( const char * str )

static

Definition at line 761 of file pgbench.c.

 {
     const char *ptr = str;
  
     /* skip leading spaces; cast is consistent with strtoint64 */
     while (*ptr && isspace((unsigned char) *ptr))
         ptr++;
  
     /* skip sign */
     if (*ptr == '+' || *ptr == '-')
         ptr++;
  
     /* at least one digit */
     if (*ptr && !isdigit((unsigned char) *ptr))
         return false;
  
     /* eat all digits */
     while (*ptr && isdigit((unsigned char) *ptr))
         ptr++;
  
     /* must have reached end of string */
     return *ptr == '\0';

References generate_unaccent_rules::str.

Referenced by makeVariableValue().

◆ isLazyFunc()

static bool isLazyFunc ( PgBenchFunction func )

static

Definition at line 1910 of file pgbench.c.

1912 {

1913 return func == PGBENCH_AND || func == PGBENCH_OR || func == PGBENCH_CASE;

References PGBENCH_AND, PGBENCH_CASE, and PGBENCH_OR.

Referenced by evalFunc(), and evalLazyFunc().

◆ listAvailableScripts()

static void listAvailableScripts ( void )

static

Definition at line 5318 of file pgbench.c.

 {
     int         i;
  
     fprintf(stderr, "Available builtin scripts:\n");
     for (i = 0; i < lengthof(builtin_script); i++)
         fprintf(stderr, "  %13s: %s\n", builtin_script[i].name, builtin_script[i].desc);
     fprintf(stderr, "\n");

References builtin_script, fprintf, i, lengthof, and name.

Referenced by findBuiltin(), and main().

◆ lookupCreateVariable()

static Variable* lookupCreateVariable	(	CState *	st,
		const char *	context,
		char *	name
	)

static

Definition at line 1570 of file pgbench.c.

 {
     Variable   *var;
  
     var = lookupVariable(st, name);
     if (var == NULL)
     {
         Variable   *newvars;
  
         /*
          * Check for the name only when declaring a new variable to avoid
          * overhead.
          */
         if (!valid_variable_name(name))
         {
             pg_log_error("%s: invalid variable name: \"%s\"", context, name);
             return NULL;
         }
  
         /* Create variable at the end of the array */
         if (st->variables)
             newvars = (Variable *) pg_realloc(st->variables,
                                               (st->nvariables + 1) * sizeof(Variable));
         else
             newvars = (Variable *) pg_malloc(sizeof(Variable));
  
         st->variables = newvars;
  
         var = &newvars[st->nvariables];
  
         var->name = pg_strdup(name);
         var->svalue = NULL;
         /* caller is expected to initialize remaining fields */
  
         st->nvariables++;
         /* we don't re-sort the array till we have to */
         st->vars_sorted = false;
     }
  
     return var;

References lookupVariable(), name, Variable::name, CState::nvariables, pg_log_error, pg_malloc(), pg_realloc(), pg_strdup(), Variable::svalue, valid_variable_name(), CState::variables, and CState::vars_sorted.

Referenced by putVariable(), and putVariableValue().

◆ lookupVariable()

static Variable* lookupVariable	(	CState *	st,
		char *	name
	)

static

Definition at line 1400 of file pgbench.c.

 {
     Variable    key;
  
     /* On some versions of Solaris, bsearch of zero items dumps core */
     if (st->nvariables <= 0)
         return NULL;
  
     /* Sort if we have to */
     if (!st->vars_sorted)
     {
         qsort((void *) st->variables, st->nvariables, sizeof(Variable),
               compareVariableNames);
         st->vars_sorted = true;
     }
  
     /* Now we can search */
     key.name = name;
     return (Variable *) bsearch((void *) &key,
                                 (void *) st->variables,
                                 st->nvariables,
                                 sizeof(Variable),
                                 compareVariableNames);

References compareVariableNames(), sort-test::key, name, CState::nvariables, qsort, CState::variables, and CState::vars_sorted.

Referenced by evaluateExpr(), getVariable(), lookupCreateVariable(), and main().

◆ main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 5755 of file pgbench.c.

 {
     static struct option long_options[] = {
         /* systematic long/short named options */
         {"builtin", required_argument, NULL, 'b'},
         {"client", required_argument, NULL, 'c'},
         {"connect", no_argument, NULL, 'C'},
         {"debug", no_argument, NULL, 'd'},
         {"define", required_argument, NULL, 'D'},
         {"file", required_argument, NULL, 'f'},
         {"fillfactor", required_argument, NULL, 'F'},
         {"host", required_argument, NULL, 'h'},
         {"initialize", no_argument, NULL, 'i'},
         {"init-steps", required_argument, NULL, 'I'},
         {"jobs", required_argument, NULL, 'j'},
         {"log", no_argument, NULL, 'l'},
         {"latency-limit", required_argument, NULL, 'L'},
         {"no-vacuum", no_argument, NULL, 'n'},
         {"port", required_argument, NULL, 'p'},
         {"progress", required_argument, NULL, 'P'},
         {"protocol", required_argument, NULL, 'M'},
         {"quiet", no_argument, NULL, 'q'},
         {"report-latencies", no_argument, NULL, 'r'},
         {"rate", required_argument, NULL, 'R'},
         {"scale", required_argument, NULL, 's'},
         {"select-only", no_argument, NULL, 'S'},
         {"skip-some-updates", no_argument, NULL, 'N'},
         {"time", required_argument, NULL, 'T'},
         {"transactions", required_argument, NULL, 't'},
         {"username", required_argument, NULL, 'U'},
         {"vacuum-all", no_argument, NULL, 'v'},
         /* long-named only options */
         {"unlogged-tables", no_argument, NULL, 1},
         {"tablespace", required_argument, NULL, 2},
         {"index-tablespace", required_argument, NULL, 3},
         {"sampling-rate", required_argument, NULL, 4},
         {"aggregate-interval", required_argument, NULL, 5},
         {"progress-timestamp", no_argument, NULL, 6},
         {"log-prefix", required_argument, NULL, 7},
         {"foreign-keys", no_argument, NULL, 8},
         {"random-seed", required_argument, NULL, 9},
         {"show-script", required_argument, NULL, 10},
         {"partitions", required_argument, NULL, 11},
         {"partition-method", required_argument, NULL, 12},
         {NULL, 0, NULL, 0}
     };
  
     int         c;
     bool        is_init_mode = false;   /* initialize mode? */
     char       *initialize_steps = NULL;
     bool        foreign_keys = false;
     bool        is_no_vacuum = false;
     bool        do_vacuum_accounts = false; /* vacuum accounts table? */
     int         optindex;
     bool        scale_given = false;
  
     bool        benchmarking_option_set = false;
     bool        initialization_option_set = false;
     bool        internal_script_used = false;
  
     CState     *state;          /* status of clients */
     TState     *threads;        /* array of thread */
  
     pg_time_usec_t
                 start_time,     /* start up time */
                 bench_start = 0,    /* first recorded benchmarking time */
                 conn_total_duration;    /* cumulated connection time in
                                          * threads */
     int64       latency_late = 0;
     StatsData   stats;
     int         weight;
  
     int         i;
     int         nclients_dealt;
  
 #ifdef HAVE_GETRLIMIT
     struct rlimit rlim;
 #endif
  
     PGconn     *con;
     char       *env;
  
     int         exit_code = 0;
     struct timeval tv;
  
     /*
      * Record difference between Unix time and instr_time time.  We'll use
      * this for logging and aggregation.
      */
     gettimeofday(&tv, NULL);
     epoch_shift = tv.tv_sec * INT64CONST(1000000) + tv.tv_usec - pg_time_now();
  
     pg_logging_init(argv[0]);
     progname = get_progname(argv[0]);
  
     if (argc > 1)
     {
         if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
         {
             usage();
             exit(0);
         }
         if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
         {
             puts("pgbench (PostgreSQL) " PG_VERSION);
             exit(0);
         }
     }
  
     state = (CState *) pg_malloc0(sizeof(CState));
  
     /* set random seed early, because it may be used while parsing scripts. */
     if (!set_random_seed(getenv("PGBENCH_RANDOM_SEED")))
     {
         pg_log_fatal("error while setting random seed from PGBENCH_RANDOM_SEED environment variable");
         exit(1);
     }
  
     while ((c = getopt_long(argc, argv, "iI:h:nvp:dqb:SNc:j:Crs:t:T:U:lf:D:F:M:P:R:L:", long_options, &optindex)) != -1)
     {
         char       *script;
  
         switch (c)
         {
             case 'i':
                 is_init_mode = true;
                 break;
             case 'I':
                 if (initialize_steps)
                     pg_free(initialize_steps);
                 initialize_steps = pg_strdup(optarg);
                 checkInitSteps(initialize_steps);
                 initialization_option_set = true;
                 break;
             case 'h':
                 pghost = pg_strdup(optarg);
                 break;
             case 'n':
                 is_no_vacuum = true;
                 break;
             case 'v':
                 benchmarking_option_set = true;
                 do_vacuum_accounts = true;
                 break;
             case 'p':
                 pgport = pg_strdup(optarg);
                 break;
             case 'd':
                 pg_logging_increase_verbosity();
                 break;
             case 'c':
                 benchmarking_option_set = true;
                 if (!option_parse_int(optarg, "-c/--clients", 1, INT_MAX,
                                       &nclients))
                 {
                     exit(1);
                 }
 #ifdef HAVE_GETRLIMIT
 #ifdef RLIMIT_NOFILE            /* most platforms use RLIMIT_NOFILE */
                 if (getrlimit(RLIMIT_NOFILE, &rlim) == -1)
 #else                           /* but BSD doesn't ... */
                 if (getrlimit(RLIMIT_OFILE, &rlim) == -1)
 #endif                          /* RLIMIT_NOFILE */
                 {
                     pg_log_fatal("getrlimit failed: %m");
                     exit(1);
                 }
                 if (rlim.rlim_cur < nclients + 3)
                 {
                     pg_log_fatal("need at least %d open files, but system limit is %ld",
                                  nclients + 3, (long) rlim.rlim_cur);
                     pg_log_info("Reduce number of clients, or use limit/ulimit to increase the system limit.");
                     exit(1);
                 }
 #endif                          /* HAVE_GETRLIMIT */
                 break;
             case 'j':           /* jobs */
                 benchmarking_option_set = true;
                 if (!option_parse_int(optarg, "-j/--jobs", 1, INT_MAX,
                                       &nthreads))
                 {
                     exit(1);
                 }
 #ifndef ENABLE_THREAD_SAFETY
                 if (nthreads != 1)
                 {
                     pg_log_fatal("threads are not supported on this platform; use -j1");
                     exit(1);
                 }
 #endif                          /* !ENABLE_THREAD_SAFETY */
                 break;
             case 'C':
                 benchmarking_option_set = true;
                 is_connect = true;
                 break;
             case 'r':
                 benchmarking_option_set = true;
                 report_per_command = true;
                 break;
             case 's':
                 scale_given = true;
                 if (!option_parse_int(optarg, "-s/--scale", 1, INT_MAX,
                                       &scale))
                     exit(1);
                 break;
             case 't':
                 benchmarking_option_set = true;
                 if (!option_parse_int(optarg, "-t/--transactions", 1, INT_MAX,
                                       &nxacts))
                     exit(1);
                 break;
             case 'T':
                 benchmarking_option_set = true;
                 if (!option_parse_int(optarg, "-T/--time", 1, INT_MAX,
                                       &duration))
                     exit(1);
                 break;
             case 'U':
                 username = pg_strdup(optarg);
                 break;
             case 'l':
                 benchmarking_option_set = true;
                 use_log = true;
                 break;
             case 'q':
                 initialization_option_set = true;
                 use_quiet = true;
                 break;
             case 'b':
                 if (strcmp(optarg, "list") == 0)
                 {
                     listAvailableScripts();
                     exit(0);
                 }
                 weight = parseScriptWeight(optarg, &script);
                 process_builtin(findBuiltin(script), weight);
                 benchmarking_option_set = true;
                 internal_script_used = true;
                 break;
             case 'S':
                 process_builtin(findBuiltin("select-only"), 1);
                 benchmarking_option_set = true;
                 internal_script_used = true;
                 break;
             case 'N':
                 process_builtin(findBuiltin("simple-update"), 1);
                 benchmarking_option_set = true;
                 internal_script_used = true;
                 break;
             case 'f':
                 weight = parseScriptWeight(optarg, &script);
                 process_file(script, weight);
                 benchmarking_option_set = true;
                 break;
             case 'D':
                 {
                     char       *p;
  
                     benchmarking_option_set = true;
  
                     if ((p = strchr(optarg, '=')) == NULL || p == optarg || *(p + 1) == '\0')
                     {
                         pg_log_fatal("invalid variable definition: \"%s\"", optarg);
                         exit(1);
                     }
  
                     *p++ = '\0';
                     if (!putVariable(&state[0], "option", optarg, p))
                         exit(1);
                 }
                 break;
             case 'F':
                 initialization_option_set = true;
                 if (!option_parse_int(optarg, "-F/--fillfactor", 10, 100,
                                       &fillfactor))
                     exit(1);
                 break;
             case 'M':
                 benchmarking_option_set = true;
                 for (querymode = 0; querymode < NUM_QUERYMODE; querymode++)
                     if (strcmp(optarg, QUERYMODE[querymode]) == 0)
                         break;
                 if (querymode >= NUM_QUERYMODE)
                 {
                     pg_log_fatal("invalid query mode (-M): \"%s\"", optarg);
                     exit(1);
                 }
                 break;
             case 'P':
                 benchmarking_option_set = true;
                 if (!option_parse_int(optarg, "-P/--progress", 1, INT_MAX,
                                       &progress))
                     exit(1);
                 break;
             case 'R':
                 {
                     /* get a double from the beginning of option value */
                     double      throttle_value = atof(optarg);
  
                     benchmarking_option_set = true;
  
                     if (throttle_value <= 0.0)
                     {
                         pg_log_fatal("invalid rate limit: \"%s\"", optarg);
                         exit(1);
                     }
                     /* Invert rate limit into per-transaction delay in usec */
                     throttle_delay = 1000000.0 / throttle_value;
                 }
                 break;
             case 'L':
                 {
                     double      limit_ms = atof(optarg);
  
                     if (limit_ms <= 0.0)
                     {
                         pg_log_fatal("invalid latency limit: \"%s\"", optarg);
                         exit(1);
                     }
                     benchmarking_option_set = true;
                     latency_limit = (int64) (limit_ms * 1000);
                 }
                 break;
             case 1:             /* unlogged-tables */
                 initialization_option_set = true;
                 unlogged_tables = true;
                 break;
             case 2:             /* tablespace */
                 initialization_option_set = true;
                 tablespace = pg_strdup(optarg);
                 break;
             case 3:             /* index-tablespace */
                 initialization_option_set = true;
                 index_tablespace = pg_strdup(optarg);
                 break;
             case 4:             /* sampling-rate */
                 benchmarking_option_set = true;
                 sample_rate = atof(optarg);
                 if (sample_rate <= 0.0 || sample_rate > 1.0)
                 {
                     pg_log_fatal("invalid sampling rate: \"%s\"", optarg);
                     exit(1);
                 }
                 break;
             case 5:             /* aggregate-interval */
                 benchmarking_option_set = true;
                 if (!option_parse_int(optarg, "--aggregate-interval", 1, INT_MAX,
                                       &agg_interval))
                     exit(1);
                 break;
             case 6:             /* progress-timestamp */
                 progress_timestamp = true;
                 benchmarking_option_set = true;
                 break;
             case 7:             /* log-prefix */
                 benchmarking_option_set = true;
                 logfile_prefix = pg_strdup(optarg);
                 break;
             case 8:             /* foreign-keys */
                 initialization_option_set = true;
                 foreign_keys = true;
                 break;
             case 9:             /* random-seed */
                 benchmarking_option_set = true;
                 if (!set_random_seed(optarg))
                 {
                     pg_log_fatal("error while setting random seed from --random-seed option");
                     exit(1);
                 }
                 break;
             case 10:            /* list */
                 {
                     const BuiltinScript *s = findBuiltin(optarg);
  
                     fprintf(stderr, "-- %s: %s\n%s\n", s->name, s->desc, s->script);
                     exit(0);
                 }
                 break;
             case 11:            /* partitions */
                 initialization_option_set = true;
                 if (!option_parse_int(optarg, "--partitions", 1, INT_MAX,
                                       &partitions))
                     exit(1);
                 break;
             case 12:            /* partition-method */
                 initialization_option_set = true;
                 if (pg_strcasecmp(optarg, "range") == 0)
                     partition_method = PART_RANGE;
                 else if (pg_strcasecmp(optarg, "hash") == 0)
                     partition_method = PART_HASH;
                 else
                 {
                     pg_log_fatal("invalid partition method, expecting \"range\" or \"hash\", got: \"%s\"",
                                  optarg);
                     exit(1);
                 }
                 break;
             default:
                 fprintf(stderr, _("Try \"%s --help\" for more information.\n"), progname);
                 exit(1);
                 break;
         }
     }
  
     /* set default script if none */
     if (num_scripts == 0 && !is_init_mode)
     {
         process_builtin(findBuiltin("tpcb-like"), 1);
         benchmarking_option_set = true;
         internal_script_used = true;
     }
  
     /* complete SQL command initialization and compute total weight */
     for (i = 0; i < num_scripts; i++)
     {
         Command   **commands = sql_script[i].commands;
  
         for (int j = 0; commands[j] != NULL; j++)
             if (commands[j]->type == SQL_COMMAND)
                 postprocess_sql_command(commands[j]);
  
         /* cannot overflow: weight is 32b, total_weight 64b */
         total_weight += sql_script[i].weight;
     }
  
     if (total_weight == 0 && !is_init_mode)
     {
         pg_log_fatal("total script weight must not be zero");
         exit(1);
     }
  
     /* show per script stats if several scripts are used */
     if (num_scripts > 1)
         per_script_stats = true;
  
     /*
      * Don't need more threads than there are clients.  (This is not merely an
      * optimization; throttle_delay is calculated incorrectly below if some
      * threads have no clients assigned to them.)
      */
     if (nthreads > nclients)
         nthreads = nclients;
  
     /*
      * Convert throttle_delay to a per-thread delay time.  Note that this
      * might be a fractional number of usec, but that's OK, since it's just
      * the center of a Poisson distribution of delays.
      */
     throttle_delay *= nthreads;
  
     if (argc > optind)
         dbName = argv[optind++];
     else
     {
         if ((env = getenv("PGDATABASE")) != NULL && *env != '\0')
             dbName = env;
         else if ((env = getenv("PGUSER")) != NULL && *env != '\0')
             dbName = env;
         else
             dbName = get_user_name_or_exit(progname);
     }
  
     if (optind < argc)
     {
         pg_log_fatal("too many command-line arguments (first is \"%s\")",
                      argv[optind]);
         fprintf(stderr, _("Try \"%s --help\" for more information.\n"), progname);
         exit(1);
     }
  
     if (is_init_mode)
     {
         if (benchmarking_option_set)
         {
             pg_log_fatal("some of the specified options cannot be used in initialization (-i) mode");
             exit(1);
         }
  
         if (partitions == 0 && partition_method != PART_NONE)
         {
             pg_log_fatal("--partition-method requires greater than zero --partitions");
             exit(1);
         }
  
         /* set default method */
         if (partitions > 0 && partition_method == PART_NONE)
             partition_method = PART_RANGE;
  
         if (initialize_steps == NULL)
             initialize_steps = pg_strdup(DEFAULT_INIT_STEPS);
  
         if (is_no_vacuum)
         {
             /* Remove any vacuum step in initialize_steps */
             char       *p;
  
             while ((p = strchr(initialize_steps, 'v')) != NULL)
                 *p = ' ';
         }
  
         if (foreign_keys)
         {
             /* Add 'f' to end of initialize_steps, if not already there */
             if (strchr(initialize_steps, 'f') == NULL)
             {
                 initialize_steps = (char *)
                     pg_realloc(initialize_steps,
                                strlen(initialize_steps) + 2);
                 strcat(initialize_steps, "f");
             }
         }
  
         runInitSteps(initialize_steps);
 

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ ALL_INIT_STEPS

◆ COMMANDS_ALLOC_NUM

◆ DEFAULT_INIT_STEPS

◆ DEFAULT_NXACTS

◆ ERRCODE_UNDEFINED_TABLE

◆ FNV_OFFSET_BASIS

◆ FNV_PRIME

◆ LOG_STEP_SECONDS

◆ M_PI

◆ MAX_ARGS

◆ MAX_FARGS

◆ MAX_PREPARE_NAME

◆ MAX_SCRIPTS

◆ MAX_ZIPFIAN_PARAM

◆ META_COMMAND

◆ MIN_GAUSSIAN_PARAM

◆ MIN_ZIPFIAN_PARAM

◆ MM2_MUL

◆ MM2_MUL_TIMES_8

◆ MM2_ROT

◆ naccounts

◆ nbranches

◆ ntellers

◆ PARAMS_ARRAY_SIZE

◆ PG_TIME_GET_DOUBLE

◆ POLL_USING_SELECT

◆ SCALE_32BIT_THRESHOLD

◆ SHELL_COMMAND_SIZE

◆ SOCKET_WAIT_METHOD

◆ SQL_COMMAND

◆ THREAD_BARRIER_DESTROY

◆ THREAD_BARRIER_INIT

◆ THREAD_BARRIER_T

◆ THREAD_BARRIER_WAIT

◆ THREAD_FUNC_CC

◆ THREAD_FUNC_RETURN

◆ THREAD_FUNC_RETURN_TYPE

◆ THREAD_T

◆ WSEP

Typedef Documentation

◆ BuiltinScript

◆ Command

◆ MetaCommand

◆ ParsedScript

◆ pg_time_usec_t

◆ QueryMode

◆ SimpleStats

◆ socket_set

◆ StatsData

Enumeration Type Documentation

◆ ConnectionStateEnum

◆ MetaCommand

◆ partition_method_t

◆ QueryMode

Function Documentation

◆ accumStats()

◆ add_socket_to_set()

◆ addScript()

◆ addToSimpleStats()

◆ advanceConnectionState()

◆ alloc_socket_set()

◆ assignVariables()

◆ CheckConditional()

◆ checkInitSteps()

◆ chooseScript()

◆ clear_socket_set()

◆ coerceToBool()

◆ coerceToDouble()

◆ coerceToInt()

◆ commandFailed()

◆ compareVariableNames()

◆ computeIterativeZipfian()

◆ ConditionError()