~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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 ((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)

#define Select Lex->current_select

#include <drizzled/server_includes.h>

#include <drizzled/lex_symbol.h>

#include <drizzled/functions/locate.h>

#include <drizzled/error.h>

#include <drizzled/nested_join.h>

#include <drizzled/sql_parse.h>

#include <drizzled/item/cmpfunc.h>

#include <drizzled/item/timefunc.h>

#include <drizzled/virtual_column_info.h>

#include <drizzled/session.h>

#include <drizzled/item/func.h>

#include <drizzled/sql_base.h>

#include <drizzled/item/create.h>

#include <drizzled/lex_string.h>

class Table_ident;

class Item;

class Item_num;

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

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

  {                                           \

    ulong val= *(F);                          \

    if (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))                             \

  {                                     \

    my_parse_error(ER(ER_SYNTAX_ERROR));\

    DRIZZLE_YYABORT;                      \

  }

/*

  Work around for broken code generated by bison 1.875.

  The code generated by bison 1.875a and later, bison 2.1 and bison 2.2 is ok.

  With bison 1.875 however, the generated code contains:

<pre>

  yyerrlab1:

  #if defined (__GNUC_MINOR__) && 2093 <= (__GNUC__ * 1000 + __GNUC_MINOR__)

    __attribute__ ((__unused__))

  #endif

</pre>

  This usage of __attribute__ is illegal, so we remove it.

  See the following references for details:

  http://lists.gnu.org/archive/html/bug-bison/2004-02/msg00014.html

  http://gcc.gnu.org/bugzilla/show_bug.cgi?id=14273

*/

#if defined (__GNUC_MINOR__) && 2093 <= (__GNUC__ * 1000 + __GNUC_MINOR__)

#undef __attribute__

#define __attribute__(X)

#endif

#define YYDEBUG 0

/**

  @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.

*/

void my_parse_error(const char *s)

{

  Session *session= current_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.

*/

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);

  my_parse_error(s);

}

/**

  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.

*/

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;

      st_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.

 */

bool add_select_to_union_list(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)

  {

    my_parse_error(ER(ER_SYNTAX_ERROR));

    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.

 */

bool setup_select_in_parentheses(LEX *lex) 

{

  SELECT_LEX * sel= lex->current_select;

  if (sel->set_braces(1))

  {

    my_parse_error(ER(ER_SYNTAX_ERROR));

    return true;

  }

  if (sel->linkage == UNION_TYPE &&

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

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

      UNION_TYPE)

  {

    my_parse_error(ER(ER_SYNTAX_ERROR));

    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;

}

%}

%union {

  int  num;

  ulong ulong_num;

  uint64_t ulonglong_number;

  int64_t longlong_number;

  LEX_STRING lex_str;

  LEX_STRING *lex_str_ptr;

  LEX_SYMBOL symbol;

  Table_ident *table;

  char *simple_string;

  Item *item;

  Item_num *item_num;

  List<Item> *item_list;

  List<String> *string_list;

  String *string;

  Key_part_spec *key_part;

  TableList *table_list;

  udf_func *udf;

  LEX_USER *lex_user;

  struct sys_var_with_base variable;

  enum enum_var_type var_type;

  Key::Keytype key_type;

  enum ha_key_alg key_alg;

  handlerton *db_type;

  enum row_type row_type;

  enum column_format_type column_format_type;

  enum ha_rkey_function ha_rkey_mode;

  enum enum_tx_isolation tx_isolation;

  enum Cast_target cast_type;

  enum ha_choice choice;

  const CHARSET_INFO *charset;

  thr_lock_type lock_type;

  struct st_table_lock_info table_lock_info;

  interval_type interval, interval_time_st;

  enum enum_drizzle_timestamp_type date_time_type;

  st_select_lex *select_lex;

  chooser_compare_func_creator boolfunc2creator;

  struct sp_cond_type *spcondtype;

  struct { int vars, conds, hndlrs, curs; } spblock;

  struct st_lex *lex;

  struct p_elem_val *p_elem_value;

  enum index_hint_type index_hint;

  enum enum_filetype filetype;

  enum ha_build_method build_method;

  enum Foreign_key::fk_option m_fk_option;

}

%{

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

%}

%pure_parser                                    /* We have threads */

/*

  Currently there are 93 shift/reduce conflicts.

  We should not introduce new conflicts any more.

*/

%expect 93

/*

   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  ACCESSIBLE_SYM

%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  ALGORITHM_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  ASCII_SYM                     /* MYSQL-FUNC */

%token  ASENSITIVE_SYM                /* FUTURE-USE */

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

%token  AUTHORS_SYM

%token  AUTOEXTEND_SIZE_SYM

%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                        /* SQL-2003-R */

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

%token  BINLOG_SYM

%token  BIN_NUM

%token  BIT_SYM                       /* MYSQL-FUNC */

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

%token  BLOCK_SIZE_SYM

%token  BLOCK_SYM

%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  CACHE_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  CHANGED

%token  CHARSET

%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  COMPLETION_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  CONTEXT_SYM

%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  CURTIME                       /* MYSQL-FUNC */

%token  DATABASE

%token  DATABASES

%token  DATAFILE_SYM

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

%token  DATETIME

%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  DELAYED_SYM

%token  DELAY_KEY_WRITE_SYM

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

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

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

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

%token  DIRECTORY_SYM

%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

%token  EQ                            /* OPERATOR */

%token  EQUAL_SYM                     /* OPERATOR */

%token  ERRORS

%token  ESCAPED

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

%token  EXCLUSIVE_SYM

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

%token  EXIT_SYM

%token  EXTENDED_SYM

%token  EXTENT_SIZE_SYM

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

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

%token  FAST_SYM

%token  FAULTS_SYM

%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  GET_FORMAT                    /* MYSQL-FUNC */

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

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

%token  GROUP_CONCAT_SYM

%token  GT_SYM                        /* OPERATOR */

%token  HANDLER_SYM

%token  HASH_SYM

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

%token  HEX_NUM

%token  HIGH_PRIORITY

%token  HOST_SYM

%token  HOSTS_SYM

%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  INITIAL_SIZE_SYM

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

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

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

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

%token  INSERT_METHOD

%token  INSTALL_SYM

%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  LEAVES

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

%token  LEVEL_SYM

%token  LEX_HOSTNAME

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

%token  LIMIT

%token  LINEAR_SYM

%token  LINES

%token  LINESTRING

%token  LIST_SYM

%token  LOAD

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

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

%token  LOCKS_SYM

%token  LOCK_SYM

%token  LOGFILE_SYM

%token  LOGS_SYM

%token  LONG_NUM

%token  LONG_SYM

%token  LOOP_SYM

%token  LOW_PRIORITY

%token  LT                            /* OPERATOR */

%token  MASTER_CONNECT_RETRY_SYM

%token  MASTER_HOST_SYM

%token  MASTER_LOG_FILE_SYM

%token  MASTER_LOG_POS_SYM

%token  MASTER_PASSWORD_SYM

%token  MASTER_PORT_SYM

%token  MASTER_SERVER_ID_SYM

%token  MASTER_SYM

%token  MASTER_USER_SYM

%token  MASTER_HEARTBEAT_PERIOD_SYM

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

%token  MAX_CONNECTIONS_PER_HOUR

%token  MAX_QUERIES_PER_HOUR

%token  MAX_ROWS

%token  MAX_SIZE_SYM

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

%token  MAX_UPDATES_PER_HOUR

%token  MAX_USER_CONNECTIONS_SYM

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

%token  MEDIUM_SYM

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

%token  MICROSECOND_SYM               /* MYSQL-FUNC */

%token  MIGRATE_SYM

%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  NODEGROUP_SYM

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

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

%token  NOW_SYM

%token  NOWAIT_SYM

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

%token  NO_WAIT_SYM

%token  NO_WRITE_TO_BINLOG

%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

%token  OPTIONS_SYM

%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  PACK_KEYS_SYM

%token  PAGE_SYM

%token  PAGE_CHECKSUM_SYM

%token  PARAM_MARKER

%token  PARSE_VCOL_EXPR_SYM

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

%token  PHASE_SYM

%token  PLUGINS_SYM

%token  PLUGIN_SYM

%token  POINT_SYM

%token  PORT_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  PURGE

%token  QUARTER_SYM

%token  QUERY_SYM

%token  QUICK

%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  REBUILD_SYM

%token  RECOVER_SYM

%token  REDOFILE_SYM

%token  REDO_BUFFER_SIZE_SYM

%token  REDUNDANT_SYM

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

%token  RELAY_LOG_FILE_SYM

%token  RELAY_LOG_POS_SYM

%token  RELAY_THREAD

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

%token  RELOAD

%token  REMOVE_SYM

%token  RENAME

%token  REORGANIZE_SYM

%token  REPAIR

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

%token  REPEAT_SYM                    /* MYSQL-FUNC */

%token  REPLACE                       /* MYSQL-FUNC */

%token  REPLICATION

%token  REQUIRE_SYM

%token  RESET_SYM

%token  RESOURCES

%token  RESTRICT

%token  RESUME_SYM

%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  SHUTDOWN

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

%token  SLAVE

%token  SNAPSHOT_SYM

%token  SOCKET_SYM

%token  SONAME_SYM

%token  SOURCE_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  SQL_THREAD

%token  STARTING

%token  STARTS_SYM

%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  SUPER_SYM

%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  TABLE_CHECKSUM_SYM

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

%token  TEMPTABLE_SYM

%token  TERMINATED

%token  TEXT_STRING

%token  TEXT_SYM

%token  THAN_SYM

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

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

%token  TIMESTAMP_ADD

%token  TIMESTAMP_DIFF

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

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

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

%token  TRANSACTION_SYM

%token  TRANSACTIONAL_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  UNDEFINED_SYM

%token  UNDERSCORE_CHARSET

%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  UNTIL_SYM

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

%token  UPGRADE_SYM

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

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

%token  USE_FRM

%token  USE_SYM

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

%token  UTC_DATE_SYM

%token  UTC_TIMESTAMP_SYM

%token  UTC_TIME_SYM

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

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

%token  VARBINARY

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

%token  VARIABLES

%token  VARIANCE_SYM

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

%token  VAR_SAMP_SYM

%token  VIRTUAL_SYM

%token  WAIT_SYM

%token  WARNINGS

%token  WEEK_SYM

%token  WEIGHT_STRING_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 key_cache_name

        BIN_NUM TEXT_STRING_filesystem ident_or_empty

        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_local opt_table_options table_options

        table_option 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

        opt_transactional_lock_timeout

        /* opt_lock_timeout_value */

%type <m_fk_option>

        delete_option

%type <ulong_num>

        ulong_num real_ulong_num

        ws_nweights

        ws_level_flag_desc ws_level_flag_reverse ws_level_flags

        opt_ws_levels ws_level_list ws_level_list_item ws_level_number

        ws_level_range ws_level_list_or_range  

%type <ulonglong_number>

        ulonglong_num

%type <choice> choice

%type <lock_type>

        replace_lock_option opt_low_priority insert_lock_option load_data_lock

        transactional_lock_mode

%type <table_lock_info>

        table_lock_info

%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 <date_time_type> date_time_type;

%type <interval> interval

%type <interval_time_st> interval_time_st

%type <interval_time_st> interval_time_stamp

%type <db_type> storage_engines known_storage_engines

%type <row_type> row_types

%type <column_format_type> column_format_types