Line data Source code
1 : %{
2 : /*-------------------------------------------------------------------------
3 : *
4 : * exprparse.y
5 : * bison grammar for a simple expression syntax
6 : *
7 : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
8 : * Portions Copyright (c) 1994, Regents of the University of California
9 : *
10 : * src/bin/pgbench/exprparse.y
11 : *
12 : *-------------------------------------------------------------------------
13 : */
14 :
15 : #include "postgres_fe.h"
16 :
17 : #include "pgbench.h"
18 :
19 : #define PGBENCH_NARGS_VARIABLE (-1)
20 : #define PGBENCH_NARGS_CASE (-2)
21 : #define PGBENCH_NARGS_HASH (-3)
22 : #define PGBENCH_NARGS_PERMUTE (-4)
23 :
24 : static PgBenchExprList *make_elist(PgBenchExpr *expr, PgBenchExprList *list);
25 : static PgBenchExpr *make_null_constant(void);
26 : static PgBenchExpr *make_boolean_constant(bool bval);
27 : static PgBenchExpr *make_integer_constant(int64 ival);
28 : static PgBenchExpr *make_double_constant(double dval);
29 : static PgBenchExpr *make_variable(char *varname);
30 : static PgBenchExpr *make_op(yyscan_t yyscanner, const char *operator,
31 : PgBenchExpr *lexpr, PgBenchExpr *rexpr);
32 : static PgBenchExpr *make_uop(yyscan_t yyscanner, const char *operator, PgBenchExpr *expr);
33 : static int find_func(yyscan_t yyscanner, const char *fname);
34 : static PgBenchExpr *make_func(yyscan_t yyscanner, int fnumber, PgBenchExprList *args);
35 : static PgBenchExpr *make_case(yyscan_t yyscanner, PgBenchExprList *when_then_list, PgBenchExpr *else_part);
36 :
37 : %}
38 :
39 : %pure-parser
40 : %expect 0
41 : %name-prefix="expr_yy"
42 :
43 : %parse-param {PgBenchExpr **expr_parse_result_p}
44 : %parse-param {yyscan_t yyscanner}
45 : %lex-param {yyscan_t yyscanner}
46 :
47 : %union
48 : {
49 : int64 ival;
50 : double dval;
51 : bool bval;
52 : char *str;
53 : PgBenchExpr *expr;
54 : PgBenchExprList *elist;
55 : }
56 :
57 : %type <elist> elist when_then_list
58 : %type <expr> expr case_control
59 : %type <ival> INTEGER_CONST function
60 : %type <dval> DOUBLE_CONST
61 : %type <bval> BOOLEAN_CONST
62 : %type <str> VARIABLE FUNCTION
63 :
64 : %token NULL_CONST INTEGER_CONST MAXINT_PLUS_ONE_CONST DOUBLE_CONST
65 : %token BOOLEAN_CONST VARIABLE FUNCTION
66 : %token AND_OP OR_OP NOT_OP NE_OP LE_OP GE_OP LS_OP RS_OP IS_OP
67 : %token CASE_KW WHEN_KW THEN_KW ELSE_KW END_KW
68 :
69 : /* Precedence: lowest to highest, taken from postgres SQL parser */
70 : %left OR_OP
71 : %left AND_OP
72 : %right NOT_OP
73 : %nonassoc IS_OP ISNULL_OP NOTNULL_OP
74 : %nonassoc '<' '>' '=' LE_OP GE_OP NE_OP
75 : %left '|' '#' '&' LS_OP RS_OP '~'
76 : %left '+' '-'
77 : %left '*' '/' '%'
78 : %right UNARY
79 :
80 : %%
81 :
82 : result: expr {
83 380 : *expr_parse_result_p = $1;
84 : (void) yynerrs; /* suppress compiler warning */
85 : }
86 :
87 5 : elist: { $$ = NULL; }
88 393 : | expr { $$ = make_elist($1, NULL); }
89 343 : | elist ',' expr { $$ = make_elist($3, $1); }
90 : ;
91 :
92 52 : expr: '(' expr ')' { $$ = $2; }
93 2 : | '+' expr %prec UNARY { $$ = $2; }
94 : /* unary minus "-x" implemented as "0 - x" */
95 46 : | '-' expr %prec UNARY { $$ = make_op(yyscanner, "-",
96 : make_integer_constant(0), $2); }
97 : /* special PG_INT64_MIN handling, only after a unary minus */
98 : | '-' MAXINT_PLUS_ONE_CONST %prec UNARY
99 1 : { $$ = make_integer_constant(PG_INT64_MIN); }
100 : /* binary ones complement "~x" implemented as 0xffff... xor x" */
101 2 : | '~' expr { $$ = make_op(yyscanner, "#",
102 : make_integer_constant(~INT64CONST(0)), $2); }
103 12 : | NOT_OP expr { $$ = make_uop(yyscanner, "!not", $2); }
104 48 : | expr '+' expr { $$ = make_op(yyscanner, "+", $1, $3); }
105 18 : | expr '-' expr { $$ = make_op(yyscanner, "-", $1, $3); }
106 204 : | expr '*' expr { $$ = make_op(yyscanner, "*", $1, $3); }
107 13 : | expr '/' expr { $$ = make_op(yyscanner, "/", $1, $3); }
108 2 : | expr '%' expr { $$ = make_op(yyscanner, "mod", $1, $3); }
109 10 : | expr '<' expr { $$ = make_op(yyscanner, "<", $1, $3); }
110 4 : | expr LE_OP expr { $$ = make_op(yyscanner, "<=", $1, $3); }
111 6 : | expr '>' expr { $$ = make_op(yyscanner, "<", $3, $1); }
112 3 : | expr GE_OP expr { $$ = make_op(yyscanner, "<=", $3, $1); }
113 32 : | expr '=' expr { $$ = make_op(yyscanner, "=", $1, $3); }
114 8 : | expr NE_OP expr { $$ = make_op(yyscanner, "<>", $1, $3); }
115 1 : | expr '&' expr { $$ = make_op(yyscanner, "&", $1, $3); }
116 2 : | expr '|' expr { $$ = make_op(yyscanner, "|", $1, $3); }
117 1 : | expr '#' expr { $$ = make_op(yyscanner, "#", $1, $3); }
118 7 : | expr LS_OP expr { $$ = make_op(yyscanner, "<<", $1, $3); }
119 1 : | expr RS_OP expr { $$ = make_op(yyscanner, ">>", $1, $3); }
120 44 : | expr AND_OP expr { $$ = make_op(yyscanner, "!and", $1, $3); }
121 5 : | expr OR_OP expr { $$ = make_op(yyscanner, "!or", $1, $3); }
122 : /* IS variants */
123 1 : | expr ISNULL_OP { $$ = make_op(yyscanner, "!is", $1, make_null_constant()); }
124 : | expr NOTNULL_OP {
125 2 : $$ = make_uop(yyscanner, "!not",
126 1 : make_op(yyscanner, "!is", $1, make_null_constant()));
127 : }
128 4 : | expr IS_OP NULL_CONST { $$ = make_op(yyscanner, "!is", $1, make_null_constant()); }
129 : | expr IS_OP NOT_OP NULL_CONST
130 : {
131 4 : $$ = make_uop(yyscanner, "!not",
132 2 : make_op(yyscanner, "!is", $1, make_null_constant()));
133 : }
134 : | expr IS_OP BOOLEAN_CONST
135 : {
136 1 : $$ = make_op(yyscanner, "!is", $1, make_boolean_constant($3));
137 : }
138 : | expr IS_OP NOT_OP BOOLEAN_CONST
139 : {
140 1 : $$ = make_uop(yyscanner, "!not",
141 1 : make_op(yyscanner, "!is", $1, make_boolean_constant($4)));
142 : }
143 : /* constants */
144 6 : | NULL_CONST { $$ = make_null_constant(); }
145 31 : | BOOLEAN_CONST { $$ = make_boolean_constant($1); }
146 794 : | INTEGER_CONST { $$ = make_integer_constant($1); }
147 61 : | DOUBLE_CONST { $$ = make_double_constant($1); }
148 : /* misc */
149 272 : | VARIABLE { $$ = make_variable($1); }
150 398 : | function '(' elist ')' { $$ = make_func(yyscanner, $1, $3); }
151 14 : | case_control { $$ = $1; }
152 : ;
153 :
154 : when_then_list:
155 2 : when_then_list WHEN_KW expr THEN_KW expr { $$ = make_elist($5, make_elist($3, $1)); }
156 14 : | WHEN_KW expr THEN_KW expr { $$ = make_elist($4, make_elist($2, NULL)); }
157 :
158 : case_control:
159 4 : CASE_KW when_then_list END_KW { $$ = make_case(yyscanner, $2, make_null_constant()); }
160 10 : | CASE_KW when_then_list ELSE_KW expr END_KW { $$ = make_case(yyscanner, $2, $4); }
161 :
162 399 : function: FUNCTION { $$ = find_func(yyscanner, $1); pg_free($1); }
163 : ;
164 :
165 : %%
166 :
167 : static PgBenchExpr *
168 18 : make_null_constant(void)
169 : {
170 18 : PgBenchExpr *expr = pg_malloc_object(PgBenchExpr);
171 :
172 18 : expr->etype = ENODE_CONSTANT;
173 18 : expr->u.constant.type = PGBT_NULL;
174 18 : expr->u.constant.u.ival = 0;
175 18 : return expr;
176 : }
177 :
178 : static PgBenchExpr *
179 843 : make_integer_constant(int64 ival)
180 : {
181 843 : PgBenchExpr *expr = pg_malloc_object(PgBenchExpr);
182 :
183 843 : expr->etype = ENODE_CONSTANT;
184 843 : expr->u.constant.type = PGBT_INT;
185 843 : expr->u.constant.u.ival = ival;
186 843 : return expr;
187 : }
188 :
189 : static PgBenchExpr *
190 61 : make_double_constant(double dval)
191 : {
192 61 : PgBenchExpr *expr = pg_malloc_object(PgBenchExpr);
193 :
194 61 : expr->etype = ENODE_CONSTANT;
195 61 : expr->u.constant.type = PGBT_DOUBLE;
196 61 : expr->u.constant.u.dval = dval;
197 61 : return expr;
198 : }
199 :
200 : static PgBenchExpr *
201 33 : make_boolean_constant(bool bval)
202 : {
203 33 : PgBenchExpr *expr = pg_malloc_object(PgBenchExpr);
204 :
205 33 : expr->etype = ENODE_CONSTANT;
206 33 : expr->u.constant.type = PGBT_BOOLEAN;
207 33 : expr->u.constant.u.bval = bval;
208 33 : return expr;
209 : }
210 :
211 : static PgBenchExpr *
212 309 : make_variable(char *varname)
213 : {
214 309 : PgBenchExpr *expr = pg_malloc_object(PgBenchExpr);
215 :
216 309 : expr->etype = ENODE_VARIABLE;
217 309 : expr->u.variable.varname = varname;
218 309 : return expr;
219 : }
220 :
221 : /* binary operators */
222 : static PgBenchExpr *
223 467 : make_op(yyscan_t yyscanner, const char *operator,
224 : PgBenchExpr *lexpr, PgBenchExpr *rexpr)
225 : {
226 467 : return make_func(yyscanner, find_func(yyscanner, operator),
227 : make_elist(rexpr, make_elist(lexpr, NULL)));
228 : }
229 :
230 : /* unary operator */
231 : static PgBenchExpr *
232 16 : make_uop(yyscan_t yyscanner, const char *operator, PgBenchExpr *expr)
233 : {
234 16 : return make_func(yyscanner, find_func(yyscanner, operator), make_elist(expr, NULL));
235 : }
236 :
237 : /*
238 : * List of available functions:
239 : * - fname: function name, "!..." for special internal functions
240 : * - nargs: number of arguments. Special cases:
241 : * - PGBENCH_NARGS_VARIABLE is a special value for least & greatest
242 : * meaning #args >= 1;
243 : * - PGBENCH_NARGS_CASE is for the "CASE WHEN ..." function, which
244 : * has #args >= 3 and odd;
245 : * - PGBENCH_NARGS_HASH is for hash functions, which have one required
246 : * and one optional argument;
247 : * - tag: function identifier from PgBenchFunction enum
248 : */
249 : static const struct
250 : {
251 : const char *fname;
252 : int nargs;
253 : PgBenchFunction tag;
254 : } PGBENCH_FUNCTIONS[] =
255 :
256 : {
257 : /* parsed as operators, executed as functions */
258 : {
259 : "+", 2, PGBENCH_ADD
260 : },
261 : {
262 : "-", 2, PGBENCH_SUB
263 : },
264 : {
265 : "*", 2, PGBENCH_MUL
266 : },
267 : {
268 : "/", 2, PGBENCH_DIV
269 : },
270 : {
271 : "mod", 2, PGBENCH_MOD
272 : },
273 : /* actual functions */
274 : {
275 : "abs", 1, PGBENCH_ABS
276 : },
277 : {
278 : "least", PGBENCH_NARGS_VARIABLE, PGBENCH_LEAST
279 : },
280 : {
281 : "greatest", PGBENCH_NARGS_VARIABLE, PGBENCH_GREATEST
282 : },
283 : {
284 : "debug", 1, PGBENCH_DEBUG
285 : },
286 : {
287 : "pi", 0, PGBENCH_PI
288 : },
289 : {
290 : "sqrt", 1, PGBENCH_SQRT
291 : },
292 : {
293 : "ln", 1, PGBENCH_LN
294 : },
295 : {
296 : "exp", 1, PGBENCH_EXP
297 : },
298 : {
299 : "int", 1, PGBENCH_INT
300 : },
301 : {
302 : "double", 1, PGBENCH_DOUBLE
303 : },
304 : {
305 : "random", 2, PGBENCH_RANDOM
306 : },
307 : {
308 : "random_gaussian", 3, PGBENCH_RANDOM_GAUSSIAN
309 : },
310 : {
311 : "random_exponential", 3, PGBENCH_RANDOM_EXPONENTIAL
312 : },
313 : {
314 : "random_zipfian", 3, PGBENCH_RANDOM_ZIPFIAN
315 : },
316 : {
317 : "pow", 2, PGBENCH_POW
318 : },
319 : {
320 : "power", 2, PGBENCH_POW
321 : },
322 : /* logical operators */
323 : {
324 : "!and", 2, PGBENCH_AND
325 : },
326 : {
327 : "!or", 2, PGBENCH_OR
328 : },
329 : {
330 : "!not", 1, PGBENCH_NOT
331 : },
332 : /* bitwise integer operators */
333 : {
334 : "&", 2, PGBENCH_BITAND
335 : },
336 : {
337 : "|", 2, PGBENCH_BITOR
338 : },
339 : {
340 : "#", 2, PGBENCH_BITXOR
341 : },
342 : {
343 : "<<", 2, PGBENCH_LSHIFT
344 : },
345 : {
346 : ">>", 2, PGBENCH_RSHIFT
347 : },
348 : /* comparison operators */
349 : {
350 : "=", 2, PGBENCH_EQ
351 : },
352 : {
353 : "<>", 2, PGBENCH_NE
354 : },
355 : {
356 : "<=", 2, PGBENCH_LE
357 : },
358 : {
359 : "<", 2, PGBENCH_LT
360 : },
361 : {
362 : "!is", 2, PGBENCH_IS
363 : },
364 : /* "case when ... then ... else ... end" construction */
365 : {
366 : "!case_end", PGBENCH_NARGS_CASE, PGBENCH_CASE
367 : },
368 : {
369 : "hash", PGBENCH_NARGS_HASH, PGBENCH_HASH_MURMUR2
370 : },
371 : {
372 : "hash_murmur2", PGBENCH_NARGS_HASH, PGBENCH_HASH_MURMUR2
373 : },
374 : {
375 : "hash_fnv1a", PGBENCH_NARGS_HASH, PGBENCH_HASH_FNV1A
376 : },
377 : {
378 : "permute", PGBENCH_NARGS_PERMUTE, PGBENCH_PERMUTE
379 : },
380 : /* keep as last array element */
381 : {
382 : NULL, 0, 0
383 : }
384 : };
385 :
386 : /*
387 : * Find a function from its name
388 : *
389 : * return the index of the function from the PGBENCH_FUNCTIONS array
390 : * or fail if the function is unknown.
391 : */
392 : static int
393 896 : find_func(yyscan_t yyscanner, const char *fname)
394 : {
395 896 : int i = 0;
396 :
397 12490 : while (PGBENCH_FUNCTIONS[i].fname)
398 : {
399 12489 : if (pg_strcasecmp(fname, PGBENCH_FUNCTIONS[i].fname) == 0)
400 895 : return i;
401 11594 : i++;
402 : }
403 :
404 1 : expr_yyerror_more(yyscanner, "unexpected function name", fname);
405 :
406 : /* not reached */
407 : return -1;
408 : }
409 :
410 : /* Expression linked list builder */
411 : static PgBenchExprList *
412 1769 : make_elist(PgBenchExpr *expr, PgBenchExprList *list)
413 : {
414 : PgBenchExprLink *cons;
415 :
416 1769 : if (list == NULL)
417 : {
418 890 : list = pg_malloc_object(PgBenchExprList);
419 890 : list->head = NULL;
420 890 : list->tail = NULL;
421 : }
422 :
423 1769 : cons = pg_malloc_object(PgBenchExprLink);
424 1769 : cons->expr = expr;
425 1769 : cons->next = NULL;
426 :
427 1769 : if (list->head == NULL)
428 890 : list->head = cons;
429 : else
430 879 : list->tail->next = cons;
431 :
432 1769 : list->tail = cons;
433 :
434 1769 : return list;
435 : }
436 :
437 : /* Return the length of an expression list */
438 : static int
439 895 : elist_length(PgBenchExprList *list)
440 : {
441 895 : PgBenchExprLink *link = list != NULL ? list->head : NULL;
442 895 : int len = 0;
443 :
444 2627 : for (; link != NULL; link = link->next)
445 1732 : len++;
446 :
447 895 : return len;
448 : }
449 :
450 : /* Build function call expression */
451 : static PgBenchExpr *
452 895 : make_func(yyscan_t yyscanner, int fnumber, PgBenchExprList *args)
453 : {
454 895 : int len = elist_length(args);
455 :
456 895 : PgBenchExpr *expr = pg_malloc_object(PgBenchExpr);
457 :
458 : Assert(fnumber >= 0);
459 :
460 : /* validate arguments number including few special cases */
461 895 : switch (PGBENCH_FUNCTIONS[fnumber].nargs)
462 : {
463 : /* check at least one arg for least & greatest */
464 8 : case PGBENCH_NARGS_VARIABLE:
465 8 : if (len == 0)
466 3 : expr_yyerror_more(yyscanner, "at least one argument expected",
467 3 : PGBENCH_FUNCTIONS[fnumber].fname);
468 5 : break;
469 :
470 : /* case (when ... then ...)+ (else ...)? end */
471 14 : case PGBENCH_NARGS_CASE:
472 : /* 'else' branch is always present, but could be a NULL-constant */
473 14 : if (len < 3 || len % 2 != 1)
474 0 : expr_yyerror_more(yyscanner,
475 : "odd and >= 3 number of arguments expected",
476 : "case control structure");
477 14 : break;
478 :
479 : /* hash functions with optional seed argument */
480 8 : case PGBENCH_NARGS_HASH:
481 8 : if (len < 1 || len > 2)
482 2 : expr_yyerror_more(yyscanner, "unexpected number of arguments",
483 2 : PGBENCH_FUNCTIONS[fnumber].fname);
484 :
485 6 : if (len == 1)
486 : {
487 2 : PgBenchExpr *var = make_variable("default_seed");
488 :
489 2 : args = make_elist(var, args);
490 : }
491 6 : break;
492 :
493 : /* pseudorandom permutation function with optional seed argument */
494 48 : case PGBENCH_NARGS_PERMUTE:
495 48 : if (len < 2 || len > 3)
496 2 : expr_yyerror_more(yyscanner, "unexpected number of arguments",
497 2 : PGBENCH_FUNCTIONS[fnumber].fname);
498 :
499 46 : if (len == 2)
500 : {
501 35 : PgBenchExpr *var = make_variable("default_seed");
502 :
503 35 : args = make_elist(var, args);
504 : }
505 46 : break;
506 :
507 : /* common case: positive arguments number */
508 817 : default:
509 : Assert(PGBENCH_FUNCTIONS[fnumber].nargs >= 0);
510 :
511 817 : if (PGBENCH_FUNCTIONS[fnumber].nargs != len)
512 1 : expr_yyerror_more(yyscanner, "unexpected number of arguments",
513 1 : PGBENCH_FUNCTIONS[fnumber].fname);
514 : }
515 :
516 887 : expr->etype = ENODE_FUNCTION;
517 887 : expr->u.function.function = PGBENCH_FUNCTIONS[fnumber].tag;
518 :
519 : /* only the link is used, the head/tail is not useful anymore */
520 887 : expr->u.function.args = args != NULL ? args->head : NULL;
521 887 : if (args)
522 886 : pg_free(args);
523 :
524 887 : return expr;
525 : }
526 :
527 : static PgBenchExpr *
528 14 : make_case(yyscan_t yyscanner, PgBenchExprList *when_then_list, PgBenchExpr *else_part)
529 : {
530 14 : return make_func(yyscanner,
531 : find_func(yyscanner, "!case_end"),
532 : make_elist(else_part, when_then_list));
533 : }
|
