sp_instr.h

/* Copyright (c) 2012, 2014, 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-1301  USA */

#ifndef _SP_INSTR_H_
#define _SP_INSTR_H_

#include "my_global.h"    // NO_EMBEDDED_ACCESS_CHECKS
#include "sp_pcontext.h"  // sp_pcontext
#include "sql_class.h"    // THD
#include "sp_head.h"      // sp_printable

// This file contains SP-instruction classes.

class sp_branch_instr
{
public:
  virtual void set_destination(uint old_dest, uint new_dest) = 0;

  virtual void backpatch(uint dest) = 0;

  virtual ~sp_branch_instr()
  { }
};


class sp_instr : public Query_arena,
                 public Sql_alloc,
                 public sp_printable
{
public:
  sp_instr(uint ip, sp_pcontext *ctx)
   :Query_arena(0, STMT_INITIALIZED_FOR_SP),
    m_marked(false),
    m_ip(ip),
    m_parsing_ctx(ctx)
  { }

  virtual ~sp_instr()
  { free_items(); }

  virtual bool execute(THD *thd, uint *nextp) = 0;

  uint get_ip() const
  { return m_ip; }

  virtual uint get_cont_dest() const
  { return get_ip() + 1; }

  sp_pcontext *get_parsing_ctx() const
  { return m_parsing_ctx; }

  // The following operations are used solely for SP-code-optimizer.

  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads)
  {
    m_marked= true;
    return get_ip() + 1;
  }

  virtual uint opt_shortcut_jump(sp_head *sp, sp_instr *start)
  { return get_ip(); }

  virtual void opt_move(uint dst, List<sp_branch_instr> *ibp)
  { m_ip= dst; }

  bool opt_is_marked() const
  { return m_marked; }

  virtual SQL_I_List<Item_trigger_field>* get_instr_trig_field_list()
  { return NULL; }

protected:
  bool m_marked;

  uint m_ip;

  sp_pcontext *m_parsing_ctx;

private:
  // Prevent use of copy constructor and assignment operator.
  sp_instr(const sp_instr &);
  void operator= (sp_instr &);
};


class sp_lex_instr : public sp_instr
{
public:
  sp_lex_instr(uint ip, sp_pcontext *ctx, LEX *lex, bool is_lex_owner)
   :sp_instr(ip, ctx),
    m_lex(NULL),
    m_is_lex_owner(false),
    m_first_execution(true),
    m_prelocking_tables(NULL),
    m_lex_query_tables_own_last(NULL)
  {
    set_lex(lex, is_lex_owner);
    memset(&m_lex_mem_root, 0, sizeof (MEM_ROOT));
  }

  virtual ~sp_lex_instr()
  {
    free_lex();
    /*
      If the instruction is reparsed, m_lex_mem_root was used to allocate
      the items, then freeing the memroot, frees the items. Also free the
      items allocated on heap as well.
    */
    if (alloc_root_inited(&m_lex_mem_root))
      free_items();
    free_root(&m_lex_mem_root, MYF(0));
  }

  bool validate_lex_and_execute_core(THD *thd, uint *nextp, bool open_tables);

  virtual SQL_I_List<Item_trigger_field>* get_instr_trig_field_list()
  { return &m_trig_field_list; }

private:
  bool reset_lex_and_exec_core(THD *thd, uint *nextp, bool open_tables);

  LEX *parse_expr(THD *thd, sp_head *sp);

  void set_lex(LEX *lex, bool is_lex_owner);

  void free_lex();

public:
  // sp_instr implementation.

  virtual bool execute(THD *thd, uint *nextp)
  { return validate_lex_and_execute_core(thd, nextp, true); }

protected:
  // Interface (virtual) methods.

  virtual bool exec_core(THD *thd, uint *nextp) = 0;

  virtual bool is_invalid() const = 0;

  virtual void invalidate() = 0;

  virtual void get_query(String *sql_query) const;

  virtual LEX_STRING get_expr_query() const
  { return EMPTY_STR; }

  virtual bool on_after_expr_parsing(THD *thd)
  { return false; }

  virtual void cleanup_before_parsing(THD *thd);

private:
  MEM_ROOT m_lex_mem_root;

  LEX *m_lex;

  bool m_is_lex_owner;

  bool m_first_execution;

  /*****************************************************************************
    Support for being able to execute this statement in two modes:
    a) inside prelocked mode set by the calling procedure or its ancestor.
    b) outside of prelocked mode, when this statement enters/leaves
       prelocked mode itself.
  *****************************************************************************/

  TABLE_LIST *m_prelocking_tables;

  TABLE_LIST **m_lex_query_tables_own_last;

  SQL_I_List<Item_trigger_field> m_trig_field_list;
};


class sp_instr_stmt : public sp_lex_instr
{
public:
  sp_instr_stmt(uint ip,
                LEX *lex,
                LEX_STRING query)
   :sp_lex_instr(ip, lex->get_sp_current_parsing_ctx(), lex, true),
    m_query(query),
    m_valid(true)
  { }

  // sp_instr implementation.

  virtual bool execute(THD *thd, uint *nextp);

  // sp_printable implementation.

  virtual void print(String *str);

  // sp_lex_instr implementation.

  virtual bool exec_core(THD *thd, uint *nextp);

  virtual bool is_invalid() const
  { return !m_valid; }

  virtual void invalidate()
  { m_valid= false; }

  virtual void get_query(String *sql_query) const
  { sql_query->append(m_query.str, m_query.length); }

  virtual bool on_after_expr_parsing(THD *thd)
  {
    m_valid= true;
    return false;
  }

private:
  LEX_STRING m_query;

  bool m_valid;
};


class sp_instr_set : public sp_lex_instr
{
public:
  sp_instr_set(uint ip,
               LEX *lex,
               uint offset,
               Item *value_item,
               LEX_STRING value_query,
               bool is_lex_owner)
   :sp_lex_instr(ip, lex->get_sp_current_parsing_ctx(), lex, is_lex_owner),
    m_offset(offset),
    m_value_item(value_item),
    m_value_query(value_query)
  { }

  // sp_printable implementation.

  virtual void print(String *str);

  // sp_lex_instr implementation.

  virtual bool exec_core(THD *thd, uint *nextp);

  virtual bool is_invalid() const
  { return m_value_item == NULL; }

  virtual void invalidate()
  { m_value_item= NULL; }

  virtual bool on_after_expr_parsing(THD *thd)
  {
    DBUG_ASSERT(thd->lex->select_lex.item_list.elements == 1);

    m_value_item= thd->lex->select_lex.item_list.head();

    return false;
  }

  virtual LEX_STRING get_expr_query() const
  { return m_value_query; }

private:
  uint m_offset;

  Item *m_value_item;

  LEX_STRING m_value_query;
};


class sp_instr_set_trigger_field : public sp_lex_instr
{
public:
  sp_instr_set_trigger_field(uint ip,
                             LEX *lex,
                             LEX_STRING trigger_field_name,
                             Item_trigger_field *trigger_field,
                             Item *value_item,
                             LEX_STRING value_query)
   :sp_lex_instr(ip, lex->get_sp_current_parsing_ctx(), lex, true),
    m_trigger_field_name(trigger_field_name),
    m_trigger_field(trigger_field),
    m_value_item(value_item),
    m_value_query(value_query)
  { }

  // sp_printable implementation.

  virtual void print(String *str);

  // sp_lex_instr implementation.

  virtual bool exec_core(THD *thd, uint *nextp);

  virtual bool is_invalid() const
  { return m_value_item == NULL; }

  virtual void invalidate()
  { m_value_item= NULL; }

  virtual bool on_after_expr_parsing(THD *thd);

  virtual void cleanup_before_parsing(THD *thd);

  virtual LEX_STRING get_expr_query() const
  { return m_value_query; }

private:
  LEX_STRING m_trigger_field_name;

  Item_trigger_field *m_trigger_field;

  Item *m_value_item;

  LEX_STRING m_value_query;
};


class sp_instr_freturn : public sp_lex_instr
{
public:
  sp_instr_freturn(uint ip,
                   LEX *lex,
                   Item *expr_item,
                   LEX_STRING expr_query,
                   enum enum_field_types return_field_type)
   :sp_lex_instr(ip, lex->get_sp_current_parsing_ctx(), lex, true),
    m_expr_item(expr_item),
    m_expr_query(expr_query),
    m_return_field_type(return_field_type)
  { }

  // sp_printable implementation.

  virtual void print(String *str);

  // sp_instr implementation.

  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads)
  {
    m_marked= true;
    return UINT_MAX;
  }

  // sp_lex_instr implementation.

  virtual bool exec_core(THD *thd, uint *nextp);

  virtual bool is_invalid() const
  { return m_expr_item == NULL; }

  virtual void invalidate()
  {
    // it's already deleted.
    m_expr_item= NULL;
  }

  virtual bool on_after_expr_parsing(THD *thd)
  {
    DBUG_ASSERT(thd->lex->select_lex.item_list.elements == 1);

    m_expr_item= thd->lex->select_lex.item_list.head();

    return false;
  }

  virtual LEX_STRING get_expr_query() const
  { return m_expr_query; }

private:
  Item *m_expr_item;

  LEX_STRING m_expr_query;

  enum enum_field_types m_return_field_type;
};


class sp_instr_jump : public sp_instr,
                      public sp_branch_instr
{
public:
  sp_instr_jump(uint ip, sp_pcontext *ctx)
   :sp_instr(ip, ctx),
    m_dest(0),
    m_optdest(NULL)
  { }

  sp_instr_jump(uint ip, sp_pcontext *ctx, uint dest)
   :sp_instr(ip, ctx),
    m_dest(dest),
    m_optdest(NULL)
  { }

  // sp_printable implementation.

  virtual void print(String *str);

  // sp_instr implementation.

  virtual bool execute(THD *thd, uint *nextp)
  {
    *nextp= m_dest;
    return false;
  }

  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads);

  virtual uint opt_shortcut_jump(sp_head *sp, sp_instr *start);

  virtual void opt_move(uint dst, List<sp_branch_instr> *ibp);

  // sp_branch_instr implementation.

  virtual void set_destination(uint old_dest, uint new_dest)
  {
    if (m_dest == old_dest)
      m_dest= new_dest;
  }

  virtual void backpatch(uint dest)
  {
    /* Calling backpatch twice is a logic flaw in jump resolution. */
    DBUG_ASSERT(m_dest == 0);
    m_dest= dest;
  }

protected:
  uint m_dest;

  // The following attribute is used by SP-optimizer.
  sp_instr *m_optdest;
};


class sp_lex_branch_instr : public sp_lex_instr,
                            public sp_branch_instr
{
protected:
  sp_lex_branch_instr(uint ip, sp_pcontext *ctx, LEX *lex,
                      Item *expr_item, LEX_STRING expr_query)
   :sp_lex_instr(ip, ctx, lex, true),
    m_dest(0),
    m_cont_dest(0),
    m_optdest(NULL),
    m_cont_optdest(NULL),
    m_expr_item(expr_item),
    m_expr_query(expr_query)
  { }

  sp_lex_branch_instr(uint ip, sp_pcontext *ctx, LEX *lex,
                      Item *expr_item, LEX_STRING expr_query,
                      uint dest)
   :sp_lex_instr(ip, ctx, lex, true),
    m_dest(dest),
    m_cont_dest(0),
    m_optdest(NULL),
    m_cont_optdest(NULL),
    m_expr_item(expr_item),
    m_expr_query(expr_query)
  { }

public:
  void set_cont_dest(uint cont_dest)
  { m_cont_dest= cont_dest; }

  // sp_instr implementation.

  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads);

  virtual void opt_move(uint dst, List<sp_branch_instr> *ibp);

  virtual uint get_cont_dest() const
  { return m_cont_dest; }

  // sp_lex_instr implementation.

  virtual bool is_invalid() const
  { return m_expr_item == NULL; }

  virtual void invalidate()
  { m_expr_item= NULL; /* it's already deleted. */ }

  virtual LEX_STRING get_expr_query() const
  { return m_expr_query; }

  // sp_branch_instr implementation.

  virtual void set_destination(uint old_dest, uint new_dest)
  {
    if (m_dest == old_dest)
      m_dest= new_dest;

    if (m_cont_dest == old_dest)
      m_cont_dest= new_dest;
  }

  virtual void backpatch(uint dest)
  {
    /* Calling backpatch twice is a logic flaw in jump resolution. */
    DBUG_ASSERT(m_dest == 0);
    m_dest= dest;
  }

protected:
  uint m_dest;

  uint m_cont_dest;

  // The following attributes are used by SP-optimizer.
  sp_instr *m_optdest;
  sp_instr *m_cont_optdest;

  Item *m_expr_item;

  LEX_STRING m_expr_query;
};


class sp_instr_jump_if_not : public sp_lex_branch_instr
{
public:
  sp_instr_jump_if_not(uint ip,
                       LEX *lex,
                       Item *expr_item,
                       LEX_STRING expr_query)
   :sp_lex_branch_instr(ip, lex->get_sp_current_parsing_ctx(), lex,
                        expr_item, expr_query)
  { }

  sp_instr_jump_if_not(uint ip,
                       LEX *lex,
                       Item *expr_item,
                       LEX_STRING expr_query,
                       uint dest)
   :sp_lex_branch_instr(ip, lex->get_sp_current_parsing_ctx(), lex,
                        expr_item, expr_query, dest)
  { }

  // sp_printable implementation.

  virtual void print(String *str);

  // sp_lex_instr implementation.

  virtual bool exec_core(THD *thd, uint *nextp);

  virtual bool on_after_expr_parsing(THD *thd)
  {
    DBUG_ASSERT(thd->lex->select_lex.item_list.elements == 1);

    m_expr_item= thd->lex->select_lex.item_list.head();

    return false;
  }
};

// Instructions used for the "simple CASE" implementation.

class sp_instr_set_case_expr : public sp_lex_branch_instr
{
public:
  sp_instr_set_case_expr(uint ip,
                         LEX *lex,
                         uint case_expr_id,
                         Item *case_expr_item,
                         LEX_STRING case_expr_query)
   :sp_lex_branch_instr(ip, lex->get_sp_current_parsing_ctx(), lex,
                        case_expr_item, case_expr_query),
    m_case_expr_id(case_expr_id)
  { }

  // sp_printable implementation.

  virtual void print(String *str);

  // sp_instr implementation.

  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads);

  virtual void opt_move(uint dst, List<sp_branch_instr> *ibp);

  // sp_branch_instr implementation.

  /*
    NOTE: set_destination() and backpatch() are overriden here just because the
    m_dest attribute is not used by this class, so there is no need to do
    anything about it.

    @todo These operations probably should be left as they are (i.e. do not
    override them here). The m_dest attribute would be set and not used, but
    that should not be a big deal.

    @todo This also indicates deficiency of the current SP-istruction class
    hierarchy.
  */

  virtual void set_destination(uint old_dest, uint new_dest)
  {
    if (m_cont_dest == old_dest)
      m_cont_dest= new_dest;
  }

  virtual void backpatch(uint dest)
  { }

  // sp_lex_instr implementation.

  virtual bool exec_core(THD *thd, uint *nextp);

  virtual bool on_after_expr_parsing(THD *thd)
  {
    DBUG_ASSERT(thd->lex->select_lex.item_list.elements == 1);

    m_expr_item= thd->lex->select_lex.item_list.head();

    return false;
  }

private:
  uint m_case_expr_id;
};


class sp_instr_jump_case_when : public sp_lex_branch_instr
{
public:
  sp_instr_jump_case_when(uint ip,
                          LEX *lex,
                          int case_expr_id,
                          Item *when_expr_item,
                          LEX_STRING when_expr_query)
   :sp_lex_branch_instr(ip, lex->get_sp_current_parsing_ctx(), lex,
                        when_expr_item, when_expr_query),
    m_case_expr_id(case_expr_id)
  { }

  // sp_printable implementation.

  virtual void print(String *str);

  // sp_lex_instr implementation.

  virtual bool exec_core(THD *thd, uint *nextp);

  virtual void invalidate()
  {
    // Items should be already deleted in lex-keeper.
    m_case_expr_item= NULL;
    m_eq_item= NULL;
    m_expr_item= NULL; // it's a WHEN-expression.
  }

  virtual bool on_after_expr_parsing(THD *thd)
  { return build_expr_items(thd); }

private:
  bool build_expr_items(THD *thd);

private:
  int m_case_expr_id;

  Item_case_expr *m_case_expr_item;

  Item *m_eq_item;
};

// SQL-condition handler instructions.

class sp_instr_hpush_jump : public sp_instr_jump
{
public:
  sp_instr_hpush_jump(uint ip,
                      sp_pcontext *ctx,
                      sp_handler *handler)
   :sp_instr_jump(ip, ctx),
    m_handler(handler),
    m_opt_hpop(0),
    m_frame(ctx->current_var_count())
  {
    DBUG_ASSERT(m_handler->condition_values.elements == 0);
  }

  virtual ~sp_instr_hpush_jump()
  {
    m_handler->condition_values.empty();
    m_handler= NULL;
  }

  void add_condition(sp_condition_value *condition_value)
  { m_handler->condition_values.push_back(condition_value); }

  sp_handler *get_handler()
  { return m_handler; }

  // sp_printable implementation.

  virtual void print(String *str);

  // sp_instr implementation.

  virtual bool execute(THD *thd, uint *nextp);

  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads);

  virtual uint opt_shortcut_jump(sp_head *sp, sp_instr *start)
  { return get_ip(); }

  // sp_branch_instr implementation.

  virtual void backpatch(uint dest)
  {
    DBUG_ASSERT(!m_dest || !m_opt_hpop);
    if (!m_dest)
      m_dest= dest;
    else
      m_opt_hpop= dest;
  }

private:
  sp_handler *m_handler;

  uint m_opt_hpop;

  // This attribute is needed for SHOW PROCEDURE CODE only (i.e. it's needed in
  // debug version only). It's used in print().
  uint m_frame;
};


class sp_instr_hpop : public sp_instr
{
public:
  sp_instr_hpop(uint ip, sp_pcontext *ctx)
    : sp_instr(ip, ctx)
  { }

  // sp_printable implementation.

  virtual void print(String *str)
  { str->append(STRING_WITH_LEN("hpop")); }

  // sp_instr implementation.

  virtual bool execute(THD *thd, uint *nextp);
};


class sp_instr_hreturn : public sp_instr_jump
{
public:
  sp_instr_hreturn(uint ip, sp_pcontext *ctx)
   :sp_instr_jump(ip, ctx),
    m_frame(ctx->current_var_count())
  { }

  // sp_printable implementation.

  virtual void print(String *str);

  // sp_instr implementation.

  virtual bool execute(THD *thd, uint *nextp);

  virtual uint opt_shortcut_jump(sp_head *sp, sp_instr *start)
  { return get_ip(); }

  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads);

private:
  // This attribute is needed for SHOW PROCEDURE CODE only (i.e. it's needed in
  // debug version only). It's used in print().
  uint m_frame;
};

// Cursor implementation.

class sp_instr_cpush : public sp_lex_instr
{
public:
  sp_instr_cpush(uint ip,
                 sp_pcontext *ctx,
                 LEX *cursor_lex,
                 LEX_STRING cursor_query,
                 int cursor_idx)
   :sp_lex_instr(ip, ctx, cursor_lex, true),
    m_cursor_query(cursor_query),
    m_valid(true),
    m_cursor_idx(cursor_idx)
  {
    // Cursor can't be stored in Query Cache, so we should prevent opening QC
    // for try to write results which are absent.

    cursor_lex->safe_to_cache_query= false;
  }

  // sp_printable implementation.

  virtual void print(String *str);

  // Query_arena implementation.

  virtual void cleanup_stmt()
  { /* no op */ }

  // sp_instr implementation.

  virtual bool execute(THD *thd, uint *nextp);

  // sp_lex_instr implementation.

  virtual bool exec_core(THD *thd, uint *nextp);

  virtual bool is_invalid() const
  { return !m_valid; }

  virtual void invalidate()
  { m_valid= false; }

  virtual void get_query(String *sql_query) const
  { sql_query->append(m_cursor_query.str, m_cursor_query.length); }

  virtual bool on_after_expr_parsing(THD *thd)
  {
    m_valid= true;
    return false;
  }

private:
  LEX_STRING m_cursor_query;

  bool m_valid;

  int m_cursor_idx;
};


class sp_instr_cpop : public sp_instr
{
public:
  sp_instr_cpop(uint ip, sp_pcontext *ctx, uint count)
   :sp_instr(ip, ctx),
    m_count(count)
  { }

  // sp_printable implementation.

  virtual void print(String *str);

  // sp_instr implementation.

  virtual bool execute(THD *thd, uint *nextp);

private:
  uint m_count;
};


class sp_instr_copen : public sp_instr
{
public:
  sp_instr_copen(uint ip, sp_pcontext *ctx, int cursor_idx)
   :sp_instr(ip, ctx),
    m_cursor_idx(cursor_idx)
  { }

  // sp_printable implementation.

  virtual void print(String *str);

  // sp_instr implementation.

  virtual bool execute(THD *thd, uint *nextp);

private:
  int m_cursor_idx;
};


class sp_instr_cclose : public sp_instr
{
public:
  sp_instr_cclose(uint ip, sp_pcontext *ctx, int cursor_idx)
   :sp_instr(ip, ctx),
    m_cursor_idx(cursor_idx)
  { }

  // sp_printable implementation.

  virtual void print(String *str);

  // sp_instr implementation.

  virtual bool execute(THD *thd, uint *nextp);

private:
  int m_cursor_idx;
};


class sp_instr_cfetch : public sp_instr
{
public:
  sp_instr_cfetch(uint ip, sp_pcontext *ctx, int cursor_idx)
   :sp_instr(ip, ctx),
    m_cursor_idx(cursor_idx)
  { }

  // sp_printable implementation.

  virtual void print(String *str);

  // sp_instr implementation.

  virtual bool execute(THD *thd, uint *nextp);

  void add_to_varlist(sp_variable *var)
  { m_varlist.push_back(var); }

private:
  List<sp_variable> m_varlist;

  int m_cursor_idx;
};


class sp_instr_error : public sp_instr
{
public:
  sp_instr_error(uint ip, sp_pcontext *ctx, int errcode)
   :sp_instr(ip, ctx),
    m_errcode(errcode)
  { }

  // sp_printable implementation.

  virtual void print(String *str);

  // sp_instr implementation.

  virtual bool execute(THD *thd, uint *nextp)
  {
    my_message(m_errcode, ER(m_errcode), MYF(0));
    *nextp= get_ip() + 1;
    return true;
  }

  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads)
  {
    m_marked= true;
    return UINT_MAX;
  }

private:
  int m_errcode;
};


#endif // _SP_INSTR_H_