sp_rcontext.h

/* Copyright (c) 2002, 2013, 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,
   51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */

#ifndef _SP_RCONTEXT_H_
#define _SP_RCONTEXT_H_

#include "sql_class.h"                    // select_result_interceptor
#include "sp_pcontext.h"                  // sp_condition_value

// sp_rcontext declaration.

class sp_cursor;
class sp_instr_cpush;
class Query_arena;
class sp_head;
class Item_cache;

/*
  This class is a runtime context of a Stored Routine. It is used in an
  execution and is intended to contain all dynamic objects (i.e.  objects, which
  can be changed during execution), such as:
    - stored routine variables;
    - cursors;
    - handlers;

  Runtime context is used with sp_head class. sp_head class is intended to
  contain all static things, related to the stored routines (code, for example).
  sp_head instance creates runtime context for the execution of a stored
  routine.

  There is a parsing context (an instance of sp_pcontext class), which is used
  on parsing stage. However, now it contains some necessary for an execution
  things, such as definition of used stored routine variables. That's why
  runtime context needs a reference to the parsing context.
*/

class sp_rcontext : public Sql_alloc
{
public:
  static sp_rcontext *create(THD *thd,
                             const sp_pcontext *root_parsing_ctx,
                             Field *return_value_fld);

  ~sp_rcontext();

private:
  sp_rcontext(const sp_pcontext *root_parsing_ctx,
              Field *return_value_fld,
              bool in_sub_stmt);

  // Prevent use of copying constructor and operator.
  sp_rcontext(const sp_rcontext &);
  void operator=(sp_rcontext &);

private:
  class sp_handler_entry
  {
  public:
    const sp_handler *handler;

    uint first_ip;

    sp_handler_entry(const sp_handler *_handler, uint _first_ip)
     :handler(_handler), first_ip(_first_ip)
    { }
  };

public:
  class Sql_condition_info
  {
  public:
    uint sql_errno;

    Sql_condition::enum_warning_level level;

    char sql_state[SQLSTATE_LENGTH + 1];

    char message[MYSQL_ERRMSG_SIZE];

    Sql_condition_info(uint _sql_errno,
                       const char *_sql_state,
                       Sql_condition::enum_warning_level _level,
                       const char *_message)
     :sql_errno(_sql_errno),
      level(_level)
    {
      memcpy(sql_state, _sql_state, SQLSTATE_LENGTH);
      sql_state[SQLSTATE_LENGTH]= '\0';

      strncpy(message, _message, MYSQL_ERRMSG_SIZE);
    }
  };

private:
  class Handler_call_frame
  {
  public:
    const sp_handler *handler;

    Sql_condition_info sql_condition_info;

    uint continue_ip;

    Handler_call_frame(const sp_handler *_handler,
                       uint _sql_errno,
                       const char *_sql_state,
                       Sql_condition::enum_warning_level _level,
                       const char *_message,
                       uint _continue_ip)
     :handler(_handler),
      sql_condition_info(_sql_errno, _sql_state, _level, _message),
      continue_ip(_continue_ip)
    { }
 };

public:
  Query_arena *callers_arena;

  bool end_partial_result_set;

  sp_head *sp;

  // SP-variables.

  bool set_variable(THD *thd, uint var_idx, Item **value)
  { return set_variable(thd, m_var_table->field[var_idx], value); }

  Item *get_item(uint var_idx) const
  { return m_var_items[var_idx]; }

  Item **get_item_addr(uint var_idx) const
  { return m_var_items.array() + var_idx; }

  bool set_return_value(THD *thd, Item **return_value_item);

  bool is_return_value_set() const
  { return m_return_value_set; }

  // SQL-handlers.

  bool push_handler(sp_handler *handler, uint first_ip);

  void pop_handlers(sp_pcontext *current_scope);

  const Sql_condition_info *raised_condition() const
  {
    return m_activated_handlers.elements() ?
      &(*m_activated_handlers.back())->sql_condition_info : NULL;
  }

  bool handle_sql_condition(THD *thd,
                            uint *ip,
                            const sp_instr *cur_spi);

  void exit_handler(sp_pcontext *target_scope);

  uint get_last_handler_continue_ip() const
  {
    uint ip= (*m_activated_handlers.back())->continue_ip;
    DBUG_ASSERT(ip != 0);

    return ip;
  }

  // Cursors.

  bool push_cursor(sp_instr_cpush *i);

  void pop_cursors(uint count);

  void pop_all_cursors()
  { pop_cursors(m_ccount); }

  sp_cursor *get_cursor(uint i) const
  { return m_cstack[i]; }

  // CASE expressions.

  bool set_case_expr(THD *thd, int case_expr_id, Item **case_expr_item_ptr);

  Item *get_case_expr(int case_expr_id) const
  { return m_case_expr_holders[case_expr_id]; }

  Item ** get_case_expr_addr(int case_expr_id) const
  { return (Item**) m_case_expr_holders.array() + case_expr_id; }

private:
  bool alloc_arrays(THD *thd);

  bool init_var_table(THD *thd);

  bool init_var_items(THD *thd);

  Item_cache *create_case_expr_holder(THD *thd, const Item *item) const;

  bool set_variable(THD *thd, Field *field, Item **value);

private:
  const sp_pcontext *m_root_parsing_ctx;

  TABLE *m_var_table;

  Bounds_checked_array<Item *> m_var_items;

  Field *m_return_value_fld;

  bool m_return_value_set;

  bool m_in_sub_stmt;

  Dynamic_array<sp_handler_entry *> m_visible_handlers;

  Dynamic_array<Handler_call_frame *> m_activated_handlers;

  Bounds_checked_array<sp_cursor *> m_cstack;

  uint m_ccount;

  Bounds_checked_array<Item_cache *> m_case_expr_holders;
}; // class sp_rcontext : public Sql_alloc

// sp_cursor declaration.

class Server_side_cursor;
typedef class st_select_lex_unit SELECT_LEX_UNIT;

/* A mediator between stored procedures and server side cursors */

class sp_cursor
{
private:
  class Select_fetch_into_spvars: public select_result_interceptor
  {
    List<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<sp_variable> *vars) { spvar_list= vars; }

    virtual bool send_eof() { return FALSE; }
    virtual bool send_data(List<Item> &items);
    virtual int prepare(List<Item> &list, SELECT_LEX_UNIT *u);
};

public:
  sp_cursor(sp_instr_cpush *i)
   :m_server_side_cursor(NULL),
    m_push_instr(i)
  { }

  virtual ~sp_cursor()
  { destroy(); }

  bool open(THD *thd);

  bool close(THD *thd);

  bool is_open() const
  { return test(m_server_side_cursor); }

  bool fetch(THD *thd, List<sp_variable> *vars);

  sp_instr_cpush *get_push_instr()
  { return m_push_instr; }

private:
  Select_fetch_into_spvars m_result;

  Server_side_cursor *m_server_side_cursor;
  sp_instr_cpush *m_push_instr;

private:
  void destroy();
}; // class sp_cursor

#endif /* _SP_RCONTEXT_H_ */