From 3f619478f796eddbba6e39502fe941b285dd97b1 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 4 May 2024 20:00:34 +0200 Subject: Adding upstream version 1:10.11.6. Signed-off-by: Daniel Baumann --- sql/sp_rcontext.cc | 909 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 909 insertions(+) create mode 100644 sql/sp_rcontext.cc (limited to 'sql/sp_rcontext.cc') diff --git a/sql/sp_rcontext.cc b/sql/sp_rcontext.cc new file mode 100644 index 00000000..d2fe53a2 --- /dev/null +++ b/sql/sp_rcontext.cc @@ -0,0 +1,909 @@ +/* Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; version 2 of the License. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */ + +#include "mariadb.h" +#include "sql_priv.h" +#include "unireg.h" +#ifdef USE_PRAGMA_IMPLEMENTATION +#pragma implementation +#endif + +#include "mysql.h" +#include "sp_head.h" +#include "sql_cursor.h" +#include "sp_rcontext.h" +#include "sp_pcontext.h" +#include "sql_select.h" // create_virtual_tmp_table +#include "sql_base.h" // open_tables_only_view_structure +#include "sql_acl.h" // SELECT_ACL +#include "sql_parse.h" // check_table_access + + +Sp_rcontext_handler_local sp_rcontext_handler_local; +Sp_rcontext_handler_package_body sp_rcontext_handler_package_body; + +sp_rcontext *Sp_rcontext_handler_local::get_rcontext(sp_rcontext *ctx) const +{ + return ctx; +} + +sp_rcontext *Sp_rcontext_handler_package_body::get_rcontext(sp_rcontext *ctx) const +{ + return ctx->m_sp->m_parent->m_rcontext; +} + +const LEX_CSTRING *Sp_rcontext_handler_local::get_name_prefix() const +{ + return &empty_clex_str; +} + +const LEX_CSTRING *Sp_rcontext_handler_package_body::get_name_prefix() const +{ + static const LEX_CSTRING sp_package_body_variable_prefix_clex_str= + {STRING_WITH_LEN("PACKAGE_BODY.")}; + return &sp_package_body_variable_prefix_clex_str; +} + + +/////////////////////////////////////////////////////////////////////////// +// sp_rcontext implementation. +/////////////////////////////////////////////////////////////////////////// + + +sp_rcontext::sp_rcontext(const sp_head *owner, + const sp_pcontext *root_parsing_ctx, + Field *return_value_fld, + bool in_sub_stmt) + :end_partial_result_set(false), + pause_state(false), quit_func(false), instr_ptr(0), + m_sp(owner), + m_root_parsing_ctx(root_parsing_ctx), + m_var_table(NULL), + m_return_value_fld(return_value_fld), + m_return_value_set(false), + m_in_sub_stmt(in_sub_stmt), + m_handlers(PSI_INSTRUMENT_MEM), m_handler_call_stack(PSI_INSTRUMENT_MEM), + m_ccount(0) +{ +} + + +sp_rcontext::~sp_rcontext() +{ + delete m_var_table; + // Leave m_handlers, m_handler_call_stack, m_var_items, m_cstack + // and m_case_expr_holders untouched. + // They are allocated in mem roots and will be freed accordingly. +} + + +sp_rcontext *sp_rcontext::create(THD *thd, + const sp_head *owner, + const sp_pcontext *root_parsing_ctx, + Field *return_value_fld, + Row_definition_list &field_def_lst) +{ + SELECT_LEX *save_current_select; + sp_rcontext *ctx= new (thd->mem_root) sp_rcontext(owner, + root_parsing_ctx, + return_value_fld, + thd->in_sub_stmt); + if (!ctx) + return NULL; + + /* Reset current_select as it's checked in Item_ident::Item_ident */ + save_current_select= thd->lex->current_select; + thd->lex->current_select= 0; + + if (ctx->alloc_arrays(thd) || + ctx->init_var_table(thd, field_def_lst) || + ctx->init_var_items(thd, field_def_lst)) + { + delete ctx; + ctx= 0; + } + + thd->lex->current_select= save_current_select; + return ctx; +} + + +bool Row_definition_list::append_uniq(MEM_ROOT *mem_root, Spvar_definition *var) +{ + DBUG_ASSERT(elements); + uint unused; + if (unlikely(find_row_field_by_name(&var->field_name, &unused))) + { + my_error(ER_DUP_FIELDNAME, MYF(0), var->field_name.str); + return true; + } + return push_back(var, mem_root); +} + + +bool Row_definition_list:: + adjust_formal_params_to_actual_params(THD *thd, List *args) +{ + List_iterator it(*this); + List_iterator it_args(*args); + DBUG_ASSERT(elements >= args->elements ); + Spvar_definition *def; + Item *arg; + while ((def= it++) && (arg= it_args++)) + { + if (def->type_handler()->adjust_spparam_type(def, arg)) + return true; + } + return false; +} + + +bool Row_definition_list:: + adjust_formal_params_to_actual_params(THD *thd, + Item **args, uint arg_count) +{ + List_iterator it(*this); + DBUG_ASSERT(elements >= arg_count ); + Spvar_definition *def; + for (uint i= 0; (def= it++) && (i < arg_count) ; i++) + { + if (def->type_handler()->adjust_spparam_type(def, args[i])) + return true; + } + return false; +} + + +bool sp_rcontext::alloc_arrays(THD *thd) +{ + { + size_t n= m_root_parsing_ctx->max_cursor_index(); + m_cstack.reset( + static_cast ( + thd->alloc(n * sizeof (sp_cursor*))), + n); + } + + { + size_t n= m_root_parsing_ctx->get_num_case_exprs(); + m_case_expr_holders.reset( + static_cast ( + thd->calloc(n * sizeof (Item_cache*))), + n); + } + + return !m_cstack.array() || !m_case_expr_holders.array(); +} + + +bool sp_rcontext::init_var_table(THD *thd, + List &field_def_lst) +{ + if (!m_root_parsing_ctx->max_var_index()) + return false; + + 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; + + return false; +} + + +/** + Check if we have access to use a column as a %TYPE reference. + @return false - OK + @return true - access denied +*/ +static inline bool +check_column_grant_for_type_ref(THD *thd, TABLE_LIST *table_list, + const char *str, size_t length, + Field *fld) +{ +#ifndef NO_EMBEDDED_ACCESS_CHECKS + table_list->table->grant.want_privilege= SELECT_ACL; + return check_column_grant_in_table_ref(thd, table_list, str, length, fld); +#else + return false; +#endif +} + + +/** + This method implementation is very close to fill_schema_table_by_open(). +*/ +bool Qualified_column_ident::resolve_type_ref(THD *thd, Column_definition *def) +{ + Open_tables_backup open_tables_state_backup; + thd->reset_n_backup_open_tables_state(&open_tables_state_backup); + + TABLE_LIST *table_list; + Field *src; + LEX *save_lex= thd->lex; + bool rc= true; + + sp_lex_local lex(thd, thd->lex); + thd->lex= &lex; + + lex.context_analysis_only= CONTEXT_ANALYSIS_ONLY_VIEW; + // Make %TYPE variables see temporary tables that shadow permanent tables + thd->temporary_tables= open_tables_state_backup.temporary_tables; + + if ((table_list= + lex.first_select_lex()->add_table_to_list(thd, this, NULL, 0, + TL_READ_NO_INSERT, + MDL_SHARED_READ)) && + !check_table_access(thd, SELECT_ACL, table_list, TRUE, UINT_MAX, FALSE) && + !open_tables_only_view_structure(thd, table_list, + thd->mdl_context.has_locks())) + { + if (likely((src= lex.query_tables->table->find_field_by_name(&m_column)))) + { + if (!(rc= check_column_grant_for_type_ref(thd, table_list, + m_column.str, + m_column.length, src))) + { + *def= Column_definition(thd, src, NULL/*No defaults,no constraints*/); + def->flags&= (uint) ~NOT_NULL_FLAG; + rc= def->sp_prepare_create_field(thd, thd->mem_root); + } + } + else + my_error(ER_BAD_FIELD_ERROR, MYF(0), m_column.str, table.str); + } + + lex.unit.cleanup(); + thd->temporary_tables= NULL; // Avoid closing temporary tables + close_thread_tables(thd); + thd->lex= save_lex; + thd->restore_backup_open_tables_state(&open_tables_state_backup); + return rc; +} + + +/** + This method resolves the structure of a variable declared as: + rec t1%ROWTYPE; + It opens the table "t1" and copies its structure to %ROWTYPE variable. +*/ +bool Table_ident::resolve_table_rowtype_ref(THD *thd, + Row_definition_list &defs) +{ + Open_tables_backup open_tables_state_backup; + thd->reset_n_backup_open_tables_state(&open_tables_state_backup); + + TABLE_LIST *table_list; + LEX *save_lex= thd->lex; + bool rc= true; + + /* + Create a temporary LEX on stack and switch to it. + In case of VIEW, open_tables_only_view_structure() will open more + tables/views recursively. We want to avoid them to stick to the current LEX. + */ + sp_lex_local lex(thd, thd->lex); + thd->lex= &lex; + + lex.context_analysis_only= CONTEXT_ANALYSIS_ONLY_VIEW; + // Make %ROWTYPE variables see temporary tables that shadow permanent tables + thd->temporary_tables= open_tables_state_backup.temporary_tables; + + if ((table_list= + lex.first_select_lex()->add_table_to_list(thd, this, NULL, 0, + TL_READ_NO_INSERT, + MDL_SHARED_READ)) && + !check_table_access(thd, SELECT_ACL, table_list, TRUE, UINT_MAX, FALSE) && + !open_tables_only_view_structure(thd, table_list, + thd->mdl_context.has_locks())) + { + for (Field **src= lex.query_tables->table->field; *src; src++) + { + /* + Make field names on the THD memory root, + as the table will be closed and freed soon, + in the end of this method. + */ + LEX_CSTRING tmp= src[0]->field_name; + Spvar_definition *def; + if ((rc= check_column_grant_for_type_ref(thd, table_list, + tmp.str, tmp.length,src[0])) || + (rc= !(src[0]->field_name.str= thd->strmake(tmp.str, tmp.length))) || + (rc= !(def= new (thd->mem_root) Spvar_definition(thd, *src)))) + break; + src[0]->field_name.str= tmp.str; // Restore field name, just in case. + def->flags&= (uint) ~NOT_NULL_FLAG; + if ((rc= def->sp_prepare_create_field(thd, thd->mem_root))) + break; + defs.push_back(def, thd->mem_root); + } + } + + lex.unit.cleanup(); + thd->temporary_tables= NULL; // Avoid closing temporary tables + close_thread_tables(thd); + thd->lex= save_lex; + thd->restore_backup_open_tables_state(&open_tables_state_backup); + return rc; +} + + +bool Row_definition_list::resolve_type_refs(THD *thd) +{ + List_iterator it(*this); + Spvar_definition *def; + while ((def= it++)) + { + if (def->is_column_type_ref() && + def->column_type_ref()->resolve_type_ref(thd, def)) + return true; + } + return false; +}; + + +bool sp_rcontext::init_var_items(THD *thd, + List &field_def_lst) +{ + uint num_vars= m_root_parsing_ctx->max_var_index(); + + m_var_items.reset( + static_cast ( + thd->alloc(num_vars * sizeof (Item *))), + num_vars); + + if (!m_var_items.array()) + return true; + + DBUG_ASSERT(field_def_lst.elements == num_vars); + List_iterator it(field_def_lst); + Spvar_definition *def= it++; + + for (uint idx= 0; idx < num_vars; ++idx, def= it++) + { + Field *field= m_var_table->field[idx]; + if (def->is_table_rowtype_ref()) + { + Row_definition_list defs; + Item_field_row *item= new (thd->mem_root) Item_field_row(thd, field); + if (!(m_var_items[idx]= item) || + def->table_rowtype_ref()->resolve_table_rowtype_ref(thd, defs) || + item->row_create_items(thd, &defs)) + return true; + } + else if (def->is_cursor_rowtype_ref()) + { + Row_definition_list defs; + Item_field_row *item= new (thd->mem_root) Item_field_row(thd, field); + if (!(m_var_items[idx]= item)) + return true; + } + else if (def->is_row()) + { + Item_field_row *item= new (thd->mem_root) Item_field_row(thd, field); + if (!(m_var_items[idx]= item) || + item->row_create_items(thd, def->row_field_definitions())) + return true; + } + else + { + if (!(m_var_items[idx]= new (thd->mem_root) Item_field(thd, field))) + return true; + } + } + return false; +} + + +bool Item_field_row::row_create_items(THD *thd, List *list) +{ + DBUG_ASSERT(list); + DBUG_ASSERT(field); + Virtual_tmp_table **ptable= field->virtual_tmp_table_addr(); + DBUG_ASSERT(ptable); + if (!(ptable[0]= create_virtual_tmp_table(thd, *list))) + return true; + + if (alloc_arguments(thd, list->elements)) + return true; + + List_iterator it(*list); + Spvar_definition *def; + for (arg_count= 0; (def= it++); arg_count++) + { + if (!(args[arg_count]= new (thd->mem_root) + Item_field(thd, ptable[0]->field[arg_count]))) + return true; + } + return false; +} + + +bool sp_rcontext::set_return_value(THD *thd, Item **return_value_item) +{ + DBUG_ASSERT(m_return_value_fld); + + m_return_value_set = true; + + return thd->sp_eval_expr(m_return_value_fld, return_value_item); +} + + +void sp_rcontext::push_cursor(sp_cursor *c) +{ + m_cstack[m_ccount++]= c; +} + + +void sp_rcontext::pop_cursor(THD *thd) +{ + DBUG_ASSERT(m_ccount > 0); + if (m_cstack[m_ccount - 1]->is_open()) + m_cstack[m_ccount - 1]->close(thd); + m_ccount--; +} + + +void sp_rcontext::pop_cursors(THD *thd, size_t count) +{ + DBUG_ASSERT(m_ccount >= count); + while (count--) + pop_cursor(thd); +} + + +bool sp_rcontext::push_handler(sp_instr_hpush_jump *entry) +{ + return m_handlers.append(entry); +} + + +void sp_rcontext::pop_handlers(size_t count) +{ + DBUG_ASSERT(m_handlers.elements() >= count); + + for (size_t i= 0; i < count; ++i) + m_handlers.pop(); +} + + +bool sp_rcontext::handle_sql_condition(THD *thd, + uint *ip, + const sp_instr *cur_spi) +{ + DBUG_ENTER("sp_rcontext::handle_sql_condition"); + + /* + If this is a fatal sub-statement error, and this runtime + context corresponds to a sub-statement, no CONTINUE/EXIT + handlers from this context are applicable: try to locate one + in the outer scope. + */ + if (unlikely(thd->is_fatal_sub_stmt_error) && m_in_sub_stmt) + DBUG_RETURN(false); + + Diagnostics_area *da= thd->get_stmt_da(); + const sp_handler *found_handler= NULL; + const Sql_condition *found_condition= NULL; + + if (unlikely(thd->is_error())) + { + found_handler= + cur_spi->m_ctx->find_handler(da->get_error_condition_identity()); + + if (found_handler) + found_condition= da->get_error_condition(); + + /* + Found condition can be NULL if the diagnostics area was full + when the error was raised. It can also be NULL if + Diagnostics_area::set_error_status(uint sql_error) was used. + In these cases, make a temporary Sql_condition here so the + error can be handled. + */ + if (!found_condition) + { + found_condition= + new (callers_arena->mem_root) Sql_condition(callers_arena->mem_root, + da->get_error_condition_identity(), + da->message(), + da->current_row_for_warning()); + } + } + else if (da->current_statement_warn_count()) + { + Diagnostics_area::Sql_condition_iterator it= da->sql_conditions(); + const Sql_condition *c; + + // Here we need to find the last warning/note from the stack. + // In MySQL most substantial warning is the last one. + // (We could have used a reverse iterator here if one existed) + + while ((c= it++)) + { + if (c->get_level() == Sql_condition::WARN_LEVEL_WARN || + c->get_level() == Sql_condition::WARN_LEVEL_NOTE) + { + const sp_handler *handler= cur_spi->m_ctx->find_handler(*c); + if (handler) + { + found_handler= handler; + found_condition= c; + } + } + } + } + + if (!found_handler) + DBUG_RETURN(false); + + // At this point, we know that: + // - there is a pending SQL-condition (error or warning); + // - there is an SQL-handler for it. + + DBUG_ASSERT(found_condition); + + sp_instr_hpush_jump *handler_entry= NULL; + for (size_t i= 0; i < m_handlers.elements(); ++i) + { + sp_instr_hpush_jump *h= m_handlers.at(i); + + if (h->get_handler() == found_handler) + { + handler_entry= h; + break; + } + } + + /* + handler_entry usually should not be NULL here, as that indicates + that the parser context thinks a HANDLER should be activated, + but the runtime context cannot find it. + + However, this can happen (and this is in line with the Standard) + if SQL-condition has been raised before DECLARE HANDLER instruction + is processed. + + For example: + CREATE PROCEDURE p() + BEGIN + DECLARE v INT DEFAULT 'get'; -- raises SQL-warning here + DECLARE EXIT HANDLER ... -- this handler does not catch the warning + END + */ + if (!handler_entry) + DBUG_RETURN(false); + + // Mark active conditions so that they can be deleted when the handler exits. + da->mark_sql_conditions_for_removal(); + + uint continue_ip= handler_entry->get_handler()->type == sp_handler::CONTINUE ? + cur_spi->get_cont_dest() : 0; + + /* End aborted result set. */ + if (end_partial_result_set) + thd->protocol->end_partial_result_set(thd); + + /* Reset error state. */ + thd->clear_error(); + thd->reset_killed(); // Some errors set thd->killed, (e.g. "bad data"). + + /* Add a frame to handler-call-stack. */ + Sql_condition_info *cond_info= + new (callers_arena->mem_root) Sql_condition_info(found_condition, + callers_arena); + Handler_call_frame *frame= + new (callers_arena->mem_root) Handler_call_frame(cond_info, continue_ip); + m_handler_call_stack.append(frame); + + *ip= handler_entry->m_ip + 1; + + DBUG_RETURN(true); +} + + +uint sp_rcontext::exit_handler(Diagnostics_area *da) +{ + DBUG_ENTER("sp_rcontext::exit_handler"); + DBUG_ASSERT(m_handler_call_stack.elements() > 0); + + Handler_call_frame *f= m_handler_call_stack.pop(); + + /* + Remove the SQL conditions that were present in DA when the + handler was activated. + */ + da->remove_marked_sql_conditions(); + + uint continue_ip= f->continue_ip; + + DBUG_RETURN(continue_ip); +} + + +int sp_rcontext::set_variable(THD *thd, uint idx, Item **value) +{ + DBUG_ENTER("sp_rcontext::set_variable"); + DBUG_ASSERT(value); + DBUG_RETURN(thd->sp_eval_expr(m_var_table->field[idx], value)); +} + + +int sp_rcontext::set_variable_row_field(THD *thd, uint var_idx, uint field_idx, + Item **value) +{ + DBUG_ENTER("sp_rcontext::set_variable_row_field"); + DBUG_ASSERT(value); + Virtual_tmp_table *vtable= virtual_tmp_table_for_row(var_idx); + DBUG_RETURN(thd->sp_eval_expr(vtable->field[field_idx], value)); +} + + +int sp_rcontext::set_variable_row_field_by_name(THD *thd, uint var_idx, + const LEX_CSTRING &field_name, + Item **value) +{ + DBUG_ENTER("sp_rcontext::set_variable_row_field_by_name"); + uint field_idx; + if (find_row_field_by_name_or_error(&field_idx, var_idx, field_name)) + DBUG_RETURN(1); + DBUG_RETURN(set_variable_row_field(thd, var_idx, field_idx, value)); +} + + +int sp_rcontext::set_variable_row(THD *thd, uint var_idx, List &items) +{ + DBUG_ENTER("sp_rcontext::set_variable_row"); + DBUG_ASSERT(get_variable(var_idx)->cols() == items.elements); + Virtual_tmp_table *vtable= virtual_tmp_table_for_row(var_idx); + Sp_eval_expr_state state(thd); + DBUG_RETURN(vtable->sp_set_all_fields_from_item_list(thd, items)); +} + + +Virtual_tmp_table *sp_rcontext::virtual_tmp_table_for_row(uint var_idx) +{ + DBUG_ASSERT(get_variable(var_idx)->type() == Item::FIELD_ITEM); + DBUG_ASSERT(get_variable(var_idx)->cmp_type() == ROW_RESULT); + Field *field= m_var_table->field[var_idx]; + Virtual_tmp_table **ptable= field->virtual_tmp_table_addr(); + DBUG_ASSERT(ptable); + DBUG_ASSERT(ptable[0]); + return ptable[0]; +} + + +bool sp_rcontext::find_row_field_by_name_or_error(uint *field_idx, + uint var_idx, + const LEX_CSTRING &field_name) +{ + Virtual_tmp_table *vtable= virtual_tmp_table_for_row(var_idx); + Field *row= m_var_table->field[var_idx]; + return vtable->sp_find_field_by_name_or_error(field_idx, + row->field_name, field_name); +} + + +Item_cache *sp_rcontext::create_case_expr_holder(THD *thd, + const Item *item) const +{ + Item_cache *holder; + Query_arena current_arena; + + thd->set_n_backup_active_arena(thd->spcont->callers_arena, ¤t_arena); + + holder= item->get_cache(thd); + + thd->restore_active_arena(thd->spcont->callers_arena, ¤t_arena); + + return holder; +} + + +bool sp_rcontext::set_case_expr(THD *thd, int case_expr_id, + Item **case_expr_item_ptr) +{ + Item *case_expr_item= thd->sp_prepare_func_item(case_expr_item_ptr, 1); + if (!case_expr_item) + return true; + + if (!m_case_expr_holders[case_expr_id] || + m_case_expr_holders[case_expr_id]->result_type() != + case_expr_item->result_type()) + { + m_case_expr_holders[case_expr_id]= + create_case_expr_holder(thd, case_expr_item); + } + + m_case_expr_holders[case_expr_id]->store(case_expr_item); + m_case_expr_holders[case_expr_id]->cache_value(); + return false; +} + + +/////////////////////////////////////////////////////////////////////////// +// sp_cursor implementation. +/////////////////////////////////////////////////////////////////////////// + + +/* + Open an SP cursor + + SYNOPSIS + open() + THD Thread handler + + + RETURN + 0 in case of success, -1 otherwise +*/ + +int sp_cursor::open(THD *thd) +{ + if (server_side_cursor) + { + my_message(ER_SP_CURSOR_ALREADY_OPEN, + ER_THD(thd, ER_SP_CURSOR_ALREADY_OPEN), + MYF(0)); + return -1; + } + if (mysql_open_cursor(thd, &result, &server_side_cursor)) + return -1; + return 0; +} + + +int sp_cursor::close(THD *thd) +{ + if (! server_side_cursor) + { + my_message(ER_SP_CURSOR_NOT_OPEN, ER_THD(thd, ER_SP_CURSOR_NOT_OPEN), + MYF(0)); + return -1; + } + sp_cursor_statistics::reset(); + destroy(); + return 0; +} + + +void sp_cursor::destroy() +{ + delete server_side_cursor; + server_side_cursor= NULL; +} + + +int sp_cursor::fetch(THD *thd, List *vars, bool error_on_no_data) +{ + if (! server_side_cursor) + { + my_message(ER_SP_CURSOR_NOT_OPEN, ER_THD(thd, ER_SP_CURSOR_NOT_OPEN), + MYF(0)); + return -1; + } + if (vars->elements != result.get_field_count() && + (vars->elements != 1 || + result.get_field_count() != + thd->spcont->get_variable(vars->head()->offset)->cols())) + { + my_message(ER_SP_WRONG_NO_OF_FETCH_ARGS, + ER_THD(thd, ER_SP_WRONG_NO_OF_FETCH_ARGS), MYF(0)); + return -1; + } + + m_fetch_count++; + DBUG_EXECUTE_IF("bug23032_emit_warning", + push_warning(thd, Sql_condition::WARN_LEVEL_WARN, + ER_UNKNOWN_ERROR, + ER_THD(thd, ER_UNKNOWN_ERROR));); + + result.set_spvar_list(vars); + + DBUG_ASSERT(!thd->is_error()); + + /* Attempt to fetch one row */ + if (server_side_cursor->is_open()) + { + server_side_cursor->fetch(1); + if (thd->is_error()) + return -1; // e.g. data type conversion failed + } + + /* + If the cursor was pointing after the last row, the fetch will + close it instead of sending any rows. + */ + if (! server_side_cursor->is_open()) + { + m_found= false; + if (!error_on_no_data) + return 0; + my_message(ER_SP_FETCH_NO_DATA, ER_THD(thd, ER_SP_FETCH_NO_DATA), MYF(0)); + return -1; + } + + m_found= true; + m_row_count++; + return 0; +} + + +bool sp_cursor::export_structure(THD *thd, Row_definition_list *list) +{ + return server_side_cursor->export_structure(thd, list); +} + +/////////////////////////////////////////////////////////////////////////// +// sp_cursor::Select_fetch_into_spvars implementation. +/////////////////////////////////////////////////////////////////////////// + + +int sp_cursor::Select_fetch_into_spvars::prepare(List &fields, + SELECT_LEX_UNIT *u) +{ + /* + Cache the number of columns in the result set in order to easily + return an error if column count does not match value count. + */ + field_count= fields.elements; + return select_result_interceptor::prepare(fields, u); +} + + +bool sp_cursor::Select_fetch_into_spvars:: + send_data_to_variable_list(List &vars, List &items) +{ + List_iterator_fast spvar_iter(vars); + List_iterator_fast item_iter(items); + sp_variable *spvar; + Item *item; + + /* Must be ensured by the caller */ + DBUG_ASSERT(vars.elements == items.elements); + + /* + Assign the row fetched from a server side cursor to stored + procedure variables. + */ + for (; spvar= spvar_iter++, item= item_iter++; ) + { + if (thd->spcont->set_variable(thd, spvar->offset, &item)) + return true; + } + return false; +} + + +int sp_cursor::Select_fetch_into_spvars::send_data(List &items) +{ + Item *item; + /* + If we have only one variable in spvar_list, and this is a ROW variable, + and the number of fields in the ROW variable matches the number of + fields in the query result, we fetch to this ROW variable. + + If there is one variable, and it is a ROW variable, but its number + of fields does not match the number of fields in the query result, + we go through send_data_to_variable_list(). It will report an error + on attempt to assign a scalar value to a ROW variable. + */ + return spvar_list->elements == 1 && + (item= thd->spcont->get_variable(spvar_list->head()->offset)) && + item->type_handler() == &type_handler_row && + item->cols() == items.elements ? + thd->spcont->set_variable_row(thd, spvar_list->head()->offset, items) : + send_data_to_variable_list(*spvar_list, items); +} -- cgit v1.2.3