sql_lex.h 70.4 KB
Newer Older
1
/* Copyright 2000-2008 MySQL AB, 2008 Sun Microsystems, Inc.
unknown's avatar
unknown committed
2

unknown's avatar
unknown committed
3 4
   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
unknown's avatar
unknown committed
5
   the Free Software Foundation; version 2 of the License.
unknown's avatar
unknown committed
6

unknown's avatar
unknown committed
7 8 9 10
   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.
unknown's avatar
unknown committed
11

unknown's avatar
unknown committed
12 13 14 15
   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 */

16 17 18
/**
  @defgroup Semantic_Analysis Semantic Analysis
*/
unknown's avatar
unknown committed
19

20 21 22
#ifndef SQL_LEX_INCLUDED
#define SQL_LEX_INCLUDED

23 24 25 26 27
#include "violite.h"                            /* SSL_type */
#include "sql_trigger.h"
#include "item.h"               /* From item_subselect.h: subselect_union_engine */
#include "thr_lock.h"                  /* thr_lock_type, TL_UNLOCK */

unknown's avatar
unknown committed
28 29 30 31 32 33
/* YACC and LEX Definitions */

/* These may not be declared yet */
class Table_ident;
class sql_exchange;
class LEX_COLUMN;
34
class sp_head;
35
class sp_name;
36 37
class sp_instr;
class sp_pcontext;
unknown's avatar
unknown committed
38
class st_alter_tablespace;
39
class partition_info;
40
class Event_parse_data;
41 42
class set_var_base;
class sys_var;
43 44 45 46 47 48
class Item_func_match;
class Alter_drop;
class Alter_column;
class Key;
class File_parser;
class Key_part_spec;
49 50 51 52 53 54 55 56 57

/**
  used by the parser to store internal variable name
*/
struct sys_var_with_base
{
  sys_var *var;
  LEX_STRING base_name;
};
unknown's avatar
unknown committed
58

59
#ifdef MYSQL_SERVER
60 61 62 63
/*
  The following hack is needed because mysql_yacc.cc does not define
  YYSTYPE before including this file
*/
unknown's avatar
unknown committed
64 65 66 67
#ifdef MYSQL_YACC
#define LEX_YYSTYPE void *
#else
#include "lex_symbol.h"
68
#if MYSQL_LEX
69
#include "item_func.h"            /* Cast_target used in sql_yacc.h */
unknown's avatar
unknown committed
70 71
#include "sql_yacc.h"
#define LEX_YYSTYPE YYSTYPE *
72 73 74
#else
#define LEX_YYSTYPE void *
#endif
unknown's avatar
unknown committed
75
#endif
76
#endif
unknown's avatar
unknown committed
77

78 79 80
/*
  When a command is added here, be sure it's also added in mysqld.cc
  in "struct show_var_st status_vars[]= {" ...
81 82 83 84 85

  If the command returns a result set or is not allowed in stored
  functions or triggers, please also make sure that
  sp_get_flags_for_command (sp_head.cc) returns proper flags for the
  added SQLCOM_.
86 87
*/

unknown's avatar
unknown committed
88
enum enum_sql_command {
89 90 91 92 93
  SQLCOM_SELECT, SQLCOM_CREATE_TABLE, SQLCOM_CREATE_INDEX, SQLCOM_ALTER_TABLE,
  SQLCOM_UPDATE, SQLCOM_INSERT, SQLCOM_INSERT_SELECT,
  SQLCOM_DELETE, SQLCOM_TRUNCATE, SQLCOM_DROP_TABLE, SQLCOM_DROP_INDEX,

  SQLCOM_SHOW_DATABASES, SQLCOM_SHOW_TABLES, SQLCOM_SHOW_FIELDS,
94 95
  SQLCOM_SHOW_KEYS, SQLCOM_SHOW_VARIABLES, SQLCOM_SHOW_STATUS,
  SQLCOM_SHOW_ENGINE_LOGS, SQLCOM_SHOW_ENGINE_STATUS, SQLCOM_SHOW_ENGINE_MUTEX,
96
  SQLCOM_SHOW_PROCESSLIST, SQLCOM_SHOW_MASTER_STAT, SQLCOM_SHOW_SLAVE_STAT,
97
  SQLCOM_SHOW_GRANTS, SQLCOM_SHOW_CREATE, SQLCOM_SHOW_CHARSETS,
98
  SQLCOM_SHOW_COLLATIONS, SQLCOM_SHOW_CREATE_DB, SQLCOM_SHOW_TABLE_STATUS,
99
  SQLCOM_SHOW_TRIGGERS,
100

unknown's avatar
unknown committed
101
  SQLCOM_LOAD,SQLCOM_SET_OPTION,SQLCOM_LOCK_TABLES,SQLCOM_UNLOCK_TABLES,
102
  SQLCOM_GRANT,
103
  SQLCOM_CHANGE_DB, SQLCOM_CREATE_DB, SQLCOM_DROP_DB, SQLCOM_ALTER_DB,
104
  SQLCOM_REPAIR, SQLCOM_REPLACE, SQLCOM_REPLACE_SELECT,
105
  SQLCOM_CREATE_FUNCTION, SQLCOM_DROP_FUNCTION,
106
  SQLCOM_REVOKE,SQLCOM_OPTIMIZE, SQLCOM_CHECK,
unknown's avatar
unknown committed
107
  SQLCOM_ASSIGN_TO_KEYCACHE, SQLCOM_PRELOAD_KEYS,
108
  SQLCOM_FLUSH, SQLCOM_KILL, SQLCOM_ANALYZE,
unknown's avatar
unknown committed
109
  SQLCOM_ROLLBACK, SQLCOM_ROLLBACK_TO_SAVEPOINT,
unknown's avatar
unknown committed
110
  SQLCOM_COMMIT, SQLCOM_SAVEPOINT, SQLCOM_RELEASE_SAVEPOINT,
111
  SQLCOM_SLAVE_START, SQLCOM_SLAVE_STOP,
112 113
  SQLCOM_BEGIN, SQLCOM_CHANGE_MASTER,
  SQLCOM_RENAME_TABLE,
114
  SQLCOM_RESET, SQLCOM_PURGE, SQLCOM_PURGE_BEFORE, SQLCOM_SHOW_BINLOGS,
115
  SQLCOM_SHOW_OPEN_TABLES,
116
  SQLCOM_HA_OPEN, SQLCOM_HA_CLOSE, SQLCOM_HA_READ,
117
  SQLCOM_SHOW_SLAVE_HOSTS, SQLCOM_DELETE_MULTI, SQLCOM_UPDATE_MULTI,
unknown's avatar
unknown committed
118
  SQLCOM_SHOW_BINLOG_EVENTS, SQLCOM_SHOW_NEW_MASTER, SQLCOM_DO,
unknown's avatar
unknown committed
119
  SQLCOM_SHOW_WARNS, SQLCOM_EMPTY_QUERY, SQLCOM_SHOW_ERRORS,
120
  SQLCOM_SHOW_STORAGE_ENGINES, SQLCOM_SHOW_PRIVILEGES,
121 122
  SQLCOM_HELP, SQLCOM_CREATE_USER, SQLCOM_DROP_USER, SQLCOM_RENAME_USER,
  SQLCOM_REVOKE_ALL, SQLCOM_CHECKSUM,
123
  SQLCOM_CREATE_PROCEDURE, SQLCOM_CREATE_SPFUNCTION, SQLCOM_CALL,
124
  SQLCOM_DROP_PROCEDURE, SQLCOM_ALTER_PROCEDURE,SQLCOM_ALTER_FUNCTION,
unknown's avatar
unknown committed
125 126
  SQLCOM_SHOW_CREATE_PROC, SQLCOM_SHOW_CREATE_FUNC,
  SQLCOM_SHOW_STATUS_PROC, SQLCOM_SHOW_STATUS_FUNC,
unknown's avatar
unknown committed
127
  SQLCOM_PREPARE, SQLCOM_EXECUTE, SQLCOM_DEALLOCATE_PREPARE,
unknown's avatar
VIEW  
unknown committed
128
  SQLCOM_CREATE_VIEW, SQLCOM_DROP_VIEW,
129
  SQLCOM_CREATE_TRIGGER, SQLCOM_DROP_TRIGGER,
130 131
  SQLCOM_XA_START, SQLCOM_XA_END, SQLCOM_XA_PREPARE,
  SQLCOM_XA_COMMIT, SQLCOM_XA_ROLLBACK, SQLCOM_XA_RECOVER,
unknown's avatar
unknown committed
132
  SQLCOM_SHOW_PROC_CODE, SQLCOM_SHOW_FUNC_CODE,
unknown's avatar
unknown committed
133
  SQLCOM_ALTER_TABLESPACE,
134
  SQLCOM_INSTALL_PLUGIN, SQLCOM_UNINSTALL_PLUGIN,
135 136
  SQLCOM_SHOW_AUTHORS, SQLCOM_BINLOG_BASE64_EVENT,
  SQLCOM_SHOW_PLUGINS,
137
  SQLCOM_SHOW_CONTRIBUTORS,
unknown's avatar
unknown committed
138
  SQLCOM_CREATE_SERVER, SQLCOM_DROP_SERVER, SQLCOM_ALTER_SERVER,
139
  SQLCOM_CREATE_EVENT, SQLCOM_ALTER_EVENT, SQLCOM_DROP_EVENT,
unknown's avatar
unknown committed
140 141
  SQLCOM_SHOW_CREATE_EVENT, SQLCOM_SHOW_EVENTS,
  SQLCOM_SHOW_CREATE_TRIGGER,
142
  SQLCOM_ALTER_DB_UPGRADE,
unknown's avatar
unknown committed
143
  SQLCOM_SHOW_PROFILE, SQLCOM_SHOW_PROFILES,
Marc Alff's avatar
Marc Alff committed
144
  SQLCOM_SIGNAL, SQLCOM_RESIGNAL,
145
  SQLCOM_SHOW_RELAYLOG_EVENTS, 
146 147 148 149
  /*
    When a command is added here, be sure it's also added in mysqld.cc
    in "struct show_var_st status_vars[]= {" ...
  */
150 151
  /* This should be the last !!! */
  SQLCOM_END
unknown's avatar
unknown committed
152 153
};

unknown's avatar
unknown committed
154 155 156
// describe/explain types
#define DESCRIBE_NORMAL		1
#define DESCRIBE_EXTENDED	2
unknown's avatar
unknown committed
157
/*
158
  This is not within #ifdef because we want "EXPLAIN PARTITIONS ..." to produce
unknown's avatar
unknown committed
159 160 161
  additional "partitions" column even if partitioning is not compiled in.
*/
#define DESCRIBE_PARTITIONS	4
unknown's avatar
unknown committed
162

163 164
#ifdef MYSQL_SERVER

165
enum enum_sp_suid_behaviour
unknown's avatar
unknown committed
166
{
167 168 169
  SP_IS_DEFAULT_SUID= 0,
  SP_IS_NOT_SUID,
  SP_IS_SUID
unknown's avatar
unknown committed
170
};
171

172 173 174 175 176 177 178 179 180
enum enum_sp_data_access
{
  SP_DEFAULT_ACCESS= 0,
  SP_CONTAINS_SQL,
  SP_NO_SQL,
  SP_READS_SQL_DATA,
  SP_MODIFIES_SQL_DATA
};

181 182
const LEX_STRING sp_data_access_name[]=
{
unknown's avatar
unknown committed
183 184 185 186 187
  { 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") }
188
};
189

unknown's avatar
VIEW  
unknown committed
190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
#define DERIVED_SUBQUERY	1
#define DERIVED_VIEW		2

enum enum_view_create_mode
{
  VIEW_CREATE_NEW,		// check that there are not such VIEW/table
  VIEW_ALTER,			// check that VIEW .frm with such name exists
  VIEW_CREATE_OR_REPLACE	// check only that there are not such table
};

enum enum_drop_mode
{
  DROP_DEFAULT, // mode is not specified
  DROP_CASCADE, // CASCADE option
  DROP_RESTRICT // RESTRICT option
};

207 208 209 210 211 212
/* Options to add_table_to_list() */
#define TL_OPTION_UPDATING	1
#define TL_OPTION_FORCE_INDEX	2
#define TL_OPTION_IGNORE_LEAVES 4
#define TL_OPTION_ALIAS         8

unknown's avatar
unknown committed
213 214
typedef List<Item> List_item;

unknown's avatar
unknown committed
215 216 217 218 219 220 221 222
/* SERVERS CACHE CHANGES */
typedef struct st_lex_server_options
{
  long port;
  uint server_name_length;
  char *server_name, *host, *db, *username, *password, *scheme, *socket, *owner;
} LEX_SERVER_OPTIONS;

223 224 225 226 227 228 229 230 231

/**
  Structure to hold parameters for CHANGE MASTER or START/STOP SLAVE
  or SHOW NEW MASTER.

  Remark: this should not be confused with Master_info (and perhaps
  would better be renamed to st_lex_replication_info).  Some fields,
  e.g., delay, are saved in Relay_log_info, not in Master_info.
*/
unknown's avatar
unknown committed
232 233
typedef struct st_lex_master_info
{
234
  char *host, *user, *password, *log_file_name;
unknown's avatar
unknown committed
235
  uint port, connect_retry;
Andrei Elkin's avatar
Andrei Elkin committed
236
  float heartbeat_period;
unknown's avatar
unknown committed
237
  ulonglong pos;
unknown's avatar
unknown committed
238
  ulong server_id;
239 240 241 242
  /*
    Enum is used for making it possible to detect if the user
    changed variable or if it should be left at old value
   */
Andrei Elkin's avatar
Andrei Elkin committed
243
  enum {LEX_MI_UNCHANGED, LEX_MI_DISABLE, LEX_MI_ENABLE}
Andrei Elkin's avatar
Andrei Elkin committed
244
    ssl, ssl_verify_server_cert, heartbeat_opt, repl_ignore_server_ids_opt;
unknown's avatar
unknown committed
245
  char *ssl_key, *ssl_cert, *ssl_ca, *ssl_capath, *ssl_cipher;
246
  char *relay_log_name;
247
  ulong relay_log_pos;
Andrei Elkin's avatar
Andrei Elkin committed
248
  DYNAMIC_ARRAY repl_ignore_server_ids;
unknown's avatar
unknown committed
249 250
} LEX_MASTER_INFO;

251

252 253
enum sub_select_type
{
unknown's avatar
unknown committed
254 255
  UNSPECIFIED_TYPE,UNION_TYPE, INTERSECT_TYPE,
  EXCEPT_TYPE, GLOBAL_OPTIONS_TYPE, DERIVED_TABLE_TYPE, OLAP_TYPE
256 257 258 259
};

enum olap_type 
{
260
  UNSPECIFIED_OLAP_TYPE, CUBE_TYPE, ROLLUP_TYPE
261
};
262

unknown's avatar
unknown committed
263 264 265 266 267
enum tablespace_op_type
{
  NO_TABLESPACE_OP, DISCARD_TABLESPACE, IMPORT_TABLESPACE
};

268 269 270 271 272
/* 
  String names used to print a statement with index hints.
  Keep in sync with index_hint_type.
*/
extern const char * index_hint_type_name[];
273
typedef uchar index_clause_map;
274 275 276 277 278 279 280 281 282 283 284 285 286

/*
  Bits in index_clause_map : one for each possible FOR clause in
  USE/FORCE/IGNORE INDEX index hint specification
*/
#define INDEX_HINT_MASK_JOIN  (1)
#define INDEX_HINT_MASK_GROUP (1 << 1)
#define INDEX_HINT_MASK_ORDER (1 << 2)

#define INDEX_HINT_MASK_ALL (INDEX_HINT_MASK_JOIN | INDEX_HINT_MASK_GROUP | \
                             INDEX_HINT_MASK_ORDER)

/* Single element of an USE/FORCE/IGNORE INDEX list specified as a SQL hint  */
unknown's avatar
unknown committed
287
class Index_hint : public Sql_alloc
288 289 290 291 292 293 294 295 296 297 298 299
{
public:
  /* The type of the hint : USE/FORCE/IGNORE */
  enum index_hint_type type;
  /* Where the hit applies to. A bitmask of INDEX_HINT_MASK_<place> values */
  index_clause_map clause;
  /* 
    The index name. Empty (str=NULL) name represents an empty list 
    USE INDEX () clause 
  */ 
  LEX_STRING key_name;

unknown's avatar
unknown committed
300
  Index_hint (enum index_hint_type type_arg, index_clause_map clause_arg,
301 302 303 304 305 306
              char *str, uint length) :
    type(type_arg), clause(clause_arg)
  {
    key_name.str= str;
    key_name.length= length;
  }
307 308

  void print(THD *thd, String *str);
309 310
}; 

unknown's avatar
unknown committed
311 312 313
/* 
  The state of the lex parsing for selects 
   
314 315 316 317 318 319 320 321 322 323
   master and slaves are pointers to select_lex.
   master is pointer to upper level node.
   slave is pointer to lower level node
   select_lex is a SELECT without union
   unit is container of either
     - One SELECT
     - UNION of selects
   select_lex and unit are both inherited form select_lex_node
   neighbors are two select_lex or units on the same level

unknown's avatar
unknown committed
324
   All select describing structures linked with following pointers:
325
   - list of neighbors (next/prev) (prev of first element point to slave
unknown's avatar
unknown committed
326
     pointer of upper structure)
327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353
     - For select this is a list of UNION's (or one element list)
     - For units this is a list of sub queries for the upper level select

   - pointer to master (master), which is
     If this is a unit
       - pointer to outer select_lex
     If this is a select_lex
       - pointer to outer unit structure for select

   - pointer to slave (slave), which is either:
     If this is a unit:
       - first SELECT that belong to this unit
     If this is a select_lex
       - first unit that belong to this SELECT (subquries or derived tables)

   - list of all select_lex (link_next/link_prev)
     This is to be used for things like derived tables creation, where we
     go through this list and create the derived tables.

   If unit contain several selects (UNION now, INTERSECT etc later)
   then it have special select_lex called fake_select_lex. It used for
   storing global parameters (like ORDER BY, LIMIT) and executing union.
   Subqueries used in global ORDER BY clause will be attached to this
   fake_select_lex, which will allow them correctly resolve fields of
   'upper' UNION and outer selects.

   For example for following query:
354

unknown's avatar
unknown committed
355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
   select *
     from table1
     where table1.field IN (select * from table1_1_1 union
                            select * from table1_1_2)
     union
   select *
     from table2
     where table2.field=(select (select f1 from table2_1_1_1_1
                                   where table2_1_1_1_1.f2=table2_1_1.f3)
                           from table2_1_1
                           where table2_1_1.f1=table2.f2)
     union
   select * from table3;

   we will have following structure:

371 372 373 374 375
   select1: (select * from table1 ...)
   select2: (select * from table2 ...)
   select3: (select * from table3)
   select1.1.1: (select * from table1_1_1)
   ...
unknown's avatar
unknown committed
376 377

     main unit
unknown's avatar
unknown committed
378
     fake0
unknown's avatar
unknown committed
379 380 381 382 383 384 385 386
     select1 select2 select3
     |^^     |^
    s|||     ||master
    l|||     |+---------------------------------+
    a|||     +---------------------------------+|
    v|||master                         slave   ||
    e||+-------------------------+             ||
     V|            neighbor      |             V|
unknown's avatar
unknown committed
387
     unit1.1<+==================>unit1.2       unit2.1
unknown's avatar
unknown committed
388 389
     fake1.1
     select1.1.1 select 1.1.2    select1.2.1   select2.1.1
unknown's avatar
unknown committed
390 391 392 393 394 395 396 397
                                               |^
                                               ||
                                               V|
                                               unit2.1.1.1
                                               select2.1.1.1.1


   relation in main unit will be following:
398 399 400 401 402 403
   (bigger picture for:
      main unit
      fake0
      select1 select2 select3
   in the above picture)

unknown's avatar
unknown committed
404
         main unit
unknown's avatar
unknown committed
405 406 407 408 409 410 411 412
         |^^^^|fake_select_lex
         |||||+--------------------------------------------+
         ||||+--------------------------------------------+|
         |||+------------------------------+              ||
         ||+--------------+                |              ||
    slave||master         |                |              ||
         V|      neighbor |       neighbor |        master|V
         select1<========>select2<========>select3        fake0
unknown's avatar
unknown committed
413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428

    list of all select_lex will be following (as it will be constructed by
    parser):

    select1->select2->select3->select2.1.1->select 2.1.2->select2.1.1.1.1-+
                                                                          |
    +---------------------------------------------------------------------+
    |
    +->select1.1.1->select1.1.2

*/

/* 
    Base class for st_select_lex (SELECT_LEX) & 
    st_select_lex_unit (SELECT_LEX_UNIT)
*/
Konstantin Osipov's avatar
Konstantin Osipov committed
429
struct LEX;
430 431
class st_select_lex;
class st_select_lex_unit;
Tor Didriksen's avatar
Tor Didriksen committed
432 433


434 435
class st_select_lex_node {
protected:
unknown's avatar
unknown committed
436 437 438
  st_select_lex_node *next, **prev,   /* neighbor list */
    *master, *slave,                  /* vertical links */
    *link_next, **link_prev;          /* list of whole SELECT_LEX */
439
public:
unknown's avatar
unknown committed
440

441
  ulonglong options;
442 443 444 445 446 447 448 449

  /*
    In sql_cache we store SQL_CACHE flag as specified by user to be
    able to restore SELECT statement from internal structures.
  */
  enum e_sql_cache { SQL_CACHE_UNSPECIFIED, SQL_NO_CACHE, SQL_CACHE };
  e_sql_cache sql_cache;

450 451 452 453
  /*
    result of this query can't be cached, bit field, can be :
      UNCACHEABLE_DEPENDENT
      UNCACHEABLE_RAND
454
      UNCACHEABLE_SIDEEFFECT
455
      UNCACHEABLE_EXPLAIN
456
      UNCACHEABLE_PREPARE
457 458
  */
  uint8 uncacheable;
459
  enum sub_select_type linkage;
unknown's avatar
unknown committed
460
  bool no_table_names_allowed; /* used for global order by */
461
  bool no_error; /* suppress error message (convert it to warnings) */
462

463
  static void *operator new(size_t size) throw ()
464
  {
465
    return sql_alloc(size);
466
  }
467
  static void *operator new(size_t size, MEM_ROOT *mem_root) throw ()
unknown's avatar
unknown committed
468
  { return (void*) alloc_root(mem_root, (uint) size); }
unknown's avatar
unknown committed
469
  static void operator delete(void *ptr,size_t size) { TRASH(ptr, size); }
470
  static void operator delete(void *ptr, MEM_ROOT *mem_root) {}
Tor Didriksen's avatar
Tor Didriksen committed
471 472 473 474 475 476 477 478 479

  // Ensures that at least all members used during cleanup() are initialized.
  st_select_lex_node()
    : next(NULL), prev(NULL),
      master(NULL), slave(NULL),
      link_next(NULL), link_prev(NULL),
      linkage(UNSPECIFIED_TYPE)
  {
  }
480
  virtual ~st_select_lex_node() {}
Tor Didriksen's avatar
Tor Didriksen committed
481

482 483 484
  inline st_select_lex_node* get_master() { return master; }
  virtual void init_query();
  virtual void init_select();
unknown's avatar
unknown committed
485 486
  void include_down(st_select_lex_node *upper);
  void include_neighbour(st_select_lex_node *before);
unknown's avatar
unknown committed
487
  void include_standalone(st_select_lex_node *sel, st_select_lex_node **ref);
unknown's avatar
unknown committed
488 489
  void include_global(st_select_lex_node **plink);
  void exclude();
490 491 492

  virtual st_select_lex_unit* master_unit()= 0;
  virtual st_select_lex* outer_select()= 0;
unknown's avatar
unknown committed
493
  virtual st_select_lex* return_after_parsing()= 0;
494 495 496 497 498 499

  virtual bool set_braces(bool value);
  virtual bool inc_in_sum_expr();
  virtual uint get_in_sum_expr();
  virtual TABLE_LIST* get_table_list();
  virtual List<Item>* get_item_list();
unknown's avatar
unknown committed
500
  virtual ulong get_table_join_options();
unknown's avatar
unknown committed
501
  virtual TABLE_LIST *add_table_to_list(THD *thd, Table_ident *table,
502
					LEX_STRING *alias,
unknown's avatar
unknown committed
503
					ulong table_options,
504
					thr_lock_type flags= TL_UNLOCK,
505
                                        enum_mdl_type mdl_type= MDL_SHARED_READ,
unknown's avatar
unknown committed
506
					List<Index_hint> *hints= 0,
unknown's avatar
unknown committed
507
                                        LEX_STRING *option= 0);
unknown's avatar
unknown committed
508
  virtual void set_lock_for_tables(thr_lock_type lock_type) {}
unknown's avatar
unknown committed
509

unknown's avatar
unknown committed
510
  friend class st_select_lex_unit;
Konstantin Osipov's avatar
Konstantin Osipov committed
511
  friend bool mysql_new_select(LEX *lex, bool move_down);
512
  friend bool mysql_make_view(THD *thd, File_parser *parser,
513
                              TABLE_LIST *table, uint flags);
unknown's avatar
unknown committed
514 515 516
private:
  void fast_exclude();
};
517
typedef class st_select_lex_node SELECT_LEX_NODE;
unknown's avatar
unknown committed
518 519 520 521 522

/* 
   SELECT_LEX_UNIT - unit of selects (UNION, INTERSECT, ...) group 
   SELECT_LEXs
*/
unknown's avatar
unknown committed
523 524 525 526
class THD;
class select_result;
class JOIN;
class select_union;
527
class Procedure;
Tor Didriksen's avatar
Tor Didriksen committed
528 529


530
class st_select_lex_unit: public st_select_lex_node {
unknown's avatar
unknown committed
531 532 533 534
protected:
  TABLE_LIST result_table_list;
  select_union *union_result;
  TABLE *table; /* temporary table using for appending UNION results */
535

unknown's avatar
unknown committed
536
  select_result *result;
537
  ulonglong found_rows_for_union;
538 539
  bool saved_error;

540
public:
Tor Didriksen's avatar
Tor Didriksen committed
541 542 543 544 545 546 547 548
  // Ensures that at least all members used during cleanup() are initialized.
  st_select_lex_unit()
    : union_result(NULL), table(NULL), result(NULL),
      cleaned(false),
      fake_select_lex(NULL)
  {
  }

unknown's avatar
unknown committed
549
  bool  prepared, // prepare phase already performed for UNION (unit)
unknown's avatar
unknown committed
550
    optimized, // optimize phase already performed for UNION (unit)
551 552
    executed, // already executed
    cleaned;
553 554 555

  // list of fields which points to temporary table for union
  List<Item> item_list;
unknown's avatar
unknown committed
556 557 558 559 560 561 562
  /*
    list of types of items inside union (used for union & derived tables)
    
    Item_type_holders from which this list consist may have pointers to Field,
    pointers is valid only after preparing SELECTS of this unit and before
    any SELECT of this unit execution
  */
563
  List<Item> types;
unknown's avatar
unknown committed
564 565 566 567
  /*
    Pointer to 'last' select or pointer to unit where stored
    global parameters for union
  */
unknown's avatar
unknown committed
568
  st_select_lex *global_parameters;
569
  //node on wich we should return current_select pointer after parsing subquery
unknown's avatar
unknown committed
570
  st_select_lex *return_to;
unknown's avatar
unknown committed
571 572
  /* LIMIT clause runtime counters */
  ha_rows select_limit_cnt, offset_limit_cnt;
573
  /* not NULL if unit used in subselect, point to subselect item */
unknown's avatar
unknown committed
574
  Item_subselect *item;
unknown's avatar
unknown committed
575
  /* thread handler */
576
  THD *thd;
unknown's avatar
unknown committed
577 578 579 580
  /*
    SELECT_LEX for hidden SELECT in onion which process global
    ORDER BY and LIMIT
  */
unknown's avatar
unknown committed
581
  st_select_lex *fake_select_lex;
582

583
  st_select_lex *union_distinct; /* pointer to the last UNION DISTINCT */
584
  bool describe; /* union exec() called for EXPLAIN */
585
  Procedure *last_procedure;	 /* Pointer to procedure, if such exists */
unknown's avatar
unknown committed
586

unknown's avatar
unknown committed
587
  void init_query();
588 589
  st_select_lex_unit* master_unit();
  st_select_lex* outer_select();
590 591 592 593 594 595 596
  st_select_lex* first_select()
  {
    return my_reinterpret_cast(st_select_lex*)(slave);
  }
  st_select_lex_unit* next_unit()
  {
    return my_reinterpret_cast(st_select_lex_unit*)(next);
597
  }
unknown's avatar
unknown committed
598
  st_select_lex* return_after_parsing() { return return_to; }
unknown's avatar
unknown committed
599
  void exclude_level();
600
  void exclude_tree();
601

unknown's avatar
unknown committed
602
  /* UNION methods */
603
  bool prepare(THD *thd, select_result *result, ulong additional_options);
unknown's avatar
unknown committed
604 605
  bool exec();
  bool cleanup();
606
  inline void unclean() { cleaned= 0; }
unknown's avatar
unknown committed
607
  void reinit_exec_mechanism();
unknown's avatar
unknown committed
608

609
  void print(String *str, enum_query_type query_type);
610

unknown's avatar
unknown committed
611
  bool add_fake_select_lex(THD *thd);
612
  void init_prepare_fake_select_lex(THD *thd);
613
  inline bool is_prepared() { return prepared; }
unknown's avatar
unknown committed
614
  bool change_result(select_subselect *result, select_subselect *old_result);
615
  void set_limit(st_select_lex *values);
616
  void set_thd(THD *thd_arg) { thd= thd_arg; }
unknown's avatar
unknown committed
617
  inline bool is_union (); 
unknown's avatar
unknown committed
618

619
  friend void lex_start(THD *thd);
620
  friend int subselect_union_engine::exec();
621 622

  List<Item> *get_unit_column_types();
unknown's avatar
unknown committed
623
};
624

unknown's avatar
unknown committed
625
typedef class st_select_lex_unit SELECT_LEX_UNIT;
unknown's avatar
unknown committed
626 627

/*
628
  SELECT_LEX - store information of parsed SELECT statment
unknown's avatar
unknown committed
629
*/
630 631
class st_select_lex: public st_select_lex_node
{
632
public:
633
  Name_resolution_context context;
unknown's avatar
unknown committed
634
  char *db;
unknown's avatar
unknown committed
635
  Item *where, *having;                         /* WHERE & HAVING clauses */
636
  Item *prep_where; /* saved WHERE clause for prepared statement processing */
unknown's avatar
unknown committed
637
  Item *prep_having;/* saved HAVING clause for prepared statement processing */
638 639
  /* Saved values of the WHERE and HAVING clauses*/
  Item::cond_result cond_value, having_value;
unknown's avatar
VIEW  
unknown committed
640
  /* point on lex in which it was created, used in view subquery detection */
Konstantin Osipov's avatar
Konstantin Osipov committed
641
  LEX *parent_lex;
642
  enum olap_type olap;
unknown's avatar
unknown committed
643 644 645 646
  /* FROM clause - points to the beginning of the TABLE_LIST::next_local list. */
  SQL_LIST	      table_list;
  SQL_LIST	      group_list; /* GROUP BY clause. */
  List<Item>          item_list;  /* list of fields & expressions */
647
  List<String>        interval_list;
unknown's avatar
unknown committed
648
  bool	              is_item_list_lookup;
unknown's avatar
unknown committed
649 650 651 652 653 654
  /* 
    Usualy it is pointer to ftfunc_list_alloc, but in union used to create fake
    select_lex for calling mysql_select under results of union
  */
  List<Item_func_match> *ftfunc_list;
  List<Item_func_match> ftfunc_list_alloc;
unknown's avatar
unknown committed
655
  JOIN *join; /* after JOIN::prepare it is pointer to corresponding JOIN */
656
  List<TABLE_LIST> top_join_list; /* join list of the top level          */
657
  List<TABLE_LIST> *join_list;    /* list for the currently parsed join  */
658
  TABLE_LIST *embedding;          /* table embedding to the above list   */
unknown's avatar
unknown committed
659 660 661 662 663 664
  /*
    Beginning of the list of leaves in a FROM clause, where the leaves
    inlcude all base tables including view tables. The tables are connected
    by TABLE_LIST::next_leaf, so leaf_tables points to the left-most leaf.
  */
  TABLE_LIST *leaf_tables;
665
  const char *type;               /* type of select for EXPLAIN          */
unknown's avatar
unknown committed
666 667

  SQL_LIST order_list;                /* ORDER clause */
unknown's avatar
unknown committed
668
  SQL_LIST *gorder_list;
669
  Item *select_limit, *offset_limit;  /* LIMIT clause parameters */
unknown's avatar
unknown committed
670 671 672
  // Arrays of pointers to top elements of all_fields list
  Item **ref_pointer_array;

unknown's avatar
merge  
unknown committed
673 674 675 676 677 678
  /*
    number of items in select_list and HAVING clause used to get number
    bigger then can be number of entries that will be added to all item
    list during split_sum_func
  */
  uint select_n_having_items;
679
  uint cond_count;    /* number of arguments of and/or/xor in where/having/on */
unknown's avatar
unknown committed
680 681
  uint between_count; /* number of between predicates in where/having/on      */
  uint max_equal_elems; /* maximal number of elements in multiple equalities  */   
unknown's avatar
unknown committed
682 683 684 685 686
  /*
    Number of fields used in select list or where clause of current select
    and all inner subselects.
  */
  uint select_n_where_fields;
unknown's avatar
unknown committed
687 688 689
  enum_parsing_place parsing_place; /* where we are parsing expression */
  bool with_sum_func;   /* sum function indicator */

unknown's avatar
unknown committed
690
  ulong table_join_options;
691
  uint in_sum_expr;
unknown's avatar
unknown committed
692
  uint select_number; /* number of select (used for EXPLAIN) */
unknown's avatar
unknown committed
693 694
  int nest_level;     /* nesting level of select */
  Item_sum *inner_sum_func_list; /* list of sum func in nested selects */ 
695
  uint with_wild; /* item list contain '*' */
unknown's avatar
unknown committed
696 697 698
  bool  braces;   	/* SELECT ... UNION (SELECT ... ) <- this braces */
  /* TRUE when having fix field called in processing of this SELECT */
  bool having_fix_field;
699 700
  /* TRUE when GROUP BY fix field called in processing of this SELECT */
  bool group_fix_field;
701 702
  /* List of references to fields referenced from inner selects */
  List<Item_outer_ref> inner_refs_list;
703 704 705 706 707
  /* Number of Item_sum-derived objects in this SELECT */
  uint n_sum_items;
  /* Number of Item_sum-derived objects in children and descendant SELECTs */
  uint n_child_sum_items;

708 709
  /* explicit LIMIT clause was used */
  bool explicit_limit;
710 711 712 713 714
  /*
    there are subquery in HAVING clause => we can't close tables before
    query processing end even if we use temporary table
  */
  bool subquery_in_having;
715 716
  /* TRUE <=> this SELECT is correlated w.r.t. some ancestor select */
  bool is_correlated;
717 718 719 720 721 722 723 724 725 726 727 728 729
  /*
    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;
730
  bool first_natural_join_processing;
unknown's avatar
unknown committed
731
  bool first_cond_optimization;
unknown's avatar
unknown committed
732 733
  /* do not wrap view fields with Item_ref */
  bool no_wrap_view_item;
734 735
  /* exclude this select from check of unique_table() */
  bool exclude_from_table_unique_test;
736 737 738 739
  /* List of fields that aren't under an aggregate function */
  List<Item_field> non_agg_fields;
  /* index in the select list of the expression currently being fixed */
  int cur_pos_in_select_list;
740

741
  List<udf_func>     udf_list;                  /* udf function calls stack */
742

743 744 745 746 747 748 749 750 751 752 753 754 755 756
  /* 
    This is a copy of the original JOIN USING list that comes from
    the parser. The parser :
      1. Sets the natural_join of the second TABLE_LIST in the join
         and the st_select_lex::prev_join_using.
      2. Makes a parent TABLE_LIST and sets its is_natural_join/
       join_using_fields members.
      3. Uses the wrapper TABLE_LIST as a table in the upper level.
    We cannot assign directly to join_using_fields in the parser because
    at stage (1.) the parent TABLE_LIST is not constructed yet and
    the assignment will override the JOIN USING fields of the lower level
    joins on the right.
  */
  List<String> *prev_join_using;
757 758 759 760 761 762 763 764 765 766
  /*
    Bitmap used in the ONLY_FULL_GROUP_BY_MODE to prevent mixture of aggregate
    functions and non aggregated fields when GROUP BY list is absent.
    Bits:
      0 - non aggregated fields are used in this select,
          defined as NON_AGG_FIELD_USED.
      1 - aggregate functions are used in this select,
          defined as SUM_FUNC_USED.
  */
  uint8 full_group_by_flag;
unknown's avatar
unknown committed
767 768
  void init_query();
  void init_select();
769
  st_select_lex_unit* master_unit();
770 771 772 773
  st_select_lex_unit* first_inner_unit() 
  { 
    return (st_select_lex_unit*) slave; 
  }
774
  st_select_lex* outer_select();
775
  st_select_lex* next_select() { return (st_select_lex*) next; }
776
  st_select_lex* next_select_in_list() 
777 778 779 780 781 782 783
  {
    return (st_select_lex*) link_next;
  }
  st_select_lex_node** next_select_in_list_addr()
  {
    return &link_next;
  }
unknown's avatar
unknown committed
784
  st_select_lex* return_after_parsing()
785 786 787
  {
    return master_unit()->return_after_parsing();
  }
788

unknown's avatar
unknown committed
789 790
  void mark_as_dependent(st_select_lex *last);

791 792 793
  bool set_braces(bool value);
  bool inc_in_sum_expr();
  uint get_in_sum_expr();
unknown's avatar
unknown committed
794

unknown's avatar
unknown committed
795 796
  bool add_item_to_list(THD *thd, Item *item);
  bool add_group_to_list(THD *thd, Item *item, bool asc);
797
  bool add_ftfunc_to_list(Item_func_match *func);
unknown's avatar
unknown committed
798
  bool add_order_to_list(THD *thd, Item *item, bool asc);
unknown's avatar
unknown committed
799
  TABLE_LIST* add_table_to_list(THD *thd, Table_ident *table,
800
				LEX_STRING *alias,
unknown's avatar
unknown committed
801
				ulong table_options,
802
				thr_lock_type flags= TL_UNLOCK,
803
                                enum_mdl_type mdl_type= MDL_SHARED_READ,
unknown's avatar
unknown committed
804
				List<Index_hint> *hints= 0,
805
                                LEX_STRING *option= 0);
unknown's avatar
unknown committed
806
  TABLE_LIST* get_table_list();
807 808 809 810 811
  bool init_nested_join(THD *thd);
  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();
unknown's avatar
unknown committed
812 813
  List<Item>* get_item_list();
  ulong get_table_join_options();
unknown's avatar
unknown committed
814
  void set_lock_for_tables(thr_lock_type lock_type);
815 816 817 818
  inline void init_order()
  {
    order_list.elements= 0;
    order_list.first= 0;
819
    order_list.next= (uchar**) &order_list.first;
820
  }
821 822 823 824 825 826 827
  /*
    This method created for reiniting LEX in mysql_admin_table() and can be
    used only if you are going remove all SELECT_LEX & units except belonger
    to LEX (LEX::unit & LEX::select, for other purposes there are
    SELECT_LEX_UNIT::exclude_level & SELECT_LEX_UNIT::exclude_tree
  */
  void cut_subtree() { slave= 0; }
unknown's avatar
unknown committed
828 829
  bool test_limit();

830
  friend void lex_start(THD *thd);
831
  st_select_lex() : n_sum_items(0), n_child_sum_items(0) {}
unknown's avatar
unknown committed
832
  void make_empty_select()
833 834 835 836
  {
    init_query();
    init_select();
  }
unknown's avatar
unknown committed
837
  bool setup_ref_array(THD *thd, uint order_group_num);
838 839 840 841 842
  void print(THD *thd, String *str, enum_query_type query_type);
  static void print_order(String *str,
                          ORDER *order,
                          enum_query_type query_type);
  void print_limit(THD *thd, String *str, enum_query_type query_type);
843
  void fix_prepare_information(THD *thd, Item **conds, Item **having_conds);
844 845 846 847 848
  /*
    Destroy the used execution plan (JOIN) of this subtree (this
    SELECT_LEX and all nested SELECT_LEXes and SELECT_LEX_UNITs).
  */
  bool cleanup();
849 850 851 852 853
  /*
    Recursively cleanup the join of this select lex and of all nested
    select lexes.
  */
  void cleanup_all_joins(bool full);
854 855 856 857 858 859 860 861 862 863 864 865

  void set_index_hint_type(enum index_hint_type type, index_clause_map clause);

  /* 
   Add a index hint to the tagged list of hints. The type and clause of the
   hint will be the current ones (set by set_index_hint()) 
  */
  bool add_index_hint (THD *thd, char *str, uint length);

  /* make a list to hold index hints */
  void alloc_index_hints (THD *thd);
  /* read and clear the index hints */
unknown's avatar
unknown committed
866
  List<Index_hint>* pop_index_hints(void) 
867
  {
unknown's avatar
unknown committed
868
    List<Index_hint> *hints= index_hints;
869 870 871 872 873 874 875 876 877 878 879
    index_hints= NULL;
    return hints;
  }

  void clear_index_hints(void) { index_hints= NULL; }

private:  
  /* current index hint kind. used in filling up index_hints */
  enum index_hint_type current_index_hint_type;
  index_clause_map current_index_hint_clause;
  /* a list of USE/FORCE/IGNORE INDEX */
unknown's avatar
unknown committed
880
  List<Index_hint> *index_hints;
unknown's avatar
unknown committed
881
};
unknown's avatar
unknown committed
882
typedef class st_select_lex SELECT_LEX;
883

unknown's avatar
unknown committed
884 885 886 887 888 889
inline bool st_select_lex_unit::is_union ()
{ 
  return first_select()->next_select() && 
    first_select()->next_select()->linkage == UNION_TYPE;
}

unknown's avatar
unknown committed
890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907
#define ALTER_ADD_COLUMN	(1L << 0)
#define ALTER_DROP_COLUMN	(1L << 1)
#define ALTER_CHANGE_COLUMN	(1L << 2)
#define ALTER_ADD_INDEX		(1L << 3)
#define ALTER_DROP_INDEX	(1L << 4)
#define ALTER_RENAME		(1L << 5)
#define ALTER_ORDER		(1L << 6)
#define ALTER_OPTIONS		(1L << 7)
#define ALTER_CHANGE_COLUMN_DEFAULT (1L << 8)
#define ALTER_KEYS_ONOFF        (1L << 9)
#define ALTER_CONVERT           (1L << 10)
#define ALTER_FORCE		(1L << 11)
#define ALTER_RECREATE          (1L << 12)
#define ALTER_ADD_PARTITION     (1L << 13)
#define ALTER_DROP_PARTITION    (1L << 14)
#define ALTER_COALESCE_PARTITION (1L << 15)
#define ALTER_REORGANIZE_PARTITION (1L << 16) 
#define ALTER_PARTITION          (1L << 17)
908
#define ALTER_ADMIN_PARTITION    (1L << 18)
unknown's avatar
unknown committed
909 910 911
#define ALTER_TABLE_REORG        (1L << 19)
#define ALTER_REBUILD_PARTITION  (1L << 20)
#define ALTER_ALL_PARTITION      (1L << 21)
912 913
#define ALTER_REMOVE_PARTITIONING (1L << 22)
#define ALTER_FOREIGN_KEY        (1L << 23)
914

unknown's avatar
unknown committed
915 916 917 918 919 920 921
enum enum_alter_table_change_level
{
  ALTER_TABLE_METADATA_ONLY= 0,
  ALTER_TABLE_DATA_CHANGED= 1,
  ALTER_TABLE_INDEX_CHANGED= 2
};

922 923 924 925 926 927 928 929
/**
  @brief Parsing data for CREATE or ALTER TABLE.

  This structure contains a list of columns or indexes to be created,
  altered or dropped.
*/

class Alter_info
930
{
931
public:
unknown's avatar
unknown committed
932 933 934
  List<Alter_drop>              drop_list;
  List<Alter_column>            alter_list;
  List<Key>                     key_list;
unknown's avatar
unknown committed
935
  List<Create_field>            create_list;
unknown's avatar
unknown committed
936 937 938 939
  uint                          flags;
  enum enum_enable_or_disable   keys_onoff;
  enum tablespace_op_type       tablespace_op;
  List<char>                    partition_names;
940
  uint                          num_parts;
unknown's avatar
unknown committed
941
  enum_alter_table_change_level change_level;
unknown's avatar
unknown committed
942
  Create_field                 *datetime_field;
unknown's avatar
unknown committed
943 944
  bool                          error_if_not_empty;

945

946 947 948 949
  Alter_info() :
    flags(0),
    keys_onoff(LEAVE_AS_IS),
    tablespace_op(NO_TABLESPACE_OP),
950
    num_parts(0),
unknown's avatar
unknown committed
951 952 953
    change_level(ALTER_TABLE_METADATA_ONLY),
    datetime_field(NULL),
    error_if_not_empty(FALSE)
954 955 956
  {}

  void reset()
unknown's avatar
unknown committed
957
  {
958 959 960 961 962
    drop_list.empty();
    alter_list.empty();
    key_list.empty();
    create_list.empty();
    flags= 0;
unknown's avatar
unknown committed
963 964
    keys_onoff= LEAVE_AS_IS;
    tablespace_op= NO_TABLESPACE_OP;
965
    num_parts= 0;
unknown's avatar
unknown committed
966
    partition_names.empty();
unknown's avatar
unknown committed
967 968 969
    change_level= ALTER_TABLE_METADATA_ONLY;
    datetime_field= 0;
    error_if_not_empty= FALSE;
unknown's avatar
unknown committed
970
  }
971 972 973 974 975
  Alter_info(const Alter_info &rhs, MEM_ROOT *mem_root);
private:
  Alter_info &operator=(const Alter_info &rhs); // not implemented
  Alter_info(const Alter_info &rhs);            // not implemented
};
976

977 978 979
struct st_sp_chistics
{
  LEX_STRING comment;
980
  enum enum_sp_suid_behaviour suid;
981
  bool detistic;
982
  enum enum_sp_data_access daccess;
983 984
};

985 986 987 988 989 990 991

struct st_trg_chistics
{
  enum trg_action_time_type action_time;
  enum trg_event_type event;
};

992
extern sys_var *trg_new_row_fake_var;
993

994 995 996
enum xa_option_words {XA_NONE, XA_JOIN, XA_RESUME, XA_ONE_PHASE,
                      XA_SUSPEND, XA_FOR_MIGRATE};

997
extern const LEX_STRING null_lex_str;
998
extern const LEX_STRING empty_lex_str;
999

1000 1001

/*
1002 1003 1004 1005 1006
  Class representing list of all tables used by statement and other
  information which is necessary for opening and locking its tables,
  like SQL command for this statement.

  Also contains information about stored functions used by statement
1007 1008 1009 1010
  since during its execution we may have to add all tables used by its
  stored functions/triggers to this list in order to pre-open and lock
  them.

Konstantin Osipov's avatar
Konstantin Osipov committed
1011
  Also used by LEX::reset_n_backup/restore_backup_query_tables_list()
1012 1013 1014 1015 1016 1017
  methods to save and restore this information.
*/

class Query_tables_list
{
public:
1018 1019 1020 1021 1022 1023 1024
  /**
    SQL command for this statement. Part of this class since the
    process of opening and locking tables for the statement needs
    this information to determine correct type of lock for some of
    the tables.
  */
  enum_sql_command sql_command;
1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
  /* Global list of all tables used by this statement */
  TABLE_LIST *query_tables;
  /* Pointer to next_global member of last element in the previous list. */
  TABLE_LIST **query_tables_last;
  /*
    If non-0 then indicates that query requires prelocking and points to
    next_global member of last own element in query table list (i.e. last
    table which was not added to it as part of preparation to prelocking).
    0 - indicates that this query does not need prelocking.
  */
  TABLE_LIST **query_tables_own_last;
1036 1037 1038 1039 1040
  /*
    Set of stored routines called by statement.
    (Note that we use lazy-initialization for this hash).
  */
  enum { START_SROUTINES_HASH_SIZE= 16 };
1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051
  HASH sroutines;
  /*
    List linking elements of 'sroutines' set. Allows you to add new elements
    to this set as you iterate through the list of existing elements.
    'sroutines_list_own_last' is pointer to ::next member of last element of
    this list which represents routine which is explicitly used by query.
    'sroutines_list_own_elements' number of explicitly used routines.
    We use these two members for restoring of 'sroutines_list' to the state
    in which it was right after query parsing.
  */
  SQL_LIST sroutines_list;
1052
  uchar    **sroutines_list_own_last;
1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069
  uint     sroutines_list_own_elements;

  /*
    These constructor and destructor serve for creation/destruction
    of Query_tables_list instances which are used as backup storage.
  */
  Query_tables_list() {}
  ~Query_tables_list() {}

  /* Initializes (or resets) Query_tables_list object for "real" use. */
  void reset_query_tables_list(bool init);
  void destroy_query_tables_list();
  void set_query_tables_list(Query_tables_list *state)
  {
    *this= *state;
  }

unknown's avatar
unknown committed
1070 1071 1072 1073 1074
  /*
    Direct addition to the list of query tables.
    If you are using this function, you must ensure that the table
    object, in particular table->db member, is initialized.
  */
1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
  void add_to_query_tables(TABLE_LIST *table)
  {
    *(table->prev_global= query_tables_last)= table;
    query_tables_last= &table->next_global;
  }
  bool requires_prelocking()
  {
    return test(query_tables_own_last);
  }
  void mark_as_requiring_prelocking(TABLE_LIST **tables_own_last)
  {
    query_tables_own_last= tables_own_last;
  }
  /* Return pointer to first not-own table in query-tables or 0 */
  TABLE_LIST* first_not_own_table()
  {
    return ( query_tables_own_last ? *query_tables_own_last : 0);
  }
  void chop_off_not_own_tables()
  {
    if (query_tables_own_last)
    {
      *query_tables_own_last= 0;
      query_tables_last= query_tables_own_last;
      query_tables_own_last= 0;
    }
  }
1102

Konstantin Osipov's avatar
Konstantin Osipov committed
1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113
  /** Return a pointer to the last element in query table list. */
  TABLE_LIST *last_table()
  {
    /* Don't use offsetof() macro in order to avoid warnings. */
    return query_tables ?
           (TABLE_LIST*) ((char*) query_tables_last -
                          ((char*) &(query_tables->next_global) -
                           (char*) query_tables)) :
           0;
  }

1114
  /**
1115
    Enumeration listing of all types of unsafe statement.
1116

1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137
    @note The order of elements of this enumeration type must
    correspond to the order of the elements of the @c explanations
    array defined in the body of @c THD::issue_unsafe_warnings.
  */
  enum enum_binlog_stmt_unsafe {
    /**
      SELECT..LIMIT is unsafe because the set of rows returned cannot
      be predicted.
    */
    BINLOG_STMT_UNSAFE_LIMIT= 0,
    /**
      INSERT DELAYED is unsafe because the time when rows are inserted
      cannot be predicted.
    */
    BINLOG_STMT_UNSAFE_INSERT_DELAYED,
    /**
      Access to log tables is unsafe because slave and master probably
      log different things.
    */
    BINLOG_STMT_UNSAFE_SYSTEM_TABLE,
    /**
1138 1139 1140 1141 1142 1143 1144
      Inserting into an autoincrement column in a stored routine is unsafe.
      Even with just one autoincrement column, if the routine is invoked more than 
      once slave is not guaranteed to execute the statement graph same way as 
      the master.
      And since it's impossible to estimate how many times a routine can be invoked at 
      the query pre-execution phase (see lock_tables), the statement is marked
      pessimistically unsafe. 
1145
    */
1146
    BINLOG_STMT_UNSAFE_AUTOINC_COLUMNS,
1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158
    /**
      Using a UDF (user-defined function) is unsafe.
    */
    BINLOG_STMT_UNSAFE_UDF,
    /**
      Using most system variables is unsafe, because slave may run
      with different options than master.
    */
    BINLOG_STMT_UNSAFE_SYSTEM_VARIABLE,
    /**
      Using some functions is unsafe (e.g., UUID).
    */
1159
    BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION,
1160

1161 1162 1163 1164 1165 1166 1167
    /**
      Mixing transactional and non-transactional statements are unsafe if
      non-transactional reads or writes are occur after transactional
      reads or writes inside a transaction.
    */
    BINLOG_STMT_UNSAFE_NONTRANS_AFTER_TRANS,

1168 1169 1170 1171 1172 1173
    /**
      Mixing self-logging and non-self-logging engines in a statement
      is unsafe.
    */
    BINLOG_STMT_UNSAFE_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE,

1174 1175 1176 1177 1178 1179
    /**
      Statements that read from both transactional and non-transactional
      tables and write to any of them are unsafe.
    */
    BINLOG_STMT_UNSAFE_MIXED_STATEMENT,

1180 1181 1182 1183 1184 1185 1186 1187 1188 1189
    /* The last element of this enumeration type. */
    BINLOG_STMT_UNSAFE_COUNT
  };
  /**
    This has all flags from 0 (inclusive) to BINLOG_STMT_FLAG_COUNT
    (exclusive) set.
  */
  static const int BINLOG_STMT_UNSAFE_ALL_FLAGS=
    ((1 << BINLOG_STMT_UNSAFE_COUNT) - 1);

1190 1191 1192 1193 1194
  /**
    Maps elements of enum_binlog_stmt_unsafe to error codes.
  */
  static const int binlog_stmt_unsafe_errcode[BINLOG_STMT_UNSAFE_COUNT];

1195 1196 1197 1198 1199
  /**
    Determine if this statement is marked as unsafe.

    @retval 0 if the statement is not marked as unsafe.
    @retval nonzero if the statement is marked as unsafe.
1200
  */
1201
  inline bool is_stmt_unsafe() const {
1202
    return get_stmt_unsafe_flags() != 0;
1203 1204 1205
  }

  /**
1206 1207
    Flag the current (top-level) statement as unsafe.
    The flag will be reset after the statement has finished.
1208

1209 1210
    @param unsafe_type The type of unsafety: one of the @c
    BINLOG_STMT_FLAG_UNSAFE_* flags in @c enum_binlog_stmt_flag.
1211
  */
1212 1213 1214 1215 1216
  inline void set_stmt_unsafe(enum_binlog_stmt_unsafe unsafe_type) {
    DBUG_ENTER("set_stmt_unsafe");
    DBUG_ASSERT(unsafe_type >= 0 && unsafe_type < BINLOG_STMT_UNSAFE_COUNT);
    binlog_stmt_flags|= (1U << unsafe_type);
    DBUG_VOID_RETURN;
1217
  }
1218

1219
  /**
1220 1221 1222 1223 1224 1225
    Set the bits of binlog_stmt_flags determining the type of
    unsafeness of the current statement.  No existing bits will be
    cleared, but new bits may be set.

    @param flags A binary combination of zero or more bits, (1<<flag)
    where flag is a member of enum_binlog_stmt_unsafe.
1226
  */
1227 1228 1229 1230
  inline void set_stmt_unsafe_flags(uint32 flags) {
    DBUG_ENTER("set_stmt_unsafe_flags");
    DBUG_ASSERT((flags & ~BINLOG_STMT_UNSAFE_ALL_FLAGS) == 0);
    binlog_stmt_flags|= flags;
1231
    DBUG_VOID_RETURN;
1232 1233
  }

1234
  /**
1235 1236 1237 1238 1239 1240 1241 1242
    Return a binary combination of all unsafe warnings for the
    statement.  If the statement has been marked as unsafe by the
    'flag' member of enum_binlog_stmt_unsafe, then the return value
    from this function has bit (1<<flag) set to 1.
  */
  inline uint32 get_stmt_unsafe_flags() const {
    DBUG_ENTER("get_stmt_unsafe_flags");
    DBUG_RETURN(binlog_stmt_flags & BINLOG_STMT_UNSAFE_ALL_FLAGS);
1243 1244
  }

1245 1246 1247 1248 1249
  /**
    Mark the current statement as safe; i.e., clear all bits in
    binlog_stmt_flags that correspond to elements of
    enum_binlog_stmt_unsafe.
  */
1250
  inline void clear_stmt_unsafe() {
1251
    DBUG_ENTER("clear_stmt_unsafe");
1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275
    binlog_stmt_flags&= ~BINLOG_STMT_UNSAFE_ALL_FLAGS;
    DBUG_VOID_RETURN;
  }

  /**
    Determine if this statement is a row injection.

    @retval 0 if the statement is not a row injection
    @retval nonzero if the statement is a row injection
  */
  inline bool is_stmt_row_injection() const {
    return binlog_stmt_flags &
      (1U << (BINLOG_STMT_UNSAFE_COUNT + BINLOG_STMT_TYPE_ROW_INJECTION));
  }

  /**
    Flag the statement as a row injection.  A row injection is either
    a BINLOG statement, or a row event in the relay log executed by
    the slave SQL thread.
  */
  inline void set_stmt_row_injection() {
    DBUG_ENTER("set_stmt_row_injection");
    binlog_stmt_flags|=
      (1U << (BINLOG_STMT_UNSAFE_COUNT + BINLOG_STMT_TYPE_ROW_INJECTION));
1276
    DBUG_VOID_RETURN;
1277 1278
  }

unknown's avatar
unknown committed
1279 1280 1281 1282 1283 1284
  /**
    true if the parsed tree contains references to stored procedures
    or functions, false otherwise
  */
  bool uses_stored_routines() const
  { return sroutines_list.elements != 0; }
1285

1286
private:
1287

1288
  /**
1289
    Enumeration listing special types of statements.
1290

1291
    Currently, the only possible type is ROW_INJECTION.
1292
  */
1293
  enum enum_binlog_stmt_type {
1294 1295 1296 1297
    /**
      The statement is a row injection (i.e., either a BINLOG
      statement or a row event executed by the slave SQL thread).
    */
1298 1299 1300 1301
    BINLOG_STMT_TYPE_ROW_INJECTION = 0,

    /** The last element of this enumeration type. */
    BINLOG_STMT_TYPE_COUNT
1302 1303
  };

1304
  /**
1305 1306 1307 1308 1309 1310
    Bit field indicating the type of statement.

    There are two groups of bits:

    - The low BINLOG_STMT_UNSAFE_COUNT bits indicate the types of
      unsafeness that the current statement has.
1311

1312 1313
    - The next BINLOG_STMT_TYPE_COUNT bits indicate if the statement
      is of some special type.
1314

1315 1316 1317
    This must be a member of LEX, not of THD: each stored procedure
    needs to remember its unsafeness state between calls and each
    stored procedure has its own LEX object (but no own THD object).
1318 1319
  */
  uint32 binlog_stmt_flags;
1320 1321 1322
};


1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334
/*
  st_parsing_options contains the flags for constructions that are
  allowed in the current statement.
*/

struct st_parsing_options
{
  bool allows_variable;
  bool allows_select_into;
  bool allows_select_procedure;
  bool allows_derived;

1335 1336
  st_parsing_options() { reset(); }
  void reset();
1337 1338 1339
};


1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363
/**
  The state of the lexical parser, when parsing comments.
*/
enum enum_comment_state
{
  /**
    Not parsing comments.
  */
  NO_COMMENT,
  /**
    Parsing comments that need to be preserved.
    Typically, these are user comments '/' '*' ... '*' '/'.
  */
  PRESERVE_COMMENT,
  /**
    Parsing comments that need to be discarded.
    Typically, these are special comments '/' '*' '!' ... '*' '/',
    or '/' '*' '!' 'M' 'M' 'm' 'm' 'm' ... '*' '/', where the comment
    markers should not be expanded.
  */
  DISCARD_COMMENT
};


1364
/**
unknown's avatar
unknown committed
1365
  @brief This class represents the character input stream consumed during
1366
  lexical analysis.
unknown's avatar
unknown committed
1367

1368 1369 1370 1371 1372 1373 1374 1375
  In addition to consuming the input stream, this class performs some
  comment pre processing, by filtering out out of bound special text
  from the query input stream.
  Two buffers, with pointers inside each buffers, are maintained in
  parallel. The 'raw' buffer is the original query text, which may
  contain out-of-bound comments. The 'cpp' (for comments pre processor)
  is the pre-processed buffer that contains only the query text that
  should be seen once out-of-bound data is removed.
1376
*/
unknown's avatar
unknown committed
1377

1378 1379 1380 1381 1382 1383
class Lex_input_stream
{
public:
  Lex_input_stream(THD *thd, const char* buff, unsigned int length);
  ~Lex_input_stream();

1384 1385
  void reset(const char *buff, unsigned int length);

1386 1387
  /**
    Set the echo mode.
unknown's avatar
unknown committed
1388

1389 1390 1391 1392 1393 1394 1395 1396 1397
    When echo is true, characters parsed from the raw input stream are
    preserved. When false, characters parsed are silently ignored.
    @param echo the echo mode.
  */
  void set_echo(bool echo)
  {
    m_echo= echo;
  }

1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409
  void save_in_comment_state()
  {
    m_echo_saved= m_echo;
    in_comment_saved= in_comment;
  }

  void restore_in_comment_state()
  {
    m_echo= m_echo_saved;
    in_comment= in_comment_saved;
  }

1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427
  /**
    Skip binary from the input stream.
    @param n number of bytes to accept.
  */
  void skip_binary(int n)
  {
    if (m_echo)
    {
      memcpy(m_cpp_ptr, m_ptr, n);
      m_cpp_ptr += n;
    }
    m_ptr += n;
  }

  /**
    Get a character, and advance in the stream.
    @return the next character to parse.
  */
Davi Arnaut's avatar
Davi Arnaut committed
1428
  unsigned char yyGet()
1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439
  {
    char c= *m_ptr++;
    if (m_echo)
      *m_cpp_ptr++ = c;
    return c;
  }

  /**
    Get the last character accepted.
    @return the last character accepted.
  */
Davi Arnaut's avatar
Davi Arnaut committed
1440
  unsigned char yyGetLast()
1441 1442 1443 1444 1445 1446 1447
  {
    return m_ptr[-1];
  }

  /**
    Look at the next character to parse, but do not accept it.
  */
Davi Arnaut's avatar
Davi Arnaut committed
1448
  unsigned char yyPeek()
1449 1450 1451 1452 1453 1454 1455 1456
  {
    return m_ptr[0];
  }

  /**
    Look ahead at some character to parse.
    @param n offset of the character to look up
  */
Davi Arnaut's avatar
Davi Arnaut committed
1457
  unsigned char yyPeekn(int n)
1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518
  {
    return m_ptr[n];
  }

  /**
    Cancel the effect of the last yyGet() or yySkip().
    Note that the echo mode should not change between calls to yyGet / yySkip
    and yyUnget. The caller is responsible for ensuring that.
  */
  void yyUnget()
  {
    m_ptr--;
    if (m_echo)
      m_cpp_ptr--;
  }

  /**
    Accept a character, by advancing the input stream.
  */
  void yySkip()
  {
    if (m_echo)
      *m_cpp_ptr++ = *m_ptr++;
    else
      m_ptr++;
  }

  /**
    Accept multiple characters at once.
    @param n the number of characters to accept.
  */
  void yySkipn(int n)
  {
    if (m_echo)
    {
      memcpy(m_cpp_ptr, m_ptr, n);
      m_cpp_ptr += n;
    }
    m_ptr += n;
  }

  /**
    End of file indicator for the query text to parse.
    @return true if there are no more characters to parse
  */
  bool eof()
  {
    return (m_ptr >= m_end_of_query);
  }

  /**
    End of file indicator for the query text to parse.
    @param n number of characters expected
    @return true if there are less than n characters to parse
  */
  bool eof(int n)
  {
    return ((m_ptr + n) >= m_end_of_query);
  }

  /** Get the raw query buffer. */
unknown's avatar
unknown committed
1519
  const char *get_buf()
1520 1521 1522 1523 1524
  {
    return m_buf;
  }

  /** Get the pre-processed query buffer. */
unknown's avatar
unknown committed
1525
  const char *get_cpp_buf()
1526 1527 1528 1529 1530
  {
    return m_cpp_buf;
  }

  /** Get the end of the raw query buffer. */
unknown's avatar
unknown committed
1531
  const char *get_end_of_query()
1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558
  {
    return m_end_of_query;
  }

  /** Mark the stream position as the start of a new token. */
  void start_token()
  {
    m_tok_start_prev= m_tok_start;
    m_tok_start= m_ptr;
    m_tok_end= m_ptr;

    m_cpp_tok_start_prev= m_cpp_tok_start;
    m_cpp_tok_start= m_cpp_ptr;
    m_cpp_tok_end= m_cpp_ptr;
  }

  /**
    Adjust the starting position of the current token.
    This is used to compensate for starting whitespace.
  */
  void restart_token()
  {
    m_tok_start= m_ptr;
    m_cpp_tok_start= m_cpp_ptr;
  }

  /** Get the token start position, in the raw buffer. */
unknown's avatar
unknown committed
1559
  const char *get_tok_start()
1560 1561 1562 1563 1564
  {
    return m_tok_start;
  }

  /** Get the token start position, in the pre-processed buffer. */
unknown's avatar
unknown committed
1565
  const char *get_cpp_tok_start()
1566 1567 1568 1569 1570
  {
    return m_cpp_tok_start;
  }

  /** Get the token end position, in the raw buffer. */
unknown's avatar
unknown committed
1571
  const char *get_tok_end()
1572 1573 1574 1575 1576
  {
    return m_tok_end;
  }

  /** Get the token end position, in the pre-processed buffer. */
unknown's avatar
unknown committed
1577
  const char *get_cpp_tok_end()
1578 1579 1580 1581 1582
  {
    return m_cpp_tok_end;
  }

  /** Get the previous token start position, in the raw buffer. */
unknown's avatar
unknown committed
1583
  const char *get_tok_start_prev()
1584 1585 1586 1587 1588
  {
    return m_tok_start_prev;
  }

  /** Get the current stream pointer, in the raw buffer. */
unknown's avatar
unknown committed
1589
  const char *get_ptr()
1590 1591 1592 1593 1594
  {
    return m_ptr;
  }

  /** Get the current stream pointer, in the pre-processed buffer. */
unknown's avatar
unknown committed
1595
  const char *get_cpp_ptr()
1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610
  {
    return m_cpp_ptr;
  }

  /** Get the length of the current token, in the raw buffer. */
  uint yyLength()
  {
    /*
      The assumption is that the lexical analyser is always 1 character ahead,
      which the -1 account for.
    */
    DBUG_ASSERT(m_ptr > m_tok_start);
    return (uint) ((m_ptr - m_tok_start) - 1);
  }

unknown's avatar
unknown committed
1611 1612 1613 1614 1615 1616 1617 1618 1619
  /** Get the utf8-body string. */
  const char *get_body_utf8_str()
  {
    return m_body_utf8;
  }

  /** Get the utf8-body length. */
  uint get_body_utf8_length()
  {
1620
    return (uint) (m_body_utf8_ptr - m_body_utf8);
unknown's avatar
unknown committed
1621 1622 1623 1624 1625 1626 1627 1628 1629 1630
  }

  void body_utf8_start(THD *thd, const char *begin_ptr);
  void body_utf8_append(const char *ptr);
  void body_utf8_append(const char *ptr, const char *end_ptr);
  void body_utf8_append_literal(THD *thd,
                                const LEX_STRING *txt,
                                CHARSET_INFO *txt_cs,
                                const char *end_ptr);

1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642
  /** Current thread. */
  THD *m_thd;

  /** Current line number. */
  uint yylineno;

  /** Length of the last token parsed. */
  uint yytoklen;

  /** Interface with bison, value of the last token parsed. */
  LEX_YYSTYPE yylval;

1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653
  /**
    LALR(2) resolution, look ahead token.
    Value of the next token to return, if any,
    or -1, if no token was parsed in advance.
    Note: 0 is a legal token, and represents YYEOF.
  */
  int lookahead_token;

  /** LALR(2) resolution, value of the look ahead token.*/
  LEX_YYSTYPE lookahead_yylval;

1654 1655
private:
  /** Pointer to the current position in the raw input stream. */
unknown's avatar
unknown committed
1656
  const char *m_ptr;
1657 1658

  /** Starting position of the last token parsed, in the raw buffer. */
unknown's avatar
unknown committed
1659
  const char *m_tok_start;
1660

1661
  /** Ending position of the previous token parsed, in the raw buffer. */
unknown's avatar
unknown committed
1662
  const char *m_tok_end;
1663

1664
  /** End of the query text in the input stream, in the raw buffer. */
unknown's avatar
unknown committed
1665
  const char *m_end_of_query;
1666

1667
  /** Starting position of the previous token parsed, in the raw buffer. */
unknown's avatar
unknown committed
1668
  const char *m_tok_start_prev;
1669

1670
  /** Begining of the query text in the input stream, in the raw buffer. */
unknown's avatar
unknown committed
1671
  const char *m_buf;
1672

unknown's avatar
unknown committed
1673 1674 1675
  /** Length of the raw buffer. */
  uint m_buf_length;

1676 1677
  /** Echo the parsed stream to the pre-processed buffer. */
  bool m_echo;
1678
  bool m_echo_saved;
1679 1680

  /** Pre-processed buffer. */
unknown's avatar
unknown committed
1681
  char *m_cpp_buf;
1682 1683

  /** Pointer to the current position in the pre-processed input stream. */
unknown's avatar
unknown committed
1684
  char *m_cpp_ptr;
1685 1686 1687 1688 1689

  /**
    Starting position of the last token parsed,
    in the pre-processed buffer.
  */
unknown's avatar
unknown committed
1690
  const char *m_cpp_tok_start;
1691 1692 1693 1694 1695

  /**
    Starting position of the previous token parsed,
    in the pre-procedded buffer.
  */
unknown's avatar
unknown committed
1696
  const char *m_cpp_tok_start_prev;
1697 1698 1699 1700 1701

  /**
    Ending position of the previous token parsed,
    in the pre-processed buffer.
  */
unknown's avatar
unknown committed
1702
  const char *m_cpp_tok_end;
1703

unknown's avatar
unknown committed
1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715
  /** UTF8-body buffer created during parsing. */
  char *m_body_utf8;

  /** Pointer to the current position in the UTF8-body buffer. */
  char *m_body_utf8_ptr;

  /**
    Position in the pre-processed buffer. The query from m_cpp_buf to
    m_cpp_utf_processed_ptr is converted to UTF8-body.
  */
  const char *m_cpp_utf8_processed_ptr;

1716
public:
1717 1718 1719 1720

  /** Current state of the lexical analyser. */
  enum my_lex_states next_state;

1721 1722 1723 1724
  /**
    Position of ';' in the stream, to delimit multiple queries.
    This delimiter is in the raw buffer.
  */
unknown's avatar
unknown committed
1725
  const char *found_semicolon;
1726

1727 1728
  /** Token character bitmaps, to detect 7bit strings. */
  uchar tok_bitmap;
unknown's avatar
unknown committed
1729

1730 1731
  /** SQL_MODE = IGNORE_SPACE. */
  bool ignore_space;
1732 1733

  /**
1734
    TRUE if we're parsing a prepared statement: in this mode
1735
    we should allow placeholders.
1736 1737
  */
  bool stmt_prepare_mode;
1738 1739 1740 1741
  /**
    TRUE if we should allow multi-statements.
  */
  bool multi_statements;
1742 1743 1744

  /** State of the lexical analyser for comments. */
  enum_comment_state in_comment;
1745
  enum_comment_state in_comment_saved;
unknown's avatar
unknown committed
1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768

  /**
    Starting position of the TEXT_STRING or IDENT in the pre-processed
    buffer.

    NOTE: this member must be used within MYSQLlex() function only.
  */
  const char *m_cpp_text_start;

  /**
    Ending position of the TEXT_STRING or IDENT in the pre-processed
    buffer.

    NOTE: this member must be used within MYSQLlex() function only.
    */
  const char *m_cpp_text_end;

  /**
    Character set specified by the character-set-introducer.

    NOTE: this member must be used within MYSQLlex() function only.
  */
  CHARSET_INFO *m_underscore_cs;
1769 1770
};

Marc Alff's avatar
Marc Alff committed
1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799
/**
  Abstract representation of a statement.
  This class is an interface between the parser and the runtime.
  The parser builds the appropriate sub classes of Sql_statement
  to represent a SQL statement in the parsed tree.
  The execute() method in the sub classes contain the runtime implementation.
  Note that this interface is used for SQL statement recently implemented,
  the code for older statements tend to load the LEX structure with more
  attributes instead.
  The recommended way to implement new statements is to sub-class
  Sql_statement, as this improves code modularity (see the 'big switch' in
  dispatch_command()), and decrease the total size of the LEX structure
  (therefore saving memory in stored programs).
*/
class Sql_statement : public Sql_alloc
{
public:
  /**
    Execute this SQL statement.
    @param thd the current thread.
    @return 0 on success.
  */
  virtual bool execute(THD *thd) = 0;

protected:
  /**
    Constructor.
    @param lex the LEX structure that represents parts of this statement.
  */
Konstantin Osipov's avatar
Konstantin Osipov committed
1800
  Sql_statement(LEX *lex)
Marc Alff's avatar
Marc Alff committed
1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824
    : m_lex(lex)
  {}

  /** Destructor. */
  virtual ~Sql_statement()
  {
    /*
      Sql_statement objects are allocated in thd->mem_root.
      In MySQL, the C++ destructor is never called, the underlying MEM_ROOT is
      simply destroyed instead.
      Do not rely on the destructor for any cleanup.
    */
    DBUG_ASSERT(FALSE);
  }

protected:
  /**
    The legacy LEX structure for this statement.
    The LEX structure contains the existing properties of the parsed tree.
    TODO: with time, attributes from LEX should move to sub classes of
    Sql_statement, so that the parser only builds Sql_statement objects
    with the minimum set of attributes, instead of a LEX structure that
    contains the collection of every possible attribute.
  */
Konstantin Osipov's avatar
Konstantin Osipov committed
1825
  LEX *m_lex;
Marc Alff's avatar
Marc Alff committed
1826
};
1827

unknown's avatar
unknown committed
1828 1829
/* The state of the lex parsing. This is saved in the THD struct */

Konstantin Osipov's avatar
Konstantin Osipov committed
1830
struct LEX: public Query_tables_list
1831
{
unknown's avatar
unknown committed
1832
  SELECT_LEX_UNIT unit;                         /* most upper unit */
1833 1834
  SELECT_LEX select_lex;                        /* first SELECT_LEX */
  /* current SELECT_LEX in parsing */
unknown's avatar
unknown committed
1835
  SELECT_LEX *current_select;
1836 1837
  /* list of all SELECT_LEX */
  SELECT_LEX *all_selects_list;
1838

1839 1840
  char *length,*dec,*change;
  LEX_STRING name;
unknown's avatar
unknown committed
1841
  char *help_arg;
1842
  char *backup_dir;				/* For RESTORE/BACKUP */
unknown's avatar
unknown committed
1843
  char* to_log;                                 /* For PURGE MASTER LOGS TO */
1844
  char* x509_subject,*x509_issuer,*ssl_cipher;
unknown's avatar
unknown committed
1845 1846
  String *wild;
  sql_exchange *exchange;
1847
  select_result *result;
1848
  Item *default_value, *on_update_value;
1849
  LEX_STRING comment, ident;
unknown's avatar
unknown committed
1850
  LEX_USER *grant_user;
unknown's avatar
unknown committed
1851
  XID *xid;
unknown's avatar
unknown committed
1852
  THD *thd;
unknown's avatar
unknown committed
1853 1854 1855 1856

  /* maintain a list of used plugins for this LEX */
  DYNAMIC_ARRAY plugins;
  plugin_ref plugins_static_buffer[INITIAL_LEX_PLUGIN_LIST_SIZE];
1857

unknown's avatar
unknown committed
1858
  CHARSET_INFO *charset;
1859
  bool text_string_is_7bit;
1860 1861
  /* store original leaf_tables for INSERT SELECT and PS/SP */
  TABLE_LIST *leaf_tables_insert;
1862

1863 1864
  /** SELECT of CREATE VIEW statement */
  LEX_STRING create_view_select;
1865

unknown's avatar
unknown committed
1866
  /** Start of 'ON table', in trigger statements.  */
1867
  const char* raw_trg_on_table_name_begin;
unknown's avatar
unknown committed
1868
  /** End of 'ON table', in trigger statements. */
1869 1870
  const char* raw_trg_on_table_name_end;

1871 1872
  /* Partition info structure filled in by PARTITION BY parse part */
  partition_info *part_info;
unknown's avatar
unknown committed
1873

1874 1875 1876 1877 1878 1879
  /*
    The definer of the object being created (view, trigger, stored routine).
    I.e. the value of DEFINER clause.
  */
  LEX_USER *definer;

unknown's avatar
unknown committed
1880 1881
  List<Key_part_spec> col_list;
  List<Key_part_spec> ref_list;
1882
  List<String>	      interval_list;
unknown's avatar
unknown committed
1883
  List<LEX_USER>      users_list;
unknown's avatar
unknown committed
1884
  List<LEX_COLUMN>    columns;
unknown's avatar
unknown committed
1885
  List<Item>	      *insert_list,field_list,value_list,update_list;
1886
  List<List_item>     many_values;
unknown's avatar
unknown committed
1887
  List<set_var_base>  var_list;
1888
  List<Item_func_set_user_var> set_var_list; // in-query assignment list
1889
  List<Item_param>    param_list;
unknown's avatar
VIEW  
unknown committed
1890
  List<LEX_STRING>    view_list; // view list (list of field names in view)
unknown's avatar
unknown committed
1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905
  /*
    A stack of name resolution contexts for the query. This stack is used
    at parse time to set local name resolution contexts for various parts
    of a query. For example, in a JOIN ... ON (some_condition) clause the
    Items in 'some_condition' must be resolved only against the operands
    of the the join, and not against the whole clause. Similarly, Items in
    subqueries should be resolved against the subqueries (and outer queries).
    The stack is used in the following way: when the parser detects that
    all Items in some clause need a local context, it creates a new context
    and pushes it on the stack. All newly created Items always store the
    top-most context in the stack. Once the parser leaves the clause that
    required a local context, the parser pops the top-most context.
  */
  List<Name_resolution_context> context_stack;

unknown's avatar
unknown committed
1906
  SQL_LIST	      proc_list, auxiliary_table_list, save_list;
unknown's avatar
unknown committed
1907
  Create_field	      *last_field;
unknown's avatar
unknown committed
1908
  Item_sum *in_sum_func;
unknown's avatar
unknown committed
1909
  udf_func udf;
1910 1911
  HA_CHECK_OPT   check_opt;			// check/repair options
  HA_CREATE_INFO create_info;
unknown's avatar
unknown committed
1912
  KEY_CREATE_INFO key_create_info;
unknown's avatar
unknown committed
1913
  LEX_MASTER_INFO mi;				// used by CHANGE MASTER
unknown's avatar
unknown committed
1914
  LEX_SERVER_OPTIONS server_options;
1915
  USER_RESOURCES mqh;
1916
  ulong type;
unknown's avatar
unknown committed
1917 1918 1919 1920 1921 1922 1923 1924 1925 1926
  /*
    This variable is used in post-parse stage to declare that sum-functions,
    or functions which have sense only if GROUP BY is present, are allowed.
    For example in a query
    SELECT ... FROM ...WHERE MIN(i) == 1 GROUP BY ... HAVING MIN(i) > 2
    MIN(i) in the WHERE clause is not allowed in the opposite to MIN(i)
    in the HAVING clause. Due to possible nesting of select construct
    the variable can contain 0 or 1 for each nest level.
  */
  nesting_map allow_sum_func;
Marc Alff's avatar
Marc Alff committed
1927 1928 1929

  Sql_statement *m_stmt;

1930 1931 1932 1933 1934 1935 1936 1937
  /*
    Usually `expr` rule of yacc is quite reused but some commands better
    not support subqueries which comes standard with this rule, like
    KILL, HA_READ, CREATE/ALTER EVENT etc. Set this to `false` to get
    syntax error back.
  */
  bool expr_allows_subselect;

unknown's avatar
unknown committed
1938
  enum SSL_type ssl_type;			/* defined in violite.h */
1939
  enum enum_duplicates duplicates;
unknown's avatar
unknown committed
1940
  enum enum_tx_isolation tx_isolation;
1941
  enum enum_ha_read_modes ha_read_mode;
1942
  union {
unknown's avatar
unknown committed
1943
    enum ha_rkey_function ha_rkey_mode;
1944 1945
    enum xa_option_words xa_opt;
  };
unknown's avatar
unknown committed
1946
  enum enum_var_type option_type;
unknown's avatar
VIEW  
unknown committed
1947 1948
  enum enum_view_create_mode create_view_mode;
  enum enum_drop_mode drop_mode;
1949

unknown's avatar
unknown committed
1950
  uint profile_query_id;
1951
  uint profile_options;
unknown's avatar
unknown committed
1952
  uint uint_geom_type;
unknown's avatar
unknown committed
1953
  uint grant, grant_tot_col, which_columns;
1954 1955 1956
  enum Foreign_key::fk_match_opt fk_match_option;
  enum Foreign_key::fk_option fk_update_opt;
  enum Foreign_key::fk_option fk_delete_opt;
1957
  uint slave_thd_opt, start_transaction_opt;
unknown's avatar
unknown committed
1958
  int nest_level;
1959 1960 1961 1962 1963 1964
  /*
    In LEX representing update which were transformed to multi-update
    stores total number of tables. For LEX representing multi-delete
    holds number of tables from which we will delete records.
  */
  uint table_count;
unknown's avatar
unknown committed
1965
  uint8 describe;
1966 1967 1968
  /*
    A flag that indicates what kinds of derived tables are present in the
    query (0 if no derived tables, otherwise a combination of flags
unknown's avatar
unknown committed
1969
    DERIVED_SUBQUERY and DERIVED_VIEW).
1970
  */
unknown's avatar
VIEW  
unknown committed
1971 1972
  uint8 derived_tables;
  uint8 create_view_algorithm;
unknown's avatar
unknown committed
1973
  uint8 create_view_check;
1974
  bool drop_if_exists, drop_temporary, local_file, one_shot_set;
1975
  bool autocommit;
1976 1977
  bool verbose, no_write_to_binlog;

1978
  enum enum_yes_no_unknown tx_chain, tx_release;
unknown's avatar
unknown committed
1979 1980 1981 1982 1983 1984 1985
  /*
    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.
  */
unknown's avatar
VIEW  
unknown committed
1986
  bool view_prepare_mode;
1987
  bool safe_to_cache_query;
1988
  bool subqueries, ignore;
1989
  st_parsing_options parsing_options;
1990
  Alter_info alter_info;
Konstantin Osipov's avatar
Konstantin Osipov committed
1991 1992 1993 1994 1995 1996
  /*
    For CREATE TABLE statement last element of table list which is not
    part of SELECT or LIKE part (i.e. either element for table we are
    creating or last of tables referenced by foreign keys).
  */
  TABLE_LIST *create_last_non_select_table;
unknown's avatar
unknown committed
1997 1998
  /* Prepared statements SQL syntax:*/
  LEX_STRING prepared_stmt_name; /* Statement name (in all queries) */
unknown's avatar
unknown committed
1999
  /*
2000 2001 2002
    Prepared statement query text or name of variable that holds the
    prepared statement (in PREPARE ... queries)
  */
unknown's avatar
unknown committed
2003
  LEX_STRING prepared_stmt_code;
2004 2005
  /* If true, prepared_stmt_code is a name of variable that holds the query */
  bool prepared_stmt_code_is_varref;
unknown's avatar
unknown committed
2006
  /* Names of user variables holding parameters (in EXECUTE) */
unknown's avatar
unknown committed
2007
  List<LEX_STRING> prepared_stmt_params;
2008
  sp_head *sphead;
2009
  sp_name *spname;
2010
  bool sp_lex_in_use;	/* Keep track on lex usage in SPs for error handling */
2011
  bool all_privileges;
2012
  sp_pcontext *spcont;
2013

2014
  st_sp_chistics sp_chistics;
2015

2016
  Event_parse_data *event_parse_data;
2017

unknown's avatar
VIEW  
unknown committed
2018 2019 2020 2021 2022 2023
  bool only_view;       /* used for SHOW CREATE TABLE/VIEW */
  /*
    field_list was created for view and should be removed before PS/SP
    rexecuton
  */
  bool empty_field_list_on_rset;
2024 2025 2026
  /*
    view created to be run from definer (standard behaviour)
  */
2027
  uint8 create_view_suid;
2028 2029 2030
  /* Characterstics of trigger being created */
  st_trg_chistics trg_chistics;
  /*
2031 2032 2033 2034 2035
    List of all items (Item_trigger_field objects) representing fields in
    old/new version of row in trigger. We use this list for checking whenever
    all such fields are valid at trigger creation time and for binding these
    fields to TABLE object at table open (altough for latter pointer to table
    being opened is probably enough).
2036
  */
2037
  SQL_LIST trg_table_fields;
2038

2039
  /*
2040 2041 2042 2043 2044
    stmt_definition_begin is intended to point to the next word after
    DEFINER-clause in the following statements:
      - CREATE TRIGGER (points to "TRIGGER");
      - CREATE PROCEDURE (points to "PROCEDURE");
      - CREATE FUNCTION (points to "FUNCTION" or "AGGREGATE");
2045
      - CREATE EVENT (points to "EVENT")
2046 2047

    This pointer is required to add possibly omitted DEFINER-clause to the
2048
    DDL-statement before dumping it to the binlog.
2049
  */
2050
  const char *stmt_definition_begin;
2051

2052 2053
  const char *stmt_definition_end;

2054 2055 2056 2057 2058 2059 2060
  /**
    During name resolution search only in the table list given by 
    Name_resolution_context::first_name_resolution_table and
    Name_resolution_context::last_name_resolution_table
    (see Item_field::fix_fields()). 
  */
  bool use_only_table_context;
unknown's avatar
unknown committed
2061 2062 2063 2064 2065 2066

  /*
    Reference to a struct that contains information in various commands
    to add/create/drop/change table spaces.
  */
  st_alter_tablespace *alter_tablespace_info;
2067 2068
  
  bool escape_used;
2069
  bool is_lex_started; /* If lex_start() did run. For debugging. */
unknown's avatar
unknown committed
2070

2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086
  /*
    Special case for SELECT .. FOR UPDATE and LOCK TABLES .. WRITE.

    Protect from a impending GRL as otherwise the thread might deadlock
    if it starts waiting for the GRL in mysql_lock_tables.

    The protection is needed because there is a race between setting
    the global read lock and waiting for all open tables to be closed.
    The problem is a circular wait where a thread holding "old" open
    tables will wait for the global read lock to be released while the
    thread holding the global read lock will wait for all "old" open
    tables to be closed -- the flush part of flush tables with read
    lock.
  */
  bool protect_against_global_read_lock;

Konstantin Osipov's avatar
Konstantin Osipov committed
2087
  LEX();
2088

Konstantin Osipov's avatar
Konstantin Osipov committed
2089
  virtual ~LEX()
2090
  {
2091
    destroy_query_tables_list();
unknown's avatar
unknown committed
2092 2093
    plugin_unlock_list(NULL, (plugin_ref *)plugins.buffer, plugins.elements);
    delete_dynamic(&plugins);
2094
  }
2095

2096
  inline void uncacheable(uint8 cause)
2097 2098
  {
    safe_to_cache_query= 0;
2099 2100 2101 2102 2103 2104

    /*
      There are no sense to mark select_lex and union fields of LEX,
      but we should merk all subselects as uncacheable from current till
      most upper
    */
unknown's avatar
unknown committed
2105
    SELECT_LEX *sl;
unknown's avatar
unknown committed
2106 2107 2108 2109
    SELECT_LEX_UNIT *un;
    for (sl= current_select, un= sl->master_unit();
	 un != &unit;
	 sl= sl->outer_select(), un= sl->master_unit())
2110
    {
2111 2112
      sl->uncacheable|= cause;
      un->uncacheable|= cause;
2113
    }
2114
  }
2115 2116
  void set_trg_event_type_for_tables();

unknown's avatar
VIEW  
unknown committed
2117 2118 2119 2120 2121 2122
  TABLE_LIST *unlink_first_table(bool *link_to_local);
  void link_first_table_back(TABLE_LIST *first, bool link_to_local);
  void first_lists_tables_same();

  bool can_be_merged();
  bool can_use_merged();
2123
  bool can_not_use_merged();
unknown's avatar
VIEW  
unknown committed
2124
  bool only_view_structure();
unknown's avatar
unknown committed
2125
  bool need_correct_ident();
2126
  uint8 get_effective_with_check(TABLE_LIST *view);
2127 2128
  /*
    Is this update command where 'WHITH CHECK OPTION' clause is important
2129

2130
    SYNOPSIS
Konstantin Osipov's avatar
Konstantin Osipov committed
2131
      LEX::which_check_option_applicable()
2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143

    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:
2144 2145
    case SQLCOM_REPLACE:
    case SQLCOM_REPLACE_SELECT:
2146 2147 2148 2149 2150 2151
    case SQLCOM_LOAD:
      return TRUE;
    default:
      return FALSE;
    }
  }
2152

2153
  void cleanup_after_one_table_open();
unknown's avatar
unknown committed
2154

2155
  bool push_context(Name_resolution_context *context)
unknown's avatar
unknown committed
2156
  {
2157
    return context_stack.push_front(context);
unknown's avatar
unknown committed
2158 2159 2160 2161 2162 2163 2164
  }

  void pop_context()
  {
    context_stack.pop();
  }

2165
  bool copy_db_to(char **p_db, size_t *p_db_length) const;
2166

unknown's avatar
unknown committed
2167 2168 2169 2170
  Name_resolution_context *current_context()
  {
    return context_stack.head();
  }
2171 2172 2173 2174
  /*
    Restore the LEX and THD in case of a parse error.
  */
  static void cleanup_lex_after_parse_error(THD *thd);
2175 2176 2177

  void reset_n_backup_query_tables_list(Query_tables_list *backup);
  void restore_backup_query_tables_list(Query_tables_list *backup);
unknown's avatar
unknown committed
2178 2179

  bool table_or_sp_used();
2180
  bool is_partition_management() const;
2181

2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202
  /**
    @brief check if the statement is a single-level join
    @return result of the check
      @retval TRUE  The statement doesn't contain subqueries, unions and 
                    stored procedure calls.
      @retval FALSE There are subqueries, UNIONs or stored procedure calls.
  */
  bool is_single_level_stmt() 
  { 
    /* 
      This check exploits the fact that the last added to all_select_list is
      on its top. So select_lex (as the first added) will be at the tail 
      of the list.
    */ 
    if (&select_lex == all_selects_list && !sroutines.records)
    {
      DBUG_ASSERT(!all_selects_list->next_select_in_list());
      return TRUE;
    }
    return FALSE;
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
2203
};
unknown's avatar
unknown committed
2204

2205

Marc Alff's avatar
Marc Alff committed
2206 2207 2208 2209 2210 2211 2212 2213
/**
  Set_signal_information is a container used in the parsed tree to represent
  the collection of assignments to condition items in the SIGNAL and RESIGNAL
  statements.
*/
class Set_signal_information
{
public:
2214 2215
  /** Empty default constructor, use clear() */
 Set_signal_information() {} 
Marc Alff's avatar
Marc Alff committed
2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227

  /** Copy constructor. */
  Set_signal_information(const Set_signal_information& set);

  /** Destructor. */
  ~Set_signal_information()
  {}

  /** Clear all items. */
  void clear();

  /**
2228
    For each condition item assignment, m_item[] contains the parsed tree
Marc Alff's avatar
Marc Alff committed
2229 2230 2231 2232 2233 2234 2235
    that represents the expression assigned, if any.
    m_item[] is an array indexed by Diag_condition_item_name.
  */
  Item *m_item[LAST_DIAG_SET_PROPERTY+1];
};


2236 2237 2238 2239 2240 2241 2242 2243 2244
/**
  The internal state of the syntax parser.
  This object is only available during parsing,
  and is private to the syntax parser implementation (sql_yacc.yy).
*/
class Yacc_state
{
public:
  Yacc_state()
2245 2246 2247 2248 2249 2250 2251 2252 2253
  {
    reset();
  }

  void reset()
  {
    yacc_yyss= NULL;
    yacc_yyvs= NULL;
    m_set_signal_info.clear();
2254
    m_lock_type= TL_READ_DEFAULT;
2255
    m_mdl_type= MDL_SHARED_READ;
2256
  }
2257 2258 2259

  ~Yacc_state();

2260 2261 2262 2263 2264 2265 2266
  /**
    Reset part of the state which needs resetting before parsing
    substatement.
  */
  void reset_before_substatement()
  {
    m_lock_type= TL_READ_DEFAULT;
2267
    m_mdl_type= MDL_SHARED_READ;
2268 2269
  }

2270 2271 2272 2273
  /**
    Bison internal state stack, yyss, when dynamically allocated using
    my_yyoverflow().
  */
2274
  uchar *yacc_yyss;
2275 2276 2277 2278 2279

  /**
    Bison internal semantic value stack, yyvs, when dynamically allocated using
    my_yyoverflow().
  */
2280
  uchar *yacc_yyvs;
2281

Marc Alff's avatar
Marc Alff committed
2282 2283 2284 2285 2286 2287
  /**
    Fragments of parsed tree,
    used during the parsing of SIGNAL and RESIGNAL.
  */
  Set_signal_information m_set_signal_info;

2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306
  /**
    Type of lock to be used for tables being added to the statement's
    table list in table_factor, table_alias_ref, single_multi and
    table_wild_one rules.
    Statements which use these rules but require lock type different
    from one specified by this member have to override it by using
    st_select_lex::set_lock_for_tables() method.

    The default value of this member is TL_READ_DEFAULT. The only two
    cases in which we change it are:
    - When parsing SELECT HIGH_PRIORITY.
    - Rule for DELETE. In which we use this member to pass information
      about type of lock from delete to single_multi part of rule.

    We should try to avoid introducing new use cases as we would like
    to get rid of this member eventually.
  */
  thr_lock_type m_lock_type;

2307 2308 2309 2310 2311 2312
  /**
    The type of requested metadata lock for tables added to
    the statement table list.
  */
  enum_mdl_type m_mdl_type;

2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335
  /*
    TODO: move more attributes from the LEX structure here.
  */
};

/**
  Internal state of the parser.
  The complete state consist of:
  - state data used during lexical parsing,
  - state data used during syntactic parsing.
*/
class Parser_state
{
public:
  Parser_state(THD *thd, const char* buff, unsigned int length)
    : m_lip(thd, buff, length), m_yacc()
  {}

  ~Parser_state()
  {}

  Lex_input_stream m_lip;
  Yacc_state m_yacc;
2336 2337 2338 2339 2340 2341

  void reset(const char *found_semicolon, unsigned int length)
  {
    m_lip.reset(found_semicolon, length);
    m_yacc.reset();
  }
2342 2343 2344
};


Konstantin Osipov's avatar
Konstantin Osipov committed
2345
struct st_lex_local: public LEX
unknown's avatar
unknown committed
2346
{
2347
  static void *operator new(size_t size) throw()
unknown's avatar
unknown committed
2348
  {
2349
    return sql_alloc(size);
unknown's avatar
unknown committed
2350
  }
2351
  static void *operator new(size_t size, MEM_ROOT *mem_root) throw()
unknown's avatar
unknown committed
2352 2353 2354
  {
    return (void*) alloc_root(mem_root, (uint) size);
  }
unknown's avatar
unknown committed
2355 2356
  static void operator delete(void *ptr,size_t size)
  { TRASH(ptr, size); }
2357 2358
  static void operator delete(void *ptr, MEM_ROOT *mem_root)
  { /* Never called */ }
unknown's avatar
unknown committed
2359
};
unknown's avatar
unknown committed
2360

unknown's avatar
unknown committed
2361 2362
extern void lex_init(void);
extern void lex_free(void);
2363
extern void lex_start(THD *thd);
unknown's avatar
unknown committed
2364
extern void lex_end(LEX *lex);
2365
extern int MYSQLlex(void *arg, void *yythd);
2366 2367

extern void trim_whitespace(CHARSET_INFO *cs, LEX_STRING *str);
unknown's avatar
unknown committed
2368

2369 2370
extern bool is_lex_native_function(const LEX_STRING *name);

2371 2372 2373 2374
/**
  @} (End of group Semantic_Analysis)
*/

Marc Alff's avatar
Marc Alff committed
2375
void my_missing_function_error(const LEX_STRING &token, const char *name);
2376
bool is_keyword(const char *name, uint len);
2377

2378
#endif /* MYSQL_SERVER */
2379
#endif /* SQL_LEX_INCLUDED */