~drizzle-trunk/drizzle/development

/* Copyright (C) 2000-2006 MySQL AB

 

   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

#ifdef MYSQL_SERVER

#ifdef MYSQL_YACC

#if defined(MYSQL_LEX)

  SQLCOM_ALTER_DB_UPGRADE,

#ifdef MYSQL_SERVER

 

enum enum_sp_data_access

{

  SP_DEFAULT_ACCESS= 0,

  SP_CONTAINS_SQL,

  SP_NO_SQL,

  SP_READS_SQL_DATA,

  SP_MODIFIES_SQL_DATA

};

 

const LEX_STRING sp_data_access_name[]=

{

  { C_STRING_WITH_LEN("") },

  { C_STRING_WITH_LEN("CONTAINS SQL") },

  { C_STRING_WITH_LEN("NO SQL") },

  { C_STRING_WITH_LEN("READS SQL DATA") },

  { C_STRING_WITH_LEN("MODIFIES SQL DATA") }

};

enum enum_drop_mode

{

  DROP_DEFAULT, // mode is not specified

  DROP_CASCADE, // CASCADE option

  DROP_RESTRICT // RESTRICT option

};

 

  long port;

  uint server_name_length;

  char *server_name, *host, *db, *username, *password, *scheme, *socket, *owner;

  uint port, connect_retry;

  ulong server_id;

  ulong relay_log_pos;

typedef uchar index_clause_map;

              char *str, uint length) :

  uint8 uncacheable;

  { return (void*) alloc_root(mem_root, (uint) size); }

  static void operator delete(void *ptr __attribute__((__unused__)),

                              size_t size __attribute__((__unused__)))

  static void operator delete(void *ptr __attribute__((__unused__)),

                              MEM_ROOT *mem_root __attribute__((__unused__)))

  virtual uint get_in_sum_expr();

  virtual TABLE_LIST* get_table_list();

  virtual ulong get_table_join_options();

  virtual TABLE_LIST *add_table_to_list(THD *thd, Table_ident *table,

                                        ulong table_options,

  virtual void set_lock_for_tables(thr_lock_type lock_type __attribute__((__unused__)))

  TABLE_LIST result_table_list;

  TABLE *table; /* temporary table using for appending UNION results */

    return my_reinterpret_cast(st_select_lex*)(slave);

    return my_reinterpret_cast(st_select_lex_unit*)(next);

  bool prepare(THD *thd, select_result *result, ulong additional_options);

  Item *prep_where; /* saved WHERE clause for prepared statement processing */

  Item *prep_having;/* saved HAVING clause for prepared statement processing */

  /* FROM clause - points to the beginning of the TABLE_LIST::next_local list. */

  List<TABLE_LIST> top_join_list; /* join list of the top level          */

  List<TABLE_LIST> *join_list;    /* list for the currently parsed join  */

  TABLE_LIST *embedding;          /* table embedding to the above list   */

  List<TABLE_LIST> sj_nests;

    by TABLE_LIST::next_leaf, so leaf_tables points to the left-most leaf.

  TABLE_LIST *leaf_tables;

  uint select_n_having_items;

  uint cond_count;    /* number of arguments of and/or/xor in where/having/on */

  uint between_count; /* number of between predicates in where/having/on      */

  uint max_equal_elems; /* maximal number of elements in multiple equalities  */   

  uint select_n_where_fields;

  ulong table_join_options;

  uint in_sum_expr;

  uint select_number; /* number of select (used for EXPLAIN) */

  uint with_wild; /* item list contain '*' */

  uint n_sum_items;

  uint n_child_sum_items;

  /*

    This variable is required to ensure proper work of subqueries and

    stored procedures. Generally, one should use the states of

    Query_arena to determine if it's a statement prepare or first

    execution of a stored procedure. However, in case when there was an

    error during the first execution of a stored procedure, the SP body

    is not expelled from the SP cache. Therefore, a deeply nested

    subquery might be left unoptimized. So we need this per-subquery

    variable to inidicate the optimization/execution state of every

    subquery. Prepared statements work OK in that regard, as in

    case of an error during prepare the PS is not created.

  */

  bool first_execution;

  bool first_cond_optimization;

  /* do not wrap view fields with Item_ref */

  bool no_wrap_view_item;

      1. Sets the natural_join of the second TABLE_LIST in the join

      2. Makes a parent TABLE_LIST and sets its is_natural_join/

      3. Uses the wrapper TABLE_LIST as a table in the upper level.

    at stage (1.) the parent TABLE_LIST is not constructed yet and

  uint8 full_group_by_flag;

  uint get_in_sum_expr();

  TABLE_LIST* add_table_to_list(THD *thd, Table_ident *table,

                                ulong table_options,

  TABLE_LIST* get_table_list();

  TABLE_LIST *end_nested_join(THD *thd);

  TABLE_LIST *nest_last_join(THD *thd);

  void add_joined_table(TABLE_LIST *table);

  TABLE_LIST *convert_right_join();

  ulong get_table_join_options();

    order_list.next= (uchar**) &order_list.first;

  bool setup_ref_array(THD *thd, uint order_group_num);

                          ORDER *order,

  bool add_index_hint (THD *thd, char *str, uint length);

  @brief Parsing data for CREATE or ALTER TABLE.

  uint                          flags;

  uint                          no_parts;

  TABLE_LIST *query_tables;

  TABLE_LIST **query_tables_last;

  TABLE_LIST **query_tables_own_last;

  uchar    **sroutines_list_own_last;

  uint     sroutines_list_own_elements;

  void add_to_query_tables(TABLE_LIST *table)

  TABLE_LIST* first_not_own_table()

  uint32 binlog_stmt_flags;

  uint yyLength()

    return (uint) ((m_ptr - m_tok_start) - 1);

  uint get_body_utf8_length()

                                CHARSET_INFO *txt_cs,

  uint yylineno;

  uint yytoklen;

  uint m_buf_length;

  uchar tok_bitmap;

  /**

    true if we're parsing a prepared statement: in this mode

    we should allow placeholders and disallow multi-statements.

  */

  bool stmt_prepare_mode;

 

  CHARSET_INFO *m_underscore_cs;

  LEX_STRING backup_dir;                                /* For RESTORE/BACKUP */

  uchar* yacc_yyss, *yacc_yyvs;

  CHARSET_INFO *charset;

  TABLE_LIST *leaf_tables_insert;

  List<LEX_USER>      users_list;

  List<LEX_STRING>    view_list; // view list (list of field names in view)

  USER_RESOURCES mqh;

  ulong type;

    bool lock_transactional;            /* For LOCK TABLE ... IN ... MODE */

  enum enum_drop_mode drop_mode;

  uint profile_query_id;

  uint profile_options;

  uint which_columns;

  uint slave_thd_opt, start_transaction_opt;

  uint table_count;

  uint8 describe;

  uint8 derived_tables;

  bool verbose, no_write_to_binlog;

  /*

    Special JOIN::prepare mode: changing of query is prohibited.

    When creating a view, we need to just check its syntax omitting

    any optimizations: afterwards definition of the view will be

    reconstructed by means of ::print() methods and written to

    to an .frm file. We need this definition to stay untouched.

  */

  bool view_prepare_mode;

  TABLE_LIST *unlink_first_table(bool *link_to_local);

  void link_first_table_back(TABLE_LIST *first, bool link_to_local);

  uint8 get_effective_with_check(TABLE_LIST *view);

  /*

    Is this update command where 'WHITH CHECK OPTION' clause is important

 

    SYNOPSIS

      st_lex::which_check_option_applicable()

 

    RETURN

      true   have to take 'WHITH CHECK OPTION' clause into account

      false  'WHITH CHECK OPTION' clause do not need

  */

  inline bool which_check_option_applicable()

  {

    switch (sql_command) {

    case SQLCOM_UPDATE:

    case SQLCOM_UPDATE_MULTI:

    case SQLCOM_INSERT:

    case SQLCOM_INSERT_SELECT:

    case SQLCOM_REPLACE:

    case SQLCOM_REPLACE_SELECT:

    case SQLCOM_LOAD:

      return true;

    default:

      return false;

    }

  }

    return (void*) alloc_root(mem_root, (uint) size);

  static void operator delete(void *ptr __attribute__((__unused__)),

                              size_t size __attribute__((__unused__)))

  static void operator delete(void *ptr __attribute__((__unused__)),

                              MEM_ROOT *mem_root __attribute__((__unused__)))