LCOV - code coverage report
Current view: top level - src/bin/pgbench - exprparse.y (source / functions) Hit Total Coverage
Test: PostgreSQL 16devel Lines: 144 145 99.3 %
Date: 2022-08-17 04:10:37 Functions: 12 12 100.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.14