| List: | Commits | « Previous MessageNext Message » | |
| From: | pem | Date: | April 7 2006 4:54pm |
| Subject: | bk commit into 5.0 tree (pem:1.2134) | ||
| View as plain text | |||
Below is the list of changes that have just been committed into a local 5.0 repository of pem. When pem does a push these changes will be propagated to the main repository and, within 24 hours after the push, to the public repository. For information on how to access the public repository see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html ChangeSet 1.2134 06/04/07 16:53:15 pem@stripped +7 -0 Renaming sp_pcontext members and methods; less cryptic and more consistent. Also added comments, and fixing some coding style (mostly in comments too). There are no functional changes, so no tests or documentation needed. (This was originally part of a bugfix, but it was decided to not include this in that patch; instead it's done separately.) sql/sql_yacc.yy 1.463 06/04/07 16:53:11 pem@stripped +44 -42 Renaming sp_pcontext members and methods; less cryptic and more consistent. sql/sp_rcontext.h 1.31 06/04/07 16:53:11 pem@stripped +4 -4 Renaming sp_pcontext members and methods; less cryptic and more consistent. sql/sp_rcontext.cc 1.41 06/04/07 16:53:11 pem@stripped +12 -12 Renaming sp_pcontext members and methods; less cryptic and more consistent. sql/sp_pcontext.h 1.28 06/04/07 16:53:11 pem@stripped +78 -52 Renaming sp_pcontext members and methods; less cryptic and more consistent. Also added comments, and fixing some coding style (mostly in comments too). sql/sp_pcontext.cc 1.30 06/04/07 16:53:11 pem@stripped +82 -81 Renaming sp_pcontext members and methods; less cryptic and more consistent. Also added comments, and fixing some coding style (mostly in comments too). sql/sp_head.h 1.81 06/04/07 16:53:11 pem@stripped +3 -3 Renaming sp_pcontext members and methods; less cryptic and more consistent. sql/sp_head.cc 1.206 06/04/07 16:53:11 pem@stripped +11 -11 Renaming sp_pcontext members and methods; less cryptic and more consistent. # This is a BitKeeper patch. What follows are the unified diffs for the # set of deltas contained in the patch. The rest of the patch, the part # that BitKeeper cares about, is below these diffs. # User: pem # Host: pem.mysql.com # Root: /extern/mysql/5.0/generic/mysql-5.0-runtime --- 1.462/sql/sql_yacc.yy 2006-03-15 18:15:43 +01:00 +++ 1.463/sql/sql_yacc.yy 2006-04-07 16:53:11 +02:00 @@ -1461,22 +1461,23 @@ 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 @@ 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 @@ { 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 @@ 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_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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ | 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 @@ 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 @@ { /* 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 @@ YYABORT; } - spv= ctx->find_pvar(&$2.base_name); + spv= ctx->find_variable(&$2.base_name); if ($4) it= $4; @@ -8006,7 +8008,7 @@ 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 @@ 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 @@ { 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); --- 1.205/sql/sp_head.cc 2006-03-21 14:35:45 +01:00 +++ 1.206/sql/sp_head.cc 2006-04-07 16:53:11 +02:00 @@ -1214,7 +1214,7 @@ 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 @@ 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 @@ 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 @@ } } - if (pvar->mode == sp_param_out) + if (spvar->mode == sp_param_out) { Item_null *null_item= new Item_null(); @@ -1521,9 +1521,9 @@ 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 @@ { /* 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 @@ 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... */ --- 1.80/sql/sp_head.h 2006-03-02 13:18:45 +01:00 +++ 1.81/sql/sp_head.h 2006-04-07 16:53:11 +02:00 @@ -44,7 +44,7 @@ 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 @@ 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 @@ private: uint m_cursor; - List<struct sp_pvar> m_varlist; + List<struct sp_variable> m_varlist; }; // class sp_instr_cfetch : public sp_instr --- 1.29/sql/sp_pcontext.cc 2006-02-15 12:11:25 +01:00 +++ 1.30/sql/sp_pcontext.cc 2006-04-07 16:53:11 +02:00 @@ -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_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 @@ 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 * 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; - - submax= max_cursors(); - if (submax > m_parent->m_csubsize) - m_parent->m_csubsize= submax; + uint submax= max_handler_index(); + if (submax > m_parent->m_max_handler_index) + m_parent->m_max_handler_index= 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 @@ 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 @@ 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 @@ } } if (!scoped && m_parent) - return m_parent->find_pvar(name, scoped); + return m_parent->find_variable(name, scoped); return NULL; } @@ -192,40 +193,40 @@ - 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 @@ 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 @@ } /* - * 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 @@ { 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 @@ { /* 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 @@ /* 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 } - --- 1.27/sql/sp_pcontext.h 2006-02-15 12:11:25 +01:00 +++ 1.28/sql/sp_pcontext.h 2006-04-07 16:53:11 +02:00 @@ -29,22 +29,23 @@ 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 @@ 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 @@ /* - 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 @@ // 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 @@ 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 @@ pop_cond(uint num) { while (num--) - pop_dynamic(&m_cond); + pop_dynamic(&m_conds); } sp_cond_type_t * @@ -293,22 +319,22 @@ 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 @@ 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 @@ 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 --- 1.40/sql/sp_rcontext.cc 2006-02-01 16:00:08 +01:00 +++ 1.41/sql/sp_rcontext.cc 2006-04-07 16:53:11 +02:00 @@ -73,16 +73,16 @@ 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 @@ { 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 @@ 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 @@ 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 @@ 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 @@ 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; --- 1.30/sql/sp_rcontext.h 2006-02-25 16:46:26 +01:00 +++ 1.31/sql/sp_rcontext.h 2006-04-07 16:53:11 +02:00 @@ -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 @@ 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 @@ } int - fetch(THD *, List<struct sp_pvar> *vars); + fetch(THD *, List<struct sp_variable> *vars); inline sp_instr_cpush * get_instr()
| Thread | ||
|---|---|---|
| • bk commit into 5.0 tree (pem:1.2134) | pem | 7 Apr |
© 1995-2008 MySQL AB, 2008-2009 Sun Microsystems, Inc.
Page generated in 0.710 sec. using MySQL 5.1.14-beta-log