sql_error.h

/* Copyright (c) 2005, 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, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */

#ifndef SQL_ERROR_H
#define SQL_ERROR_H

#include "sql_list.h"
#include "m_string.h" /* LEX_STRING */
#include "sql_string.h"                        /* String */
#include "sql_plist.h" /* I_P_List */
#include "mysql_com.h" /* MYSQL_ERRMSG_SIZE */

class THD;
class my_decimal;


class Sql_condition : public Sql_alloc
{
public:
  /*
    Enumeration value describing the severity of the error.

    Note that these enumeration values must correspond to the indices
    of the sql_print_message_handlers array.
  */
  enum enum_warning_level
  { WARN_LEVEL_NOTE, WARN_LEVEL_WARN, WARN_LEVEL_ERROR, WARN_LEVEL_END};

  const char* get_message_text() const;

  int get_message_octet_length() const;

  const char* get_sqlstate() const
  { return m_returned_sqlstate; }

  uint get_sql_errno() const
  { return m_sql_errno; }

  Sql_condition::enum_warning_level get_level() const
  { return m_level; }

private:
  /*
    The interface of Sql_condition is mostly private, by design,
    so that only the following code:
    - various raise_error() or raise_warning() methods in class THD,
    - the implementation of SIGNAL / RESIGNAL / GET DIAGNOSTICS
    - catch / re-throw of SQL conditions in stored procedures (sp_rcontext)
    is allowed to create / modify a SQL condition.
    Enforcing this policy prevents confusion, since the only public
    interface available to the rest of the server implementation
    is the interface offered by the THD methods (THD::raise_error()),
    which should be used.
  */
  friend class THD;
  friend class Warning_info;
  friend class Sql_cmd_common_signal;
  friend class Sql_cmd_signal;
  friend class Sql_cmd_resignal;
  friend class sp_rcontext;
  friend class Condition_information_item;

  Sql_condition();

  void init(MEM_ROOT *mem_root);

  Sql_condition(MEM_ROOT *mem_root);

  ~Sql_condition()
  {}

  void copy_opt_attributes(const Sql_condition *cond);

  void set(uint sql_errno, const char* sqlstate,
           Sql_condition::enum_warning_level level,
           const char* msg);

  void set_builtin_message_text(const char* str);

  void set_sqlstate(const char* sqlstate);

  void set_class_origins();

  void clear();

private:
  String m_class_origin;

  String m_subclass_origin;

  String m_constraint_catalog;

  String m_constraint_schema;

  String m_constraint_name;

  String m_catalog_name;

  String m_schema_name;

  String m_table_name;

  String m_column_name;

  String m_cursor_name;

  String m_message_text;

  uint m_sql_errno;

  char m_returned_sqlstate[SQLSTATE_LENGTH+1];

  Sql_condition::enum_warning_level m_level;

  Sql_condition *next_in_wi;
  Sql_condition **prev_in_wi;

  MEM_ROOT *m_mem_root;
};


class Warning_info
{
  typedef I_P_List<Sql_condition,
                   I_P_List_adapter<Sql_condition,
                                    &Sql_condition::next_in_wi,
                                    &Sql_condition::prev_in_wi>,
                   I_P_List_counter,
                   I_P_List_fast_push_back<Sql_condition> >
          Sql_condition_list;

  MEM_ROOT           m_warn_root;

  Sql_condition_list   m_warn_list;

  uint               m_warn_count[(uint) Sql_condition::WARN_LEVEL_END];

  uint               m_current_statement_warn_count;

  /*
    Row counter, to print in errors and warnings. Not increased in
    create_sort_index(); may differ from examined_row_count.
  */
  ulong              m_current_row_for_warning;

  ulonglong          m_warn_id;

  const Sql_condition *m_error_condition;

  bool               m_allow_unlimited_warnings;

  bool m_read_only;

  Warning_info *m_next_in_da;
  Warning_info **m_prev_in_da;

  List<Sql_condition> m_marked_sql_conditions;

public:
  Warning_info(ulonglong warn_id_arg, bool allow_unlimited_warnings);
  ~Warning_info();

private:
  Warning_info(const Warning_info &rhs); /* Not implemented */
  Warning_info& operator=(const Warning_info &rhs); /* Not implemented */

  bool has_sql_condition(const char *message_str, ulong message_length) const;

  void clear(ulonglong new_id);

  void opt_clear(ulonglong query_id)
  {
    if (query_id != m_warn_id)
      clear(query_id);
  }

  void append_warning_info(THD *thd, const Warning_info *source);

  void reset_for_next_command()
  { m_current_statement_warn_count= 0; }

  void mark_sql_conditions_for_removal();

  void unmark_sql_conditions_from_removal()
  { m_marked_sql_conditions.empty(); }

  void remove_marked_sql_conditions();

  bool is_marked_for_removal(const Sql_condition *cond) const;

  void mark_condition_for_removal(Sql_condition *cond)
  { m_marked_sql_conditions.push_back(cond, &m_warn_root); }

  ulong warn_count() const
  {
    /*
      This may be higher than warn_list.elements() if we have
      had more warnings than thd->variables.max_error_count.
    */
    return (m_warn_count[(uint) Sql_condition::WARN_LEVEL_NOTE] +
            m_warn_count[(uint) Sql_condition::WARN_LEVEL_ERROR] +
            m_warn_count[(uint) Sql_condition::WARN_LEVEL_WARN]);
  }

  ulong error_count() const
  { return m_warn_count[(uint) Sql_condition::WARN_LEVEL_ERROR]; }

  uint cond_count() const
  {
    return m_warn_list.elements();
  }

  ulonglong id() const { return m_warn_id; }

  void id(ulonglong id) { m_warn_id= id; }

  bool is_empty() const { return m_warn_list.is_empty(); }

  void inc_current_row_for_warning() { m_current_row_for_warning++; }

  void reset_current_row_for_warning() { m_current_row_for_warning= 1; }

  ulong current_row_for_warning() const { return m_current_row_for_warning; }

  ulong current_statement_warn_count() const
  { return m_current_statement_warn_count; }

  void reserve_space(THD *thd, uint count);

  Sql_condition *push_warning(THD *thd,
                              uint sql_errno,
                              const char* sqlstate,
                              Sql_condition::enum_warning_level level,
                              const char* msg);

  Sql_condition *push_warning(THD *thd, const Sql_condition *sql_condition);

  void set_read_only(bool read_only)
  { m_read_only= read_only; }

  bool is_read_only() const
  { return m_read_only; }

  const Sql_condition *get_error_condition() const
  { return m_error_condition; }

  void set_error_condition(const Sql_condition *error_condition)
  { m_error_condition= error_condition; }

  void clear_error_condition()
  { m_error_condition= NULL; }

  // for:
  //   - m_next_in_da / m_prev_in_da
  //   - is_marked_for_removal()
  friend class Diagnostics_area;
};

uint err_conv(char *buff, size_t to_length, const char *from,
              size_t from_length, const CHARSET_INFO *from_cs);

class ErrConvString
{
  char err_buffer[MYSQL_ERRMSG_SIZE];
  size_t buf_length;
public:
  ErrConvString(String *str)
  {
    buf_length= err_conv(err_buffer, sizeof(err_buffer), str->ptr(),
                         str->length(), str->charset());
  }

  ErrConvString(const char *str, const CHARSET_INFO* cs)
  {
    buf_length= err_conv(err_buffer, sizeof(err_buffer), str, strlen(str), cs);
  }

  ErrConvString(const char *str, uint length)
  {
    buf_length= err_conv(err_buffer, sizeof(err_buffer), str, length,
                         &my_charset_latin1);
  }

  ErrConvString(const char *str, uint length, const CHARSET_INFO* cs)
  {
    buf_length= err_conv(err_buffer, sizeof(err_buffer), str, length, cs);
  }

  ErrConvString(longlong nr)
  {
    buf_length= my_snprintf(err_buffer, sizeof(err_buffer), "%lld", nr);
  }

  ErrConvString(longlong nr, bool unsigned_flag)
  {
    buf_length= longlong10_to_str(nr, err_buffer, unsigned_flag ? 10 : -10) -
                err_buffer;
  }

  ErrConvString(double nr);
  ErrConvString(const my_decimal *nr);
  ErrConvString(const struct st_mysql_time *ltime, uint dec);
 
  ~ErrConvString() { };
  char *ptr() { return err_buffer; }
  size_t length() const { return buf_length; }
};


class Diagnostics_area
{
private:
  typedef I_P_List<Warning_info,
                   I_P_List_adapter<Warning_info,
                                    &Warning_info::m_next_in_da,
                                    &Warning_info::m_prev_in_da>,
                   I_P_List_counter,
                   I_P_List_fast_push_back<Warning_info> >
          Warning_info_list;

public:
  typedef Warning_info::Sql_condition_list::Const_Iterator
    Sql_condition_iterator;

  enum enum_diagnostics_status
  {
    DA_EMPTY= 0,
    DA_OK,
    DA_EOF,
    DA_ERROR,
    DA_DISABLED
  };

  void set_overwrite_status(bool can_overwrite_status)
  { m_can_overwrite_status= can_overwrite_status; }

  bool is_sent() const { return m_is_sent; }

  void set_is_sent(bool is_sent) { m_is_sent= is_sent; }

  void set_ok_status(ulonglong affected_rows,
                     ulonglong last_insert_id,
                     const char *message);

  void set_eof_status(THD *thd);

  void set_error_status(uint sql_errno);

  void set_error_status(uint sql_errno,
                        const char *message,
                        const char *sqlstate,
                        const Sql_condition *error_condition);

  void disable_status();

  void reset_diagnostics_area();

  bool is_set() const { return m_status != DA_EMPTY; }

  bool is_error() const { return m_status == DA_ERROR; }

  bool is_eof() const { return m_status == DA_EOF; }

  bool is_ok() const { return m_status == DA_OK; }

  bool is_disabled() const { return m_status == DA_DISABLED; }

  enum_diagnostics_status status() const { return m_status; }

  const char *message() const
  { DBUG_ASSERT(m_status == DA_ERROR || m_status == DA_OK); return m_message; }

  uint sql_errno() const
  { DBUG_ASSERT(m_status == DA_ERROR); return m_sql_errno; }

  const char* get_sqlstate() const
  { DBUG_ASSERT(m_status == DA_ERROR); return m_sqlstate; }

  ulonglong affected_rows() const
  { DBUG_ASSERT(m_status == DA_OK); return m_affected_rows; }

  ulonglong last_insert_id() const
  { DBUG_ASSERT(m_status == DA_OK); return m_last_insert_id; }

  uint statement_warn_count() const
  {
    DBUG_ASSERT(m_status == DA_OK || m_status == DA_EOF);
    return m_statement_warn_count;
  }

  Diagnostics_area();
  Diagnostics_area(ulonglong warning_info_id, bool allow_unlimited_warnings);

  void push_warning_info(Warning_info *wi)
  { m_wi_stack.push_front(wi); }

  void pop_warning_info()
  {
    DBUG_ASSERT(m_wi_stack.elements() > 0);
    m_wi_stack.remove(m_wi_stack.front());
  }

  void set_warning_info_id(ulonglong id)
  { get_warning_info()->id(id); }

  ulonglong warning_info_id() const
  { return get_warning_info()->id(); }

  bool warning_info_changed(const Warning_info *wi) const
  { return get_warning_info()->id() != wi->id(); }

  bool is_warning_info_empty() const
  { return get_warning_info()->is_empty(); }

  ulong current_statement_warn_count() const
  { return get_warning_info()->current_statement_warn_count(); }

  bool has_sql_condition(const char *message_str, ulong message_length) const
  { return get_warning_info()->has_sql_condition(message_str, message_length); }

  void reset_for_next_command()
  { get_warning_info()->reset_for_next_command(); }

  void clear_warning_info(ulonglong id)
  { get_warning_info()->clear(id); }

  void opt_clear_warning_info(ulonglong query_id)
  { get_warning_info()->opt_clear(query_id); }

  ulong current_row_for_warning() const
  { return get_warning_info()->current_row_for_warning(); }

  void inc_current_row_for_warning()
  { get_warning_info()->inc_current_row_for_warning(); }

  void reset_current_row_for_warning()
  { get_warning_info()->reset_current_row_for_warning(); }

  bool is_warning_info_read_only() const
  { return get_warning_info()->is_read_only(); }

  void set_warning_info_read_only(bool read_only)
  { get_warning_info()->set_read_only(read_only); }

  ulong error_count() const
  { return get_warning_info()->error_count(); }

  ulong warn_count() const
  { return get_warning_info()->warn_count(); }

  uint cond_count() const
  { return get_warning_info()->cond_count(); }

  Sql_condition_iterator sql_conditions() const
  { return get_warning_info()->m_warn_list; }

  void reserve_space(THD *thd, uint count)
  { get_warning_info()->reserve_space(thd, count); }

  Sql_condition *push_warning(THD *thd, const Sql_condition *sql_condition)
  { return get_warning_info()->push_warning(thd, sql_condition); }

  Sql_condition *push_warning(THD *thd,
                              uint sql_errno,
                              const char* sqlstate,
                              Sql_condition::enum_warning_level level,
                              const char* msg)
  {
    return get_warning_info()->push_warning(thd,
                                            sql_errno, sqlstate, level, msg);
  }

  void mark_sql_conditions_for_removal()
  { get_warning_info()->mark_sql_conditions_for_removal(); }

  void unmark_sql_conditions_from_removal()
  { get_warning_info()->unmark_sql_conditions_from_removal(); }

  void remove_marked_sql_conditions()
  { get_warning_info()->remove_marked_sql_conditions(); }

  const Sql_condition *get_error_condition() const
  { return get_warning_info()->get_error_condition(); }

  void copy_sql_conditions_to_wi(THD *thd, Warning_info *dst_wi) const
  { dst_wi->append_warning_info(thd, get_warning_info()); }

  void copy_sql_conditions_from_wi(THD *thd, const Warning_info *src_wi)
  { get_warning_info()->append_warning_info(thd, src_wi); }

  void copy_non_errors_from_wi(THD *thd, const Warning_info *src_wi);

private:
  Warning_info *get_warning_info() { return m_wi_stack.front(); }

  const Warning_info *get_warning_info() const { return m_wi_stack.front(); }

private:
  bool m_is_sent;

  bool m_can_overwrite_status;

  char m_message[MYSQL_ERRMSG_SIZE];

  uint m_sql_errno;

  char m_sqlstate[SQLSTATE_LENGTH+1];

  ulonglong    m_affected_rows;

  ulonglong   m_last_insert_id;

  uint       m_statement_warn_count;

  enum_diagnostics_status m_status;

  Warning_info m_main_wi;

  Warning_info_list m_wi_stack;
};



void push_warning(THD *thd, Sql_condition::enum_warning_level level,
                  uint code, const char *msg);

void push_warning_printf(THD *thd, Sql_condition::enum_warning_level level,
                         uint code, const char *format, ...);

bool mysqld_show_warnings(THD *thd, ulong levels_to_show);

uint32 convert_error_message(char *to, uint32 to_length,
                             const CHARSET_INFO *to_cs,
                             const char *from, uint32 from_length,
                             const CHARSET_INFO *from_cs, uint *errors);

extern const LEX_STRING warning_level_names[];

bool is_sqlstate_valid(const LEX_STRING *sqlstate);


inline bool is_sqlstate_completion(const char *s)
{ return s[0] == '0' && s[1] == '0'; }


inline bool is_sqlstate_warning(const char *s)
{ return s[0] == '0' && s[1] == '1'; }


inline bool is_sqlstate_not_found(const char *s)
{ return s[0] == '0' && s[1] == '2'; }


inline bool is_sqlstate_exception(const char *s)
{ return s[0] != '0' || s[1] > '2'; }


#endif // SQL_ERROR_H