Table 275. pgbench Functions ┌─────────────────────────────────────────┐ │                                         │ │       Function                          │ │                                         │ │              .PP Description            │ │                                         │ │              .PP Example(s)             │ ├─────────────────────────────────────────┤ │                                         │ │       abs ( number ) → same type as     │ │       input                             │ │                                         │ │              .PP Absolute value         │ │                                         │ │              .PP abs(-17) → 17          │ ├─────────────────────────────────────────┤ │                                         │ │       debug ( number ) → same type as   │ │       input                             │ │                                         │ │              .PP Prints the argument to │ │       stderr, and returns the argument. │ │                                         │ │              .PP debug(5432.1) → 5432.1 │ ├─────────────────────────────────────────┤ │                                         │ │       double ( number ) → double        │ │                                         │ │              .PP Casts to double.       │ │                                         │ │              .PP double(5432) → 5432.0  │ ├─────────────────────────────────────────┤ │                                         │ │       exp ( number ) → double           │ │                                         │ │              .PP Exponential (e raised  │ │       to the given power)               │ │                                         │ │              .PP exp(1.0) →             │ │       2.718281828459045                 │ ├─────────────────────────────────────────┤ │                                         │ │       greatest ( number [, ... ] ) →    │ │       double if any argument is double, │ │       else integer                      │ │                                         │ │              .PP Selects the largest    │ │       value among the arguments.        │ │                                         │ │              .PP greatest(5, 4, 3, 2) → │ │       5                                 │ ├─────────────────────────────────────────┤ │                                         │ │       hash ( value [, seed ] ) →        │ │       integer                           │ │                                         │ │              .PP This is an alias for   │ │       hash_murmur2.                     │ │                                         │ │              .PP hash(10, 5432) →       │ │       -5817877081768721676              │ ├─────────────────────────────────────────┤ │                                         │ │       hash_fnv1a ( value [, seed ] ) →  │ │       integer                           │ │                                         │ │              .PP Computes FNV-1a hash.  │ │                                         │ │              .PP hash_fnv1a(10, 5432) → │ │       -7793829335365542153              │ ├─────────────────────────────────────────┤ │                                         │ │       hash_murmur2 ( value [, seed ] )  │ │       → integer                         │ │                                         │ │              .PP Computes MurmurHash2   │ │       hash.                             │ │                                         │ │              .PP hash_murmur2(10, 5432) │ │       → -5817877081768721676            │ ├─────────────────────────────────────────┤ │                                         │ │       int ( number ) → integer          │ │                                         │ │              .PP Casts to integer.      │ │                                         │ │              .PP int(5.4 + 3.8) → 9     │ ├─────────────────────────────────────────┤ │                                         │ │       least ( number [, ... ] ) →       │ │       double if any argument is double, │ │       else integer                      │ │                                         │ │              .PP Selects the smallest   │ │       value among the arguments.        │ │                                         │ │              .PP least(5, 4, 3, 2.1) →  │ │       2.1                               │ ├─────────────────────────────────────────┤ │                                         │ │       ln ( number ) → double            │ │                                         │ │              .PP Natural logarithm      │ │                                         │ │              .PP ln(2.718281828459045)  │ │       → 1.0                             │ ├─────────────────────────────────────────┤ │                                         │ │       mod ( integer, integer ) →        │ │       integer                           │ │                                         │ │              .PP Modulo (remainder)     │ │                                         │ │              .PP mod(54, 32) → 22       │ ├─────────────────────────────────────────┤ │                                         │ │       pi () → double                    │ │                                         │ │              .PP Approximate value of π │ │                                         │ │              .PP pi() →                 │ │       3.14159265358979323846            │ ├─────────────────────────────────────────┤ │                                         │ │       pow ( x, y ) → double             │ │                                         │ │              .PP power ( x, y ) →       │ │       double                            │ │                                         │ │              .PP x raised to the power  │ │       of y                              │ │                                         │ │              .PP pow(2.0, 10) → 1024.0  │ ├─────────────────────────────────────────┤ │                                         │ │       random ( lb, ub ) → integer       │ │                                         │ │              .PP Computes a             │ │       uniformly-distributed random      │ │       integer in [lb, ub].              │ │                                         │ │              .PP random(1, 10) → an     │ │       integer between 1 and 10          │ ├─────────────────────────────────────────┤ │                                         │ │       random_exponential ( lb, ub,      │ │       parameter ) → integer             │ │                                         │ │              .PP Computes an            │ │       exponentially-distributed random  │ │       integer in [lb, ub], see below.   │ │                                         │ │              .PP random_exponential(1,  │ │       10, 3.0) → an integer between 1   │ │       and 10                            │ ├─────────────────────────────────────────┤ │                                         │ │       random_gaussian ( lb, ub,         │ │       parameter ) → integer             │ │                                         │ │              .PP Computes a             │ │       Gaussian-distributed random       │ │       integer in [lb, ub], see below.   │ │                                         │ │              .PP random_gaussian(1, 10, │ │       2.5) → an integer between 1 and   │ │       10                                │ ├─────────────────────────────────────────┤ │                                         │ │       random_zipfian ( lb, ub,          │ │       parameter ) → integer             │ │                                         │ │              .PP Computes a             │ │       Zipfian-distributed random        │ │       integer in [lb, ub], see below.   │ │                                         │ │              .PP random_zipfian(1, 10,  │ │       1.5) → an integer between 1 and   │ │       10                                │ ├─────────────────────────────────────────┤ │                                         │ │       sqrt ( number ) → double          │ │                                         │ │              .PP Square root            │ │                                         │ │              .PP sqrt(2.0) →            │ │       1.414213562                       │ └─────────────────────────────────────────┘