sql_lex.h 27.7 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
unknown's avatar
unknown committed
2

unknown's avatar
unknown committed
3 4 5 6
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
unknown's avatar
unknown committed
7

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

unknown's avatar
unknown committed
13 14 15 16 17 18 19 20 21 22 23
   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;
24
class sp_head;
25
class sp_name;
26 27
class sp_instr;
class sp_pcontext;
unknown's avatar
unknown committed
28

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

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

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

44 45 46 47 48
/*
  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
49
enum enum_sql_command {
50 51 52 53 54
  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
55
  SQLCOM_SHOW_KEYS, SQLCOM_SHOW_VARIABLES, SQLCOM_SHOW_LOGS, SQLCOM_SHOW_STATUS,
unknown's avatar
unknown committed
56
  SQLCOM_SHOW_INNODB_STATUS,
57
  SQLCOM_SHOW_PROCESSLIST, SQLCOM_SHOW_MASTER_STAT, SQLCOM_SHOW_SLAVE_STAT,
58
  SQLCOM_SHOW_GRANTS, SQLCOM_SHOW_CREATE, SQLCOM_SHOW_CHARSETS,
59
  SQLCOM_SHOW_COLLATIONS, SQLCOM_SHOW_CREATE_DB, SQLCOM_SHOW_TABLE_STATUS,
60

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

unknown's avatar
unknown committed
93 94 95 96
// describe/explain types
#define DESCRIBE_NORMAL		1
#define DESCRIBE_EXTENDED	2

97
enum enum_sp_suid_behaviour
unknown's avatar
unknown committed
98
{
99 100 101
  SP_IS_DEFAULT_SUID= 0,
  SP_IS_NOT_SUID,
  SP_IS_SUID
unknown's avatar
unknown committed
102
};
103

104 105 106 107 108 109 110 111 112 113
enum enum_sp_data_access
{
  SP_DEFAULT_ACCESS= 0,
  SP_CONTAINS_SQL,
  SP_NO_SQL,
  SP_READS_SQL_DATA,
  SP_MODIFIES_SQL_DATA
};


unknown's avatar
VIEW  
unknown committed
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
#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
131 132 133 134
typedef List<Item> List_item;

typedef struct st_lex_master_info
{
135
  char *host, *user, *password, *log_file_name;
unknown's avatar
unknown committed
136 137
  uint port, connect_retry;
  ulonglong pos;
unknown's avatar
unknown committed
138
  ulong server_id;
unknown's avatar
unknown committed
139 140 141 142 143 144 145
  /* 
     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;
146
  char *relay_log_name;
147
  ulong relay_log_pos;
unknown's avatar
unknown committed
148 149
} LEX_MASTER_INFO;

150

151 152
enum sub_select_type
{
unknown's avatar
unknown committed
153 154
  UNSPECIFIED_TYPE,UNION_TYPE, INTERSECT_TYPE,
  EXCEPT_TYPE, GLOBAL_OPTIONS_TYPE, DERIVED_TABLE_TYPE, OLAP_TYPE
155 156 157 158
};

enum olap_type 
{
159
  UNSPECIFIED_OLAP_TYPE, CUBE_TYPE, ROLLUP_TYPE
160
};
161

unknown's avatar
unknown committed
162 163 164 165 166
enum tablespace_op_type
{
  NO_TABLESPACE_OP, DISCARD_TABLESPACE, IMPORT_TABLESPACE
};

unknown's avatar
unknown committed
167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
/* 
  The state of the lex parsing for selects 
   
   All select describing structures linked with following pointers:
   - list of neighbors (next/prev) (prev of first element point to slave 
     pointer of upper structure)
     - one level units for unit (union) structure
     - member of one union(unit) for ordinary select_lex
   - pointer to master
     - outer select_lex for unit (union)
     - unit structure for ordinary select_lex
   - pointer to slave
     - first list element of select_lex belonged to this unit for unit
     - first unit in list of units that belong to this select_lex (as
       subselects or derived tables) for ordinary select_lex
   - list of all select_lex (for group operation like correcting list of opened
     tables)
unknown's avatar
unknown committed
184 185 186 187 188 189
   - if unit contain several selects (union) then it have special 
     select_lex called fake_select_lex. It used for storing global parameters
     and executing union. subqueries of global ORDER BY clause will be
     attached to this fake_select_lex, which will allow them correctly
     resolve fields of 'upper' union and other more outer selects. 

unknown's avatar
unknown committed
190
   for example for following query:
191

unknown's avatar
unknown committed
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
   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:


     main unit
unknown's avatar
unknown committed
210
     fake0
unknown's avatar
unknown committed
211 212 213 214 215 216 217 218
     select1 select2 select3
     |^^     |^
    s|||     ||master
    l|||     |+---------------------------------+
    a|||     +---------------------------------+|
    v|||master                         slave   ||
    e||+-------------------------+             ||
     V|            neighbor      |             V|
unknown's avatar
unknown committed
219
     unit1.1<+==================>unit1.2       unit2.1
unknown's avatar
unknown committed
220 221
     fake1.1
     select1.1.1 select 1.1.2    select1.2.1   select2.1.1
unknown's avatar
unknown committed
222 223 224 225 226 227 228 229 230 231
                                               |^
                                               ||
                                               V|
                                               unit2.1.1.1
                                               select2.1.1.1.1


   relation in main unit will be following:
                          
         main unit
unknown's avatar
unknown committed
232 233 234 235 236 237 238 239
         |^^^^|fake_select_lex
         |||||+--------------------------------------------+
         ||||+--------------------------------------------+|
         |||+------------------------------+              ||
         ||+--------------+                |              ||
    slave||master         |                |              ||
         V|      neighbor |       neighbor |        master|V
         select1<========>select2<========>select3        fake0
unknown's avatar
unknown committed
240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255

    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
256
struct st_lex;
257 258
class st_select_lex;
class st_select_lex_unit;
259 260
class st_select_lex_node {
protected:
unknown's avatar
unknown committed
261 262 263
  st_select_lex_node *next, **prev,   /* neighbor list */
    *master, *slave,                  /* vertical links */
    *link_next, **link_prev;          /* list of whole SELECT_LEX */
264
public:
unknown's avatar
unknown committed
265

266
  ulong options;
267 268 269 270
  /*
    result of this query can't be cached, bit field, can be :
      UNCACHEABLE_DEPENDENT
      UNCACHEABLE_RAND
271
      UNCACHEABLE_SIDEEFFECT
272
      UNCACHEABLE_EXPLAIN
273 274
  */
  uint8 uncacheable;
275
  enum sub_select_type linkage;
unknown's avatar
unknown committed
276
  bool no_table_names_allowed; /* used for global order by */
277
  bool no_error; /* suppress error message (convert it to warnings) */
278 279 280

  static void *operator new(size_t size)
  {
281
    return (void*) sql_alloc((uint) size);
282
  }
unknown's avatar
unknown committed
283 284
  static void *operator new(size_t size, MEM_ROOT *mem_root)
  { return (void*) alloc_root(mem_root, (uint) size); }
285
  static void operator delete(void *ptr,size_t size) {}
286
  static void operator delete(void *ptr,size_t size, MEM_ROOT *mem_root) {}
287
  st_select_lex_node(): linkage(UNSPECIFIED_TYPE) {}
288 289 290 291
  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
292 293
  void include_down(st_select_lex_node *upper);
  void include_neighbour(st_select_lex_node *before);
unknown's avatar
unknown committed
294
  void include_standalone(st_select_lex_node *sel, st_select_lex_node **ref);
unknown's avatar
unknown committed
295 296
  void include_global(st_select_lex_node **plink);
  void exclude();
297 298 299

  virtual st_select_lex_unit* master_unit()= 0;
  virtual st_select_lex* outer_select()= 0;
unknown's avatar
unknown committed
300
  virtual st_select_lex* return_after_parsing()= 0;
301 302 303 304 305 306 307 308

  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
309
  virtual ulong get_table_join_options();
unknown's avatar
unknown committed
310
  virtual TABLE_LIST *add_table_to_list(THD *thd, Table_ident *table,
311
					LEX_STRING *alias,
unknown's avatar
unknown committed
312
					ulong table_options,
313 314
					thr_lock_type flags= TL_UNLOCK,
					List<String> *use_index= 0,
unknown's avatar
unknown committed
315 316
					List<String> *ignore_index= 0,
                                        LEX_STRING *option= 0);
unknown's avatar
unknown committed
317
  virtual void set_lock_for_tables(thr_lock_type lock_type) {}
unknown's avatar
unknown committed
318

unknown's avatar
unknown committed
319
  friend class st_select_lex_unit;
unknown's avatar
unknown committed
320
  friend bool mysql_new_select(struct st_lex *lex, bool move_down);
unknown's avatar
VIEW  
unknown committed
321 322
  friend my_bool mysql_make_view (File_parser *parser,
				  TABLE_LIST *table);
unknown's avatar
unknown committed
323 324 325
private:
  void fast_exclude();
};
326
typedef class st_select_lex_node SELECT_LEX_NODE;
unknown's avatar
unknown committed
327 328 329 330 331

/* 
   SELECT_LEX_UNIT - unit of selects (UNION, INTERSECT, ...) group 
   SELECT_LEXs
*/
332
struct st_lex;
unknown's avatar
unknown committed
333 334 335 336
class THD;
class select_result;
class JOIN;
class select_union;
337
class Procedure;
338
class st_select_lex_unit: public st_select_lex_node {
unknown's avatar
unknown committed
339 340 341 342
protected:
  TABLE_LIST result_table_list;
  select_union *union_result;
  TABLE *table; /* temporary table using for appending UNION results */
343

unknown's avatar
unknown committed
344
  select_result *result;
unknown's avatar
unknown committed
345
  ulong found_rows_for_union;
unknown's avatar
unknown committed
346
  bool res;
unknown's avatar
unknown committed
347
  bool  prepared, // prepare phase already performed for UNION (unit)
unknown's avatar
unknown committed
348
    optimized, // optimize phase already performed for UNION (unit)
349 350
    executed, // already executed
    cleaned;
351

352
public:
353 354
  // list of fields which points to temporary table for union
  List<Item> item_list;
unknown's avatar
unknown committed
355 356 357 358 359 360 361
  /*
    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
  */
362
  List<Item> types;
unknown's avatar
unknown committed
363 364 365 366
  /*
    Pointer to 'last' select or pointer to unit where stored
    global parameters for union
  */
unknown's avatar
unknown committed
367
  st_select_lex *global_parameters;
368
  //node on wich we should return current_select pointer after parsing subquery
unknown's avatar
unknown committed
369
  st_select_lex *return_to;
unknown's avatar
unknown committed
370 371
  /* LIMIT clause runtime counters */
  ha_rows select_limit_cnt, offset_limit_cnt;
372
  /* not NULL if unit used in subselect, point to subselect item */
unknown's avatar
unknown committed
373
  Item_subselect *item;
unknown's avatar
unknown committed
374
  /* thread handler */
375
  THD *thd;
unknown's avatar
unknown committed
376 377 378 379
  /*
    SELECT_LEX for hidden SELECT in onion which process global
    ORDER BY and LIMIT
  */
unknown's avatar
unknown committed
380
  st_select_lex *fake_select_lex;
381

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

unknown's avatar
unknown committed
386
  void init_query();
387 388
  st_select_lex_unit* master_unit();
  st_select_lex* outer_select();
389 390 391 392
  st_select_lex* first_select()
  {
    return my_reinterpret_cast(st_select_lex*)(slave);
  }
393 394
  st_select_lex* first_select_in_union() 
  { 
395 396 397 398 399
    return my_reinterpret_cast(st_select_lex*)(slave);
  }
  st_select_lex_unit* next_unit()
  {
    return my_reinterpret_cast(st_select_lex_unit*)(next);
400
  }
unknown's avatar
unknown committed
401
  st_select_lex* return_after_parsing() { return return_to; }
unknown's avatar
unknown committed
402
  void exclude_level();
403
  void exclude_tree();
404

unknown's avatar
unknown committed
405
  /* UNION methods */
unknown's avatar
unknown committed
406 407 408
  bool prepare(THD *thd, select_result *result, ulong additional_options);
  bool exec();
  bool cleanup();
409
  inline void unclean() { cleaned= 0; }
unknown's avatar
unknown committed
410
  void reinit_exec_mechanism();
unknown's avatar
unknown committed
411

412
  bool check_updateable(char *db, char *table);
unknown's avatar
unknown committed
413
  void print(String *str);
414 415

  ulong init_prepare_fake_select_lex(THD *thd);
unknown's avatar
unknown committed
416
  bool change_result(select_subselect *result, select_subselect *old_result);
unknown's avatar
unknown committed
417
  void set_limit(st_select_lex *values, st_select_lex *sl);
unknown's avatar
unknown committed
418

419
  friend void lex_start(THD *thd, uchar *buf, uint length);
420
  friend int subselect_union_engine::exec();
unknown's avatar
unknown committed
421
};
unknown's avatar
unknown committed
422
typedef class st_select_lex_unit SELECT_LEX_UNIT;
unknown's avatar
unknown committed
423 424 425 426

/*
  SELECT_LEX - store information of parsed SELECT_LEX statment
*/
427 428
class st_select_lex: public st_select_lex_node
{
429
public:
unknown's avatar
unknown committed
430 431
  char *db, *db1, *table1, *db2, *table2;      	/* For outer join using .. */
  Item *where, *having;                         /* WHERE & HAVING clauses */
432
  Item *prep_where; /* saved WHERE clause for prepared statement processing */
unknown's avatar
VIEW  
unknown committed
433 434
  /* point on lex in which it was created, used in view subquery detection */
  st_lex *parent_lex;
435
  enum olap_type olap;
unknown's avatar
unknown committed
436 437 438
  SQL_LIST	      table_list, group_list;   /* FROM & GROUP BY clauses */
  List<Item>          item_list; /* list of fields & expressions */
  List<String>        interval_list, use_index, *use_index_ptr,
unknown's avatar
unknown committed
439
		      ignore_index, *ignore_index_ptr;
unknown's avatar
unknown committed
440 441 442 443 444 445
  /* 
    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
446
  JOIN *join; /* after JOIN::prepare it is pointer to corresponding JOIN */
447
  List<TABLE_LIST> top_join_list; /* join list of the top level          */
448
  List<TABLE_LIST> *join_list;    /* list for the currently parsed join  */
449
  TABLE_LIST *embedding;          /* table embedding to the above list   */
450
  TABLE_LIST *leaf_tables;        /* list of leaves in join table tree   */
451
  const char *type;               /* type of select for EXPLAIN          */
unknown's avatar
unknown committed
452 453 454 455

  SQL_LIST order_list;                /* ORDER clause */
  List<List_item>     expr_list;
  List<List_item>     when_list;      /* WHEN clause (expression) */
unknown's avatar
unknown committed
456
  SQL_LIST *gorder_list;
unknown's avatar
unknown committed
457 458 459 460
  ha_rows select_limit, offset_limit; /* LIMIT clause parameters */
  // Arrays of pointers to top elements of all_fields list
  Item **ref_pointer_array;

unknown's avatar
merge  
unknown committed
461 462 463 464 465 466
  /*
    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;
unknown's avatar
unknown committed
467 468 469
  uint cond_count;      /* number of arguments of and/or/xor in where/having */
  enum_parsing_place parsing_place; /* where we are parsing expression */
  bool with_sum_func;   /* sum function indicator */
470 471 472 473 474
  /* 
    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
475

unknown's avatar
unknown committed
476
  ulong table_join_options;
477
  uint in_sum_expr;
unknown's avatar
unknown committed
478
  uint select_number; /* number of select (used for EXPLAIN) */
479
  uint with_wild; /* item list contain '*' */
unknown's avatar
unknown committed
480 481 482
  bool  braces;   	/* SELECT ... UNION (SELECT ... ) <- this braces */
  /* TRUE when having fix field called in processing of this SELECT */
  bool having_fix_field;
483 484
  /* explicit LIMIT clause was used */
  bool explicit_limit;
485 486 487 488 489
  /*
    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;
490
  bool first_execution; /* first execution in SP or PS */
unknown's avatar
unknown committed
491
  bool first_cond_optimization;
unknown's avatar
unknown committed
492 493
  /* do not wrap view fields with Item_ref */
  bool no_wrap_view_item;
494

495
  /* 
496 497 498 499 500 501 502 503 504 505
     SELECT for SELECT command st_select_lex. Used to privent scaning
     item_list of non-SELECT st_select_lex (no sense find to finding
     reference in it (all should be in tables, it is dangerouse due
     to order of fix_fields calling for non-SELECTs commands (item list
     can be not fix_fieldsd)). This value will be assigned for
     primary select (sql_yac.yy) and for any subquery and
     UNION SELECT (sql_parse.cc mysql_new_select())


     INSERT for primary st_select_lex structure of simple INSERT/REPLACE
506 507 508 509
     (used for name resolution, see Item_fiels & Item_ref fix_fields,
     FALSE for INSERT/REPLACE ... SELECT, because it's
     st_select_lex->table_list will be preprocessed (first table removed)
     before passing to handle_select)
510 511

     NOMATTER for other
512
  */
513 514
  enum {NOMATTER_MODE, SELECT_MODE, INSERT_MODE} resolve_mode;

unknown's avatar
unknown committed
515

unknown's avatar
unknown committed
516 517
  void init_query();
  void init_select();
518
  st_select_lex_unit* master_unit();
519 520 521 522
  st_select_lex_unit* first_inner_unit() 
  { 
    return (st_select_lex_unit*) slave; 
  }
523
  st_select_lex* outer_select();
524
  st_select_lex* next_select() { return (st_select_lex*) next; }
525
  st_select_lex* next_select_in_list() 
526 527 528 529 530 531 532
  {
    return (st_select_lex*) link_next;
  }
  st_select_lex_node** next_select_in_list_addr()
  {
    return &link_next;
  }
unknown's avatar
unknown committed
533
  st_select_lex* return_after_parsing()
534 535 536
  {
    return master_unit()->return_after_parsing();
  }
537

unknown's avatar
unknown committed
538 539
  void mark_as_dependent(st_select_lex *last);

540 541 542
  bool set_braces(bool value);
  bool inc_in_sum_expr();
  uint get_in_sum_expr();
unknown's avatar
unknown committed
543

unknown's avatar
unknown committed
544 545
  bool add_item_to_list(THD *thd, Item *item);
  bool add_group_to_list(THD *thd, Item *item, bool asc);
546
  bool add_ftfunc_to_list(Item_func_match *func);
unknown's avatar
unknown committed
547
  bool add_order_to_list(THD *thd, Item *item, bool asc);
unknown's avatar
unknown committed
548
  TABLE_LIST* add_table_to_list(THD *thd, Table_ident *table,
549
				LEX_STRING *alias,
unknown's avatar
unknown committed
550
				ulong table_options,
551 552
				thr_lock_type flags= TL_UNLOCK,
				List<String> *use_index= 0,
553 554
				List<String> *ignore_index= 0,
                                LEX_STRING *option= 0);
unknown's avatar
unknown committed
555
  TABLE_LIST* get_table_list();
556 557 558 559 560 561
  bool init_nested_join(THD *thd);
  TABLE_LIST *end_nested_join(THD *thd);
  TABLE_LIST *nest_last_join(THD *thd);
  void save_names_for_using_list(TABLE_LIST *tab1, TABLE_LIST *tab2);
  void add_joined_table(TABLE_LIST *table);
  TABLE_LIST *convert_right_join();
unknown's avatar
unknown committed
562 563 564 565
  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
566
  void set_lock_for_tables(thr_lock_type lock_type);
567 568 569 570 571 572
  inline void init_order()
  {
    order_list.elements= 0;
    order_list.first= 0;
    order_list.next= (byte**) &order_list.first;
  }
573
  
unknown's avatar
unknown committed
574 575
  bool test_limit();

576
  friend void lex_start(THD *thd, uchar *buf, uint length);
unknown's avatar
unknown committed
577 578
  st_select_lex() {}
  void make_empty_select()
579 580 581 582
  {
    init_query();
    init_select();
  }
unknown's avatar
unknown committed
583
  bool setup_ref_array(THD *thd, uint order_group_num);
584
  bool check_updateable(char *db, char *table);
585
  bool check_updateable_in_subqueries(char *db, char *table);
unknown's avatar
unknown committed
586 587 588
  void print(THD *thd, String *str);
  static void print_order(String *str, ORDER *order);
  void print_limit(THD *thd, String *str);
unknown's avatar
VIEW  
unknown committed
589
  void fix_prepare_information(THD *thd, Item **conds);
unknown's avatar
unknown committed
590
};
unknown's avatar
unknown committed
591
typedef class st_select_lex SELECT_LEX;
592

593 594 595 596 597 598 599 600
#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
601 602 603
#define ALTER_CHANGE_COLUMN_DEFAULT 256
#define ALTER_KEYS_ONOFF        512
#define ALTER_CONVERT          1024
604

605 606 607 608 609 610 611 612 613 614 615 616 617
typedef struct st_alter_info
{
  List<Alter_drop>            drop_list;
  List<Alter_column>          alter_list;
  uint                        flags;
  enum enum_enable_or_disable keys_onoff;
  enum tablespace_op_type     tablespace_op;

  st_alter_info(){clear();}
  void clear(){keys_onoff= LEAVE_AS_IS;tablespace_op= NO_TABLESPACE_OP;}
  void reset(){drop_list.empty();alter_list.empty();clear();}
} ALTER_INFO;

618 619 620
struct st_sp_chistics
{
  LEX_STRING comment;
621
  enum enum_sp_suid_behaviour suid;
622
  bool detistic;
623
  enum enum_sp_data_access daccess;
624 625
};

626 627 628 629 630 631 632 633 634

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;

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

637 638
typedef struct st_lex
{
unknown's avatar
unknown committed
639 640
  uint	 yylineno,yytoklen;			/* Simulate lex */
  LEX_YYSTYPE yylval;
unknown's avatar
unknown committed
641
  SELECT_LEX_UNIT unit;                         /* most upper unit */
642 643
  SELECT_LEX select_lex;                        /* first SELECT_LEX */
  /* current SELECT_LEX in parsing */
unknown's avatar
unknown committed
644
  SELECT_LEX *current_select;
645 646
  /* list of all SELECT_LEX */
  SELECT_LEX *all_selects_list;
647
  uchar *buf;			/* The beginning of string, used by SPs */
unknown's avatar
unknown committed
648 649
  uchar *ptr,*tok_start,*tok_end,*end_of_query;
  char *length,*dec,*change,*name;
unknown's avatar
unknown committed
650
  char *help_arg;
651
  char *backup_dir;				/* For RESTORE/BACKUP */
unknown's avatar
unknown committed
652
  char* to_log;                                 /* For PURGE MASTER LOGS TO */
653
  time_t purge_time;                            /* For PURGE MASTER LOGS BEFORE */
654
  char* x509_subject,*x509_issuer,*ssl_cipher;
655
  char* found_colon;                            /* For multi queries - next query */
unknown's avatar
unknown committed
656 657
  String *wild;
  sql_exchange *exchange;
658
  select_result *result;
659
  Item *default_value, *on_update_value;
660
  LEX_STRING *comment, name_and_length;
unknown's avatar
unknown committed
661 662 663 664
  LEX_USER *grant_user;
  gptr yacc_yyss,yacc_yyvs;
  THD *thd;
  CHARSET_INFO *charset;
unknown's avatar
VIEW  
unknown committed
665
  TABLE_LIST *query_tables;	/* global list of all tables in this query */
666 667 668 669 670
  /*
    last element next_global of previous list (used only for list building
    during parsing and VIEW processing. This pointer is not valid in
    mysql_execute_command
  */
unknown's avatar
VIEW  
unknown committed
671
  TABLE_LIST **query_tables_last;
672
  TABLE_LIST *proc_table; /* refer to mysql.proc if it was opened by VIEW */
673 674
  /* store original leaf_tables for INSERT SELECT and PS/SP */
  TABLE_LIST *leaf_tables_insert;
unknown's avatar
unknown committed
675 676

  List<key_part_spec> col_list;
677
  List<key_part_spec> ref_list;
678
  List<String>	      interval_list;
unknown's avatar
unknown committed
679
  List<LEX_USER>      users_list;
unknown's avatar
unknown committed
680 681 682
  List<LEX_COLUMN>    columns;
  List<Key>	      key_list;
  List<create_field>  create_list;
683 684
  List<Item>	      *insert_list,field_list,value_list;
  List<List_item>     many_values;
unknown's avatar
unknown committed
685
  List<set_var_base>  var_list;
686
  List<Item_param>    param_list;
unknown's avatar
VIEW  
unknown committed
687
  List<LEX_STRING>    view_list; // view list (list of field names in view)
688
  SQL_LIST	      proc_list, auxilliary_table_list, save_list;
unknown's avatar
unknown committed
689 690
  TYPELIB	      *interval;
  create_field	      *last_field;
unknown's avatar
unknown committed
691
  char		      *savepoint_name;		// Transaction savepoint id
unknown's avatar
unknown committed
692
  udf_func udf;
693 694
  HA_CHECK_OPT   check_opt;			// check/repair options
  HA_CREATE_INFO create_info;
unknown's avatar
unknown committed
695
  LEX_MASTER_INFO mi;				// used by CHANGE MASTER
696
  USER_RESOURCES mqh;
697
  ulong thread_id,type;
698
  enum_sql_command sql_command, orig_sql_command;
unknown's avatar
unknown committed
699
  thr_lock_type lock_option, multi_lock_option;
unknown's avatar
unknown committed
700
  enum SSL_type ssl_type;			/* defined in violite.h */
701
  enum my_lex_states next_state;
702
  enum enum_duplicates duplicates;
unknown's avatar
unknown committed
703
  enum enum_tx_isolation tx_isolation;
704 705
  enum enum_ha_read_modes ha_read_mode;
  enum ha_rkey_function ha_rkey_mode;
unknown's avatar
unknown committed
706
  enum enum_var_type option_type;
unknown's avatar
VIEW  
unknown committed
707 708
  enum enum_view_create_mode create_view_mode;
  enum enum_drop_mode drop_mode;
unknown's avatar
unknown committed
709
  uint uint_geom_type;
unknown's avatar
unknown committed
710
  uint grant, grant_tot_col, which_columns;
711
  uint fk_delete_opt, fk_update_opt, fk_match_option;
712
  uint slave_thd_opt, start_transaction_opt;
unknown's avatar
unknown committed
713
  uint table_count; /* used when usual update transformed in multiupdate */
unknown's avatar
unknown committed
714
  uint8 describe;
unknown's avatar
VIEW  
unknown committed
715 716
  uint8 derived_tables;
  uint8 create_view_algorithm;
unknown's avatar
unknown committed
717
  uint8 create_view_check;
718
  bool drop_if_exists, drop_temporary, local_file, one_shot_set;
719
  bool in_comment, ignore_space, verbose, no_write_to_binlog;
unknown's avatar
VIEW  
unknown committed
720 721
  /* special JOIN::prepare mode: changing of query is prohibited */
  bool view_prepare_mode;
722
  bool safe_to_cache_query;
unknown's avatar
VIEW  
unknown committed
723
  bool variables_used;
724
  ALTER_INFO alter_info;
unknown's avatar
unknown committed
725 726
  /* Prepared statements SQL syntax:*/
  LEX_STRING prepared_stmt_name; /* Statement name (in all queries) */
727 728 729 730 731 732 733
  /* 
    Prepared statement query text or name of variable that holds the
    prepared statement (in PREPARE ... queries)
  */
  LEX_STRING prepared_stmt_code; 
  /* 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
734 735
  /* Names of user variables holding parameters (in EXECUTE) */
  List<LEX_STRING> prepared_stmt_params; 
736 737 738 739 740 741
  /*
    If points to fake_time_zone_tables_list indicates that time zone
    tables are implicitly used by statement, also is used for holding
    list of those tables after they are opened.
  */
  TABLE_LIST *time_zone_tables_used;
742
  sp_head *sphead;
743
  sp_name *spname;
744
  bool sp_lex_in_use;	/* Keep track on lex usage in SPs for error handling */
745
  sp_pcontext *spcont;
746
  HASH spfuns;		/* Called functions */
747
  st_sp_chistics sp_chistics;
unknown's avatar
VIEW  
unknown committed
748 749 750 751 752 753
  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;
754 755 756
  /* Characterstics of trigger being created */
  st_trg_chistics trg_chistics;
  /*
757 758 759 760 761
    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).
762
  */
763
  SQL_LIST trg_table_fields;
764

765
  st_lex() :result(0), sql_command(SQLCOM_END)
766
  {
767 768
    extern byte *sp_lex_spfuns_key(const byte *ptr, uint *plen, my_bool first);
    hash_init(&spfuns, system_charset_info, 0, 0, 0, sp_lex_spfuns_key, 0, 0);
769 770 771 772 773 774 775
  }
  
  ~st_lex()
  {
    if (spfuns.array.buffer)
      hash_free(&spfuns);
  }
776

777
  inline void uncacheable(uint8 cause)
778 779
  {
    safe_to_cache_query= 0;
780 781 782 783 784 785

    /*
      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
786
    SELECT_LEX *sl;
unknown's avatar
unknown committed
787 788 789 790
    SELECT_LEX_UNIT *un;
    for (sl= current_select, un= sl->master_unit();
	 un != &unit;
	 sl= sl->outer_select(), un= sl->master_unit())
791
    {
792 793
      sl->uncacheable|= cause;
      un->uncacheable|= cause;
794
    }
795
  }
unknown's avatar
VIEW  
unknown committed
796 797 798
  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();
799 800 801 802 803
  inline void add_to_query_tables(TABLE_LIST *table)
  {
    *(table->prev_global= query_tables_last)= table;
    query_tables_last= &table->next_global;
  }
unknown's avatar
VIEW  
unknown committed
804 805 806

  bool can_be_merged();
  bool can_use_merged();
807
  bool can_not_use_merged();
unknown's avatar
VIEW  
unknown committed
808
  bool only_view_structure();
unknown's avatar
unknown committed
809
  bool need_correct_ident();
unknown's avatar
unknown committed
810 811
} LEX;

812
extern TABLE_LIST fake_time_zone_tables_list;
unknown's avatar
unknown committed
813 814 815 816 817 818 819 820 821 822 823 824
struct st_lex_local: public st_lex
{
  static void *operator new(size_t size)
  {
    return (void*) sql_alloc((uint) size);
  }
  static void *operator new(size_t size, MEM_ROOT *mem_root)
  {
    return (void*) alloc_root(mem_root, (uint) size);
  }
  static void operator delete(void *ptr,size_t size) {}
};
unknown's avatar
unknown committed
825 826 827

void lex_init(void);
void lex_free(void);
unknown's avatar
unknown committed
828
void lex_start(THD *thd, uchar *buf,uint length);
unknown's avatar
unknown committed
829 830 831 832
void lex_end(LEX *lex);

extern pthread_key(LEX*,THR_LEX);

unknown's avatar
unknown committed
833
#define current_lex (current_thd->lex)