summaryrefslogtreecommitdiff
path: root/sql
diff options
context:
space:
mode:
Diffstat (limited to 'sql')
-rw-r--r--sql/sp_head.cc22
-rw-r--r--sql/sp_head.h6
-rw-r--r--sql/sp_pcontext.cc161
-rw-r--r--sql/sp_pcontext.h130
-rw-r--r--sql/sp_rcontext.cc24
-rw-r--r--sql/sp_rcontext.h8
-rw-r--r--sql/sql_yacc.yy86
7 files changed, 233 insertions, 204 deletions
diff --git a/sql/sp_head.cc b/sql/sp_head.cc
index bba9479c8f3..15d621b1d6d 100644
--- a/sql/sp_head.cc
+++ b/sql/sp_head.cc
@@ -1214,7 +1214,7 @@ sp_head::execute_function(THD *thd, Item **argp, uint argcount,
DBUG_ENTER("sp_head::execute_function");
DBUG_PRINT("info", ("function %s", m_name.str));
- params = m_pcont->context_pvars();
+ params = m_pcont->context_var_count();
/*
Check that the function is called with all specified arguments.
@@ -1391,7 +1391,7 @@ bool
sp_head::execute_procedure(THD *thd, List<Item> *args)
{
bool err_status= FALSE;
- uint params = m_pcont->context_pvars();
+ uint params = m_pcont->context_var_count();
sp_rcontext *save_spcont, *octx;
sp_rcontext *nctx = NULL;
DBUG_ENTER("sp_head::execute_procedure");
@@ -1443,15 +1443,15 @@ sp_head::execute_procedure(THD *thd, List<Item> *args)
for (uint i= 0 ; i < params ; i++)
{
Item *arg_item= it_args++;
- sp_pvar_t *pvar= m_pcont->find_pvar(i);
+ sp_variable_t *spvar= m_pcont->find_variable(i);
if (!arg_item)
break;
- if (!pvar)
+ if (!spvar)
continue;
- if (pvar->mode != sp_param_in)
+ if (spvar->mode != sp_param_in)
{
if (!arg_item->is_splocal() && !item_is_user_var(arg_item))
{
@@ -1461,7 +1461,7 @@ sp_head::execute_procedure(THD *thd, List<Item> *args)
}
}
- if (pvar->mode == sp_param_out)
+ if (spvar->mode == sp_param_out)
{
Item_null *null_item= new Item_null();
@@ -1521,9 +1521,9 @@ sp_head::execute_procedure(THD *thd, List<Item> *args)
if (!arg_item)
break;
- sp_pvar_t *pvar= m_pcont->find_pvar(i);
+ sp_variable_t *spvar= m_pcont->find_variable(i);
- if (pvar->mode == sp_param_in)
+ if (spvar->mode == sp_param_in)
continue;
if (arg_item->is_splocal())
@@ -2388,7 +2388,7 @@ sp_instr_set::print(String *str)
{
/* set name@offset ... */
int rsrv = SP_INSTR_UINT_MAXLEN+6;
- sp_pvar_t *var = m_ctx->find_pvar(m_offset);
+ sp_variable_t *var = m_ctx->find_variable(m_offset);
/* 'var' should always be non-null, but just in case... */
if (var)
@@ -3004,8 +3004,8 @@ sp_instr_cfetch::execute(THD *thd, uint *nextp)
void
sp_instr_cfetch::print(String *str)
{
- List_iterator_fast<struct sp_pvar> li(m_varlist);
- sp_pvar_t *pv;
+ List_iterator_fast<struct sp_variable> li(m_varlist);
+ sp_variable_t *pv;
LEX_STRING n;
my_bool found= m_ctx->find_cursor(m_cursor, &n);
/* cfetch name@offset vars... */
diff --git a/sql/sp_head.h b/sql/sp_head.h
index 64d9167fb17..17a5d1ae528 100644
--- a/sql/sp_head.h
+++ b/sql/sp_head.h
@@ -44,7 +44,7 @@ class sp_instr;
class sp_instr_opt_meta;
class sp_instr_jump_if_not;
struct sp_cond_type;
-struct sp_pvar;
+struct sp_variable;
class sp_name : public Sql_alloc
{
@@ -1074,7 +1074,7 @@ public:
virtual void print(String *str);
- void add_to_varlist(struct sp_pvar *var)
+ void add_to_varlist(struct sp_variable *var)
{
m_varlist.push_back(var);
}
@@ -1082,7 +1082,7 @@ public:
private:
uint m_cursor;
- List<struct sp_pvar> m_varlist;
+ List<struct sp_variable> m_varlist;
}; // class sp_instr_cfetch : public sp_instr
diff --git a/sql/sp_pcontext.cc b/sql/sp_pcontext.cc
index f69053a7c88..448df908a32 100644
--- a/sql/sp_pcontext.cc
+++ b/sql/sp_pcontext.cc
@@ -27,10 +27,10 @@
#include "sp_head.h"
/*
- * Sanity check for SQLSTATEs. Will not check if it's really an existing
- * state (there are just too many), but will check length and bad characters.
- * Returns TRUE if it's ok, FALSE if it's bad.
- */
+ Sanity check for SQLSTATEs. Will not check if it's really an existing
+ state (there are just too many), but will check length and bad characters.
+ Returns TRUE if it's ok, FALSE if it's bad.
+*/
bool
sp_cond_check(LEX_STRING *sqlstate)
{
@@ -51,25 +51,25 @@ sp_cond_check(LEX_STRING *sqlstate)
}
sp_pcontext::sp_pcontext(sp_pcontext *prev)
- :Sql_alloc(), m_total_pvars(0), m_csubsize(0), m_hsubsize(0),
- m_handlers(0), m_parent(prev), m_pboundary(0)
+ :Sql_alloc(), m_max_var_index(0), m_max_cursor_index(0), m_max_handler_index(0),
+ m_context_handlers(0), m_parent(prev), m_pboundary(0)
{
- VOID(my_init_dynamic_array(&m_pvar, sizeof(sp_pvar_t *), 16, 8));
+ VOID(my_init_dynamic_array(&m_vars, sizeof(sp_variable_t *), 16, 8));
VOID(my_init_dynamic_array(&m_case_expr_id_lst, sizeof(int), 16, 8));
- VOID(my_init_dynamic_array(&m_cond, sizeof(sp_cond_type_t *), 16, 8));
- VOID(my_init_dynamic_array(&m_cursor, sizeof(LEX_STRING), 16, 8));
- VOID(my_init_dynamic_array(&m_handler, sizeof(sp_cond_type_t *), 16, 8));
+ VOID(my_init_dynamic_array(&m_conds, sizeof(sp_cond_type_t *), 16, 8));
+ VOID(my_init_dynamic_array(&m_cursors, sizeof(LEX_STRING), 16, 8));
+ VOID(my_init_dynamic_array(&m_handlers, sizeof(sp_cond_type_t *), 16, 8));
m_label.empty();
m_children.empty();
if (!prev)
{
- m_poffset= m_coffset= 0;
+ m_var_offset= m_cursor_offset= 0;
m_num_case_exprs= 0;
}
else
{
- m_poffset= prev->m_poffset + prev->m_total_pvars;
- m_coffset= prev->current_cursors();
+ m_var_offset= prev->m_var_offset + prev->m_max_var_index;
+ m_cursor_offset= prev->current_cursor_count();
m_num_case_exprs= prev->get_num_case_exprs();
}
}
@@ -85,11 +85,11 @@ sp_pcontext::destroy()
m_children.empty();
m_label.empty();
- delete_dynamic(&m_pvar);
+ delete_dynamic(&m_vars);
delete_dynamic(&m_case_expr_id_lst);
- delete_dynamic(&m_cond);
- delete_dynamic(&m_cursor);
- delete_dynamic(&m_handler);
+ delete_dynamic(&m_conds);
+ delete_dynamic(&m_cursors);
+ delete_dynamic(&m_handlers);
}
sp_pcontext *
@@ -105,15 +105,15 @@ sp_pcontext::push_context()
sp_pcontext *
sp_pcontext::pop_context()
{
- m_parent->m_total_pvars= m_parent->m_total_pvars + m_total_pvars;
+ m_parent->m_max_var_index+= m_max_var_index;
- uint submax= max_handlers();
- if (submax > m_parent->m_hsubsize)
- m_parent->m_hsubsize= submax;
+ uint submax= max_handler_index();
+ if (submax > m_parent->m_max_handler_index)
+ m_parent->m_max_handler_index= submax;
- submax= max_cursors();
- if (submax > m_parent->m_csubsize)
- m_parent->m_csubsize= submax;
+ submax= max_cursor_index();
+ if (submax > m_parent->m_max_cursor_index)
+ m_parent->m_max_cursor_index= submax;
if (m_num_case_exprs > m_parent->m_num_case_exprs)
m_parent->m_num_case_exprs= m_num_case_exprs;
@@ -130,12 +130,12 @@ sp_pcontext::diff_handlers(sp_pcontext *ctx, bool exclusive)
while (pctx && pctx != ctx)
{
- n+= pctx->m_handlers;
+ n+= pctx->m_context_handlers;
last_ctx= pctx;
pctx= pctx->parent_context();
}
if (pctx)
- return (exclusive && last_ctx ? n - last_ctx->m_handlers : n);
+ return (exclusive && last_ctx ? n - last_ctx->m_context_handlers : n);
return 0; // Didn't find ctx
}
@@ -148,32 +148,33 @@ sp_pcontext::diff_cursors(sp_pcontext *ctx, bool exclusive)
while (pctx && pctx != ctx)
{
- n+= pctx->m_cursor.elements;
+ n+= pctx->m_cursors.elements;
last_ctx= pctx;
pctx= pctx->parent_context();
}
if (pctx)
- return (exclusive && last_ctx ? n - last_ctx->m_cursor.elements : n);
+ return (exclusive && last_ctx ? n - last_ctx->m_cursors.elements : n);
return 0; // Didn't find ctx
}
-/* This does a linear search (from newer to older variables, in case
-** we have shadowed names).
-** It's possible to have a more efficient allocation and search method,
-** but it might not be worth it. The typical number of parameters and
-** variables will in most cases be low (a handfull).
-** ...and, this is only called during parsing.
+/*
+ This does a linear search (from newer to older variables, in case
+ we have shadowed names).
+ It's possible to have a more efficient allocation and search method,
+ but it might not be worth it. The typical number of parameters and
+ variables will in most cases be low (a handfull).
+ ...and, this is only called during parsing.
*/
-sp_pvar_t *
-sp_pcontext::find_pvar(LEX_STRING *name, my_bool scoped)
+sp_variable_t *
+sp_pcontext::find_variable(LEX_STRING *name, my_bool scoped)
{
- uint i= m_pvar.elements - m_pboundary;
+ uint i= m_vars.elements - m_pboundary;
while (i--)
{
- sp_pvar_t *p;
+ sp_variable_t *p;
- get_dynamic(&m_pvar, (gptr)&p, i);
+ get_dynamic(&m_vars, (gptr)&p, i);
if (my_strnncoll(system_charset_info,
(const uchar *)name->str, name->length,
(const uchar *)p->name.str, p->name.length) == 0)
@@ -182,7 +183,7 @@ sp_pcontext::find_pvar(LEX_STRING *name, my_bool scoped)
}
}
if (!scoped && m_parent)
- return m_parent->find_pvar(name, scoped);
+ return m_parent->find_variable(name, scoped);
return NULL;
}
@@ -192,40 +193,40 @@ sp_pcontext::find_pvar(LEX_STRING *name, my_bool scoped)
- When evaluating parameters at the beginning, and setting out parameters
at the end, of invokation. (Top frame only, so no recursion then.)
- For printing of sp_instr_set. (Debug mode only.)
- */
-sp_pvar_t *
-sp_pcontext::find_pvar(uint offset)
+*/
+sp_variable_t *
+sp_pcontext::find_variable(uint offset)
{
- if (m_poffset <= offset && offset < m_poffset + m_pvar.elements)
+ if (m_var_offset <= offset && offset < m_var_offset + m_vars.elements)
{ // This frame
- sp_pvar_t *p;
+ sp_variable_t *p;
- get_dynamic(&m_pvar, (gptr)&p, offset - m_poffset);
+ get_dynamic(&m_vars, (gptr)&p, offset - m_var_offset);
return p;
}
if (m_parent)
- return m_parent->find_pvar(offset); // Some previous frame
+ return m_parent->find_variable(offset); // Some previous frame
return NULL; // index out of bounds
}
-sp_pvar_t *
-sp_pcontext::push_pvar(LEX_STRING *name, enum enum_field_types type,
- sp_param_mode_t mode)
+sp_variable_t *
+sp_pcontext::push_variable(LEX_STRING *name, enum enum_field_types type,
+ sp_param_mode_t mode)
{
- sp_pvar_t *p= (sp_pvar_t *)sql_alloc(sizeof(sp_pvar_t));
+ sp_variable_t *p= (sp_variable_t *)sql_alloc(sizeof(sp_variable_t));
if (!p)
return NULL;
- ++m_total_pvars;
+ ++m_max_var_index;
p->name.str= name->str;
p->name.length= name->length;
p->type= type;
p->mode= mode;
- p->offset= current_pvars();
+ p->offset= current_var_count();
p->dflt= NULL;
- insert_dynamic(&m_pvar, (gptr)&p);
+ insert_dynamic(&m_vars, (gptr)&p);
return p;
}
@@ -272,23 +273,23 @@ sp_pcontext::push_cond(LEX_STRING *name, sp_cond_type_t *val)
p->name.str= name->str;
p->name.length= name->length;
p->val= val;
- insert_dynamic(&m_cond, (gptr)&p);
+ insert_dynamic(&m_conds, (gptr)&p);
}
}
/*
- * See comment for find_pvar() above
- */
+ See comment for find_variable() above
+*/
sp_cond_type_t *
sp_pcontext::find_cond(LEX_STRING *name, my_bool scoped)
{
- uint i= m_cond.elements;
+ uint i= m_conds.elements;
while (i--)
{
sp_cond_t *p;
- get_dynamic(&m_cond, (gptr)&p, i);
+ get_dynamic(&m_conds, (gptr)&p, i);
if (my_strnncoll(system_charset_info,
(const uchar *)name->str, name->length,
(const uchar *)p->name.str, p->name.length) == 0)
@@ -302,20 +303,20 @@ sp_pcontext::find_cond(LEX_STRING *name, my_bool scoped)
}
/*
- * This only searches the current context, for error checking of
- * duplicates.
- * Returns TRUE if found.
- */
+ This only searches the current context, for error checking of
+ duplicates.
+ Returns TRUE if found.
+*/
bool
sp_pcontext::find_handler(sp_cond_type_t *cond)
{
- uint i= m_handler.elements;
+ uint i= m_handlers.elements;
while (i--)
{
sp_cond_type_t *p;
- get_dynamic(&m_handler, (gptr)&p, i);
+ get_dynamic(&m_handlers, (gptr)&p, i);
if (cond->type == p->type)
{
switch (p->type)
@@ -341,31 +342,31 @@ sp_pcontext::push_cursor(LEX_STRING *name)
{
LEX_STRING n;
- if (m_cursor.elements == m_csubsize)
- m_csubsize+= 1;
+ if (m_cursors.elements == m_max_cursor_index)
+ m_max_cursor_index+= 1;
n.str= name->str;
n.length= name->length;
- insert_dynamic(&m_cursor, (gptr)&n);
+ insert_dynamic(&m_cursors, (gptr)&n);
}
/*
- * See comment for find_pvar() above
- */
+ See comment for find_variable() above
+*/
my_bool
sp_pcontext::find_cursor(LEX_STRING *name, uint *poff, my_bool scoped)
{
- uint i= m_cursor.elements;
+ uint i= m_cursors.elements;
while (i--)
{
LEX_STRING n;
- get_dynamic(&m_cursor, (gptr)&n, i);
+ get_dynamic(&m_cursors, (gptr)&n, i);
if (my_strnncoll(system_charset_info,
(const uchar *)name->str, name->length,
(const uchar *)n.str, n.length) == 0)
{
- *poff= m_coffset + i;
+ *poff= m_cursor_offset + i;
return TRUE;
}
}
@@ -380,10 +381,10 @@ sp_pcontext::retrieve_field_definitions(List<create_field> *field_def_lst)
{
/* Put local/context fields in the result list. */
- for (uint i = 0; i < m_pvar.elements; ++i)
+ for (uint i = 0; i < m_vars.elements; ++i)
{
- sp_pvar_t *var_def;
- get_dynamic(&m_pvar, (gptr) &var_def, i);
+ sp_variable_t *var_def;
+ get_dynamic(&m_vars, (gptr) &var_def, i);
field_def_lst->push_back(&var_def->field_def);
}
@@ -400,17 +401,17 @@ sp_pcontext::retrieve_field_definitions(List<create_field> *field_def_lst)
/*
Find a cursor by offset from the top.
This is only used for debugging.
- */
+*/
my_bool
sp_pcontext::find_cursor(uint offset, LEX_STRING *n)
{
- if (m_coffset <= offset && offset < m_coffset + m_cursor.elements)
+ if (m_cursor_offset <= offset &&
+ offset < m_cursor_offset + m_cursors.elements)
{ // This frame
- get_dynamic(&m_cursor, (gptr)n, offset - m_coffset);
+ get_dynamic(&m_cursors, (gptr)n, offset - m_cursor_offset);
return TRUE;
}
if (m_parent)
return m_parent->find_cursor(offset, n); // Some previous frame
return FALSE; // index out of bounds
}
-
diff --git a/sql/sp_pcontext.h b/sql/sp_pcontext.h
index 872c7c1d505..e61057537da 100644
--- a/sql/sp_pcontext.h
+++ b/sql/sp_pcontext.h
@@ -29,22 +29,23 @@ typedef enum
sp_param_inout
} sp_param_mode_t;
-typedef struct sp_pvar
+typedef struct sp_variable
{
LEX_STRING name;
enum enum_field_types type;
sp_param_mode_t mode;
/*
- offset -- basically, this is an index of variable in the scope of root
- parsing context. This means, that all variables in a stored routine
- have distinct indexes/offsets.
+ offset -- this the index to the variable's value in the runtime frame.
+ This is calculated during parsing and used when creating sp_instr_set
+ instructions and Item_splocal items.
+ I.e. values are set/referred by array indexing in runtime.
*/
uint offset;
Item *dflt;
create_field field_def;
-} sp_pvar_t;
+} sp_variable_t;
#define SP_LAB_REF 0 // Unresolved reference (for goto)
@@ -76,9 +77,10 @@ typedef struct sp_cond_type
uint mysqlerr;
} sp_cond_type_t;
-/* Sanity check for SQLSTATEs. Will not check if it's really an existing
- * state (there are just too many), but will check length bad characters.
- */
+/*
+ Sanity check for SQLSTATEs. Will not check if it's really an existing
+ state (there are just too many), but will check length bad characters.
+*/
extern bool
sp_cond_check(LEX_STRING *sqlstate);
@@ -90,7 +92,17 @@ typedef struct sp_cond
/*
- This seems to be an "SP parsing context" or something.
+ The parse-time context, used to keep track on declared variables/parameters,
+ conditions, handlers, cursors and labels, during parsing.
+ sp_contexts are organized as a tree, with one object for each begin-end
+ block, plus a root-context for the parameters.
+ This is used during parsing for looking up defined names (e.g. declared
+ variables and visible labels), for error checking, and to calculate offsets
+ to be used at runtime. (During execution variable values, active handlers
+ and cursors, etc, are referred to by an index in a stack.)
+ The pcontext tree is also kept during execution and is used for error
+ checking (e.g. correct number of parameters), and in the future, used by
+ the debugger.
*/
class sp_pcontext : public Sql_alloc
@@ -134,50 +146,64 @@ class sp_pcontext : public Sql_alloc
// Parameters and variables
//
+ /*
+ The maximum number of variables used in this and all child contexts
+ In the root, this gives us the number of slots needed for variables
+ during execution.
+ */
inline uint
- total_pvars()
+ max_var_index()
{
- return m_total_pvars;
+ return m_max_var_index;
}
+ /*
+ The current number of variables used in the parents (from the root),
+ including this context.
+ */
inline uint
- current_pvars()
+ current_var_count()
{
- return m_poffset + m_pvar.elements;
+ return m_var_offset + m_vars.elements;
}
+ /* The number of variables in this context alone */
inline uint
- context_pvars()
+ context_var_count()
{
- return m_pvar.elements;
+ return m_vars.elements;
}
+ /* Map index in this pcontext to runtime offset */
inline uint
- pvar_context2index(uint i)
+ var_context2runtime(uint i)
{
- return m_poffset + i;
+ return m_var_offset + i;
}
+ /* Set type of variable. 'i' is the offset from the top */
inline void
set_type(uint i, enum enum_field_types type)
{
- sp_pvar_t *p= find_pvar(i);
+ sp_variable_t *p= find_variable(i);
if (p)
p->type= type;
}
+ /* Set default value of variable. 'i' is the offset from the top */
inline void
set_default(uint i, Item *it)
{
- sp_pvar_t *p= find_pvar(i);
+ sp_variable_t *p= find_variable(i);
if (p)
p->dflt= it;
}
- sp_pvar_t *
- push_pvar(LEX_STRING *name, enum enum_field_types type, sp_param_mode_t mode);
+ sp_variable_t *
+ push_variable(LEX_STRING *name, enum enum_field_types type,
+ sp_param_mode_t mode);
/*
Retrieve definitions of fields from the current context and its
@@ -187,12 +213,12 @@ class sp_pcontext : public Sql_alloc
retrieve_field_definitions(List<create_field> *field_def_lst);
// Find by name
- sp_pvar_t *
- find_pvar(LEX_STRING *name, my_bool scoped=0);
+ sp_variable_t *
+ find_variable(LEX_STRING *name, my_bool scoped=0);
- // Find by offset
- sp_pvar_t *
- find_pvar(uint offset);
+ // Find by offset (from the top)
+ sp_variable_t *
+ find_variable(uint offset);
/*
Set the current scope boundary (for default values).
@@ -280,7 +306,7 @@ class sp_pcontext : public Sql_alloc
pop_cond(uint num)
{
while (num--)
- pop_dynamic(&m_cond);
+ pop_dynamic(&m_conds);
}
sp_cond_type_t *
@@ -293,22 +319,22 @@ class sp_pcontext : public Sql_alloc
inline void
push_handler(sp_cond_type_t *cond)
{
- insert_dynamic(&m_handler, (gptr)&cond);
+ insert_dynamic(&m_handlers, (gptr)&cond);
}
bool
find_handler(sp_cond_type *cond);
inline uint
- max_handlers()
+ max_handler_index()
{
- return m_hsubsize + m_handlers;
+ return m_max_handler_index + m_context_handlers;
}
inline void
add_handlers(uint n)
{
- m_handlers+= n;
+ m_context_handlers+= n;
}
//
@@ -326,51 +352,51 @@ class sp_pcontext : public Sql_alloc
find_cursor(uint offset, LEX_STRING *n);
inline uint
- max_cursors()
+ max_cursor_index()
{
- return m_csubsize + m_cursor.elements;
+ return m_max_cursor_index + m_cursors.elements;
}
inline uint
- current_cursors()
+ current_cursor_count()
{
- return m_coffset + m_cursor.elements;
+ return m_cursor_offset + m_cursors.elements;
}
protected:
/*
- m_total_pvars -- number of variables (including all types of arguments)
+ m_max_var_index -- number of variables (including all types of arguments)
in this context including all children contexts.
- m_total_pvars >= m_pvar.elements.
+ m_max_var_index >= m_vars.elements.
- m_total_pvars of the root parsing context contains number of all
+ m_max_var_index of the root parsing context contains number of all
variables (including arguments) in all enclosed contexts.
*/
- uint m_total_pvars;
+ uint m_max_var_index;
// The maximum sub context's framesizes
- uint m_csubsize;
- uint m_hsubsize;
- uint m_handlers; // No. of handlers in this context
+ uint m_max_cursor_index;
+ uint m_max_handler_index;
+ uint m_context_handlers; // No. of handlers in this context
private:
sp_pcontext *m_parent; // Parent context
/*
- m_poffset -- basically, this is an index of the first variable in this
- parsing context.
+ m_var_offset -- this is an index of the first variable in this
+ parsing context.
- m_poffset is 0 for root context.
+ m_var_offset is 0 for root context.
Since now each variable is stored in separate place, no reuse is done,
- so m_poffset is different for all enclosed contexts.
+ so m_var_offset is different for all enclosed contexts.
*/
- uint m_poffset;
+ uint m_var_offset;
- uint m_coffset; // Cursor offset for this context
+ uint m_cursor_offset; // Cursor offset for this context
/*
Boundary for finding variables in this context. This is the number
@@ -382,11 +408,11 @@ private:
int m_num_case_exprs;
- DYNAMIC_ARRAY m_pvar; // Parameters/variables
+ DYNAMIC_ARRAY m_vars; // Parameters/variables
DYNAMIC_ARRAY m_case_expr_id_lst; /* Stack of CASE expression ids. */
- DYNAMIC_ARRAY m_cond; // Conditions
- DYNAMIC_ARRAY m_cursor; // Cursors
- DYNAMIC_ARRAY m_handler; // Handlers, for checking of duplicates
+ DYNAMIC_ARRAY m_conds; // Conditions
+ DYNAMIC_ARRAY m_cursors; // Cursors
+ DYNAMIC_ARRAY m_handlers; // Handlers, for checking for duplicates
List<sp_label_t> m_label; // The label list
diff --git a/sql/sp_rcontext.cc b/sql/sp_rcontext.cc
index af4e41c29be..38b6de0e75a 100644
--- a/sql/sp_rcontext.cc
+++ b/sql/sp_rcontext.cc
@@ -73,16 +73,16 @@ bool sp_rcontext::init(THD *thd)
return
!(m_handler=
- (sp_handler_t*)thd->alloc(m_root_parsing_ctx->max_handlers() *
+ (sp_handler_t*)thd->alloc(m_root_parsing_ctx->max_handler_index() *
sizeof(sp_handler_t))) ||
!(m_hstack=
- (uint*)thd->alloc(m_root_parsing_ctx->max_handlers() *
+ (uint*)thd->alloc(m_root_parsing_ctx->max_handler_index() *
sizeof(uint))) ||
!(m_in_handler=
- (uint*)thd->alloc(m_root_parsing_ctx->max_handlers() *
+ (uint*)thd->alloc(m_root_parsing_ctx->max_handler_index() *
sizeof(uint))) ||
!(m_cstack=
- (sp_cursor**)thd->alloc(m_root_parsing_ctx->max_cursors() *
+ (sp_cursor**)thd->alloc(m_root_parsing_ctx->max_cursor_index() *
sizeof(sp_cursor*))) ||
!(m_case_expr_holders=
(Item_cache**)thd->calloc(m_root_parsing_ctx->get_num_case_exprs() *
@@ -105,12 +105,12 @@ sp_rcontext::init_var_table(THD *thd)
{
List<create_field> field_def_lst;
- if (!m_root_parsing_ctx->total_pvars())
+ if (!m_root_parsing_ctx->max_var_index())
return FALSE;
m_root_parsing_ctx->retrieve_field_definitions(&field_def_lst);
- DBUG_ASSERT(field_def_lst.elements == m_root_parsing_ctx->total_pvars());
+ DBUG_ASSERT(field_def_lst.elements == m_root_parsing_ctx->max_var_index());
if (!(m_var_table= create_virtual_tmp_table(thd, field_def_lst)))
return TRUE;
@@ -134,7 +134,7 @@ bool
sp_rcontext::init_var_items()
{
uint idx;
- uint num_vars= m_root_parsing_ctx->total_pvars();
+ uint num_vars= m_root_parsing_ctx->max_var_index();
if (!(m_var_items= (Item**) sql_alloc(num_vars * sizeof (Item *))))
return TRUE;
@@ -381,7 +381,7 @@ sp_cursor::destroy()
int
-sp_cursor::fetch(THD *thd, List<struct sp_pvar> *vars)
+sp_cursor::fetch(THD *thd, List<struct sp_variable> *vars)
{
if (! server_side_cursor)
{
@@ -528,9 +528,9 @@ int Select_fetch_into_spvars::prepare(List<Item> &fields, SELECT_LEX_UNIT *u)
bool Select_fetch_into_spvars::send_data(List<Item> &items)
{
- List_iterator_fast<struct sp_pvar> pv_iter(*spvar_list);
+ List_iterator_fast<struct sp_variable> spvar_iter(*spvar_list);
List_iterator_fast<Item> item_iter(items);
- sp_pvar_t *pv;
+ sp_variable_t *spvar;
Item *item;
/* Must be ensured by the caller */
@@ -540,9 +540,9 @@ bool Select_fetch_into_spvars::send_data(List<Item> &items)
Assign the row fetched from a server side cursor to stored
procedure variables.
*/
- for (; pv= pv_iter++, item= item_iter++; )
+ for (; spvar= spvar_iter++, item= item_iter++; )
{
- if (thd->spcont->set_variable(thd, pv->offset, item))
+ if (thd->spcont->set_variable(thd, spvar->offset, item))
return TRUE;
}
return FALSE;
diff --git a/sql/sp_rcontext.h b/sql/sp_rcontext.h
index e7393902e72..20aaea3b7c1 100644
--- a/sql/sp_rcontext.h
+++ b/sql/sp_rcontext.h
@@ -24,7 +24,7 @@
struct sp_cond_type;
class sp_cursor;
-struct sp_pvar;
+struct sp_variable;
class sp_lex_keeper;
class sp_instr_cpush;
@@ -265,12 +265,12 @@ private:
class Select_fetch_into_spvars: public select_result_interceptor
{
- List<struct sp_pvar> *spvar_list;
+ List<struct sp_variable> *spvar_list;
uint field_count;
public:
Select_fetch_into_spvars() {} /* Remove gcc warning */
uint get_field_count() { return field_count; }
- void set_spvar_list(List<struct sp_pvar> *vars) { spvar_list= vars; }
+ void set_spvar_list(List<struct sp_variable> *vars) { spvar_list= vars; }
virtual bool send_eof() { return FALSE; }
virtual bool send_data(List<Item> &items);
@@ -307,7 +307,7 @@ public:
}
int
- fetch(THD *, List<struct sp_pvar> *vars);
+ fetch(THD *, List<struct sp_variable> *vars);
inline sp_instr_cpush *
get_instr()
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index ddc267eb970..37f72c351e5 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -1461,22 +1461,23 @@ sp_fdparam:
LEX *lex= Lex;
sp_pcontext *spc= lex->spcont;
- if (spc->find_pvar(&$1, TRUE))
+ if (spc->find_variable(&$1, TRUE))
{
my_error(ER_SP_DUP_PARAM, MYF(0), $1.str);
YYABORT;
}
- sp_pvar_t *pvar= spc->push_pvar(&$1, (enum enum_field_types)$3,
- sp_param_in);
+ sp_variable_t *spvar= spc->push_variable(&$1,
+ (enum enum_field_types)$3,
+ sp_param_in);
if (lex->sphead->fill_field_definition(YYTHD, lex,
(enum enum_field_types) $3,
- &pvar->field_def))
+ &spvar->field_def))
{
YYABORT;
}
- pvar->field_def.field_name= pvar->name.str;
- pvar->field_def.pack_flag |= FIELDFLAG_MAYBE_NULL;
+ spvar->field_def.field_name= spvar->name.str;
+ spvar->field_def.pack_flag |= FIELDFLAG_MAYBE_NULL;
}
;
@@ -1497,22 +1498,23 @@ sp_pdparam:
LEX *lex= Lex;
sp_pcontext *spc= lex->spcont;
- if (spc->find_pvar(&$3, TRUE))
+ if (spc->find_variable(&$3, TRUE))
{
my_error(ER_SP_DUP_PARAM, MYF(0), $3.str);
YYABORT;
}
- sp_pvar_t *pvar= spc->push_pvar(&$3, (enum enum_field_types)$4,
- (sp_param_mode_t)$1);
+ sp_variable_t *spvar= spc->push_variable(&$3,
+ (enum enum_field_types)$4,
+ (sp_param_mode_t)$1);
if (lex->sphead->fill_field_definition(YYTHD, lex,
(enum enum_field_types) $4,
- &pvar->field_def))
+ &spvar->field_def))
{
YYABORT;
}
- pvar->field_def.field_name= pvar->name.str;
- pvar->field_def.pack_flag |= FIELDFLAG_MAYBE_NULL;
+ spvar->field_def.field_name= spvar->name.str;
+ spvar->field_def.pack_flag |= FIELDFLAG_MAYBE_NULL;
}
;
@@ -1576,7 +1578,7 @@ sp_decl:
{
LEX *lex= Lex;
sp_pcontext *pctx= lex->spcont;
- uint num_vars= pctx->context_pvars();
+ uint num_vars= pctx->context_var_count();
enum enum_field_types var_type= (enum enum_field_types) $4;
Item *dflt_value_item= $5;
create_field *create_field_op;
@@ -1589,23 +1591,23 @@ sp_decl:
for (uint i = num_vars-$2 ; i < num_vars ; i++)
{
- uint var_idx= pctx->pvar_context2index(i);
- sp_pvar_t *pvar= pctx->find_pvar(var_idx);
+ uint var_idx= pctx->var_context2runtime(i);
+ sp_variable_t *spvar= pctx->find_variable(var_idx);
- if (!pvar)
+ if (!spvar)
YYABORT;
- pvar->type= var_type;
- pvar->dflt= dflt_value_item;
+ spvar->type= var_type;
+ spvar->dflt= dflt_value_item;
if (lex->sphead->fill_field_definition(YYTHD, lex, var_type,
- &pvar->field_def))
+ &spvar->field_def))
{
YYABORT;
}
- pvar->field_def.field_name= pvar->name.str;
- pvar->field_def.pack_flag |= FIELDFLAG_MAYBE_NULL;
+ spvar->field_def.field_name= spvar->name.str;
+ spvar->field_def.pack_flag |= FIELDFLAG_MAYBE_NULL;
/* The last instruction is responsible for freeing LEX. */
@@ -1642,7 +1644,7 @@ sp_decl:
sp_pcontext *ctx= lex->spcont;
sp_instr_hpush_jump *i=
new sp_instr_hpush_jump(sp->instructions(), ctx, $2,
- ctx->current_pvars());
+ ctx->current_var_count());
sp->add_instr(i);
sp->push_backpatch(i, ctx->push_label((char *)"", 0));
@@ -1659,7 +1661,7 @@ sp_decl:
if ($2 == SP_HANDLER_CONTINUE)
{
i= new sp_instr_hreturn(sp->instructions(), ctx,
- ctx->current_pvars());
+ ctx->current_var_count());
sp->add_instr(i);
}
else
@@ -1690,7 +1692,7 @@ sp_decl:
YYABORT;
}
i= new sp_instr_cpush(sp->instructions(), ctx, $5,
- ctx->current_cursors());
+ ctx->current_cursor_count());
sp->add_instr(i);
ctx->push_cursor(&$2);
$$.vars= $$.conds= $$.hndlrs= 0;
@@ -1845,12 +1847,12 @@ sp_decl_idents:
LEX *lex= Lex;
sp_pcontext *spc= lex->spcont;
- if (spc->find_pvar(&$1, TRUE))
+ if (spc->find_variable(&$1, TRUE))
{
my_error(ER_SP_DUP_VAR, MYF(0), $1.str);
YYABORT;
}
- spc->push_pvar(&$1, (enum_field_types)0, sp_param_in);
+ spc->push_variable(&$1, (enum_field_types)0, sp_param_in);
$$= 1;
}
| sp_decl_idents ',' ident
@@ -1860,12 +1862,12 @@ sp_decl_idents:
LEX *lex= Lex;
sp_pcontext *spc= lex->spcont;
- if (spc->find_pvar(&$3, TRUE))
+ if (spc->find_variable(&$3, TRUE))
{
my_error(ER_SP_DUP_VAR, MYF(0), $3.str);
YYABORT;
}
- spc->push_pvar(&$3, (enum_field_types)0, sp_param_in);
+ spc->push_variable(&$3, (enum_field_types)0, sp_param_in);
$$= $1 + 1;
}
;
@@ -2198,9 +2200,9 @@ sp_fetch_list:
LEX *lex= Lex;
sp_head *sp= lex->sphead;
sp_pcontext *spc= lex->spcont;
- sp_pvar_t *spv;
+ sp_variable_t *spv;
- if (!spc || !(spv = spc->find_pvar(&$1)))
+ if (!spc || !(spv = spc->find_variable(&$1)))
{
my_error(ER_SP_UNDECLARED_VAR, MYF(0), $1.str);
YYABORT;
@@ -2219,9 +2221,9 @@ sp_fetch_list:
LEX *lex= Lex;
sp_head *sp= lex->sphead;
sp_pcontext *spc= lex->spcont;
- sp_pvar_t *spv;
+ sp_variable_t *spv;
- if (!spc || !(spv = spc->find_pvar(&$3)))
+ if (!spc || !(spv = spc->find_variable(&$3)))
{
my_error(ER_SP_UNDECLARED_VAR, MYF(0), $3.str);
YYABORT;
@@ -5868,9 +5870,9 @@ select_var_ident:
| ident_or_text
{
LEX *lex=Lex;
- sp_pvar_t *t;
+ sp_variable_t *t;
- if (!lex->spcont || !(t=lex->spcont->find_pvar(&$1)))
+ if (!lex->spcont || !(t=lex->spcont->find_variable(&$1)))
{
my_error(ER_SP_UNDECLARED_VAR, MYF(0), $1.str);
YYABORT;
@@ -7200,10 +7202,10 @@ order_ident:
simple_ident:
ident
{
- sp_pvar_t *spv;
+ sp_variable_t *spv;
LEX *lex = Lex;
sp_pcontext *spc = lex->spcont;
- if (spc && (spv = spc->find_pvar(&$1)))
+ if (spc && (spv = spc->find_variable(&$1)))
{
/* We're compiling a stored procedure and found a variable */
Item_splocal *splocal;
@@ -7947,7 +7949,7 @@ sys_option_value:
{
/* An SP local variable */
sp_pcontext *ctx= lex->spcont;
- sp_pvar_t *spv;
+ sp_variable_t *spv;
sp_instr_set *sp_set;
Item *it;
if ($1)
@@ -7956,7 +7958,7 @@ sys_option_value:
YYABORT;
}
- spv= ctx->find_pvar(&$2.base_name);
+ spv= ctx->find_variable(&$2.base_name);
if ($4)
it= $4;
@@ -8006,7 +8008,7 @@ option_value:
names.str= (char *)"names";
names.length= 5;
- if (spc && spc->find_pvar(&names))
+ if (spc && spc->find_variable(&names))
my_error(ER_SP_BAD_VAR_SHADOW, MYF(0), names.str);
else
yyerror(ER(ER_SYNTAX_ERROR));
@@ -8036,7 +8038,7 @@ option_value:
pw.str= (char *)"password";
pw.length= 8;
- if (spc && spc->find_pvar(&pw))
+ if (spc && spc->find_variable(&pw))
{
my_error(ER_SP_BAD_VAR_SHADOW, MYF(0), pw.str);
YYABORT;
@@ -8058,10 +8060,10 @@ internal_variable_name:
{
LEX *lex= Lex;
sp_pcontext *spc= lex->spcont;
- sp_pvar_t *spv;
+ sp_variable_t *spv;
/* We have to lookup here since local vars can shadow sysvars */
- if (!spc || !(spv = spc->find_pvar(&$1)))
+ if (!spc || !(spv = spc->find_variable(&$1)))
{
/* Not an SP local variable */
sys_var *tmp=find_sys_var($1.str, $1.length);
View Lorry Controller Status