sql_lex.h 42.1 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000-2006 MySQL AB
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 16 17 18 19 20 21 22
   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 */


/* YACC and LEX Definitions */

/* These may not be declared yet */
class Table_ident;
class sql_exchange;
class LEX_COLUMN;
23
class sp_head;
24
class sp_name;
25 26
class sp_instr;
class sp_pcontext;
unknown's avatar
unknown committed
27

28 29 30 31
/*
  The following hack is needed because mysql_yacc.cc does not define
  YYSTYPE before including this file
*/
unknown's avatar
unknown committed
32

unknown's avatar
unknown committed
33 34
#include "set_var.h"

unknown's avatar
unknown committed
35 36 37 38
#ifdef MYSQL_YACC
#define LEX_YYSTYPE void *
#else
#include "lex_symbol.h"
39
#if MYSQL_LEX
unknown's avatar
unknown committed
40 41
#include "sql_yacc.h"
#define LEX_YYSTYPE YYSTYPE *
42 43 44
#else
#define LEX_YYSTYPE void *
#endif
unknown's avatar
unknown committed
45 46
#endif

47 48 49 50 51
/*
  When a command is added here, be sure it's also added in mysqld.cc
  in "struct show_var_st status_vars[]= {" ...
*/

unknown's avatar
unknown committed
52
enum enum_sql_command {
53 54 55 56 57
  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,
unknown's avatar
unknown committed
58
  SQLCOM_SHOW_KEYS, SQLCOM_SHOW_VARIABLES, SQLCOM_SHOW_LOGS, SQLCOM_SHOW_STATUS,
59
  SQLCOM_SHOW_INNODB_STATUS, SQLCOM_SHOW_NDBCLUSTER_STATUS, SQLCOM_SHOW_MUTEX_STATUS,
60
  SQLCOM_SHOW_PROCESSLIST, SQLCOM_SHOW_MASTER_STAT, SQLCOM_SHOW_SLAVE_STAT,
61
  SQLCOM_SHOW_GRANTS, SQLCOM_SHOW_CREATE, SQLCOM_SHOW_CHARSETS,
62
  SQLCOM_SHOW_COLLATIONS, SQLCOM_SHOW_CREATE_DB, SQLCOM_SHOW_TABLE_STATUS,
63
  SQLCOM_SHOW_TRIGGERS,
64

unknown's avatar
unknown committed
65
  SQLCOM_LOAD,SQLCOM_SET_OPTION,SQLCOM_LOCK_TABLES,SQLCOM_UNLOCK_TABLES,
66
  SQLCOM_GRANT,
67
  SQLCOM_CHANGE_DB, SQLCOM_CREATE_DB, SQLCOM_DROP_DB, SQLCOM_ALTER_DB,
68
  SQLCOM_REPAIR, SQLCOM_REPLACE, SQLCOM_REPLACE_SELECT,
69
  SQLCOM_CREATE_FUNCTION, SQLCOM_DROP_FUNCTION,
70
  SQLCOM_REVOKE,SQLCOM_OPTIMIZE, SQLCOM_CHECK,
unknown's avatar
unknown committed
71
  SQLCOM_ASSIGN_TO_KEYCACHE, SQLCOM_PRELOAD_KEYS,
72
  SQLCOM_FLUSH, SQLCOM_KILL, SQLCOM_ANALYZE,
unknown's avatar
unknown committed
73
  SQLCOM_ROLLBACK, SQLCOM_ROLLBACK_TO_SAVEPOINT,
unknown's avatar
unknown committed
74
  SQLCOM_COMMIT, SQLCOM_SAVEPOINT, SQLCOM_RELEASE_SAVEPOINT,
75
  SQLCOM_SLAVE_START, SQLCOM_SLAVE_STOP,
76
  SQLCOM_BEGIN, SQLCOM_LOAD_MASTER_TABLE, SQLCOM_CHANGE_MASTER,
unknown's avatar
unknown committed
77
  SQLCOM_RENAME_TABLE, SQLCOM_BACKUP_TABLE, SQLCOM_RESTORE_TABLE,
78
  SQLCOM_RESET, SQLCOM_PURGE, SQLCOM_PURGE_BEFORE, SQLCOM_SHOW_BINLOGS,
79
  SQLCOM_SHOW_OPEN_TABLES, SQLCOM_LOAD_MASTER_DATA,
80
  SQLCOM_HA_OPEN, SQLCOM_HA_CLOSE, SQLCOM_HA_READ,
81
  SQLCOM_SHOW_SLAVE_HOSTS, SQLCOM_DELETE_MULTI, SQLCOM_UPDATE_MULTI,
unknown's avatar
unknown committed
82
  SQLCOM_SHOW_BINLOG_EVENTS, SQLCOM_SHOW_NEW_MASTER, SQLCOM_DO,
unknown's avatar
unknown committed
83
  SQLCOM_SHOW_WARNS, SQLCOM_EMPTY_QUERY, SQLCOM_SHOW_ERRORS,
unknown's avatar
unknown committed
84
  SQLCOM_SHOW_COLUMN_TYPES, SQLCOM_SHOW_STORAGE_ENGINES, SQLCOM_SHOW_PRIVILEGES,
85 86
  SQLCOM_HELP, SQLCOM_CREATE_USER, SQLCOM_DROP_USER, SQLCOM_RENAME_USER,
  SQLCOM_REVOKE_ALL, SQLCOM_CHECKSUM,
87
  SQLCOM_CREATE_PROCEDURE, SQLCOM_CREATE_SPFUNCTION, SQLCOM_CALL,
88
  SQLCOM_DROP_PROCEDURE, SQLCOM_ALTER_PROCEDURE,SQLCOM_ALTER_FUNCTION,
unknown's avatar
unknown committed
89 90
  SQLCOM_SHOW_CREATE_PROC, SQLCOM_SHOW_CREATE_FUNC,
  SQLCOM_SHOW_STATUS_PROC, SQLCOM_SHOW_STATUS_FUNC,
unknown's avatar
unknown committed
91
  SQLCOM_PREPARE, SQLCOM_EXECUTE, SQLCOM_DEALLOCATE_PREPARE,
unknown's avatar
VIEW  
unknown committed
92
  SQLCOM_CREATE_VIEW, SQLCOM_DROP_VIEW,
93
  SQLCOM_CREATE_TRIGGER, SQLCOM_DROP_TRIGGER,
94 95
  SQLCOM_XA_START, SQLCOM_XA_END, SQLCOM_XA_PREPARE,
  SQLCOM_XA_COMMIT, SQLCOM_XA_ROLLBACK, SQLCOM_XA_RECOVER,
unknown's avatar
unknown committed
96
  SQLCOM_SHOW_PROC_CODE, SQLCOM_SHOW_FUNC_CODE,
97
  /* This should be the last !!! */
98

99
  SQLCOM_END
unknown's avatar
unknown committed
100 101
};

unknown's avatar
unknown committed
102 103 104 105
// describe/explain types
#define DESCRIBE_NORMAL		1
#define DESCRIBE_EXTENDED	2

106
enum enum_sp_suid_behaviour
unknown's avatar
unknown committed
107
{
108 109 110
  SP_IS_DEFAULT_SUID= 0,
  SP_IS_NOT_SUID,
  SP_IS_SUID
unknown's avatar
unknown committed
111
};
112

113 114 115 116 117 118 119 120 121
enum enum_sp_data_access
{
  SP_DEFAULT_ACCESS= 0,
  SP_CONTAINS_SQL,
  SP_NO_SQL,
  SP_READS_SQL_DATA,
  SP_MODIFIES_SQL_DATA
};

122 123 124 125 126 127 128 129
const LEX_STRING sp_data_access_name[]=
{
  { (char*) STRING_WITH_LEN("") },
  { (char*) STRING_WITH_LEN("CONTAINS SQL") },
  { (char*) STRING_WITH_LEN("NO SQL") },
  { (char*) STRING_WITH_LEN("READS SQL DATA") },
  { (char*) STRING_WITH_LEN("MODIFIES SQL DATA") }
};
130

unknown's avatar
VIEW  
unknown committed
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
#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
};

unknown's avatar
unknown committed
148 149 150 151
typedef List<Item> List_item;

typedef struct st_lex_master_info
{
152
  char *host, *user, *password, *log_file_name;
unknown's avatar
unknown committed
153 154
  uint port, connect_retry;
  ulonglong pos;
unknown's avatar
unknown committed
155
  ulong server_id;
unknown's avatar
unknown committed
156 157 158 159 160 161 162
  /* 
     Variable for MASTER_SSL option.
     MASTER_SSL=0 in CHANGE MASTER TO corresponds to SSL_DISABLE
     MASTER_SSL=1 corresponds to SSL_ENABLE
  */
  enum {SSL_UNCHANGED=0, SSL_DISABLE, SSL_ENABLE} ssl; 
  char *ssl_key, *ssl_cert, *ssl_ca, *ssl_capath, *ssl_cipher;
163
  char *relay_log_name;
164
  ulong relay_log_pos;
unknown's avatar
unknown committed
165 166
} LEX_MASTER_INFO;

167

168 169
enum sub_select_type
{
unknown's avatar
unknown committed
170 171
  UNSPECIFIED_TYPE,UNION_TYPE, INTERSECT_TYPE,
  EXCEPT_TYPE, GLOBAL_OPTIONS_TYPE, DERIVED_TABLE_TYPE, OLAP_TYPE
172 173 174 175
};

enum olap_type 
{
176
  UNSPECIFIED_OLAP_TYPE, CUBE_TYPE, ROLLUP_TYPE
177
};
178

unknown's avatar
unknown committed
179 180 181 182 183
enum tablespace_op_type
{
  NO_TABLESPACE_OP, DISCARD_TABLESPACE, IMPORT_TABLESPACE
};

unknown's avatar
unknown committed
184 185 186
/* 
  The state of the lex parsing for selects 
   
187 188 189 190 191 192 193 194 195 196
   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
197
   All select describing structures linked with following pointers:
198
   - list of neighbors (next/prev) (prev of first element point to slave
unknown's avatar
unknown committed
199
     pointer of upper structure)
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226
     - 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:
227

unknown's avatar
unknown committed
228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243
   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:

244 245 246 247 248
   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
249 250

     main unit
unknown's avatar
unknown committed
251
     fake0
unknown's avatar
unknown committed
252 253 254 255 256 257 258 259
     select1 select2 select3
     |^^     |^
    s|||     ||master
    l|||     |+---------------------------------+
    a|||     +---------------------------------+|
    v|||master                         slave   ||
    e||+-------------------------+             ||
     V|            neighbor      |             V|
unknown's avatar
unknown committed
260
     unit1.1<+==================>unit1.2       unit2.1
unknown's avatar
unknown committed
261 262
     fake1.1
     select1.1.1 select 1.1.2    select1.2.1   select2.1.1
unknown's avatar
unknown committed
263 264 265 266 267 268 269 270
                                               |^
                                               ||
                                               V|
                                               unit2.1.1.1
                                               select2.1.1.1.1


   relation in main unit will be following:
271 272 273 274 275 276
   (bigger picture for:
      main unit
      fake0
      select1 select2 select3
   in the above picture)

unknown's avatar
unknown committed
277
         main unit
unknown's avatar
unknown committed
278 279 280 281 282 283 284 285
         |^^^^|fake_select_lex
         |||||+--------------------------------------------+
         ||||+--------------------------------------------+|
         |||+------------------------------+              ||
         ||+--------------+                |              ||
    slave||master         |                |              ||
         V|      neighbor |       neighbor |        master|V
         select1<========>select2<========>select3        fake0
unknown's avatar
unknown committed
286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301

    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)
*/
unknown's avatar
unknown committed
302
struct st_lex;
303 304
class st_select_lex;
class st_select_lex_unit;
305 306
class st_select_lex_node {
protected:
unknown's avatar
unknown committed
307 308 309
  st_select_lex_node *next, **prev,   /* neighbor list */
    *master, *slave,                  /* vertical links */
    *link_next, **link_prev;          /* list of whole SELECT_LEX */
310
public:
unknown's avatar
unknown committed
311

312
  ulonglong options;
313 314 315 316 317 318 319 320

  /*
    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;

321 322 323 324
  /*
    result of this query can't be cached, bit field, can be :
      UNCACHEABLE_DEPENDENT
      UNCACHEABLE_RAND
325
      UNCACHEABLE_SIDEEFFECT
326
      UNCACHEABLE_EXPLAIN
327
      UNCACHEABLE_PREPARE
328 329
  */
  uint8 uncacheable;
330
  enum sub_select_type linkage;
unknown's avatar
unknown committed
331
  bool no_table_names_allowed; /* used for global order by */
332
  bool no_error; /* suppress error message (convert it to warnings) */
333 334 335

  static void *operator new(size_t size)
  {
336
    return (void*) sql_alloc((uint) size);
337
  }
unknown's avatar
unknown committed
338 339
  static void *operator new(size_t size, MEM_ROOT *mem_root)
  { return (void*) alloc_root(mem_root, (uint) size); }
unknown's avatar
unknown committed
340
  static void operator delete(void *ptr,size_t size) { TRASH(ptr, size); }
341
  static void operator delete(void *ptr, MEM_ROOT *mem_root) {}
342
  st_select_lex_node(): linkage(UNSPECIFIED_TYPE) {}
343 344 345 346
  virtual ~st_select_lex_node() {}
  inline st_select_lex_node* get_master() { return master; }
  virtual void init_query();
  virtual void init_select();
unknown's avatar
unknown committed
347 348
  void include_down(st_select_lex_node *upper);
  void include_neighbour(st_select_lex_node *before);
unknown's avatar
unknown committed
349
  void include_standalone(st_select_lex_node *sel, st_select_lex_node **ref);
unknown's avatar
unknown committed
350 351
  void include_global(st_select_lex_node **plink);
  void exclude();
352 353 354

  virtual st_select_lex_unit* master_unit()= 0;
  virtual st_select_lex* outer_select()= 0;
unknown's avatar
unknown committed
355
  virtual st_select_lex* return_after_parsing()= 0;
356 357 358 359 360 361 362 363

  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();
  virtual List<String>* get_use_index();
  virtual List<String>* get_ignore_index();
unknown's avatar
unknown committed
364
  virtual ulong get_table_join_options();
unknown's avatar
unknown committed
365
  virtual TABLE_LIST *add_table_to_list(THD *thd, Table_ident *table,
366
					LEX_STRING *alias,
unknown's avatar
unknown committed
367
					ulong table_options,
368 369
					thr_lock_type flags= TL_UNLOCK,
					List<String> *use_index= 0,
unknown's avatar
unknown committed
370 371
					List<String> *ignore_index= 0,
                                        LEX_STRING *option= 0);
unknown's avatar
unknown committed
372
  virtual void set_lock_for_tables(thr_lock_type lock_type) {}
unknown's avatar
unknown committed
373

unknown's avatar
unknown committed
374
  friend class st_select_lex_unit;
unknown's avatar
unknown committed
375
  friend bool mysql_new_select(struct st_lex *lex, bool move_down);
376
  friend bool mysql_make_view(THD *thd, File_parser *parser,
377
                              TABLE_LIST *table, uint flags);
unknown's avatar
unknown committed
378 379 380
private:
  void fast_exclude();
};
381
typedef class st_select_lex_node SELECT_LEX_NODE;
unknown's avatar
unknown committed
382 383 384 385 386

/* 
   SELECT_LEX_UNIT - unit of selects (UNION, INTERSECT, ...) group 
   SELECT_LEXs
*/
unknown's avatar
unknown committed
387 388 389 390
class THD;
class select_result;
class JOIN;
class select_union;
391
class Procedure;
392
class st_select_lex_unit: public st_select_lex_node {
unknown's avatar
unknown committed
393 394 395 396
protected:
  TABLE_LIST result_table_list;
  select_union *union_result;
  TABLE *table; /* temporary table using for appending UNION results */
397

unknown's avatar
unknown committed
398
  select_result *result;
399
  ulonglong found_rows_for_union;
400 401
  bool saved_error;

402
public:
unknown's avatar
unknown committed
403
  bool  prepared, // prepare phase already performed for UNION (unit)
unknown's avatar
unknown committed
404
    optimized, // optimize phase already performed for UNION (unit)
405 406
    executed, // already executed
    cleaned;
407 408 409

  // list of fields which points to temporary table for union
  List<Item> item_list;
unknown's avatar
unknown committed
410 411 412 413 414 415 416
  /*
    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
  */
417
  List<Item> types;
unknown's avatar
unknown committed
418 419 420 421
  /*
    Pointer to 'last' select or pointer to unit where stored
    global parameters for union
  */
unknown's avatar
unknown committed
422
  st_select_lex *global_parameters;
423
  //node on wich we should return current_select pointer after parsing subquery
unknown's avatar
unknown committed
424
  st_select_lex *return_to;
unknown's avatar
unknown committed
425 426
  /* LIMIT clause runtime counters */
  ha_rows select_limit_cnt, offset_limit_cnt;
427
  /* not NULL if unit used in subselect, point to subselect item */
unknown's avatar
unknown committed
428
  Item_subselect *item;
unknown's avatar
unknown committed
429
  /* thread handler */
430
  THD *thd;
unknown's avatar
unknown committed
431 432 433 434
  /*
    SELECT_LEX for hidden SELECT in onion which process global
    ORDER BY and LIMIT
  */
unknown's avatar
unknown committed
435
  st_select_lex *fake_select_lex;
436

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

unknown's avatar
unknown committed
441
  void init_query();
442 443
  st_select_lex_unit* master_unit();
  st_select_lex* outer_select();
444 445 446 447 448 449 450
  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);
451
  }
unknown's avatar
unknown committed
452
  st_select_lex* return_after_parsing() { return return_to; }
unknown's avatar
unknown committed
453
  void exclude_level();
454
  void exclude_tree();
455

unknown's avatar
unknown committed
456
  /* UNION methods */
457
  bool prepare(THD *thd, select_result *result, ulong additional_options);
unknown's avatar
unknown committed
458 459
  bool exec();
  bool cleanup();
460
  inline void unclean() { cleaned= 0; }
unknown's avatar
unknown committed
461
  void reinit_exec_mechanism();
unknown's avatar
unknown committed
462 463

  void print(String *str);
464

unknown's avatar
unknown committed
465
  bool add_fake_select_lex(THD *thd);
466
  void init_prepare_fake_select_lex(THD *thd);
467
  inline bool is_prepared() { return prepared; }
unknown's avatar
unknown committed
468
  bool change_result(select_subselect *result, select_subselect *old_result);
469
  void set_limit(st_select_lex *values);
470
  void set_thd(THD *thd_arg) { thd= thd_arg; }
unknown's avatar
unknown committed
471
  inline bool is_union (); 
unknown's avatar
unknown committed
472

473
  friend void lex_start(THD *thd);
474
  friend int subselect_union_engine::exec();
475 476

  List<Item> *get_unit_column_types();
unknown's avatar
unknown committed
477
};
478

unknown's avatar
unknown committed
479
typedef class st_select_lex_unit SELECT_LEX_UNIT;
unknown's avatar
unknown committed
480 481

/*
482
  SELECT_LEX - store information of parsed SELECT statment
unknown's avatar
unknown committed
483
*/
484 485
class st_select_lex: public st_select_lex_node
{
486
public:
487
  Name_resolution_context context;
unknown's avatar
unknown committed
488
  char *db;
unknown's avatar
unknown committed
489
  Item *where, *having;                         /* WHERE & HAVING clauses */
490
  Item *prep_where; /* saved WHERE clause for prepared statement processing */
unknown's avatar
unknown committed
491
  Item *prep_having;/* saved HAVING clause for prepared statement processing */
492 493
  /* Saved values of the WHERE and HAVING clauses*/
  Item::cond_result cond_value, having_value;
unknown's avatar
VIEW  
unknown committed
494 495
  /* point on lex in which it was created, used in view subquery detection */
  st_lex *parent_lex;
496
  enum olap_type olap;
unknown's avatar
unknown committed
497 498 499 500
  /* 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 */
unknown's avatar
unknown committed
501
  List<String>        interval_list, use_index, *use_index_ptr,
unknown's avatar
unknown committed
502
		      ignore_index, *ignore_index_ptr;
unknown's avatar
unknown committed
503
  bool	              is_item_list_lookup;
unknown's avatar
unknown committed
504 505 506 507 508 509
  /* 
    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
510
  JOIN *join; /* after JOIN::prepare it is pointer to corresponding JOIN */
511
  List<TABLE_LIST> top_join_list; /* join list of the top level          */
512
  List<TABLE_LIST> *join_list;    /* list for the currently parsed join  */
513
  TABLE_LIST *embedding;          /* table embedding to the above list   */
unknown's avatar
unknown committed
514 515 516 517 518 519
  /*
    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;
520
  const char *type;               /* type of select for EXPLAIN          */
unknown's avatar
unknown committed
521 522 523

  SQL_LIST order_list;                /* ORDER clause */
  List<List_item>     expr_list;
unknown's avatar
unknown committed
524
  SQL_LIST *gorder_list;
525
  Item *select_limit, *offset_limit;  /* LIMIT clause parameters */
unknown's avatar
unknown committed
526 527 528
  // Arrays of pointers to top elements of all_fields list
  Item **ref_pointer_array;

unknown's avatar
merge  
unknown committed
529 530 531 532 533 534
  /*
    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;
535
  uint cond_count;    /* number of arguments of and/or/xor in where/having/on */
unknown's avatar
unknown committed
536 537
  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
538 539 540 541 542
  /*
    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
543 544
  enum_parsing_place parsing_place; /* where we are parsing expression */
  bool with_sum_func;   /* sum function indicator */
545 546 547 548 549
  /* 
    PS or SP cond natural joins was alredy processed with permanent
    arena and all additional items which we need alredy stored in it
  */
  bool conds_processed_with_permanent_arena;
unknown's avatar
unknown committed
550

unknown's avatar
unknown committed
551
  ulong table_join_options;
552
  uint in_sum_expr;
unknown's avatar
unknown committed
553
  uint select_number; /* number of select (used for EXPLAIN) */
unknown's avatar
unknown committed
554 555
  int nest_level;     /* nesting level of select */
  Item_sum *inner_sum_func_list; /* list of sum func in nested selects */ 
556
  uint with_wild; /* item list contain '*' */
unknown's avatar
unknown committed
557 558 559
  bool  braces;   	/* SELECT ... UNION (SELECT ... ) <- this braces */
  /* TRUE when having fix field called in processing of this SELECT */
  bool having_fix_field;
560 561
  /* List of references to fields referenced from inner selects */
  List<Item_outer_ref> inner_refs_list;
562 563 564 565 566
  /* 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;

567 568
  /* explicit LIMIT clause was used */
  bool explicit_limit;
569 570 571 572 573
  /*
    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;
574 575
  /* TRUE <=> this SELECT is correlated w.r.t. some ancestor select */
  bool is_correlated;
576 577 578 579 580 581 582 583 584 585 586 587 588
  /*
    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;
unknown's avatar
unknown committed
589
  bool first_cond_optimization;
unknown's avatar
unknown committed
590 591
  /* do not wrap view fields with Item_ref */
  bool no_wrap_view_item;
592 593
  /* exclude this select from check of unique_table() */
  bool exclude_from_table_unique_test;
594 595 596 597
  /* 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;
598

599
  List<udf_func>     udf_list;                  /* udf function calls stack */
600 601 602 603 604 605 606 607 608 609 610 611 612 613
  /* 
    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;
614

unknown's avatar
unknown committed
615 616
  void init_query();
  void init_select();
617
  st_select_lex_unit* master_unit();
618 619 620 621
  st_select_lex_unit* first_inner_unit() 
  { 
    return (st_select_lex_unit*) slave; 
  }
622
  st_select_lex* outer_select();
623
  st_select_lex* next_select() { return (st_select_lex*) next; }
624
  st_select_lex* next_select_in_list() 
625 626 627 628 629 630 631
  {
    return (st_select_lex*) link_next;
  }
  st_select_lex_node** next_select_in_list_addr()
  {
    return &link_next;
  }
unknown's avatar
unknown committed
632
  st_select_lex* return_after_parsing()
633 634 635
  {
    return master_unit()->return_after_parsing();
  }
636

unknown's avatar
unknown committed
637 638
  void mark_as_dependent(st_select_lex *last);

639 640 641
  bool set_braces(bool value);
  bool inc_in_sum_expr();
  uint get_in_sum_expr();
unknown's avatar
unknown committed
642

unknown's avatar
unknown committed
643 644
  bool add_item_to_list(THD *thd, Item *item);
  bool add_group_to_list(THD *thd, Item *item, bool asc);
645
  bool add_ftfunc_to_list(Item_func_match *func);
unknown's avatar
unknown committed
646
  bool add_order_to_list(THD *thd, Item *item, bool asc);
unknown's avatar
unknown committed
647
  TABLE_LIST* add_table_to_list(THD *thd, Table_ident *table,
648
				LEX_STRING *alias,
unknown's avatar
unknown committed
649
				ulong table_options,
650 651
				thr_lock_type flags= TL_UNLOCK,
				List<String> *use_index= 0,
652 653
				List<String> *ignore_index= 0,
                                LEX_STRING *option= 0);
unknown's avatar
unknown committed
654
  TABLE_LIST* get_table_list();
655 656 657 658 659
  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
660 661 662 663
  List<Item>* get_item_list();
  List<String>* get_use_index();
  List<String>* get_ignore_index();
  ulong get_table_join_options();
unknown's avatar
unknown committed
664
  void set_lock_for_tables(thr_lock_type lock_type);
665 666 667 668 669 670
  inline void init_order()
  {
    order_list.elements= 0;
    order_list.first= 0;
    order_list.next= (byte**) &order_list.first;
  }
671 672 673 674 675 676 677
  /*
    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
678 679
  bool test_limit();

680
  friend void lex_start(THD *thd);
681
  st_select_lex() : n_sum_items(0), n_child_sum_items(0) {}
unknown's avatar
unknown committed
682
  void make_empty_select()
683 684 685 686
  {
    init_query();
    init_select();
  }
unknown's avatar
unknown committed
687
  bool setup_ref_array(THD *thd, uint order_group_num);
unknown's avatar
unknown committed
688 689 690
  void print(THD *thd, String *str);
  static void print_order(String *str, ORDER *order);
  void print_limit(THD *thd, String *str);
691
  void fix_prepare_information(THD *thd, Item **conds, Item **having_conds);
692 693 694 695 696
  /*
    Destroy the used execution plan (JOIN) of this subtree (this
    SELECT_LEX and all nested SELECT_LEXes and SELECT_LEX_UNITs).
  */
  bool cleanup();
697 698 699 700 701
  /*
    Recursively cleanup the join of this select lex and of all nested
    select lexes.
  */
  void cleanup_all_joins(bool full);
unknown's avatar
unknown committed
702
};
unknown's avatar
unknown committed
703
typedef class st_select_lex SELECT_LEX;
704

unknown's avatar
unknown committed
705 706 707 708 709 710 711

inline bool st_select_lex_unit::is_union ()
{ 
  return first_select()->next_select() && 
    first_select()->next_select()->linkage == UNION_TYPE;
}

712 713 714 715 716 717 718 719
#define ALTER_ADD_COLUMN	1
#define ALTER_DROP_COLUMN	2
#define ALTER_CHANGE_COLUMN	4
#define ALTER_ADD_INDEX		8
#define ALTER_DROP_INDEX	16
#define ALTER_RENAME		32
#define ALTER_ORDER		64
#define ALTER_OPTIONS		128
720 721 722
#define ALTER_CHANGE_COLUMN_DEFAULT 256
#define ALTER_KEYS_ONOFF        512
#define ALTER_CONVERT          1024
723
#define ALTER_FORCE		2048
724

unknown's avatar
unknown committed
725 726 727 728 729 730 731 732
/**
  @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
733
{
unknown's avatar
unknown committed
734
public:
735 736
  List<Alter_drop>            drop_list;
  List<Alter_column>          alter_list;
unknown's avatar
unknown committed
737 738
  List<Key>	              key_list;
  List<create_field>          create_list;
739 740 741 742
  uint                        flags;
  enum enum_enable_or_disable keys_onoff;
  enum tablespace_op_type     tablespace_op;

unknown's avatar
unknown committed
743 744 745
  Alter_info() :
    flags(0),
    keys_onoff(LEAVE_AS_IS),
746
    tablespace_op(NO_TABLESPACE_OP)
unknown's avatar
unknown committed
747
  {}
748

unknown's avatar
unknown committed
749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776
  void reset()
  {
    drop_list.empty();
    alter_list.empty();
    key_list.empty();
    create_list.empty();
    flags= 0;
    keys_onoff= LEAVE_AS_IS;
    tablespace_op= NO_TABLESPACE_OP;
  }
  /**
    Construct a copy of this object to be used for mysql_alter_table
    and mysql_create_table. Historically, these two functions modify
    their Alter_info arguments. This behaviour breaks re-execution of
    prepared statements and stored procedures and is compensated by
    always supplying a copy of Alter_info to these functions.
    The constructed copy still shares key Key, Alter_drop, create_field
    and Alter_column elements of the lists - these structures are not
    modified and thus are not copied.

    @note You need to use check thd->is_fatal_error for out
    of memory condition after calling this function.
  */
  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
};
777

778 779 780
struct st_sp_chistics
{
  LEX_STRING comment;
781
  enum enum_sp_suid_behaviour suid;
782
  bool detistic;
783
  enum enum_sp_data_access daccess;
784 785
};

786 787 788 789 790 791 792 793 794

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

extern sys_var_long_ptr trg_new_row_fake_var;

795 796 797
enum xa_option_words {XA_NONE, XA_JOIN, XA_RESUME, XA_ONE_PHASE,
                      XA_SUSPEND, XA_FOR_MIGRATE};

798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823

/*
  Class representing list of all tables used by statement.
  It also contains information about stored functions used by statement
  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.

  Also used by st_lex::reset_n_backup/restore_backup_query_tables_list()
  methods to save and restore this information.
*/

class Query_tables_list
{
public:
  /* 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;
824 825 826 827 828
  /*
    Set of stored routines called by statement.
    (Note that we use lazy-initialization for this hash).
  */
  enum { START_SROUTINES_HASH_SIZE= 16 };
829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857
  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;
  byte     **sroutines_list_own_last;
  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
858 859 860 861 862
  /*
    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.
  */
863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889
  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;
    }
  }
unknown's avatar
unknown committed
890 891 892 893 894 895
  /**
    true if the parsed tree contains references to stored procedures
    or functions, false otherwise
  */
  bool uses_stored_routines() const
  { return sroutines_list.elements != 0; }
896 897 898
};


899 900 901 902 903 904 905 906 907 908 909 910
/*
  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;

911 912
  st_parsing_options() { reset(); }
  void reset();
913 914 915
};


916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960
/**
  This class represents the character input stream consumed during
  lexical analysis.
*/
class Lex_input_stream
{
public:
  Lex_input_stream(THD *thd, const char* buff, unsigned int length);
  ~Lex_input_stream();

  /** 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;

  /** Pointer to the current position in the input stream. */
  const char* ptr;

  /** Starting position of the last token parsed. */
  const char* tok_start;

  /** Ending position of the last token parsed. */
  const char* tok_end;

  /** End of the query text in the input stream. */
  const char* end_of_query;

  /** Starting position of the previous token parsed. */
  const char* tok_start_prev;

  /** Begining of the query text in the input stream. */
  const char* buf;

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

  /** Position of ';' in the stream, to delimit multiple queries. */
  const char* found_semicolon;
961 962 963
  
  /** Token character bitmaps, to detect 7bit strings. */
  uchar tok_bitmap;
unknown's avatar
unknown committed
964 965 966

  /** SQL_MODE = IGNORE_SPACE. */
  bool ignore_space;
967 968 969 970 971
  /*
    TRUE if we're parsing a prepared statement: in this mode
    we should allow placeholders and disallow multi-statements.
  */
  bool stmt_prepare_mode;
972 973 974
};


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

977
typedef struct st_lex : public Query_tables_list
978
{
unknown's avatar
unknown committed
979
  SELECT_LEX_UNIT unit;                         /* most upper unit */
980 981
  SELECT_LEX select_lex;                        /* first SELECT_LEX */
  /* current SELECT_LEX in parsing */
unknown's avatar
unknown committed
982
  SELECT_LEX *current_select;
983 984
  /* list of all SELECT_LEX */
  SELECT_LEX *all_selects_list;
985

unknown's avatar
unknown committed
986
  char *length,*dec,*change,*name;
unknown's avatar
unknown committed
987
  char *help_arg;
988
  char *backup_dir;				/* For RESTORE/BACKUP */
unknown's avatar
unknown committed
989
  char* to_log;                                 /* For PURGE MASTER LOGS TO */
990
  char* x509_subject,*x509_issuer,*ssl_cipher;
unknown's avatar
unknown committed
991 992
  String *wild;
  sql_exchange *exchange;
993
  select_result *result;
994
  Item *default_value, *on_update_value;
995
  LEX_STRING comment, ident;
unknown's avatar
unknown committed
996
  LEX_USER *grant_user;
unknown's avatar
unknown committed
997
  XID *xid;
unknown's avatar
unknown committed
998 999
  gptr yacc_yyss,yacc_yyvs;
  THD *thd;
1000
  CHARSET_INFO *charset, *underscore_charset;
1001
  bool text_string_is_7bit;
1002 1003
  /* store original leaf_tables for INSERT SELECT and PS/SP */
  TABLE_LIST *leaf_tables_insert;
1004 1005
  /* Position (first character index) of SELECT of CREATE VIEW statement */
  uint create_view_select_start;
unknown's avatar
unknown committed
1006

1007 1008 1009 1010 1011 1012
  /*
    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
1013
  List<key_part_spec> col_list;
1014
  List<key_part_spec> ref_list;
1015
  List<String>	      interval_list;
unknown's avatar
unknown committed
1016
  List<LEX_USER>      users_list;
unknown's avatar
unknown committed
1017
  List<LEX_COLUMN>    columns;
unknown's avatar
unknown committed
1018
  List<Item>	      *insert_list,field_list,value_list,update_list;
1019
  List<List_item>     many_values;
unknown's avatar
unknown committed
1020
  List<set_var_base>  var_list;
1021
  List<Item_param>    param_list;
unknown's avatar
VIEW  
unknown committed
1022
  List<LEX_STRING>    view_list; // view list (list of field names in view)
unknown's avatar
unknown committed
1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
  /*
    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
1038
  SQL_LIST	      proc_list, auxiliary_table_list, save_list;
unknown's avatar
unknown committed
1039
  create_field	      *last_field;
unknown's avatar
unknown committed
1040
  Item_sum *in_sum_func;
unknown's avatar
unknown committed
1041
  udf_func udf;
1042 1043
  HA_CHECK_OPT   check_opt;			// check/repair options
  HA_CREATE_INFO create_info;
unknown's avatar
unknown committed
1044
  LEX_MASTER_INFO mi;				// used by CHANGE MASTER
1045
  USER_RESOURCES mqh;
1046
  ulong type;
unknown's avatar
unknown committed
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
  /*
    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;
1057
  enum_sql_command sql_command, orig_sql_command;
1058
  thr_lock_type lock_option;
unknown's avatar
unknown committed
1059
  enum SSL_type ssl_type;			/* defined in violite.h */
1060
  enum enum_duplicates duplicates;
unknown's avatar
unknown committed
1061
  enum enum_tx_isolation tx_isolation;
1062
  enum enum_ha_read_modes ha_read_mode;
1063
  union {
unknown's avatar
unknown committed
1064
    enum ha_rkey_function ha_rkey_mode;
1065 1066
    enum xa_option_words xa_opt;
  };
unknown's avatar
unknown committed
1067
  enum enum_var_type option_type;
unknown's avatar
VIEW  
unknown committed
1068 1069
  enum enum_view_create_mode create_view_mode;
  enum enum_drop_mode drop_mode;
unknown's avatar
unknown committed
1070
  uint uint_geom_type;
unknown's avatar
unknown committed
1071
  uint grant, grant_tot_col, which_columns;
1072
  uint fk_delete_opt, fk_update_opt, fk_match_option;
1073
  uint slave_thd_opt, start_transaction_opt;
unknown's avatar
unknown committed
1074
  int nest_level;
1075 1076 1077 1078 1079 1080
  /*
    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
1081
  uint8 describe;
1082 1083 1084
  /*
    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
1085
    DERIVED_SUBQUERY and DERIVED_VIEW).
1086
  */
unknown's avatar
VIEW  
unknown committed
1087 1088
  uint8 derived_tables;
  uint8 create_view_algorithm;
unknown's avatar
unknown committed
1089
  uint8 create_view_check;
1090
  bool drop_if_exists, drop_temporary, local_file, one_shot_set;
unknown's avatar
unknown committed
1091
  bool in_comment, verbose, no_write_to_binlog;
unknown's avatar
unknown committed
1092
  bool tx_chain, tx_release;
unknown's avatar
unknown committed
1093 1094 1095 1096 1097 1098 1099
  /*
    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
1100
  bool view_prepare_mode;
1101
  bool safe_to_cache_query;
1102
  bool subqueries, ignore;
1103
  st_parsing_options parsing_options;
unknown's avatar
unknown committed
1104
  Alter_info alter_info;
unknown's avatar
unknown committed
1105 1106
  /* Prepared statements SQL syntax:*/
  LEX_STRING prepared_stmt_name; /* Statement name (in all queries) */
unknown's avatar
unknown committed
1107
  /*
1108 1109 1110
    Prepared statement query text or name of variable that holds the
    prepared statement (in PREPARE ... queries)
  */
unknown's avatar
unknown committed
1111
  LEX_STRING prepared_stmt_code;
1112 1113
  /* 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
1114
  /* Names of user variables holding parameters (in EXECUTE) */
unknown's avatar
unknown committed
1115
  List<LEX_STRING> prepared_stmt_params;
1116
  /*
1117 1118
    Points to part of global table list which contains time zone tables
    implicitly used by the statement.
1119 1120
  */
  TABLE_LIST *time_zone_tables_used;
1121
  sp_head *sphead;
1122
  sp_name *spname;
1123
  bool sp_lex_in_use;	/* Keep track on lex usage in SPs for error handling */
1124
  bool all_privileges;
1125
  sp_pcontext *spcont;
1126

1127
  st_sp_chistics sp_chistics;
unknown's avatar
VIEW  
unknown committed
1128 1129 1130 1131 1132 1133
  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;
1134 1135 1136
  /*
    view created to be run from definer (standard behaviour)
  */
1137
  uint8 create_view_suid;
1138 1139 1140
  /* Characterstics of trigger being created */
  st_trg_chistics trg_chistics;
  /*
1141 1142 1143 1144 1145
    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).
1146
  */
1147
  SQL_LIST trg_table_fields;
1148

1149
  /*
1150 1151 1152 1153 1154 1155 1156 1157
    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");

    This pointer is required to add possibly omitted DEFINER-clause to the
    DDL-statement before dumping it to the binlog. 
1158
  */
1159
  const char *stmt_definition_begin;
1160

unknown's avatar
unknown committed
1161 1162 1163 1164
  /*
    Pointers to part of LOAD DATA statement that should be rewritten
    during replication ("LOCAL 'filename' REPLACE INTO" part).
  */
1165 1166 1167
  const char *fname_start;
  const char *fname_end;

1168
  bool escape_used;
unknown's avatar
unknown committed
1169

1170
  st_lex();
1171 1172

  virtual ~st_lex()
1173
  {
1174
    destroy_query_tables_list();
1175
  }
1176

1177
  inline void uncacheable(uint8 cause)
1178 1179
  {
    safe_to_cache_query= 0;
1180 1181 1182 1183 1184 1185

    /*
      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
1186
    SELECT_LEX *sl;
unknown's avatar
unknown committed
1187 1188 1189 1190
    SELECT_LEX_UNIT *un;
    for (sl= current_select, un= sl->master_unit();
	 un != &unit;
	 sl= sl->outer_select(), un= sl->master_unit())
1191
    {
1192 1193
      sl->uncacheable|= cause;
      un->uncacheable|= cause;
1194
    }
1195
  }
1196 1197
  void set_trg_event_type_for_tables();

unknown's avatar
VIEW  
unknown committed
1198 1199 1200
  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();
1201
  bool add_time_zone_tables_to_query_tables(THD *thd);
unknown's avatar
VIEW  
unknown committed
1202 1203 1204

  bool can_be_merged();
  bool can_use_merged();
1205
  bool can_not_use_merged();
unknown's avatar
VIEW  
unknown committed
1206
  bool only_view_structure();
unknown's avatar
unknown committed
1207
  bool need_correct_ident();
1208
  uint8 get_effective_with_check(TABLE_LIST *view);
1209 1210
  /*
    Is this update command where 'WHITH CHECK OPTION' clause is important
1211

1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
    SYNOPSIS
      st_lex::which_check_option_applicable()

    RETURN
      TRUE   have to take 'WHITH CHECK OPTION' clause into account
      FALSE  'WHITH CHECK OPTION' clause do not need
  */
  inline bool which_check_option_applicable()
  {
    switch (sql_command) {
    case SQLCOM_UPDATE:
    case SQLCOM_UPDATE_MULTI:
    case SQLCOM_INSERT:
    case SQLCOM_INSERT_SELECT:
1226 1227
    case SQLCOM_REPLACE:
    case SQLCOM_REPLACE_SELECT:
1228 1229 1230 1231 1232 1233
    case SQLCOM_LOAD:
      return TRUE;
    default:
      return FALSE;
    }
  }
1234

1235
  void cleanup_after_one_table_open();
unknown's avatar
unknown committed
1236

1237
  bool push_context(Name_resolution_context *context)
unknown's avatar
unknown committed
1238
  {
1239
    return context_stack.push_front(context);
unknown's avatar
unknown committed
1240 1241 1242 1243 1244 1245 1246
  }

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

1247 1248
  bool copy_db_to(char **p_db, uint *p_db_length) const;

unknown's avatar
unknown committed
1249 1250 1251 1252
  Name_resolution_context *current_context()
  {
    return context_stack.head();
  }
1253 1254 1255 1256
  /*
    Restore the LEX and THD in case of a parse error.
  */
  static void cleanup_lex_after_parse_error(THD *thd);
1257 1258 1259

  void reset_n_backup_query_tables_list(Query_tables_list *backup);
  void restore_backup_query_tables_list(Query_tables_list *backup);
1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281

  /**
    @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;
  }
unknown's avatar
unknown committed
1282 1283
} LEX;

unknown's avatar
unknown committed
1284 1285
struct st_lex_local: public st_lex
{
1286
  static void *operator new(size_t size) throw()
unknown's avatar
unknown committed
1287 1288 1289
  {
    return (void*) sql_alloc((uint) size);
  }
1290
  static void *operator new(size_t size, MEM_ROOT *mem_root) throw()
unknown's avatar
unknown committed
1291 1292 1293
  {
    return (void*) alloc_root(mem_root, (uint) size);
  }
unknown's avatar
unknown committed
1294 1295
  static void operator delete(void *ptr,size_t size)
  { TRASH(ptr, size); }
1296 1297
  static void operator delete(void *ptr, MEM_ROOT *mem_root)
  { /* Never called */ }
unknown's avatar
unknown committed
1298
};
unknown's avatar
unknown committed
1299

unknown's avatar
unknown committed
1300 1301
extern void lex_init(void);
extern void lex_free(void);
1302
extern void lex_start(THD *thd);
unknown's avatar
unknown committed
1303
extern void lex_end(LEX *lex);
1304
extern int MYSQLlex(void *arg, void *yythd);
1305
extern char *skip_rear_comments(CHARSET_INFO *cs, char *begin, char *end);
1306