Mirrors
/
mariadb
mirror of https://github.com/MariaDB/server
3
0
Fork 0
Code Releases Activity
Browse Source

MDEV-18796 Synchronize PS grammar between sql_yacc.yy and sql_yacc_ora.yy

pull/1217/head
Alexander Barkov 7 years ago
parent
3b47587f41
commit
47b7ca629f
10 changed files with 193 additions and 129 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      mysql-test/main/ps.result
  2. 2
      mysql-test/suite/compat/oracle/r/ps.result
  3. 5
      sql/protocol.cc
  4. 2
      sql/sql_class.h
  5. 49
      sql/sql_lex.cc
  6. 84
      sql/sql_lex.h
  7. 6
      sql/sql_list.h
  8. 36
      sql/sql_prepare.cc
  9. 69
      sql/sql_yacc.yy
  10. 67
      sql/sql_yacc_ora.yy

2
mysql-test/main/ps.result
View File

@ -4663,7 +4663,7 @@ EXECUTE IMMEDIATE 'SELECT ? FROM DUAL' USING (SELECT 1);
ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MariaDB server version for the right syntax to use near 'SELECT 1)' at line 1
CREATE FUNCTION f1() RETURNS VARCHAR(10) RETURN 'test';
EXECUTE IMMEDIATE 'SELECT ? FROM DUAL' USING f1();
ERROR 42000: EXECUTE..USING does not support subqueries or stored functions
ERROR 42000: EXECUTE IMMEDIATE does not support subqueries or stored functions
DROP FUNCTION f1;
#
# DDL

2
mysql-test/suite/compat/oracle/r/ps.result
View File

@ -163,7 +163,7 @@ RETURN 'test';
END;
$$
EXECUTE IMMEDIATE 'SELECT ? FROM DUAL' USING f1();
ERROR 42000: EXECUTE..USING does not support subqueries or stored functions
ERROR 42000: EXECUTE IMMEDIATE does not support subqueries or stored functions
DROP FUNCTION f1;
#
# Testing simple expressions

5
sql/protocol.cc
View File

@ -1338,11 +1338,10 @@ bool Protocol_text::store_time(MYSQL_TIME *tm, int decimals)
bool Protocol_text::send_out_parameters(List<Item_param> *sp_params)
{
DBUG_ASSERT(sp_params->elements ==
thd->lex->prepared_stmt_params.elements);
DBUG_ASSERT(sp_params->elements == thd->lex->prepared_stmt.param_count());
List_iterator_fast<Item_param> item_param_it(*sp_params);
List_iterator_fast<Item> param_it(thd->lex->prepared_stmt_params);
List_iterator_fast<Item> param_it(thd->lex->prepared_stmt.params());
while (true)
{

2
sql/sql_class.h
View File

@ -1214,7 +1214,7 @@ public:
int insert(THD *thd, Statement *statement);
Statement *find_by_name(LEX_CSTRING *name)
Statement *find_by_name(const LEX_CSTRING *name)
{
Statement *stmt;
stmt= (Statement*)my_hash_search(&names_hash, (uchar*)name->str,

49
sql/sql_lex.cc
View File

@ -705,7 +705,7 @@ void LEX::start(THD *thd_arg)
with_persistent_for_clause= FALSE;
column_list= NULL;
index_list= NULL;
prepared_stmt_params.empty();
prepared_stmt.lex_start();
auxiliary_table_list.empty();
unit.next= unit.master= unit.link_next= unit.return_to= 0;
unit.prev= unit.link_prev= 0;
@ -10216,3 +10216,50 @@ bool LEX::stmt_uninstall_plugin_by_soname(const DDL_options_st &opt,
ident= soname;
return false;
}
bool LEX::stmt_prepare_validate(const char *stmt_type)
{
if (unlikely(table_or_sp_used()))
{
my_error(ER_SUBQUERIES_NOT_SUPPORTED, MYF(0), stmt_type);
return true;
}
return check_main_unit_semantics();
}
bool LEX::stmt_prepare(const Lex_ident_sys_st &ident, Item *code)
{
sql_command= SQLCOM_PREPARE;
if (stmt_prepare_validate("PREPARE..FROM"))
return true;
prepared_stmt.set(ident, code, NULL);
return false;
}
bool LEX::stmt_execute_immediate(Item *code, List<Item> *params)
{
sql_command= SQLCOM_EXECUTE_IMMEDIATE;
if (stmt_prepare_validate("EXECUTE IMMEDIATE"))
return true;
static const Lex_ident_sys immediate(STRING_WITH_LEN("IMMEDIATE"));
prepared_stmt.set(immediate, code, params);
return false;
}
bool LEX::stmt_execute(const Lex_ident_sys_st &ident, List<Item> *params)
{
sql_command= SQLCOM_EXECUTE;
prepared_stmt.set(ident, NULL, params);
return stmt_prepare_validate("EXECUTE..USING");
}
void LEX::stmt_deallocate_prepare(const Lex_ident_sys_st &ident)
{
sql_command= SQLCOM_DEALLOCATE_PREPARE;
prepared_stmt.set(ident, NULL, NULL);
}

84
sql/sql_lex.h
View File

@ -169,6 +169,16 @@ public:
{
((LEX_CSTRING &) *this)= null_clex_str;
}
Lex_ident_sys(const char *name, size_t length)
{
LEX_CSTRING tmp= {name, length};
set_valid_utf8(&tmp);
}
Lex_ident_sys & operator=(const Lex_ident_sys_st &name)
{
Lex_ident_sys_st::operator=(name);
return *this;
}
};
@ -2990,6 +3000,56 @@ struct Account_options: public USER_RESOURCES
class Query_arena_memroot;
/* The state of the lex parsing. This is saved in the THD struct */
class Lex_prepared_stmt
{
Lex_ident_sys m_name; // Statement name (in all queries)
Item *m_code; // PREPARE or EXECUTE IMMEDIATE source expression
List<Item> m_params; // List of parameters for EXECUTE [IMMEDIATE]
public:
Lex_prepared_stmt()
:m_code(NULL)
{ }
const Lex_ident_sys &name() const
{
return m_name;
}
uint param_count() const
{
return m_params.elements;
}
List<Item> &params()
{
return m_params;
}
void set(const Lex_ident_sys_st &ident, Item *code, List<Item> *params)
{
DBUG_ASSERT(m_params.elements == 0);
m_name= ident;
m_code= code;
if (params)
m_params= *params;
}
bool params_fix_fields(THD *thd)
{
// Fix Items in the EXECUTE..USING list
List_iterator_fast<Item> param_it(m_params);
while (Item *param= param_it++)
{
if (param->fix_fields_if_needed_for_scalar(thd, 0))
return true;
}
return false;
}
bool get_dynamic_sql_string(THD *thd, LEX_CSTRING *dst, String *buffer);
void lex_start()
{
m_params.empty();
}
};
struct LEX: public Query_tables_list
{
SELECT_LEX_UNIT unit; /* most upper unit */
@ -3254,12 +3314,7 @@ public:
creating or last of tables referenced by foreign keys).
*/
TABLE_LIST *create_last_non_select_table;
/* Prepared statements SQL syntax:*/
LEX_CSTRING prepared_stmt_name; /* Statement name (in all queries) */
/* PREPARE or EXECUTE IMMEDIATE source expression */
Item *prepared_stmt_code;
/* Names of user variables holding parameters (in EXECUTE) */
List<Item> prepared_stmt_params;
Lex_prepared_stmt prepared_stmt;
sp_head *sphead;
sp_name *spname;
bool sp_lex_in_use; // Keep track on lex usage in SPs for error handling
@ -3647,18 +3702,6 @@ public:
bool sp_proc_stmt_statement_finalize_buf(THD *, const LEX_CSTRING &qbuf);
bool sp_proc_stmt_statement_finalize(THD *, bool no_lookahead);
bool get_dynamic_sql_string(LEX_CSTRING *dst, String *buffer);
bool prepared_stmt_params_fix_fields(THD *thd)
{
// Fix Items in the EXECUTE..USING list
List_iterator_fast<Item> param_it(prepared_stmt_params);
while (Item *param= param_it++)
{
if (param->fix_fields_if_needed_for_scalar(thd, 0))
return true;
}
return false;
}
sp_variable *sp_param_init(LEX_CSTRING *name);
bool sp_param_fill_definition(sp_variable *spvar);
@ -4403,6 +4446,11 @@ public:
const Lex_ident_sys_st &name);
bool stmt_uninstall_plugin_by_soname(const DDL_options_st &opt,
const LEX_CSTRING &soname);
bool stmt_prepare_validate(const char *stmt_type);
bool stmt_prepare(const Lex_ident_sys_st &ident, Item *code);
bool stmt_execute(const Lex_ident_sys_st &ident, List<Item> *params);
bool stmt_execute_immediate(Item *code, List<Item> *params);
void stmt_deallocate_prepare(const Lex_ident_sys_st &ident);
};

6
sql/sql_list.h
View File

@ -518,6 +518,12 @@ public:
empty();
}
T *elem(uint n) { return (T*) base_list::elem(n); }
// Create a new list with one element
static List<T> *make(MEM_ROOT *mem_root, T *first)
{
List<T> *res= new (mem_root) List<T>;
return res == NULL || res->push_back(first, mem_root) ? NULL : res;
}
};

36
sql/sql_prepare.cc
View File

@ -190,7 +190,7 @@ public:
void setup_set_params();
virtual Query_arena::Type type() const;
virtual void cleanup_stmt();
bool set_name(LEX_CSTRING *name);
bool set_name(const LEX_CSTRING *name);
inline void close_cursor() { delete cursor; cursor= 0; }
inline bool is_in_use() { return flags & (uint) IS_IN_USE; }
inline bool is_sql_prepare() const { return flags & (uint) IS_SQL_PREPARE; }
@ -2664,7 +2664,7 @@ end:
}
/**
Get an SQL statement from an item in lex->prepared_stmt_code.
Get an SQL statement from an item in m_code.
This function can return pointers to very different memory classes:
- a static string "NULL", if the item returned NULL
@ -2689,13 +2689,15 @@ end:
@retval true on error (out of memory)
*/
bool LEX::get_dynamic_sql_string(LEX_CSTRING *dst, String *buffer)
bool Lex_prepared_stmt::get_dynamic_sql_string(THD *thd,
LEX_CSTRING *dst,
String *buffer)
{
if (prepared_stmt_code->fix_fields_if_needed_for_scalar(thd, NULL))
if (m_code->fix_fields_if_needed_for_scalar(thd, NULL))
return true;
const String *str= prepared_stmt_code->val_str(buffer);
if (prepared_stmt_code->null_value)
const String *str= m_code->val_str(buffer);
if (m_code->null_value)
{
/*
Prepare source was NULL, so we need to set "str" to
@ -2776,7 +2778,7 @@ bool LEX::get_dynamic_sql_string(LEX_CSTRING *dst, String *buffer)
void mysql_sql_stmt_prepare(THD *thd)
{
LEX *lex= thd->lex;
LEX_CSTRING *name= &lex->prepared_stmt_name;
const LEX_CSTRING *name= &lex->prepared_stmt.name();
Prepared_statement *stmt;
LEX_CSTRING query;
DBUG_ENTER("mysql_sql_stmt_prepare");
@ -2801,7 +2803,7 @@ void mysql_sql_stmt_prepare(THD *thd)
See comments in get_dynamic_sql_string().
*/
StringBuffer<256> buffer;
if (lex->get_dynamic_sql_string(&query, &buffer) ||
if (lex->prepared_stmt.get_dynamic_sql_string(thd, &query, &buffer) ||
! (stmt= new Prepared_statement(thd)))
{
DBUG_VOID_RETURN; /* out of memory */
@ -2864,7 +2866,7 @@ void mysql_sql_stmt_execute_immediate(THD *thd)
LEX_CSTRING query;
DBUG_ENTER("mysql_sql_stmt_execute_immediate");
if (lex->prepared_stmt_params_fix_fields(thd))
if (lex->prepared_stmt.params_fix_fields(thd))
DBUG_VOID_RETURN;
/*
@ -2876,7 +2878,7 @@ void mysql_sql_stmt_execute_immediate(THD *thd)
See comments in get_dynamic_sql_string().
*/
StringBuffer<256> buffer;
if (lex->get_dynamic_sql_string(&query, &buffer) ||
if (lex->prepared_stmt.get_dynamic_sql_string(thd, &query, &buffer) ||
!(stmt= new Prepared_statement(thd)))
DBUG_VOID_RETURN; // out of memory
@ -3265,7 +3267,7 @@ void mysql_sql_stmt_execute(THD *thd)
{
LEX *lex= thd->lex;
Prepared_statement *stmt;
LEX_CSTRING *name= &lex->prepared_stmt_name;
const LEX_CSTRING *name= &lex->prepared_stmt.name();
/* Query text for binary, general or slow log, if any of them is open */
String expanded_query;
DBUG_ENTER("mysql_sql_stmt_execute");
@ -3278,7 +3280,7 @@ void mysql_sql_stmt_execute(THD *thd)
DBUG_VOID_RETURN;
}
if (stmt->param_count != lex->prepared_stmt_params.elements)
if (stmt->param_count != lex->prepared_stmt.param_count())
{
my_error(ER_WRONG_ARGUMENTS, MYF(0), "EXECUTE");
DBUG_VOID_RETURN;
@ -3286,7 +3288,7 @@ void mysql_sql_stmt_execute(THD *thd)
DBUG_PRINT("info",("stmt: %p", stmt));
if (lex->prepared_stmt_params_fix_fields(thd))
if (lex->prepared_stmt.params_fix_fields(thd))
DBUG_VOID_RETURN;
/*
@ -3506,7 +3508,7 @@ void mysqld_stmt_close(THD *thd, char *packet)
void mysql_sql_stmt_close(THD *thd)
{
Prepared_statement* stmt;
LEX_CSTRING *name= &thd->lex->prepared_stmt_name;
const LEX_CSTRING *name= &thd->lex->prepared_stmt.name();
DBUG_PRINT("info", ("DEALLOCATE PREPARE: %.*s\n", (int) name->length,
name->str));
@ -3871,7 +3873,7 @@ void Prepared_statement::cleanup_stmt()
}
bool Prepared_statement::set_name(LEX_CSTRING *name_arg)
bool Prepared_statement::set_name(const LEX_CSTRING *name_arg)
{
name.length= name_arg->length;
name.str= (char*) memdup_root(mem_root, name_arg->str, name_arg->length);
@ -4120,7 +4122,7 @@ Prepared_statement::set_parameters(String *expanded_query,
if (is_sql_ps)
{
/* SQL prepared statement */
res= set_params_from_actual_params(this, thd->lex->prepared_stmt_params,
res= set_params_from_actual_params(this, thd->lex->prepared_stmt.params(),
expanded_query);
}
else if (param_count)
@ -4849,7 +4851,7 @@ bool Prepared_statement::execute_immediate(const char *query, uint query_len)
if (unlikely(prepare(query, query_len)))
DBUG_RETURN(true);
if (param_count != thd->lex->prepared_stmt_params.elements)
if (param_count != thd->lex->prepared_stmt.param_count())
{
my_error(ER_WRONG_ARGUMENTS, MYF(0), "EXECUTE");
deallocate_immediate();

69
sql/sql_yacc.yy
View File

@ -1856,7 +1856,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, size_t *yystacksize);
%type <item>
literal insert_ident order_ident temporal_literal
simple_ident expr sum_expr in_sum_expr
simple_ident expr prepare_src sum_expr in_sum_expr
variable variable_aux bool_pri
predicate bit_expr parenthesized_expr
table_wild simple_expr column_default_non_parenthesized_expr udf_expr
@ -1897,6 +1897,8 @@ bool my_yyoverflow(short **a, YYSTYPE **b, size_t *yystacksize);
expr_list opt_udf_expr_list udf_expr_list when_list when_list_opt_else
ident_list ident_list_arg opt_expr_list
decode_when_list_oracle
execute_using
execute_params
%type <sp_cursor_stmt>
sp_cursor_stmt_lex
@ -2054,7 +2056,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, size_t *yystacksize);
select_var_list select_var_list_init help
opt_extended_describe shutdown
opt_format_json
prepare prepare_src execute deallocate
prepare execute deallocate
statement
sp_c_chistics sp_a_chistics sp_chistic sp_c_chistic xa
opt_field_or_var_spec fields_or_vars opt_load_data_set_spec
@ -2306,9 +2308,7 @@ statement:
deallocate:
deallocate_or_drop PREPARE_SYM ident
{
LEX *lex= thd->lex;
lex->sql_command= SQLCOM_DEALLOCATE_PREPARE;
lex->prepared_stmt_name= $3;
Lex->stmt_deallocate_prepare($3);
}
;
@ -2320,14 +2320,8 @@ deallocate_or_drop:
prepare:
PREPARE_SYM ident FROM prepare_src
{
LEX *lex= thd->lex;
if (unlikely(lex->table_or_sp_used()))
my_yyabort_error((ER_SUBQUERIES_NOT_SUPPORTED, MYF(0),
"PREPARE..FROM"));
if (Lex->check_main_unit_semantics())
if (Lex->stmt_prepare($2, $4))
MYSQL_YYABORT;
lex->sql_command= SQLCOM_PREPARE;
lex->prepared_stmt_name= $2;
}
;
@ -2335,63 +2329,48 @@ prepare_src:
{ Lex->expr_allows_subselect= false; }
expr
{
Lex->prepared_stmt_code= $2;
Lex->expr_allows_subselect= true;
$$= $2;
}
;
execute:
EXECUTE_SYM ident
{
LEX *lex= thd->lex;
lex->sql_command= SQLCOM_EXECUTE;
lex->prepared_stmt_name= $2;
}
execute_using
EXECUTE_SYM ident execute_using
{
if (Lex->check_main_unit_semantics())
if (Lex->stmt_execute($2, $3))
MYSQL_YYABORT;
}
| EXECUTE_SYM IMMEDIATE_SYM prepare_src
| EXECUTE_SYM IMMEDIATE_SYM prepare_src execute_using
{
if (unlikely(Lex->table_or_sp_used()))
my_yyabort_error((ER_SUBQUERIES_NOT_SUPPORTED, MYF(0),
"EXECUTE IMMEDIATE"));
Lex->sql_command= SQLCOM_EXECUTE_IMMEDIATE;
}
execute_using
{
if (Lex->check_main_unit_semantics())
if (Lex->stmt_execute_immediate($3, $4))
MYSQL_YYABORT;
}
;
execute_using:
/* nothing */
/* nothing */ { $$= NULL; }
| USING { Lex->expr_allows_subselect= false; }
execute_var_list
execute_params
{
if (unlikely(Lex->table_or_sp_used()))
my_yyabort_error((ER_SUBQUERIES_NOT_SUPPORTED, MYF(0),
"EXECUTE..USING"));
$$= $3;
Lex->expr_allows_subselect= true;
}
;
execute_var_list:
execute_var_list ',' execute_var_ident
| execute_var_ident
;
execute_var_ident:
execute_params:
expr_or_default
{
if (unlikely(Lex->prepared_stmt_params.push_back($1,
thd->mem_root)))
if (unlikely(!($$= List<Item>::make(thd->mem_root, $1))))
MYSQL_YYABORT;
}
| execute_params ',' expr_or_default
{
if (($$= $1)->push_back($3, thd->mem_root))
MYSQL_YYABORT;
}
;
/* help */
help:
@ -11833,9 +11812,7 @@ opt_expr_list:
expr_list:
expr
{
$$= new (thd->mem_root) List<Item>;
if (unlikely($$ == NULL) ||
unlikely($$->push_back($1, thd->mem_root)))
if (unlikely(!($$= List<Item>::make(thd->mem_root, $1))))
MYSQL_YYABORT;
}
| expr_list ',' expr

67
sql/sql_yacc_ora.yy
View File

@ -1357,7 +1357,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, size_t *yystacksize);
%type <item>
literal insert_ident order_ident temporal_literal
simple_ident expr sum_expr in_sum_expr
simple_ident expr prepare_src sum_expr in_sum_expr
variable variable_aux bool_pri
predicate bit_expr parenthesized_expr
table_wild simple_expr column_default_non_parenthesized_expr udf_expr
@ -1398,6 +1398,8 @@ bool my_yyoverflow(short **a, YYSTYPE **b, size_t *yystacksize);
expr_list opt_udf_expr_list udf_expr_list when_list when_list_opt_else
ident_list ident_list_arg opt_expr_list
decode_when_list_oracle
execute_using
execute_params
%type <sp_cursor_stmt>
sp_cursor_stmt_lex
@ -1557,7 +1559,7 @@ bool my_yyoverflow(short **a, YYSTYPE **b, size_t *yystacksize);
select_var_list select_var_list_init help
opt_extended_describe shutdown
opt_format_json
prepare prepare_src execute deallocate
prepare execute deallocate
statement
sp_c_chistics sp_a_chistics sp_chistic sp_c_chistic xa
opt_field_or_var_spec fields_or_vars opt_load_data_set_spec
@ -1827,9 +1829,7 @@ statement:
deallocate:
deallocate_or_drop PREPARE_SYM ident
{
LEX *lex= thd->lex;
lex->sql_command= SQLCOM_DEALLOCATE_PREPARE;
lex->prepared_stmt_name= $3;
Lex->stmt_deallocate_prepare($3);
}
;
@ -1841,12 +1841,8 @@ deallocate_or_drop:
prepare:
PREPARE_SYM ident FROM prepare_src
{
LEX *lex= thd->lex;
if (unlikely(lex->table_or_sp_used()))
my_yyabort_error((ER_SUBQUERIES_NOT_SUPPORTED, MYF(0),
"PREPARE..FROM"));
lex->sql_command= SQLCOM_PREPARE;
lex->prepared_stmt_name= $2;
if (Lex->stmt_prepare($2, $4))
MYSQL_YYABORT;
}
;
@ -1854,57 +1850,48 @@ prepare_src:
{ Lex->expr_allows_subselect= false; }
expr
{
Lex->prepared_stmt_code= $2;
Lex->expr_allows_subselect= true;
$$= $2;
}
;
execute:
EXECUTE_SYM ident
EXECUTE_SYM ident execute_using
{
LEX *lex= thd->lex;
lex->sql_command= SQLCOM_EXECUTE;
lex->prepared_stmt_name= $2;
if (Lex->stmt_execute($2, $3))
MYSQL_YYABORT;
}
execute_using
{}
| EXECUTE_SYM IMMEDIATE_SYM prepare_src
| EXECUTE_SYM IMMEDIATE_SYM prepare_src execute_using
{
if (unlikely(Lex->table_or_sp_used()))
my_yyabort_error((ER_SUBQUERIES_NOT_SUPPORTED, MYF(0),
"EXECUTE IMMEDIATE"));
Lex->sql_command= SQLCOM_EXECUTE_IMMEDIATE;
if (Lex->stmt_execute_immediate($3, $4))
MYSQL_YYABORT;
}
execute_using
{}
;
execute_using:
/* nothing */
/* nothing */ { $$= NULL; }
| USING { Lex->expr_allows_subselect= false; }
execute_var_list
execute_params
{
if (unlikely(Lex->table_or_sp_used()))
my_yyabort_error((ER_SUBQUERIES_NOT_SUPPORTED, MYF(0),
"EXECUTE..USING"));
$$= $3;
Lex->expr_allows_subselect= true;
}
;
execute_var_list:
execute_var_list ',' execute_var_ident
| execute_var_ident
;
execute_var_ident:
execute_params:
expr_or_default
{
if (unlikely(Lex->prepared_stmt_params.push_back($1,
thd->mem_root)))
if (unlikely(!($$= List<Item>::make(thd->mem_root, $1))))
MYSQL_YYABORT;
}
| execute_params ',' expr_or_default
{
if (($$= $1)->push_back($3, thd->mem_root))
MYSQL_YYABORT;
}
;
/* help */
help:
@ -11919,9 +11906,7 @@ opt_expr_list:
expr_list:
expr
{
$$= new (thd->mem_root) List<Item>;
if (unlikely($$ == NULL) ||
unlikely($$->push_back($1, thd->mem_root)))
if (unlikely(!($$= List<Item>::make(thd->mem_root, $1))))
MYSQL_YYABORT;
}
| expr_list ',' expr

Write Preview
Loading…
Cancel
Save