sql_lex.h 35.1 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;
28
class partition_info;
unknown's avatar
unknown committed
29

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

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

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

45 46 47 48 49
/*
  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
50
enum enum_sql_command {
51 52 53 54 55
  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,
56 57
  SQLCOM_SHOW_KEYS, SQLCOM_SHOW_VARIABLES, SQLCOM_SHOW_STATUS,
  SQLCOM_SHOW_ENGINE_LOGS, SQLCOM_SHOW_ENGINE_STATUS, SQLCOM_SHOW_ENGINE_MUTEX,
58
  SQLCOM_SHOW_PROCESSLIST, SQLCOM_SHOW_MASTER_STAT, SQLCOM_SHOW_SLAVE_STAT,
59
  SQLCOM_SHOW_GRANTS, SQLCOM_SHOW_CREATE, SQLCOM_SHOW_CHARSETS,
60
  SQLCOM_SHOW_COLLATIONS, SQLCOM_SHOW_CREATE_DB, SQLCOM_SHOW_TABLE_STATUS,
61
  SQLCOM_SHOW_TRIGGERS,
62

unknown's avatar
unknown committed
63
  SQLCOM_LOAD,SQLCOM_SET_OPTION,SQLCOM_LOCK_TABLES,SQLCOM_UNLOCK_TABLES,
64
  SQLCOM_GRANT,
65
  SQLCOM_CHANGE_DB, SQLCOM_CREATE_DB, SQLCOM_DROP_DB, SQLCOM_ALTER_DB,
66
  SQLCOM_REPAIR, SQLCOM_REPLACE, SQLCOM_REPLACE_SELECT,
67
  SQLCOM_CREATE_FUNCTION, SQLCOM_DROP_FUNCTION,
68
  SQLCOM_REVOKE,SQLCOM_OPTIMIZE, SQLCOM_CHECK,
unknown's avatar
unknown committed
69
  SQLCOM_ASSIGN_TO_KEYCACHE, SQLCOM_PRELOAD_KEYS,
70
  SQLCOM_FLUSH, SQLCOM_KILL, SQLCOM_ANALYZE,
unknown's avatar
unknown committed
71
  SQLCOM_ROLLBACK, SQLCOM_ROLLBACK_TO_SAVEPOINT,
unknown's avatar
unknown committed
72
  SQLCOM_COMMIT, SQLCOM_SAVEPOINT, SQLCOM_RELEASE_SAVEPOINT,
73
  SQLCOM_SLAVE_START, SQLCOM_SLAVE_STOP,
74
  SQLCOM_BEGIN, SQLCOM_LOAD_MASTER_TABLE, SQLCOM_CHANGE_MASTER,
unknown's avatar
unknown committed
75
  SQLCOM_RENAME_TABLE, SQLCOM_BACKUP_TABLE, SQLCOM_RESTORE_TABLE,
76
  SQLCOM_RESET, SQLCOM_PURGE, SQLCOM_PURGE_BEFORE, SQLCOM_SHOW_BINLOGS,
77
  SQLCOM_SHOW_OPEN_TABLES, SQLCOM_LOAD_MASTER_DATA,
78
  SQLCOM_HA_OPEN, SQLCOM_HA_CLOSE, SQLCOM_HA_READ,
79
  SQLCOM_SHOW_SLAVE_HOSTS, SQLCOM_DELETE_MULTI, SQLCOM_UPDATE_MULTI,
unknown's avatar
unknown committed
80
  SQLCOM_SHOW_BINLOG_EVENTS, SQLCOM_SHOW_NEW_MASTER, SQLCOM_DO,
unknown's avatar
unknown committed
81
  SQLCOM_SHOW_WARNS, SQLCOM_EMPTY_QUERY, SQLCOM_SHOW_ERRORS,
unknown's avatar
unknown committed
82
  SQLCOM_SHOW_COLUMN_TYPES, SQLCOM_SHOW_STORAGE_ENGINES, SQLCOM_SHOW_PRIVILEGES,
83 84
  SQLCOM_HELP, SQLCOM_CREATE_USER, SQLCOM_DROP_USER, SQLCOM_RENAME_USER,
  SQLCOM_REVOKE_ALL, SQLCOM_CHECKSUM,
85
  SQLCOM_CREATE_PROCEDURE, SQLCOM_CREATE_SPFUNCTION, SQLCOM_CALL,
86
  SQLCOM_DROP_PROCEDURE, SQLCOM_ALTER_PROCEDURE,SQLCOM_ALTER_FUNCTION,
unknown's avatar
unknown committed
87 88
  SQLCOM_SHOW_CREATE_PROC, SQLCOM_SHOW_CREATE_FUNC,
  SQLCOM_SHOW_STATUS_PROC, SQLCOM_SHOW_STATUS_FUNC,
unknown's avatar
unknown committed
89
  SQLCOM_PREPARE, SQLCOM_EXECUTE, SQLCOM_DEALLOCATE_PREPARE,
unknown's avatar
VIEW  
unknown committed
90
  SQLCOM_CREATE_VIEW, SQLCOM_DROP_VIEW,
91
  SQLCOM_CREATE_TRIGGER, SQLCOM_DROP_TRIGGER,
92 93
  SQLCOM_XA_START, SQLCOM_XA_END, SQLCOM_XA_PREPARE,
  SQLCOM_XA_COMMIT, SQLCOM_XA_ROLLBACK, SQLCOM_XA_RECOVER,
unknown's avatar
unknown committed
94
  SQLCOM_SHOW_PROC_CODE, SQLCOM_SHOW_FUNC_CODE,
95
  SQLCOM_INSTALL_PLUGIN, SQLCOM_UNINSTALL_PLUGIN,
unknown's avatar
unknown committed
96
  SQLCOM_SHOW_AUTHORS,
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
  /*
    result of this query can't be cached, bit field, can be :
      UNCACHEABLE_DEPENDENT
      UNCACHEABLE_RAND
317
      UNCACHEABLE_SIDEEFFECT
318
      UNCACHEABLE_EXPLAIN
319
      UNCACHEABLE_PREPARE
320 321
  */
  uint8 uncacheable;
322
  enum sub_select_type linkage;
unknown's avatar
unknown committed
323
  bool no_table_names_allowed; /* used for global order by */
324
  bool no_error; /* suppress error message (convert it to warnings) */
325 326 327

  static void *operator new(size_t size)
  {
328
    return (void*) sql_alloc((uint) size);
329
  }
unknown's avatar
unknown committed
330 331
  static void *operator new(size_t size, MEM_ROOT *mem_root)
  { return (void*) alloc_root(mem_root, (uint) size); }
unknown's avatar
unknown committed
332
  static void operator delete(void *ptr,size_t size) { TRASH(ptr, size); }
333
  static void operator delete(void *ptr, MEM_ROOT *mem_root) {}
334
  st_select_lex_node(): linkage(UNSPECIFIED_TYPE) {}
335 336 337 338
  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
339 340
  void include_down(st_select_lex_node *upper);
  void include_neighbour(st_select_lex_node *before);
unknown's avatar
unknown committed
341
  void include_standalone(st_select_lex_node *sel, st_select_lex_node **ref);
unknown's avatar
unknown committed
342 343
  void include_global(st_select_lex_node **plink);
  void exclude();
344 345 346

  virtual st_select_lex_unit* master_unit()= 0;
  virtual st_select_lex* outer_select()= 0;
unknown's avatar
unknown committed
347
  virtual st_select_lex* return_after_parsing()= 0;
348 349 350 351 352 353 354 355

  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
356
  virtual ulong get_table_join_options();
unknown's avatar
unknown committed
357
  virtual TABLE_LIST *add_table_to_list(THD *thd, Table_ident *table,
358
					LEX_STRING *alias,
unknown's avatar
unknown committed
359
					ulong table_options,
360 361
					thr_lock_type flags= TL_UNLOCK,
					List<String> *use_index= 0,
unknown's avatar
unknown committed
362 363
					List<String> *ignore_index= 0,
                                        LEX_STRING *option= 0);
unknown's avatar
unknown committed
364
  virtual void set_lock_for_tables(thr_lock_type lock_type) {}
unknown's avatar
unknown committed
365

unknown's avatar
unknown committed
366
  friend class st_select_lex_unit;
unknown's avatar
unknown committed
367
  friend bool mysql_new_select(struct st_lex *lex, bool move_down);
368 369
  friend bool mysql_make_view(THD *thd, File_parser *parser,
                              TABLE_LIST *table);
unknown's avatar
unknown committed
370 371 372
private:
  void fast_exclude();
};
373
typedef class st_select_lex_node SELECT_LEX_NODE;
unknown's avatar
unknown committed
374 375 376 377 378

/* 
   SELECT_LEX_UNIT - unit of selects (UNION, INTERSECT, ...) group 
   SELECT_LEXs
*/
unknown's avatar
unknown committed
379 380 381 382
class THD;
class select_result;
class JOIN;
class select_union;
383
class Procedure;
384
class st_select_lex_unit: public st_select_lex_node {
unknown's avatar
unknown committed
385 386 387 388
protected:
  TABLE_LIST result_table_list;
  select_union *union_result;
  TABLE *table; /* temporary table using for appending UNION results */
389

unknown's avatar
unknown committed
390
  select_result *result;
unknown's avatar
unknown committed
391
  ulong found_rows_for_union;
unknown's avatar
unknown committed
392
  bool res;
393
public:
unknown's avatar
unknown committed
394
  bool  prepared, // prepare phase already performed for UNION (unit)
unknown's avatar
unknown committed
395
    optimized, // optimize phase already performed for UNION (unit)
396 397
    executed, // already executed
    cleaned;
398 399 400

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

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

unknown's avatar
unknown committed
432
  void init_query();
433 434
  st_select_lex_unit* master_unit();
  st_select_lex* outer_select();
435 436 437 438 439 440 441
  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);
442
  }
unknown's avatar
unknown committed
443
  st_select_lex* return_after_parsing() { return return_to; }
unknown's avatar
unknown committed
444
  void exclude_level();
445
  void exclude_tree();
446

unknown's avatar
unknown committed
447
  /* UNION methods */
448
  bool prepare(THD *thd, select_result *result, ulong additional_options);
unknown's avatar
unknown committed
449 450
  bool exec();
  bool cleanup();
451
  inline void unclean() { cleaned= 0; }
unknown's avatar
unknown committed
452
  void reinit_exec_mechanism();
unknown's avatar
unknown committed
453 454

  void print(String *str);
455

456
  void init_prepare_fake_select_lex(THD *thd);
457
  inline bool is_prepared() { return prepared; }
unknown's avatar
unknown committed
458
  bool change_result(select_subselect *result, select_subselect *old_result);
459
  void set_limit(st_select_lex *values);
460
  void set_thd(THD *thd_arg) { thd= thd_arg; }
unknown's avatar
unknown committed
461

unknown's avatar
unknown committed
462
  friend void lex_start(THD *thd, const uchar *buf, uint length);
463
  friend int subselect_union_engine::exec();
464 465

  List<Item> *get_unit_column_types();
unknown's avatar
unknown committed
466
};
467

unknown's avatar
unknown committed
468
typedef class st_select_lex_unit SELECT_LEX_UNIT;
unknown's avatar
unknown committed
469 470

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

  SQL_LIST order_list;                /* ORDER clause */
  List<List_item>     expr_list;
  List<List_item>     when_list;      /* WHEN clause (expression) */
unknown's avatar
unknown committed
511
  SQL_LIST *gorder_list;
512
  Item *select_limit, *offset_limit;  /* LIMIT clause parameters */
unknown's avatar
unknown committed
513 514 515
  // Arrays of pointers to top elements of all_fields list
  Item **ref_pointer_array;

unknown's avatar
merge  
unknown committed
516 517 518 519 520 521
  /*
    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
522 523 524
  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 */
525 526 527 528 529
  /* 
    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
530

unknown's avatar
unknown committed
531
  ulong table_join_options;
532
  uint in_sum_expr;
unknown's avatar
unknown committed
533
  uint select_number; /* number of select (used for EXPLAIN) */
534
  uint with_wild; /* item list contain '*' */
unknown's avatar
unknown committed
535 536 537
  bool  braces;   	/* SELECT ... UNION (SELECT ... ) <- this braces */
  /* TRUE when having fix field called in processing of this SELECT */
  bool having_fix_field;
538 539
  /* explicit LIMIT clause was used */
  bool explicit_limit;
540 541 542 543 544
  /*
    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;
545 546 547 548 549 550 551 552 553 554 555 556 557
  /*
    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
558
  bool first_cond_optimization;
unknown's avatar
unknown committed
559 560
  /* do not wrap view fields with Item_ref */
  bool no_wrap_view_item;
561 562
  /* exclude this select from check of unique_table() */
  bool exclude_from_table_unique_test;
563

unknown's avatar
unknown committed
564 565
  void init_query();
  void init_select();
566
  st_select_lex_unit* master_unit();
567 568 569 570
  st_select_lex_unit* first_inner_unit() 
  { 
    return (st_select_lex_unit*) slave; 
  }
571
  st_select_lex* outer_select();
572
  st_select_lex* next_select() { return (st_select_lex*) next; }
573
  st_select_lex* next_select_in_list() 
574 575 576 577 578 579 580
  {
    return (st_select_lex*) link_next;
  }
  st_select_lex_node** next_select_in_list_addr()
  {
    return &link_next;
  }
unknown's avatar
unknown committed
581
  st_select_lex* return_after_parsing()
582 583 584
  {
    return master_unit()->return_after_parsing();
  }
585

unknown's avatar
unknown committed
586 587
  void mark_as_dependent(st_select_lex *last);

588 589 590
  bool set_braces(bool value);
  bool inc_in_sum_expr();
  uint get_in_sum_expr();
unknown's avatar
unknown committed
591

unknown's avatar
unknown committed
592 593
  bool add_item_to_list(THD *thd, Item *item);
  bool add_group_to_list(THD *thd, Item *item, bool asc);
594
  bool add_ftfunc_to_list(Item_func_match *func);
unknown's avatar
unknown committed
595
  bool add_order_to_list(THD *thd, Item *item, bool asc);
unknown's avatar
unknown committed
596
  TABLE_LIST* add_table_to_list(THD *thd, Table_ident *table,
597
				LEX_STRING *alias,
unknown's avatar
unknown committed
598
				ulong table_options,
599 600
				thr_lock_type flags= TL_UNLOCK,
				List<String> *use_index= 0,
601 602
				List<String> *ignore_index= 0,
                                LEX_STRING *option= 0);
unknown's avatar
unknown committed
603
  TABLE_LIST* get_table_list();
604 605 606 607 608
  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
609 610 611 612
  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
613
  void set_lock_for_tables(thr_lock_type lock_type);
614 615 616 617 618 619
  inline void init_order()
  {
    order_list.elements= 0;
    order_list.first= 0;
    order_list.next= (byte**) &order_list.first;
  }
620 621 622 623 624 625 626
  /*
    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
627 628
  bool test_limit();

unknown's avatar
unknown committed
629
  friend void lex_start(THD *thd, const uchar *buf, uint length);
unknown's avatar
unknown committed
630 631
  st_select_lex() {}
  void make_empty_select()
632 633 634 635
  {
    init_query();
    init_select();
  }
unknown's avatar
unknown committed
636
  bool setup_ref_array(THD *thd, uint order_group_num);
unknown's avatar
unknown committed
637 638 639
  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
640
  void fix_prepare_information(THD *thd, Item **conds);
641 642 643 644 645
  /*
    Destroy the used execution plan (JOIN) of this subtree (this
    SELECT_LEX and all nested SELECT_LEXes and SELECT_LEX_UNITs).
  */
  bool cleanup();
646 647 648 649 650
  /*
    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
651
};
unknown's avatar
unknown committed
652
typedef class st_select_lex SELECT_LEX;
653

654 655 656 657 658 659 660 661
#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
662 663 664
#define ALTER_CHANGE_COLUMN_DEFAULT 256
#define ALTER_KEYS_ONOFF        512
#define ALTER_CONVERT          1024
665
#define ALTER_FORCE		2048
unknown's avatar
unknown committed
666
#define ALTER_RECREATE          4096
unknown's avatar
unknown committed
667 668 669 670
#define ALTER_ADD_PARTITION     8192
#define ALTER_DROP_PARTITION    16384
#define ALTER_COALESCE_PARTITION 32768
#define ALTER_REORGANISE_PARTITION   65536
671

672 673 674 675 676 677 678
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;
unknown's avatar
unknown committed
679 680
  List<char>                  partition_names;
  uint                        no_parts;
681 682

  st_alter_info(){clear();}
unknown's avatar
unknown committed
683 684 685 686 687 688 689
  void clear()
  {
    keys_onoff= LEAVE_AS_IS;
    tablespace_op= NO_TABLESPACE_OP;
    no_parts= 0;
    partition_names.empty();
  }
690 691 692
  void reset(){drop_list.empty();alter_list.empty();clear();}
} ALTER_INFO;

693 694 695
struct st_sp_chistics
{
  LEX_STRING comment;
696
  enum enum_sp_suid_behaviour suid;
697
  bool detistic;
698
  enum enum_sp_data_access daccess;
699 700
};

701 702 703 704 705 706 707

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

708
extern sys_var *trg_new_row_fake_var;
709

710 711 712
enum xa_option_words {XA_NONE, XA_JOIN, XA_RESUME, XA_ONE_PHASE,
                      XA_SUSPEND, XA_FOR_MIGRATE};

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

715 716
typedef struct st_lex
{
unknown's avatar
unknown committed
717 718
  uint	 yylineno,yytoklen;			/* Simulate lex */
  LEX_YYSTYPE yylval;
unknown's avatar
unknown committed
719
  SELECT_LEX_UNIT unit;                         /* most upper unit */
720 721
  SELECT_LEX select_lex;                        /* first SELECT_LEX */
  /* current SELECT_LEX in parsing */
unknown's avatar
unknown committed
722
  SELECT_LEX *current_select;
723 724
  /* list of all SELECT_LEX */
  SELECT_LEX *all_selects_list;
unknown's avatar
unknown committed
725 726
  const uchar *buf;		/* The beginning of string, used by SPs */
  const uchar *ptr,*tok_start,*tok_end,*end_of_query;
727 728
  
  /* The values of tok_start/tok_end as they were one call of yylex before */
unknown's avatar
unknown committed
729
  const uchar *tok_start_prev, *tok_end_prev;
730

unknown's avatar
unknown committed
731
  char *length,*dec,*change,*name;
unknown's avatar
unknown committed
732
  char *help_arg;
733
  char *backup_dir;				/* For RESTORE/BACKUP */
unknown's avatar
unknown committed
734
  char* to_log;                                 /* For PURGE MASTER LOGS TO */
735
  char* x509_subject,*x509_issuer,*ssl_cipher;
736
  char* found_semicolon;                        /* For multi queries - next query */
unknown's avatar
unknown committed
737 738
  String *wild;
  sql_exchange *exchange;
739
  select_result *result;
740
  Item *default_value, *on_update_value;
741
  LEX_STRING comment, ident;
unknown's avatar
unknown committed
742
  LEX_USER *grant_user;
unknown's avatar
unknown committed
743
  XID *xid;
unknown's avatar
unknown committed
744 745 746
  gptr yacc_yyss,yacc_yyvs;
  THD *thd;
  CHARSET_INFO *charset;
unknown's avatar
VIEW  
unknown committed
747
  TABLE_LIST *query_tables;	/* global list of all tables in this query */
748 749
  /*
    last element next_global of previous list (used only for list building
750 751 752
    during parsing and VIEW processing. This pointer could be invalid during
    processing of information schema tables(see get_schema_tables_result
    function)
753
  */
unknown's avatar
VIEW  
unknown committed
754
  TABLE_LIST **query_tables_last;
755 756
  /* store original leaf_tables for INSERT SELECT and PS/SP */
  TABLE_LIST *leaf_tables_insert;
757 758
  /* Position (first character index) of SELECT of CREATE VIEW statement */
  uint create_view_select_start;
759 760
  /* Partition info structure filled in by PARTITION BY parse part */
  partition_info *part_info;
unknown's avatar
unknown committed
761

762 763 764 765 766 767
  /*
    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
768
  List<key_part_spec> col_list;
769
  List<key_part_spec> ref_list;
770
  List<String>	      interval_list;
unknown's avatar
unknown committed
771
  List<LEX_USER>      users_list;
unknown's avatar
unknown committed
772 773 774
  List<LEX_COLUMN>    columns;
  List<Key>	      key_list;
  List<create_field>  create_list;
unknown's avatar
unknown committed
775
  List<Item>	      *insert_list,field_list,value_list,update_list;
776
  List<List_item>     many_values;
unknown's avatar
unknown committed
777
  List<set_var_base>  var_list;
778
  List<Item_param>    param_list;
unknown's avatar
VIEW  
unknown committed
779
  List<LEX_STRING>    view_list; // view list (list of field names in view)
unknown's avatar
unknown committed
780 781 782 783 784 785 786 787 788 789 790 791 792 793 794
  /*
    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;

795
  SQL_LIST	      proc_list, auxilliary_table_list, save_list;
unknown's avatar
unknown committed
796 797
  create_field	      *last_field;
  udf_func udf;
798 799
  HA_CHECK_OPT   check_opt;			// check/repair options
  HA_CREATE_INFO create_info;
unknown's avatar
unknown committed
800
  LEX_MASTER_INFO mi;				// used by CHANGE MASTER
801
  USER_RESOURCES mqh;
802
  ulong type;
803
  enum_sql_command sql_command, orig_sql_command;
804
  thr_lock_type lock_option;
unknown's avatar
unknown committed
805
  enum SSL_type ssl_type;			/* defined in violite.h */
806
  enum my_lex_states next_state;
807
  enum enum_duplicates duplicates;
unknown's avatar
unknown committed
808
  enum enum_tx_isolation tx_isolation;
809
  enum enum_ha_read_modes ha_read_mode;
810
  union {
unknown's avatar
unknown committed
811
    enum ha_rkey_function ha_rkey_mode;
812 813
    enum xa_option_words xa_opt;
  };
unknown's avatar
unknown committed
814
  enum enum_var_type option_type;
unknown's avatar
VIEW  
unknown committed
815 816
  enum enum_view_create_mode create_view_mode;
  enum enum_drop_mode drop_mode;
unknown's avatar
unknown committed
817
  uint uint_geom_type;
unknown's avatar
unknown committed
818
  uint grant, grant_tot_col, which_columns;
819
  uint fk_delete_opt, fk_update_opt, fk_match_option;
820
  uint slave_thd_opt, start_transaction_opt;
821 822 823 824 825 826
  /*
    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
827
  uint8 describe;
828 829 830
  /*
    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
831
    DERIVED_SUBQUERY and DERIVED_VIEW).
832
  */
unknown's avatar
VIEW  
unknown committed
833 834
  uint8 derived_tables;
  uint8 create_view_algorithm;
unknown's avatar
unknown committed
835
  uint8 create_view_check;
836
  bool drop_if_exists, drop_temporary, local_file, one_shot_set;
837
  bool in_comment, ignore_space, verbose, no_write_to_binlog;
unknown's avatar
unknown committed
838
  bool tx_chain, tx_release;
unknown's avatar
unknown committed
839 840 841 842 843 844 845
  /*
    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
846
  bool view_prepare_mode;
847 848 849 850 851
  /*
    TRUE if we're parsing a prepared statement: in this mode
    we should allow placeholders and disallow multistatements.
  */
  bool stmt_prepare_mode;
852
  bool safe_to_cache_query;
853
  bool subqueries, ignore;
unknown's avatar
VIEW  
unknown committed
854
  bool variables_used;
855
  ALTER_INFO alter_info;
unknown's avatar
unknown committed
856 857
  /* Prepared statements SQL syntax:*/
  LEX_STRING prepared_stmt_name; /* Statement name (in all queries) */
unknown's avatar
unknown committed
858
  /*
859 860 861
    Prepared statement query text or name of variable that holds the
    prepared statement (in PREPARE ... queries)
  */
unknown's avatar
unknown committed
862
  LEX_STRING prepared_stmt_code;
863 864
  /* 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
865
  /* Names of user variables holding parameters (in EXECUTE) */
unknown's avatar
unknown committed
866
  List<LEX_STRING> prepared_stmt_params;
867
  /*
868 869
    Points to part of global table list which contains time zone tables
    implicitly used by the statement.
870 871
  */
  TABLE_LIST *time_zone_tables_used;
872
  sp_head *sphead;
873
  sp_name *spname;
874
  bool sp_lex_in_use;	/* Keep track on lex usage in SPs for error handling */
875
  bool all_privileges;
876
  sp_pcontext *spcont;
877 878 879 880 881
  /* Set of stored routines called by statement. */
  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.
882 883 884 885 886
    '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.
887 888
  */
  SQL_LIST sroutines_list;
889 890
  byte     **sroutines_list_own_last;
  uint     sroutines_list_own_elements;
891

892
  st_sp_chistics sp_chistics;
unknown's avatar
VIEW  
unknown committed
893 894 895 896 897 898
  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;
899 900 901 902
  /*
    view created to be run from definer (standard behaviour)
  */
  bool create_view_suid;
903 904 905
  /* Characterstics of trigger being created */
  st_trg_chistics trg_chistics;
  /*
906 907 908 909 910
    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).
911
  */
912
  SQL_LIST trg_table_fields;
913

914 915 916 917 918 919 920 921
  /*
    trigger_definition_begin points to the beginning of the word "TRIGGER" in
    CREATE TRIGGER statement. This is used to add possibly omitted DEFINER
    clause to the trigger definition statement before dumping it to the
    binlog. 
  */
  const char *trigger_definition_begin;

922 923 924 925 926 927 928 929
  /*
    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;

unknown's avatar
unknown committed
930 931 932 933
  /*
    Pointers to part of LOAD DATA statement that should be rewritten
    during replication ("LOCAL 'filename' REPLACE INTO" part).
  */
unknown's avatar
unknown committed
934
  const uchar *fname_start, *fname_end;
935 936
  
  bool escape_used;
unknown's avatar
unknown committed
937

938
  st_lex();
939 940

  virtual ~st_lex()
941
  {
942
    hash_free(&sroutines);
943
  }
944

945
  inline void uncacheable(uint8 cause)
946 947
  {
    safe_to_cache_query= 0;
948 949 950 951 952 953

    /*
      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
954
    SELECT_LEX *sl;
unknown's avatar
unknown committed
955 956 957 958
    SELECT_LEX_UNIT *un;
    for (sl= current_select, un= sl->master_unit();
	 un != &unit;
	 sl= sl->outer_select(), un= sl->master_unit())
959
    {
960 961
      sl->uncacheable|= cause;
      un->uncacheable|= cause;
962
    }
963
  }
unknown's avatar
VIEW  
unknown committed
964 965 966
  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();
967 968 969 970 971
  inline void add_to_query_tables(TABLE_LIST *table)
  {
    *(table->prev_global= query_tables_last)= table;
    query_tables_last= &table->next_global;
  }
972
  bool add_time_zone_tables_to_query_tables(THD *thd);
unknown's avatar
VIEW  
unknown committed
973 974 975

  bool can_be_merged();
  bool can_use_merged();
976
  bool can_not_use_merged();
unknown's avatar
VIEW  
unknown committed
977
  bool only_view_structure();
unknown's avatar
unknown committed
978
  bool need_correct_ident();
979 980 981
  uint8 get_effective_with_check(st_table_list *view);
  /*
    Is this update command where 'WHITH CHECK OPTION' clause is important
982

983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002
    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:
    case SQLCOM_LOAD:
      return TRUE;
    default:
      return FALSE;
    }
  }
1003 1004
  inline bool requires_prelocking()
  {
unknown's avatar
unknown committed
1005
    return test(query_tables_own_last);
1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
  }
  inline 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);
  }
1016 1017 1018 1019 1020 1021 1022 1023 1024
  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;
    }
  }
1025
  void cleanup_after_one_table_open();
unknown's avatar
unknown committed
1026

1027
  bool push_context(Name_resolution_context *context)
unknown's avatar
unknown committed
1028
  {
1029
    return context_stack.push_front(context);
unknown's avatar
unknown committed
1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040
  }

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

  Name_resolution_context *current_context()
  {
    return context_stack.head();
  }
unknown's avatar
unknown committed
1041 1042
} LEX;

unknown's avatar
unknown committed
1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
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);
  }
unknown's avatar
unknown committed
1053 1054
  static void operator delete(void *ptr,size_t size)
  { TRASH(ptr, size); }
1055 1056
  static void operator delete(void *ptr, MEM_ROOT *mem_root)
  { /* Never called */ }
unknown's avatar
unknown committed
1057
};
unknown's avatar
unknown committed
1058

unknown's avatar
unknown committed
1059 1060
extern void lex_init(void);
extern void lex_free(void);
unknown's avatar
unknown committed
1061
extern void lex_start(THD *thd, const uchar *buf, uint length);
unknown's avatar
unknown committed
1062 1063
extern void lex_end(LEX *lex);
extern int yylex(void *arg, void *yythd);
unknown's avatar
unknown committed
1064 1065 1066

extern pthread_key(LEX*,THR_LEX);

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