pgbench.h File Reference

#include "fe_utils/psqlscan.h"

Include dependency graph for pgbench.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	PgBenchValue
struct	PgBenchExpr
struct	PgBenchExprLink
struct	PgBenchExprList

Macros
#define	yyscan_t   void *

Typedefs
typedef enum PgBenchExprType	PgBenchExprType
typedef enum PgBenchFunction	PgBenchFunction
typedef struct PgBenchExpr	PgBenchExpr
typedef struct PgBenchExprLink	PgBenchExprLink
typedef struct PgBenchExprList	PgBenchExprList

Enumerations
enum	PgBenchValueType {   PGBT_NO_VALUE = 0 , PGBT_NULL , PGBT_INT , PGBT_DOUBLE ,   PGBT_BOOLEAN }
enum	PgBenchExprType { ENODE_CONSTANT , ENODE_VARIABLE , ENODE_FUNCTION }
enum	PgBenchFunction {   PGBENCH_ADD , PGBENCH_SUB , PGBENCH_MUL , PGBENCH_DIV ,   PGBENCH_MOD , PGBENCH_DEBUG , PGBENCH_ABS , PGBENCH_LEAST ,   PGBENCH_GREATEST , PGBENCH_INT , PGBENCH_DOUBLE , PGBENCH_PI ,   PGBENCH_SQRT , PGBENCH_LN , PGBENCH_EXP , PGBENCH_RANDOM ,   PGBENCH_RANDOM_GAUSSIAN , PGBENCH_RANDOM_EXPONENTIAL , PGBENCH_RANDOM_ZIPFIAN , PGBENCH_POW ,   PGBENCH_AND , PGBENCH_OR , PGBENCH_NOT , PGBENCH_BITAND ,   PGBENCH_BITOR , PGBENCH_BITXOR , PGBENCH_LSHIFT , PGBENCH_RSHIFT ,   PGBENCH_EQ , PGBENCH_NE , PGBENCH_LE , PGBENCH_LT ,   PGBENCH_IS , PGBENCH_CASE , PGBENCH_HASH_FNV1A , PGBENCH_HASH_MURMUR2 ,   PGBENCH_PERMUTE }

Functions
int	expr_yyparse (PgBenchExpr **expr_parse_result_p, yyscan_t yyscanner)
int	expr_yylex (union YYSTYPE *yylval_param, yyscan_t yyscanner)
pg_noreturn void	expr_yyerror (PgBenchExpr **expr_parse_result_p, yyscan_t yyscanner, const char *message)
pg_noreturn void	expr_yyerror_more (yyscan_t yyscanner, const char *message, const char *more)
bool	expr_lex_one_word (PsqlScanState state, PQExpBuffer word_buf, int *offset)
yyscan_t	expr_scanner_init (PsqlScanState state, const char *source, int lineno, int start_offset, const char *command)
void	expr_scanner_finish (yyscan_t yyscanner)
char *	expr_scanner_get_substring (PsqlScanState state, int start_offset, bool chomp)
pg_noreturn void	syntax_error (const char *source, int lineno, const char *line, const char *command, const char *msg, const char *more, int column)
bool	strtoint64 (const char *str, bool errorOK, int64 *result)
bool	strtodouble (const char *str, bool errorOK, double *dv)

Macro Definition Documentation

yyscan_t

#define yyscan_t   void *

Definition at line 23 of file pgbench.h.

Typedef Documentation

PgBenchExpr

typedef struct PgBenchExpr PgBenchExpr

Definition at line 106 of file pgbench.h.

PgBenchExprLink

typedef struct PgBenchExprLink PgBenchExprLink

Definition at line 107 of file pgbench.h.

PgBenchExprList

typedef struct PgBenchExprList PgBenchExprList

Definition at line 108 of file pgbench.h.

PgBenchExprType

typedef enum PgBenchExprType PgBenchExprType

PgBenchFunction

typedef enum PgBenchFunction PgBenchFunction

Enumeration Type Documentation

PgBenchExprType

enum PgBenchExprType

Enumerator
ENODE_CONSTANT
ENODE_VARIABLE
ENODE_FUNCTION

Definition at line 57 of file pgbench.h.

{
    ENODE_CONSTANT,
    ENODE_VARIABLE,
    ENODE_FUNCTION,
} PgBenchExprType;

PgBenchFunction

enum PgBenchFunction

Enumerator
PGBENCH_ADD
PGBENCH_SUB
PGBENCH_MUL
PGBENCH_DIV
PGBENCH_MOD
PGBENCH_DEBUG
PGBENCH_ABS
PGBENCH_LEAST
PGBENCH_GREATEST
PGBENCH_INT
PGBENCH_DOUBLE
PGBENCH_PI
PGBENCH_SQRT
PGBENCH_LN
PGBENCH_EXP
PGBENCH_RANDOM
PGBENCH_RANDOM_GAUSSIAN
PGBENCH_RANDOM_EXPONENTIAL
PGBENCH_RANDOM_ZIPFIAN
PGBENCH_POW
PGBENCH_AND
PGBENCH_OR
PGBENCH_NOT
PGBENCH_BITAND
PGBENCH_BITOR
PGBENCH_BITXOR
PGBENCH_LSHIFT
PGBENCH_RSHIFT
PGBENCH_EQ
PGBENCH_NE
PGBENCH_LE
PGBENCH_LT
PGBENCH_IS
PGBENCH_CASE
PGBENCH_HASH_FNV1A
PGBENCH_HASH_MURMUR2
PGBENCH_PERMUTE

Definition at line 65 of file pgbench.h.

{
    PGBENCH_ADD,
    PGBENCH_SUB,
    PGBENCH_MUL,
    PGBENCH_DIV,
    PGBENCH_MOD,
    PGBENCH_DEBUG,
    PGBENCH_ABS,
    PGBENCH_LEAST,
    PGBENCH_GREATEST,
    PGBENCH_INT,
    PGBENCH_DOUBLE,
    PGBENCH_PI,
    PGBENCH_SQRT,
    PGBENCH_LN,
    PGBENCH_EXP,
    PGBENCH_RANDOM,
    PGBENCH_RANDOM_GAUSSIAN,
    PGBENCH_RANDOM_EXPONENTIAL,
    PGBENCH_RANDOM_ZIPFIAN,
    PGBENCH_POW,
    PGBENCH_AND,
    PGBENCH_OR,
    PGBENCH_NOT,
    PGBENCH_BITAND,
    PGBENCH_BITOR,
    PGBENCH_BITXOR,
    PGBENCH_LSHIFT,
    PGBENCH_RSHIFT,
    PGBENCH_EQ,
    PGBENCH_NE,
    PGBENCH_LE,
    PGBENCH_LT,
    PGBENCH_IS,
    PGBENCH_CASE,
    PGBENCH_HASH_FNV1A,
    PGBENCH_HASH_MURMUR2,
    PGBENCH_PERMUTE,
} PgBenchFunction;

PgBenchValueType

enum PgBenchValueType

Enumerator
PGBT_NO_VALUE
PGBT_NULL
PGBT_INT
PGBT_DOUBLE
PGBT_BOOLEAN

Definition at line 34 of file pgbench.h.

{
    PGBT_NO_VALUE = 0,
    PGBT_NULL,
    PGBT_INT,
    PGBT_DOUBLE,
    PGBT_BOOLEAN,
    /* add other types here */
} PgBenchValueType;

Function Documentation

expr_lex_one_word()

bool expr_lex_one_word	(	PsqlScanState	state,
		PQExpBuffer	word_buf,
		int *	offset
	)

Definition at line 318 of file exprscan.l.

{
    int         lexresult;
    YYSTYPE     lval;
 
    /* Must be scanning already */
    Assert(state->scanbufhandle != NULL);
 
    /* Set current output target */
    state->output_buf = word_buf;
    resetPQExpBuffer(word_buf);
 
    /* Set input source */
    if (state->buffer_stack != NULL)
        yy_switch_to_buffer(state->buffer_stack->buf, state->scanner);
    else
        yy_switch_to_buffer(state->scanbufhandle, state->scanner);
 
    /* Set start state */
    state->start_state = INITIAL;
 
    /* And lex. */
    lexresult = yylex(&lval, state->scanner);
 
    /* Save start offset of word, if any. */
    if (lexresult)
    {
        int         lineno;
        int         end_offset;
 
        psql_scan_get_location(state, &lineno, &end_offset);
        *offset = end_offset - word_buf->len;
    }
    else
        *offset = -1;
 
    /*
     * In case the caller returns to using the regular SQL lexer, reselect the
     * appropriate initial state.
     */
    psql_scan_reselect_sql_lexer(state);
 
    return (bool) lexresult;
}

References Assert(), PQExpBufferData::len, psql_scan_get_location(), psql_scan_reselect_sql_lexer(), resetPQExpBuffer(), and yylex().

Referenced by process_backslash_command().

expr_scanner_finish()

void expr_scanner_finish

(

yyscan_t

yyscanner

)

Definition at line 402 of file exprscan.l.

{
    PsqlScanState state = yyget_extra(yyscanner);
 
    /*
     * Reselect appropriate initial state for SQL lexer.
     */
    psql_scan_reselect_sql_lexer(state);
}

References psql_scan_reselect_sql_lexer().

Referenced by process_backslash_command().

expr_scanner_get_substring()

char * expr_scanner_get_substring	(	PsqlScanState	state,
		int	start_offset,
		bool	chomp
	)

Definition at line 425 of file exprscan.l.

{
    char       *result;
    const char *scanptr = state->scanbuf + start_offset;
    size_t      slen = strlen(scanptr);
 
    if (chomp)
    {
        while (slen > 0 &&
               (scanptr[slen - 1] == '\n' || scanptr[slen - 1] == '\r'))
            slen--;
    }
 
    result = (char *) pg_malloc(slen + 1);
    memcpy(result, scanptr, slen);
    result[slen] = '\0';
 
    return result;
}

References pg_malloc().

Referenced by expr_yyerror_more(), and process_backslash_command().

expr_scanner_init()

yyscan_t expr_scanner_init	(	PsqlScanState	state,
		const char *	source,
		int	lineno,
		int	start_offset,
		const char *	command
	)

Definition at line 370 of file exprscan.l.

{
    /* Save error context info */
    expr_source = source;
    expr_lineno = lineno;
    expr_start_offset = start_offset;
    expr_command = command;
 
    /* Must be scanning already */
    Assert(state->scanbufhandle != NULL);
 
    /* Set current output target */
    state->output_buf = NULL;
 
    /* Set input source */
    if (state->buffer_stack != NULL)
        yy_switch_to_buffer(state->buffer_stack->buf, state->scanner);
    else
        yy_switch_to_buffer(state->scanbufhandle, state->scanner);
 
    /* Set start state */
    state->start_state = EXPR;
 
    return state->scanner;
}

References Assert(), expr_command, expr_lineno, expr_source, expr_start_offset, and source.

Referenced by process_backslash_command().

expr_yyerror()

pg_noreturn void expr_yyerror	(	PgBenchExpr **	expr_parse_result_p,
		yyscan_t	yyscanner,
		const char *	message
	)

Definition at line 307 of file exprscan.l.

{
    expr_yyerror_more(yyscanner, message, NULL);
}

References expr_yyerror_more().

expr_yyerror_more()

pg_noreturn void expr_yyerror_more	(	yyscan_t	yyscanner,
		const char *	message,
		const char *	more
	)

Definition at line 271 of file exprscan.l.

{
    PsqlScanState state = yyget_extra(yyscanner);
    int         lineno;
    int         error_detection_offset;
    YYSTYPE     lval;
    char       *full_line;
 
    psql_scan_get_location(state, &lineno, &error_detection_offset);
    error_detection_offset--;
 
    /*
     * While parsing an expression, we may not have collected the whole line
     * yet from the input source.  Lex till EOL so we can report whole line.
     * (If we're at EOF, it's okay to call yylex() an extra time.)
     */
    if (!last_was_newline)
    {
        while (yylex(&lval, yyscanner))
             /* skip */ ;
    }
 
    /* Extract the line, trimming trailing newline if any */
    full_line = expr_scanner_get_substring(state,
                                           expr_start_offset,
                                           true);
 
    syntax_error(expr_source, expr_lineno, full_line, expr_command,
                 message, more, error_detection_offset - expr_start_offset);
}

References expr_command, expr_lineno, expr_scanner_get_substring(), expr_source, expr_start_offset, last_was_newline, psql_scan_get_location(), syntax_error(), and yylex().

Referenced by expr_yyerror().

expr_yylex()

int expr_yylex	(	union YYSTYPE *	yylval_param,
		yyscan_t	yyscanner
	)

expr_yyparse()

int expr_yyparse	(	PgBenchExpr **	expr_parse_result_p,
		yyscan_t	yyscanner
	)

Referenced by process_backslash_command().

strtodouble()

bool strtodouble	(	const char *	str,
		bool	errorOK,
		double *	dv
	)

Definition at line 1085 of file pgbench.c.

{
    char       *end;
 
    errno = 0;
    *dv = strtod(str, &end);
 
    if (unlikely(errno != 0))
    {
        if (!errorOK)
            pg_log_error("value \"%s\" is out of range for type double", str);
        return false;
    }
 
    if (unlikely(end == str || *end != '\0'))
    {
        if (!errorOK)
            pg_log_error("invalid input syntax for type double: \"%s\"", str);
        return false;
    }
    return true;

References pg_log_error, str, and unlikely.

Referenced by makeVariableValue().

strtoint64()

bool strtoint64	(	const char *	str,
		bool	errorOK,
		int64 *	result
	)

Definition at line 1014 of file pgbench.c.

{
    const char *ptr = str;
    int64       tmp = 0;
    bool        neg = false;
 
    /*
     * Do our own scan, rather than relying on sscanf which might be broken
     * for long long.
     *
     * As INT64_MIN can't be stored as a positive 64 bit integer, accumulate
     * value as a negative number.
     */
 
    /* skip leading spaces */
    while (*ptr && isspace((unsigned char) *ptr))
        ptr++;
 
    /* handle sign */
    if (*ptr == '-')
    {
        ptr++;
        neg = true;
    }
    else if (*ptr == '+')
        ptr++;
 
    /* require at least one digit */
    if (unlikely(!isdigit((unsigned char) *ptr)))
        goto invalid_syntax;
 
    /* process digits */
    while (*ptr && isdigit((unsigned char) *ptr))
    {
        int8        digit = (*ptr++ - '0');
 
        if (unlikely(pg_mul_s64_overflow(tmp, 10, &tmp)) ||
            unlikely(pg_sub_s64_overflow(tmp, digit, &tmp)))
            goto out_of_range;
    }
 
    /* allow trailing whitespace, but not other trailing chars */
    while (*ptr != '\0' && isspace((unsigned char) *ptr))
        ptr++;
 
    if (unlikely(*ptr != '\0'))
        goto invalid_syntax;
 
    if (!neg)
    {
        if (unlikely(tmp == PG_INT64_MIN))
            goto out_of_range;
        tmp = -tmp;
    }
 
    *result = tmp;
    return true;
 
out_of_range:
    if (!errorOK)
        pg_log_error("value \"%s\" is out of range for type bigint", str);
    return false;
 
invalid_syntax:
    if (!errorOK)
        pg_log_error("invalid input syntax for type bigint: \"%s\"", str);
    return false;

References PG_INT64_MIN, pg_log_error, pg_mul_s64_overflow(), pg_sub_s64_overflow(), str, and unlikely.

Referenced by makeVariableValue().

syntax_error()

pg_noreturn void syntax_error	(	const char *	source,
		int	lineno,
		const char *	line,
		const char *	command,
		const char *	msg,
		const char *	more,
		int	column
	)

Definition at line 5517 of file pgbench.c.

{
    PQExpBufferData buf;
 
    initPQExpBuffer(&buf);
 
    printfPQExpBuffer(&buf, "%s:%d: %s", source, lineno, msg);
    if (more != NULL)
        appendPQExpBuffer(&buf, " (%s)", more);
    if (column >= 0 && line == NULL)
        appendPQExpBuffer(&buf, " at column %d", column + 1);
    if (command != NULL)
        appendPQExpBuffer(&buf, " in command \"%s\"", command);
 
    pg_log_error("%s", buf.data);
 
    termPQExpBuffer(&buf);
 
    if (line != NULL)
    {
        fprintf(stderr, "%s\n", line);
        if (column >= 0)
            fprintf(stderr, "%*c error found here\n", column + 1, '^');
    }
 
    exit(1);

References appendPQExpBuffer(), buf, fprintf, initPQExpBuffer(), pg_log_error, printfPQExpBuffer(), source, and termPQExpBuffer().

Referenced by expr_yyerror_more(), ParseScript(), process_backslash_command(), and string_to_uuid().