sp_pcontext.h

/* -*- C++ -*- */
/* Copyright (c) 2002, 2011, 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_PCONTEXT_H_
#define _SP_PCONTEXT_H_

#include "sql_string.h"                         // LEX_STRING
#include "mysql_com.h"                          // enum_field_types
#include "field.h"                              // Create_field
#include "sql_array.h"                          // Dynamic_array



class sp_variable : public Sql_alloc
{
public:
  enum enum_mode
  {
    MODE_IN,
    MODE_OUT,
    MODE_INOUT
  };

  LEX_STRING name;

  enum enum_field_types type;

  enum_mode mode;

  uint offset;

  Item *default_value;

  Create_field field_def;

public:
  sp_variable(LEX_STRING _name, enum_field_types _type, enum_mode _mode,
              uint _offset)
   :Sql_alloc(),
    name(_name),
    type(_type),
    mode(_mode),
    offset(_offset),
    default_value(NULL)
  { }
};



class sp_label : public Sql_alloc
{
public:
  enum enum_type
  {
    IMPLICIT,

    BEGIN,

    ITERATION
  };

  LEX_STRING name;

  uint ip;

  enum_type type;

  class sp_pcontext *ctx;

public:
  sp_label(LEX_STRING _name, uint _ip, enum_type _type, sp_pcontext *_ctx)
   :Sql_alloc(),
    name(_name),
    ip(_ip),
    type(_type),
    ctx(_ctx)
  { }
};



class sp_condition_value : public Sql_alloc
{
public:
  enum enum_type
  {
    ERROR_CODE,
    SQLSTATE,
    WARNING,
    NOT_FOUND,
    EXCEPTION
  };

  enum_type type;

  char sql_state[SQLSTATE_LENGTH+1];

  uint mysqlerr;

public:
  sp_condition_value(uint _mysqlerr)
   :Sql_alloc(),
    type(ERROR_CODE),
    mysqlerr(_mysqlerr)
  { }

  sp_condition_value(const char *_sql_state)
   :Sql_alloc(),
    type(SQLSTATE)
  {
    memcpy(sql_state, _sql_state, SQLSTATE_LENGTH);
    sql_state[SQLSTATE_LENGTH]= 0;
  }

  sp_condition_value(enum_type _type)
   :Sql_alloc(),
    type(_type)
  {
    DBUG_ASSERT(type != ERROR_CODE && type != SQLSTATE);
  }

  bool equals(const sp_condition_value *cv) const;
};



class sp_condition : public Sql_alloc
{
public:
  LEX_STRING name;

  sp_condition_value *value;

public:
  sp_condition(LEX_STRING _name, sp_condition_value *_value)
   :Sql_alloc(),
    name(_name),
    value(_value)
  { }
};



class sp_handler : public Sql_alloc
{
public:
  enum enum_type
  {
    EXIT,
    CONTINUE
  };

  enum_type type;

  sp_pcontext *scope;

  List<sp_condition_value> condition_values;

public:
  sp_handler(enum_type _type, sp_pcontext *_scope)
   :Sql_alloc(),
    type(_type),
    scope(_scope)
  { }
};



class sp_pcontext : public Sql_alloc
{
public:
  enum enum_scope
  {
    REGULAR_SCOPE,

    HANDLER_SCOPE
  };

public:
  sp_pcontext();
  ~sp_pcontext();



  sp_pcontext *push_context(THD *thd, enum_scope scope);

  sp_pcontext *pop_context();

  sp_pcontext *parent_context() const
  { return m_parent; }

  int get_level() const
  { return m_level; }

  uint diff_handlers(const sp_pcontext *ctx, bool exclusive) const;

  uint diff_cursors(const sp_pcontext *ctx, bool exclusive) const;

  // SP-variables (parameters and variables).

  uint max_var_index() const
  { return m_max_var_index; }

  uint current_var_count() const
  { return m_var_offset + m_vars.elements(); }

  uint context_var_count() const
  { return m_vars.elements(); }

  uint var_context2runtime(uint i) const
  { return m_var_offset + i; }

  sp_variable *add_variable(THD *thd,
                            LEX_STRING name,
                            enum enum_field_types type,
                            sp_variable::enum_mode mode);

  void retrieve_field_definitions(List<Create_field> *field_def_lst) const;

  sp_variable *find_variable(LEX_STRING name, bool current_scope_only) const;

  sp_variable *find_variable(uint offset) const;

  void declare_var_boundary(uint n)
  { m_pboundary= n; }

  // CASE expressions.

  int get_num_case_exprs() const
  { return m_num_case_exprs; }

  int push_case_expr_id()
  {
    if (m_case_expr_ids.append(m_num_case_exprs))
      return -1;

    return m_num_case_exprs++;
  }

  void pop_case_expr_id()
  { m_case_expr_ids.pop(); }

  int get_current_case_expr_id() const
  { return *m_case_expr_ids.back(); }

  // Labels.

  sp_label *push_label(THD *thd, LEX_STRING name, uint ip);

  sp_label *find_label(LEX_STRING name);

  sp_label *last_label()
  {
    sp_label *label= m_labels.head();

    if (!label && m_parent)
      label= m_parent->last_label();

    return label;
  }

  sp_label *pop_label()
  { return m_labels.pop(); }

  // Conditions.

  bool add_condition(THD *thd, LEX_STRING name, sp_condition_value *value);

  sp_condition_value *find_condition(LEX_STRING name,
                                     bool current_scope_only) const;

  // Handlers.

  sp_handler *add_handler(THD* thd, sp_handler::enum_type type);

  bool check_duplicate_handler(const sp_condition_value *cond_value) const;

  sp_handler *find_handler(const char *sql_state,
                           uint sql_errno,
                           Sql_condition::enum_warning_level level) const;

  // Cursors.

  bool add_cursor(LEX_STRING name);

  bool find_cursor(LEX_STRING name, uint *poff, bool current_scope_only) const;

  const LEX_STRING *find_cursor(uint offset) const;

  uint max_cursor_index() const
  { return m_max_cursor_index + m_cursors.elements(); }

  uint current_cursor_count() const
  { return m_cursor_offset + m_cursors.elements(); }

private:
  sp_pcontext(sp_pcontext *prev, enum_scope scope);

  void init(uint var_offset, uint cursor_offset, int num_case_expressions);

  /* Prevent use of these */
  sp_pcontext(const sp_pcontext &);
  void operator=(sp_pcontext &);

private:
  int m_level;

  uint m_max_var_index;

  uint m_max_cursor_index;

  sp_pcontext *m_parent;

  uint m_var_offset;

  uint m_cursor_offset;

  uint m_pboundary;

  int m_num_case_exprs;

  Dynamic_array<sp_variable *> m_vars;

  Dynamic_array<int> m_case_expr_ids;

  Dynamic_array<sp_condition *> m_conditions;

  Dynamic_array<LEX_STRING> m_cursors;

  Dynamic_array<sp_handler *> m_handlers;

  List<sp_label> m_labels;

  Dynamic_array<sp_pcontext *> m_children;

  enum_scope m_scope;
}; // class sp_pcontext : public Sql_alloc


#endif /* _SP_PCONTEXT_H_ */