~drizzle-trunk/drizzle/development

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

/* sql_yacc.yy */

/**

  @defgroup Parser Parser

  @{

*/

%{

/* session is passed as an argument to yyparse(), and subsequently to yylex().

** The type will be void*, so it must be  cast to (Session*) when used.

** Use the YYSession macro for this.

*/

#define YYPARSE_PARAM yysession

#define YYLEX_PARAM yysession

#define YYSession (static_cast<Session *>(yysession))

#define YYENABLE_NLS 0

#define YYLTYPE_IS_TRIVIAL 0

#define DRIZZLE_YACC

#define YYINITDEPTH 100

#define YYMAXDEPTH 3200                        /* Because of 64K stack */

#define Lex (YYSession->lex)

#include "config.h"

#include <cstdio>

#include "drizzled/parser.h"

int yylex(void *yylval, void *yysession);

#define yyoverflow(A,B,C,D,E,F)               \

  {                                           \

    ulong val= *(F);                          \

    if (drizzled::my_yyoverflow((B), (D), &val)) \

    {                                         \

      yyerror((char*) (A));                   \

      return 2;                               \

    }                                         \

    else                                      \

    {                                         \

      *(F)= (YYSIZE_T)val;                    \

    }                                         \

  }

#define DRIZZLE_YYABORT                         \

  do                                          \

  {                                           \

    LEX::cleanup_lex_after_parse_error(YYSession);\

    YYABORT;                                  \

  } while (0)

#define DRIZZLE_YYABORT_UNLESS(A)         \

  if (!(A))                             \

  {                                     \

    struct my_parse_error_st pass= { ER(ER_SYNTAX_ERROR), YYSession };\

    my_parse_error(&pass);\

    DRIZZLE_YYABORT;                      \

  }

#define YYDEBUG 0

namespace drizzled

{

class Table_ident;

class Item;

class Item_num;

static bool check_reserved_words(LEX_STRING *name)

{

  if (!my_strcasecmp(system_charset_info, name->str, "GLOBAL") ||

      !my_strcasecmp(system_charset_info, name->str, "LOCAL") ||

      !my_strcasecmp(system_charset_info, name->str, "SESSION"))

    return true;

  return false;

}

/**

  @brief Push an error message into MySQL error stack with line

  and position information.

  This function provides semantic action implementers with a way

  to push the famous "You have a syntax error near..." error

  message into the error stack, which is normally produced only if

  a parse error is discovered internally by the Bison generated

  parser.

*/

struct my_parse_error_st {

  const char *s;

  Session *session;

};

static void my_parse_error(void *arg)

{

 struct my_parse_error_st *ptr= (struct my_parse_error_st *)arg;

  const char *s= ptr->s;

  Session *session= ptr->session;

  Lex_input_stream *lip= session->m_lip;

  const char *yytext= lip->get_tok_start();

  /* Push an error into the error stack */

  my_printf_error(ER_PARSE_ERROR,  ER(ER_PARSE_ERROR), MYF(0), s,

                  (yytext ? yytext : ""),

                  lip->yylineno);

}

/**

  @brief Bison callback to report a syntax/OOM error

  This function is invoked by the bison-generated parser

  when a syntax error, a parse error or an out-of-memory

  condition occurs. This function is not invoked when the

  parser is requested to abort by semantic action code

  by means of YYABORT or YYACCEPT macros. This is why these

  macros should not be used (use DRIZZLE_YYABORT/DRIZZLE_YYACCEPT

  instead).

  The parser will abort immediately after invoking this callback.

  This function is not for use in semantic actions and is internal to

  the parser, as it performs some pre-return cleanup.

  In semantic actions, please use my_parse_error or my_error to

  push an error into the error stack and DRIZZLE_YYABORT

  to abort from the parser.

*/

static void DRIZZLEerror(const char *s)

{

  Session *session= current_session;

  /*

    Restore the original LEX if it was replaced when parsing

    a stored procedure. We must ensure that a parsing error

    does not leave any side effects in the Session.

  */

  LEX::cleanup_lex_after_parse_error(session);

  /* "parse error" changed into "syntax error" between bison 1.75 and 1.875 */

  if (strcmp(s,"parse error") == 0 || strcmp(s,"syntax error") == 0)

    s= ER(ER_SYNTAX_ERROR);

  struct my_parse_error_st pass= { s, session };

  my_parse_error(&pass);

}

/**

  Helper to resolve the SQL:2003 Syntax exception 1) in <in predicate>.

  See SQL:2003, Part 2, section 8.4 <in predicate>, Note 184, page 383.

  This function returns the proper item for the SQL expression

  <code>left [NOT] IN ( expr )</code>

  @param session the current thread

  @param left the in predicand

  @param equal true for IN predicates, false for NOT IN predicates

  @param expr first and only expression of the in value list

  @return an expression representing the IN predicate.

*/

static Item* handle_sql2003_note184_exception(Session *session,

                                              Item* left, bool equal,

                                              Item *expr)

{

  /*

    Relevant references for this issue:

    - SQL:2003, Part 2, section 8.4 <in predicate>, page 383,

    - SQL:2003, Part 2, section 7.2 <row value expression>, page 296,

    - SQL:2003, Part 2, section 6.3 <value expression primary>, page 174,

    - SQL:2003, Part 2, section 7.15 <subquery>, page 370,

    - SQL:2003 Feature F561, "Full value expressions".

    The exception in SQL:2003 Note 184 means:

    Item_singlerow_subselect, which corresponds to a <scalar subquery>,

    should be re-interpreted as an Item_in_subselect, which corresponds

    to a <table subquery> when used inside an <in predicate>.

    Our reading of Note 184 is reccursive, so that all:

    - IN (( <subquery> ))

    - IN ((( <subquery> )))

    - IN '('^N <subquery> ')'^N

    - etc

    should be interpreted as a <table subquery>, no matter how deep in the

    expression the <subquery> is.

  */

  Item *result;

  if (expr->type() == Item::SUBSELECT_ITEM)

  {

    Item_subselect *expr2 = (Item_subselect*) expr;

    if (expr2->substype() == Item_subselect::SINGLEROW_SUBS)

    {

      Item_singlerow_subselect *expr3 = (Item_singlerow_subselect*) expr2;

      Select_Lex *subselect;

      /*

        Implement the mandated change, by altering the semantic tree:

          left IN Item_singlerow_subselect(subselect)

        is modified to

          left IN (subselect)

        which is represented as

          Item_in_subselect(left, subselect)

      */

      subselect= expr3->invalidate_and_restore_select_lex();

      result= new (session->mem_root) Item_in_subselect(left, subselect);

      if (! equal)

        result = negate_expression(session, result);

      return(result);

    }

  }

  if (equal)

    result= new (session->mem_root) Item_func_eq(left, expr);

  else

    result= new (session->mem_root) Item_func_ne(left, expr);

  return(result);

}

/**

   @brief Creates a new Select_Lex for a UNION branch.

   Sets up and initializes a Select_Lex structure for a query once the parser

   discovers a UNION token. The current Select_Lex is pushed on the stack and

   the new Select_Lex becomes the current one..=

   @lex The parser state.

   @is_union_distinct True if the union preceding the new select statement

   uses UNION DISTINCT.

   @return <code>false</code> if successful, <code>true</code> if an error was

   reported. In the latter case parsing should stop.

 */

static bool add_select_to_union_list(Session *session, LEX *lex, bool is_union_distinct)

{

  if (lex->result)

  {

    /* Only the last SELECT can have  INTO...... */

    my_error(ER_WRONG_USAGE, MYF(0), "UNION", "INTO");

    return true;

  }

  if (lex->current_select->linkage == GLOBAL_OPTIONS_TYPE)

  {

    struct my_parse_error_st pass= { ER(ER_SYNTAX_ERROR), session };

    my_parse_error(&pass);

    return true;

  }

  /* This counter shouldn't be incremented for UNION parts */

  lex->nest_level--;

  if (mysql_new_select(lex, 0))

    return true;

  mysql_init_select(lex);

  lex->current_select->linkage=UNION_TYPE;

  if (is_union_distinct) /* UNION DISTINCT - remember position */

    lex->current_select->master_unit()->union_distinct=

      lex->current_select;

  return false;

}

/**

   @brief Initializes a Select_Lex for a query within parentheses (aka

   braces).

   @return false if successful, true if an error was reported. In the latter

   case parsing should stop.

 */

static bool setup_select_in_parentheses(Session *session, LEX *lex)

{

  Select_Lex * sel= lex->current_select;

  if (sel->set_braces(1))

  {

    struct my_parse_error_st pass= { ER(ER_SYNTAX_ERROR), session };

    my_parse_error(&pass);

    return true;

  }

  if (sel->linkage == UNION_TYPE &&

      !sel->master_unit()->first_select()->braces &&

      sel->master_unit()->first_select()->linkage ==

      UNION_TYPE)

  {

    struct my_parse_error_st pass= { ER(ER_SYNTAX_ERROR), session };

    my_parse_error(&pass);

    return true;

  }

  if (sel->linkage == UNION_TYPE &&

      sel->olap != UNSPECIFIED_OLAP_TYPE &&

      sel->master_unit()->fake_select_lex)

  {

    my_error(ER_WRONG_USAGE, MYF(0), "CUBE/ROLLUP", "ORDER BY");

    return true;

  }

  /* select in braces, can't contain global parameters */

  if (sel->master_unit()->fake_select_lex)

    sel->master_unit()->global_parameters=

      sel->master_unit()->fake_select_lex;

  return false;

}

static Item* reserved_keyword_function(Session *session, const std::string &name, List<Item> *item_list)

{

  const plugin::Function *udf= plugin::Function::get(name.c_str(), name.length());

  Item *item= NULL;

  if (udf)

  {

    item= Create_udf_func::s_singleton.create(session, udf, item_list);

  } else {

    my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "FUNCTION", name.c_str());

  }

  return item;

}

} /* namespace drizzled; */

using namespace drizzled;

%}

%union {

  int  num;

  ulong ulong_num;

  uint64_t ulonglong_number;

  int64_t longlong_number;

  drizzled::LEX_STRING lex_str;

  drizzled::LEX_STRING *lex_str_ptr;

  drizzled::LEX_SYMBOL symbol;

  drizzled::Table_ident *table;

  char *simple_string;

  drizzled::Item *item;

  drizzled::Item_num *item_num;

  drizzled::List<drizzled::Item> *item_list;

  drizzled::List<drizzled::String> *string_list;

  drizzled::String *string;

  drizzled::Key_part_spec *key_part;

  const drizzled::plugin::Function *udf;

  drizzled::TableList *table_list;

  struct drizzled::sys_var_with_base variable;

  enum drizzled::sql_var_t var_type;

  drizzled::Key::Keytype key_type;

  enum drizzled::ha_key_alg key_alg;

  enum drizzled::column_format_type column_format_type;

  enum drizzled::ha_rkey_function ha_rkey_mode;

  enum drizzled::enum_tx_isolation tx_isolation;

  enum drizzled::Cast_target cast_type;

  const drizzled::CHARSET_INFO *charset;

  drizzled::thr_lock_type lock_type;

  drizzled::interval_type interval, interval_time_st;

  enum drizzled::enum_drizzle_timestamp_type date_time_type;

  drizzled::Select_Lex *select_lex;

  drizzled::chooser_compare_func_creator boolfunc2creator;

  struct drizzled::st_lex *lex;

  enum drizzled::index_hint_type index_hint;

  enum drizzled::enum_filetype filetype;

  enum drizzled::ha_build_method build_method;

  drizzled::message::Table::ForeignKeyConstraint::ForeignKeyOption m_fk_option;

}

%{

namespace drizzled

{

bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);

}

%}

%pure_parser                                    /* We have threads */

/*

  Currently there are 88 shift/reduce conflicts.

  We should not introduce new conflicts any more.

*/

%expect 94

/*

   Comments for TOKENS.

   For each token, please include in the same line a comment that contains

   the following tags:

   SQL-2003-R : Reserved keyword as per SQL-2003

   SQL-2003-N : Non Reserved keyword as per SQL-2003

   SQL-1999-R : Reserved keyword as per SQL-1999

   SQL-1999-N : Non Reserved keyword as per SQL-1999

   MYSQL      : MySQL extention (unspecified)

   MYSQL-FUNC : MySQL extention, function

   INTERNAL   : Not a real token, lex optimization

   OPERATOR   : SQL operator

   FUTURE-USE : Reserved for futur use

   This makes the code grep-able, and helps maintenance.

*/

%token  ABORT_SYM                     /* INTERNAL (used in lex) */

%token  ACTION                        /* SQL-2003-N */

%token  ADD                           /* SQL-2003-R */

%token  ADDDATE_SYM                   /* MYSQL-FUNC */

%token  AFTER_SYM                     /* SQL-2003-N */

%token  AGGREGATE_SYM

%token  ALL                           /* SQL-2003-R */

%token  ALTER                         /* SQL-2003-R */

%token  ANALYZE_SYM

%token  AND_SYM                       /* SQL-2003-R */

%token  ANY_SYM                       /* SQL-2003-R */

%token  AS                            /* SQL-2003-R */

%token  ASC                           /* SQL-2003-N */

%token  ASENSITIVE_SYM                /* FUTURE-USE */

%token  AT_SYM                        /* SQL-2003-R */

%token  AUTO_INC

%token  AVG_ROW_LENGTH

%token  AVG_SYM                       /* SQL-2003-N */

%token  BEFORE_SYM                    /* SQL-2003-N */

%token  BEGIN_SYM                     /* SQL-2003-R */

%token  BETWEEN_SYM                   /* SQL-2003-R */

%token  BIGINT_SYM                    /* SQL-2003-R */

%token  BINARY                        /* SQL-2003-R */

%token  BIN_NUM

%token  BIT_SYM                       /* MYSQL-FUNC */

%token  BLOB_SYM                      /* SQL-2003-R */

%token  BOOLEAN_SYM                   /* SQL-2003-R */

%token  BOOL_SYM

%token  BOTH                          /* SQL-2003-R */

%token  BTREE_SYM

%token  BY                            /* SQL-2003-R */

%token  BYTE_SYM

%token  CALL_SYM                      /* SQL-2003-R */

%token  CASCADE                       /* SQL-2003-N */

%token  CASCADED                      /* SQL-2003-R */

%token  CASE_SYM                      /* SQL-2003-R */

%token  CAST_SYM                      /* SQL-2003-R */

%token  CHAIN_SYM                     /* SQL-2003-N */

%token  CHANGE

%token  CHAR_SYM                      /* SQL-2003-R */

%token  CHECKSUM_SYM

%token  CHECK_SYM                     /* SQL-2003-R */

%token  CLOSE_SYM                     /* SQL-2003-R */

%token  COALESCE                      /* SQL-2003-N */

%token  COLLATE_SYM                   /* SQL-2003-R */

%token  COLLATION_SYM                 /* SQL-2003-N */

%token  COLUMNS

%token  COLUMN_SYM                    /* SQL-2003-R */

%token  COMMENT_SYM

%token  COMMITTED_SYM                 /* SQL-2003-N */

%token  COMMIT_SYM                    /* SQL-2003-R */

%token  COMPACT_SYM

%token  COMPRESSED_SYM

%token  CONCURRENT

%token  CONDITION_SYM                 /* SQL-2003-N */

%token  CONNECTION_SYM

%token  CONSISTENT_SYM

%token  CONSTRAINT                    /* SQL-2003-R */

%token  CONTAINS_SYM                  /* SQL-2003-N */

%token  CONTINUE_SYM                  /* SQL-2003-R */

%token  CONVERT_SYM                   /* SQL-2003-N */

%token  COUNT_SYM                     /* SQL-2003-N */

%token  CREATE                        /* SQL-2003-R */

%token  CROSS                         /* SQL-2003-R */

%token  CUBE_SYM                      /* SQL-2003-R */

%token  CURDATE                       /* MYSQL-FUNC */

%token  CURRENT_USER                  /* SQL-2003-R */

%token  CURSOR_SYM                    /* SQL-2003-R */

%token  DATABASE

%token  DATABASES

%token  DATAFILE_SYM

%token  DATA_SYM                      /* SQL-2003-N */

%token  DATETIME_SYM

%token  DATE_ADD_INTERVAL             /* MYSQL-FUNC */

%token  DATE_SUB_INTERVAL             /* MYSQL-FUNC */

%token  DATE_SYM                      /* SQL-2003-R */

%token  DAY_HOUR_SYM

%token  DAY_MICROSECOND_SYM

%token  DAY_MINUTE_SYM

%token  DAY_SECOND_SYM

%token  DAY_SYM                       /* SQL-2003-R */

%token  DEALLOCATE_SYM                /* SQL-2003-R */

%token  DECIMAL_NUM

%token  DECIMAL_SYM                   /* SQL-2003-R */

%token  DECLARE_SYM                   /* SQL-2003-R */

%token  DEFAULT                       /* SQL-2003-R */

%token  DELETE_SYM                    /* SQL-2003-R */

%token  DESC                          /* SQL-2003-N */

%token  DESCRIBE                      /* SQL-2003-R */

%token  DETERMINISTIC_SYM             /* SQL-2003-R */

%token  DISABLE_SYM

%token  DISCARD

%token  DISTINCT                      /* SQL-2003-R */

%token  DIV_SYM

%token  DOUBLE_SYM                    /* SQL-2003-R */

%token  DROP                          /* SQL-2003-R */

%token  DUMPFILE

%token  DUPLICATE_SYM

%token  DYNAMIC_SYM                   /* SQL-2003-R */

%token  EACH_SYM                      /* SQL-2003-R */

%token  ELSE                          /* SQL-2003-R */

%token  ELSEIF_SYM

%token  ENABLE_SYM

%token  ENCLOSED

%token  END                           /* SQL-2003-R */

%token  ENDS_SYM

%token  END_OF_INPUT                  /* INTERNAL */

%token  ENGINE_SYM

%token  ENUM_SYM

%token  EQ                            /* OPERATOR */

%token  EQUAL_SYM                     /* OPERATOR */

%token  ERRORS

%token  ESCAPED

%token  ESCAPE_SYM                    /* SQL-2003-R */

%token  EXCLUSIVE_SYM

%token  EXECUTE_SYM

%token  EXISTS                        /* SQL-2003-R */

%token  EXTENDED_SYM

%token  EXTRACT_SYM                   /* SQL-2003-N */

%token  FALSE_SYM                     /* SQL-2003-R */

%token  FETCH_SYM                     /* SQL-2003-R */

%token  COLUMN_FORMAT_SYM

%token  FILE_SYM

%token  FIRST_SYM                     /* SQL-2003-N */

%token  FIXED_SYM

%token  FLOAT_NUM

%token  FLUSH_SYM

%token  FORCE_SYM

%token  FOREIGN                       /* SQL-2003-R */

%token  FOR_SYM                       /* SQL-2003-R */

%token  FOUND_SYM                     /* SQL-2003-R */

%token  FRAC_SECOND_SYM

%token  FROM

%token  FULL                          /* SQL-2003-R */

%token  GE

%token  GLOBAL_SYM                    /* SQL-2003-R */

%token  GROUP_SYM                     /* SQL-2003-R */

%token  GROUP_CONCAT_SYM

%token  GT_SYM                        /* OPERATOR */

%token  HASH_SYM

%token  HAVING                        /* SQL-2003-R */

%token  HEX_NUM

%token  HOUR_MICROSECOND_SYM

%token  HOUR_MINUTE_SYM

%token  HOUR_SECOND_SYM

%token  HOUR_SYM                      /* SQL-2003-R */

%token  IDENT

%token  IDENTIFIED_SYM

%token  IDENT_QUOTED

%token  IF

%token  IGNORE_SYM

%token  IMPORT

%token  INDEXES

%token  INDEX_SYM

%token  INFILE

%token  INNER_SYM                     /* SQL-2003-R */

%token  INOUT_SYM                     /* SQL-2003-R */

%token  INSENSITIVE_SYM               /* SQL-2003-R */

%token  INSERT                        /* SQL-2003-R */

%token  INTERVAL_SYM                  /* SQL-2003-R */

%token  INTO                          /* SQL-2003-R */

%token  INT_SYM                       /* SQL-2003-R */

%token  IN_SYM                        /* SQL-2003-R */

%token  IS                            /* SQL-2003-R */

%token  ISOLATION                     /* SQL-2003-R */

%token  ITERATE_SYM

%token  JOIN_SYM                      /* SQL-2003-R */

%token  KEYS

%token  KEY_BLOCK_SIZE

%token  KEY_SYM                       /* SQL-2003-N */

%token  KILL_SYM

%token  LAST_SYM                      /* SQL-2003-N */

%token  LE                            /* OPERATOR */

%token  LEADING                       /* SQL-2003-R */

%token  LEFT                          /* SQL-2003-R */

%token  LEVEL_SYM

%token  LEX_HOSTNAME

%token  LIKE                          /* SQL-2003-R */

%token  LIMIT

%token  LINES

%token  LIST_SYM

%token  LOAD

%token  LOCAL_SYM                     /* SQL-2003-R */

%token  LOCATOR_SYM                   /* SQL-2003-N */

%token  LOCKS_SYM

%token  LOCK_SYM

%token  LOGS_SYM

%token  LONG_NUM

%token  LONG_SYM

%token  LOOP_SYM

%token  LT                            /* OPERATOR */

%token  MATCH                         /* SQL-2003-R */

%token  MAX_ROWS

%token  MAX_SIZE_SYM

%token  MAX_SYM                       /* SQL-2003-N */

%token  MAX_VALUE_SYM                 /* SQL-2003-N */

%token  MEDIUM_SYM

%token  MERGE_SYM                     /* SQL-2003-R */

%token  MICROSECOND_SYM               /* MYSQL-FUNC */

%token  MINUTE_MICROSECOND_SYM

%token  MINUTE_SECOND_SYM

%token  MINUTE_SYM                    /* SQL-2003-R */

%token  MIN_ROWS

%token  MIN_SYM                       /* SQL-2003-N */

%token  MODE_SYM

%token  MODIFIES_SYM                  /* SQL-2003-R */

%token  MODIFY_SYM

%token  MOD_SYM                       /* SQL-2003-N */

%token  MONTH_SYM                     /* SQL-2003-R */

%token  NAMES_SYM                     /* SQL-2003-N */

%token  NAME_SYM                      /* SQL-2003-N */

%token  NATIONAL_SYM                  /* SQL-2003-R */

%token  NATURAL                       /* SQL-2003-R */

%token  NE                            /* OPERATOR */

%token  NEG

%token  NEW_SYM                       /* SQL-2003-R */

%token  NEXT_SYM                      /* SQL-2003-N */

%token  NONE_SYM                      /* SQL-2003-R */

%token  NOT_SYM                       /* SQL-2003-R */

%token  NOW_SYM

%token  NO_SYM                        /* SQL-2003-R */

%token  NULL_SYM                      /* SQL-2003-R */

%token  NUM

%token  NUMERIC_SYM                   /* SQL-2003-R */

%token  OFFLINE_SYM

%token  OFFSET_SYM

%token  ON                            /* SQL-2003-R */

%token  ONE_SHOT_SYM

%token  ONE_SYM

%token  ONLINE_SYM

%token  OPEN_SYM                      /* SQL-2003-R */

%token  OPTIMIZE                      /* Leave assuming we might add it back */

%token  OPTION                        /* SQL-2003-N */

%token  OPTIONALLY

%token  ORDER_SYM                     /* SQL-2003-R */

%token  OR_SYM                        /* SQL-2003-R */

%token  OUTER

%token  OUTFILE

%token  OUT_SYM                       /* SQL-2003-R */

%token  PAGE_SYM

%token  PARTIAL                       /* SQL-2003-N */

%token  PHASE_SYM

%token  POSITION_SYM                  /* SQL-2003-N */

%token  PRECISION                     /* SQL-2003-R */

%token  PREV_SYM

%token  PRIMARY_SYM                   /* SQL-2003-R */

%token  PROCESS

%token  PROCESSLIST_SYM

%token  QUARTER_SYM

%token  QUERY_SYM

%token  RANGE_SYM                     /* SQL-2003-R */

%token  READS_SYM                     /* SQL-2003-R */

%token  READ_ONLY_SYM

%token  READ_SYM                      /* SQL-2003-N */

%token  READ_WRITE_SYM

%token  REAL                          /* SQL-2003-R */

%token  REDUNDANT_SYM

%token  REFERENCES                    /* SQL-2003-R */

%token  RELEASE_SYM                   /* SQL-2003-R */

%token  RENAME

%token  REPEATABLE_SYM                /* SQL-2003-N */

%token  REPEAT_SYM                    /* MYSQL-FUNC */

%token  REPLACE                       /* MYSQL-FUNC */

%token  RESTRICT

%token  RETURNS_SYM                   /* SQL-2003-R */

%token  RETURN_SYM                    /* SQL-2003-R */

%token  REVERSE_SYM

%token  REVOKE                        /* SQL-2003-R */

%token  RIGHT                         /* SQL-2003-R */

%token  ROLLBACK_SYM                  /* SQL-2003-R */

%token  ROLLUP_SYM                    /* SQL-2003-R */

%token  ROUTINE_SYM                   /* SQL-2003-N */

%token  ROWS_SYM                      /* SQL-2003-R */

%token  ROW_FORMAT_SYM

%token  ROW_SYM                       /* SQL-2003-R */

%token  SAVEPOINT_SYM                 /* SQL-2003-R */

%token  SECOND_MICROSECOND_SYM

%token  SECOND_SYM                    /* SQL-2003-R */

%token  SECURITY_SYM                  /* SQL-2003-N */

%token  SELECT_SYM                    /* SQL-2003-R */

%token  SENSITIVE_SYM                 /* FUTURE-USE */

%token  SEPARATOR_SYM

%token  SERIALIZABLE_SYM              /* SQL-2003-N */

%token  SERIAL_SYM

%token  SESSION_SYM                   /* SQL-2003-N */

%token  SERVER_SYM

%token  SERVER_OPTIONS

%token  SET                           /* SQL-2003-R */

%token  SET_VAR

%token  SHARE_SYM

%token  SHOW

%token  SIMPLE_SYM                    /* SQL-2003-N */

%token  SNAPSHOT_SYM

%token  SPECIFIC_SYM                  /* SQL-2003-R */

%token  SQLEXCEPTION_SYM              /* SQL-2003-R */

%token  SQLSTATE_SYM                  /* SQL-2003-R */

%token  SQLWARNING_SYM                /* SQL-2003-R */

%token  SQL_BIG_RESULT

%token  SQL_BUFFER_RESULT

%token  SQL_CALC_FOUND_ROWS

%token  SQL_SMALL_RESULT

%token  SQL_SYM                       /* SQL-2003-R */

%token  STARTING

%token  START_SYM                     /* SQL-2003-R */

%token  STATUS_SYM

%token  STDDEV_SAMP_SYM               /* SQL-2003-N */

%token  STD_SYM

%token  STOP_SYM

%token  STORAGE_SYM

%token  STORED_SYM

%token  STRAIGHT_JOIN

%token  STRING_SYM

%token  SUBDATE_SYM

%token  SUBJECT_SYM

%token  SUBSTRING                     /* SQL-2003-N */

%token  SUM_SYM                       /* SQL-2003-N */

%token  SUSPEND_SYM

%token  SWAPS_SYM

%token  SWITCHES_SYM

%token  SYSDATE

%token  TABLES

%token  TABLESPACE

%token  TABLE_REF_PRIORITY

%token  TABLE_SYM                     /* SQL-2003-R */

%token  TEMPORARY_SYM                 /* SQL-2003-N */

%token  TERMINATED

%token  TEXT_STRING

%token  TEXT_SYM

%token  THEN_SYM                      /* SQL-2003-R */

%token  TIMESTAMP_SYM                 /* SQL-2003-R */

%token  TIMESTAMP_ADD

%token  TIMESTAMP_DIFF

%token  TO_SYM                        /* SQL-2003-R */

%token  TRAILING                      /* SQL-2003-R */

%token  TRANSACTION_SYM

%token  TRIM                          /* SQL-2003-N */

%token  TRUE_SYM                      /* SQL-2003-R */

%token  TRUNCATE_SYM

%token  TYPES_SYM

%token  TYPE_SYM                      /* SQL-2003-N */

%token  ULONGLONG_NUM

%token  UNCOMMITTED_SYM               /* SQL-2003-N */

%token  UNDOFILE_SYM

%token  UNDO_SYM                      /* FUTURE-USE */

%token  UNION_SYM                     /* SQL-2003-R */

%token  UNIQUE_SYM

%token  UNKNOWN_SYM                   /* SQL-2003-R */

%token  UNLOCK_SYM

%token  UPDATE_SYM                    /* SQL-2003-R */

%token  USAGE                         /* SQL-2003-N */

%token  USER                          /* SQL-2003-R */

%token  USE_SYM

%token  USING                         /* SQL-2003-R */

%token  UTC_DATE_SYM

%token  UTC_TIMESTAMP_SYM

%token  VALUES                        /* SQL-2003-R */

%token  VALUE_SYM                     /* SQL-2003-R */

%token  VARBINARY

%token  VARCHAR_SYM                   /* SQL-2003-R */

%token  VARIABLES

%token  VARIANCE_SYM

%token  VARYING                       /* SQL-2003-R */

%token  VAR_SAMP_SYM

%token  WARNINGS

%token  WEEK_SYM

%token  WHEN_SYM                      /* SQL-2003-R */

%token  WHERE                         /* SQL-2003-R */

%token  WITH                          /* SQL-2003-R */

%token  WITH_ROLLUP_SYM               /* INTERNAL */

%token  WORK_SYM                      /* SQL-2003-N */

%token  WRITE_SYM                     /* SQL-2003-N */

%token  XOR

%token  YEAR_MONTH_SYM

%token  YEAR_SYM                      /* SQL-2003-R */

%left   JOIN_SYM INNER_SYM STRAIGHT_JOIN CROSS LEFT RIGHT

/* A dummy token to force the priority of table_ref production in a join. */

%left   TABLE_REF_PRIORITY

%left   SET_VAR

%left   OR_SYM

%left   XOR

%left   AND_SYM

%left   BETWEEN_SYM CASE_SYM WHEN_SYM THEN_SYM ELSE

%left   EQ EQUAL_SYM GE GT_SYM LE LT NE IS LIKE IN_SYM

%left   '-' '+'

%left   '*' '/' '%' DIV_SYM MOD_SYM

%left   NEG

%right  NOT_SYM

%right  BINARY COLLATE_SYM

%left  INTERVAL_SYM

%type <lex_str>

        IDENT IDENT_QUOTED TEXT_STRING DECIMAL_NUM FLOAT_NUM NUM LONG_NUM HEX_NUM

        LEX_HOSTNAME ULONGLONG_NUM field_ident select_alias ident ident_or_text

        IDENT_sys TEXT_STRING_sys TEXT_STRING_literal

        opt_component

        BIN_NUM TEXT_STRING_filesystem ident_or_empty

        execute_var_or_string

        opt_constraint constraint opt_ident

%type <lex_str_ptr>

        opt_table_alias

%type <table>

        table_ident references

%type <simple_string>

        remember_name remember_end opt_db

%type <string>

        text_string opt_gconcat_separator

%type <num>

        type int_type real_type order_dir field_def

        if_exists opt_table_options

        opt_if_not_exists

        opt_temporary all_or_any opt_distinct

        union_option

        start_transaction_opts opt_chain opt_release

        union_opt select_derived_init option_type2

%type <m_fk_option>

        delete_option

%type <ulong_num>

        ulong_num

%type <ulonglong_number>

        ulonglong_num

%type <lock_type>

        load_data_lock

%type <item>

        literal text_literal insert_ident order_ident

        simple_ident expr opt_expr opt_else sum_expr in_sum_expr

        variable variable_aux bool_pri

        predicate bit_expr

        table_wild simple_expr udf_expr

        expr_or_default set_expr_or_default

        signed_literal now_or_signed_literal opt_escape

        simple_ident_nospvar simple_ident_q

        field_or_var limit_option

        function_call_keyword

        function_call_nonkeyword

        function_call_generic

        function_call_conflict

%type <item_num>

        NUM_literal

%type <item_list>

        expr_list opt_udf_expr_list udf_expr_list when_list

%type <var_type>

        option_type opt_var_type opt_var_ident_type

%type <key_type>

        key_type opt_unique constraint_key_type

%type <key_alg>

        btree_or_rtree

%type <string_list>

        using_list

%type <key_part>

        key_part

%type <table_list>

        join_table_list  join_table

        table_factor table_ref esc_table_ref

        select_derived derived_table_list

        select_derived_union

%type <interval> interval

%type <interval_time_st> interval_time_st

%type <interval_time_st> interval_time_stamp

%type <column_format_type> column_format_types

%type <tx_isolation> isolation_types

%type <cast_type> cast_type

%type <symbol> keyword keyword_sp

%type <charset>

        collation_name

        collation_name_or_default

%type <variable> internal_variable_name

%type <select_lex> subselect

        get_select_lex query_specification

        query_expression_body

%type <boolfunc2creator> comp_op

%type <build_method> build_method

%type <NONE>

        query verb_clause create select drop insert replace insert2

        insert_values update delete truncate rename

        show describe load alter flush

        begin commit rollback savepoint release

        analyze check start

        field_list field_list_item field_spec kill column_def key_def

        select_item_list select_item values_list no_braces

        opt_limit_clause delete_limit_clause fields opt_values values

        opt_precision opt_ignore opt_column

        set unlock string_list

        ref_list opt_match_clause opt_on_update_delete use

        opt_delete_options opt_delete_option varchar

        opt_outer table_list table_name

        opt_option opt_place

        opt_attribute opt_attribute_list attribute

        flush_options flush_option

        equal optional_braces

        normal_join

        table_to_table_list table_to_table opt_table_list opt_as

        single_multi

        union_clause union_list

        precision subselect_start

        subselect_end select_var_list select_var_list_init opt_len

        opt_extended_describe

        statement

        opt_field_or_var_spec fields_or_vars opt_load_data_set_spec

        init_key_options key_options key_opts key_opt key_using_alg