sp_head.h

/* Copyright (c) 2002, 2012, 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_HEAD_H_
#define _SP_HEAD_H_

/*
  It is necessary to include set_var.h instead of item.h because there
  are dependencies on include order for set_var.h and item.h. This
  will be resolved later.
*/
#include "my_global.h"                          /* NO_EMBEDDED_ACCESS_CHECKS */
#include "sql_class.h"                          // THD, set_var.h: THD
#include "set_var.h"                            // Item
#include "sp_pcontext.h"                        // sp_pcontext

class sp_instr;
class sp_branch_instr;
class sp_lex_branch_instr;


class sp_printable
{
public:
  virtual void print(String *str) = 0;

  virtual ~sp_printable()
  { }
};


class Stored_program_creation_ctx : public Default_object_creation_ctx
{
public:
  const CHARSET_INFO *get_db_cl()
  {
    return m_db_cl;
  }

public:
  virtual Stored_program_creation_ctx *clone(MEM_ROOT *mem_root) = 0;

protected:
  Stored_program_creation_ctx(THD *thd)
    : Default_object_creation_ctx(thd),
      m_db_cl(thd->variables.collation_database)
  { }

  Stored_program_creation_ctx(const CHARSET_INFO *client_cs,
                              const CHARSET_INFO *connection_cl,
                              const CHARSET_INFO *db_cl)
    : Default_object_creation_ctx(client_cs, connection_cl),
      m_db_cl(db_cl)
  { }

protected:
  virtual void change_env(THD *thd) const
  {
    thd->variables.collation_database= m_db_cl;

    Default_object_creation_ctx::change_env(thd);
  }

protected:
  const CHARSET_INFO *m_db_cl;
};


class sp_name : public Sql_alloc
{
public:

  LEX_STRING m_db;
  LEX_STRING m_name;
  LEX_STRING m_qname;
  bool       m_explicit_name;                   
  sp_name(LEX_STRING db, LEX_STRING name, bool use_explicit_name)
    : m_db(db), m_name(name), m_explicit_name(use_explicit_name)
  {
    m_qname.str= 0;
    m_qname.length= 0;
  }

  sp_name(const MDL_key *key, char *qname_buff);

  // Init. the qualified name from the db and name.
  void init_qname(THD *thd);    // thd for memroot allocation
};


class sp_parser_data
{
private:
  struct Backpatch_info
  {
    sp_label *label;
    sp_branch_instr *instr;
  };

public:
  sp_parser_data() :
    m_expr_start_ptr(NULL),
    m_current_stmt_start_ptr(NULL),
    m_option_start_ptr(NULL),
    m_param_start_ptr(NULL),
    m_param_end_ptr(NULL),
    m_body_start_ptr(NULL),
    m_cont_level(0),
    m_saved_memroot(NULL),
    m_saved_free_list(NULL)
  { }


  void start_parsing_sp_body(THD *thd, sp_head *sp);

  void finish_parsing_sp_body(THD *thd)
  {
    /*
      In some cases the parser detects a syntax error and calls
      LEX::cleanup_lex_after_parse_error() method only after finishing parsing
      the whole routine. In such a situation sp_head::restore_thd_mem_root() will
      be called twice - the first time as part of normal parsing process and the
      second time by cleanup_lex_after_parse_error().

      To avoid ruining active arena/mem_root state in this case we skip
      restoration of old arena/mem_root if this method has been already called for
      this routine.
    */
    if (!is_parsing_sp_body())
      return;

    thd->free_items();
    thd->mem_root= m_saved_memroot;
    thd->free_list= m_saved_free_list;

    m_saved_memroot= NULL;
    m_saved_free_list= NULL;
  }

  bool is_parsing_sp_body() const
  { return m_saved_memroot != NULL; }


  void process_new_sp_instr(THD *thd, sp_instr *i);


  const char *pop_expr_start_ptr()
  {
#ifndef DBUG_OFF
    DBUG_ASSERT(m_expr_start_ptr);
    const char *p= m_expr_start_ptr;
    m_expr_start_ptr= NULL;
    return p;
#else
    return m_expr_start_ptr;
#endif
  }

  void push_expr_start_ptr(const char *expr_start_ptr)
  {
    DBUG_ASSERT(!m_expr_start_ptr);
    m_expr_start_ptr= expr_start_ptr;
  }


  const char *get_current_stmt_start_ptr() const
  { return m_current_stmt_start_ptr; }

  void set_current_stmt_start_ptr(const char *stmt_start_ptr)
  { m_current_stmt_start_ptr= stmt_start_ptr; }


  const char *get_option_start_ptr() const
  { return m_option_start_ptr; }

  void set_option_start_ptr(const char *option_start_ptr)
  { m_option_start_ptr= option_start_ptr; }


  const char *get_parameter_start_ptr() const
  { return m_param_start_ptr; }

  void set_parameter_start_ptr(const char *ptr)
  { m_param_start_ptr= ptr; }

  const char *get_parameter_end_ptr() const
  { return m_param_end_ptr; }

  void set_parameter_end_ptr(const char *ptr)
  { m_param_end_ptr= ptr; }


  const char *get_body_start_ptr() const
  { return m_body_start_ptr; }

  void set_body_start_ptr(const char *ptr)
  { m_body_start_ptr= ptr; }


  void push_lex(LEX *lex)
  { m_lex_stack.push_front(lex); }

  LEX *pop_lex()
  { return m_lex_stack.pop(); }

  // Backpatch-list operations.

  bool add_backpatch_entry(sp_branch_instr *i, sp_label *label);

  void do_backpatch(sp_label *label, uint dest);

  // Backpatch operations for supporting CONTINUE handlers.

  bool new_cont_backpatch()
  {
    ++m_cont_level;
    return false;
  }

  bool add_cont_backpatch_entry(sp_lex_branch_instr *i);

  void do_cont_backpatch(uint dest);

private:
  const char *m_expr_start_ptr;

  const char *m_current_stmt_start_ptr;

  const char *m_option_start_ptr;

  List<LEX> m_lex_stack;

  const char *m_param_start_ptr;

  const char *m_param_end_ptr;

  const char *m_body_start_ptr;

  List<Backpatch_info> m_backpatch;

  List<sp_lex_branch_instr> m_cont_backpatch;

  uint m_cont_level;

  /**********************************************************************
    The following attributes are used to store THD values during parsing
    of stored program body.

    @sa start_parsing_sp_body()
    @sa finish_parsing_sp_body()
  **********************************************************************/

  MEM_ROOT *m_saved_memroot;

  Item *m_saved_free_list;
};


class sp_head : private Query_arena
{
public:
  enum {
    HAS_RETURN= 1,              // For FUNCTIONs only: is set if has RETURN
    MULTI_RESULTS= 8,           // Is set if a procedure with SELECT(s)
    CONTAINS_DYNAMIC_SQL= 16,   // Is set if a procedure with PREPARE/EXECUTE
    IS_INVOKED= 32,             // Is set if this sp_head is being used
    HAS_SET_AUTOCOMMIT_STMT= 64,// Is set if a procedure with 'set autocommit'
    /* Is set if a procedure with COMMIT (implicit or explicit) | ROLLBACK */
    HAS_COMMIT_OR_ROLLBACK= 128,
    LOG_SLOW_STATEMENTS= 256,   // Used by events
    LOG_GENERAL_LOG= 512,        // Used by events
    HAS_SQLCOM_RESET= 1024,
    HAS_SQLCOM_FLUSH= 2048,

    MODIFIES_DATA= 4096
  };

public:
  /************************************************************************
    Public attributes.
  ************************************************************************/

  enum_sp_type m_type;

  uint m_flags;

  Create_field m_return_field_def;

  sp_parser_data m_parser_data;

  st_sp_chistics *m_chistics;

  sql_mode_t m_sql_mode;

  LEX_STRING m_qname;

  bool m_explicit_name;         

  LEX_STRING m_db;
  LEX_STRING m_name;
  LEX_STRING m_params;
  LEX_STRING m_body;
  LEX_STRING m_body_utf8;
  LEX_STRING m_defstr;
  LEX_STRING m_definer_user;
  LEX_STRING m_definer_host;

  longlong m_created;
  longlong m_modified;

  ulong m_recursion_level;

  sp_head *m_next_cached_sp;

  sp_head *m_first_instance;

  sp_head *m_first_free_instance;

  sp_head *m_last_cached_sp;

  HASH m_sroutines;

  /*
    Security context for stored routine which should be run under
    definer privileges.
  */
  Security_context m_security_ctx;

  // Trigger-specific public attributes.

  SQL_I_List<Item_trigger_field> m_trg_table_fields;

  st_trg_chistics m_trg_chistics;

  class Table_triggers_list *m_trg_list;

public:
  static void *operator new(size_t size) throw ();
  static void operator delete(void *ptr, size_t size) throw ();

  ~sp_head();

  bool is_invoked() const
  { return m_flags & IS_INVOKED; }

  ulong sp_cache_version() const
  { return m_sp_cache_version; }

  void set_sp_cache_version(ulong sp_cache_version)
  { m_sp_cache_version= sp_cache_version; }

  Stored_program_creation_ctx *get_creation_ctx()
  { return m_creation_ctx; }

  void set_creation_ctx(Stored_program_creation_ctx *creation_ctx)
  { m_creation_ctx= creation_ctx->clone(mem_root); }

  void set_body_start(THD *thd, const char *begin_ptr);

  void set_body_end(THD *thd);

  bool execute_trigger(THD *thd,
                       const LEX_STRING *db_name,
                       const LEX_STRING *table_name,
                       GRANT_INFO *grant_info);

  bool execute_function(THD *thd, Item **args, uint argcount,
                        Field *return_fld);

  bool execute_procedure(THD *thd, List<Item> *args);

  bool show_create_routine(THD *thd, enum_sp_type type);

  bool add_instr(THD *thd, sp_instr *instr);

  bool modifies_data() const
  { return m_flags & MODIFIES_DATA; }

  uint instructions()
  { return m_instructions.elements(); }

  sp_instr *last_instruction()
  { return *m_instructions.back(); }

  bool reset_lex(THD *thd);

  bool restore_lex(THD *thd);

  char *name(uint *lenp = 0) const
  {
    if (lenp)
      *lenp= (uint) m_name.length;
    return m_name.str;
  }

  char *create_string(THD *thd, ulong *lenp);

  Field *create_result_field(uint field_max_length,
                             const char *field_name,
                             TABLE *table);

  void set_info(longlong created,
                longlong modified,
                st_sp_chistics *chistics,
                sql_mode_t sql_mode);

  void set_definer(const char *definer, uint definerlen);
  void set_definer(const LEX_STRING *user_name, const LEX_STRING *host_name);

  void optimize();

  void add_mark_lead(uint ip, List<sp_instr> *leads);

  sp_instr *get_instr(uint i)
  {
    return (i < (uint) m_instructions.elements()) ? m_instructions.at(i) : NULL;
  }

  bool add_used_tables_to_table_list(THD *thd,
                                     TABLE_LIST ***query_tables_last_ptr,
                                     TABLE_LIST *belong_to_view);

  bool is_not_allowed_in_function(const char *where)
  {
    if (m_flags & CONTAINS_DYNAMIC_SQL)
      my_error(ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0), "Dynamic SQL");
    else if (m_flags & MULTI_RESULTS)
      my_error(ER_SP_NO_RETSET, MYF(0), where);
    else if (m_flags & HAS_SET_AUTOCOMMIT_STMT)
      my_error(ER_SP_CANT_SET_AUTOCOMMIT, MYF(0));
    else if (m_flags & HAS_COMMIT_OR_ROLLBACK)
      my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    else if (m_flags & HAS_SQLCOM_RESET)
      my_error(ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0), "RESET");
    else if (m_flags & HAS_SQLCOM_FLUSH)
      my_error(ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0), "FLUSH");

    return test(m_flags &
                (CONTAINS_DYNAMIC_SQL|MULTI_RESULTS|HAS_SET_AUTOCOMMIT_STMT|
                 HAS_COMMIT_OR_ROLLBACK|HAS_SQLCOM_RESET|HAS_SQLCOM_FLUSH));
  }

#ifndef DBUG_OFF

  bool show_routine_code(THD *thd);
#endif

  /*
    This method is intended for attributes of a routine which need
    to propagate upwards to the Query_tables_list of the caller (when
    a property of a sp_head needs to "taint" the calling statement).
  */
  void propagate_attributes(Query_tables_list *prelocking_ctx)
  {
    /*
      If this routine needs row-based binary logging, the entire top statement
      too (we cannot switch from statement-based to row-based only for this
      routine, as in statement-based the top-statement may be binlogged and
      the sub-statements not).
    */
    DBUG_PRINT("info", ("lex->get_stmt_unsafe_flags(): 0x%x",
                        prelocking_ctx->get_stmt_unsafe_flags()));
    DBUG_PRINT("info", ("sp_head(0x%p=%s)->unsafe_flags: 0x%x",
                        this, name(), unsafe_flags));
    prelocking_ctx->set_stmt_unsafe_flags(unsafe_flags);
  }

  sp_pcontext *get_root_parsing_context() const
  { return const_cast<sp_pcontext *> (m_root_parsing_ctx); }

  MEM_ROOT *get_persistent_mem_root() const
  { return const_cast<MEM_ROOT *> (&main_mem_root); }

  MEM_ROOT *get_current_mem_root() const
  { return const_cast<MEM_ROOT *> (mem_root); }

  bool check_show_access(THD *thd, bool *full_access);

#ifndef NO_EMBEDDED_ACCESS_CHECKS

  bool set_security_ctx(THD *thd, Security_context **save_ctx);
#endif

private:
  sp_head(enum_sp_type type);

  MEM_ROOT main_mem_root;

  sp_pcontext *m_root_parsing_ctx;

  Dynamic_array<sp_instr *> m_instructions;

  HASH m_sptabs;

  ulong m_sp_cache_version;

  Stored_program_creation_ctx *m_creation_ctx;

  uint32 unsafe_flags;

private:
  void init_sp_name(THD *thd, sp_name *spname);

  bool execute(THD *thd, bool merge_da_on_success);

  void opt_mark();

  bool merge_table_list(THD *thd, TABLE_LIST *table, LEX *lex_for_tmp_check);

  friend sp_head *sp_start_parsing(THD *, enum_sp_type, sp_name *);

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


#endif /* _SP_HEAD_H_ */