Method parse_expr

sql/sp_instr.cc:914–1140

LEX* sp_lex_instr::parse_expr(THD *thd, sp_head *sp, LEX *sp_instr_lex)
{
  sql_query_cache.free();
  get_query(&sql_query_cache);

  if (sql_query_cache.length() == 0)
  {
    /**
      The instruction has returned zero-length query string. That means, the
      re-preparation of the instruction is not possible. We should not come
      here in the normal case.
    */
    assert(false);
    my_error(ER_UNKNOWN_ERROR, MYF(0));
    return nullptr;
  }

  /*
    Remember a pointer to the next list of Item_trigger_field objects.
    The current list of Item_trigger_field objects is cleared up in the
    method cleanup_before_parsing().
  */
  SQL_I_List<Item_trigger_field> *saved_ptr_to_next_trg_items_list= nullptr;

  if (m_cur_trigger_stmt_items.elements)
    saved_ptr_to_next_trg_items_list=
      m_cur_trigger_stmt_items.first->next_trig_field_list;

  /*
    Clean up items owned by this SP instruction except instances of Item_param.
    `sp_statement_param_values` stores instances of the class Item_param
    associated with the SP instruction's statement before the statement
    has been re-parsed.
  */
  List<Item_param> sp_statement_param_values=
    cleanup_before_parsing(sp->m_handler->type());
  DBUG_ASSERT(mem_root != thd->mem_root);
  /*
    Back up the current free_list pointer and reset it to nullptr.
    Set thd->mem_root pointing to a mem_root of SP instruction being re-parsed.
    In that way any items created on parsing a statement of the current
    instruction is allocated on SP instruction's mem_root and placed on its own
    free_list that later assigned to the current sp_instr. We use the separate
    free list for every instruction since at least at one place in the source
    code (the function subst_spvars() to be accurate) we iterate along the
    list sp_instr->free_list on executing of every SP instruction.
  */
  Query_arena backup;
  /*
    A statement of SP instruction is going to be re-parsed, so reset
    SP arena's state to STMT_INITIALIZED_FOR_SP as its initial state.
  */
  state= STMT_INITIALIZED_FOR_SP;

  /*
    First, set up a mem_root for the statement is going to re-compile.
  */
  bool mem_root_allocated;