sql_lex.h 34.5 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,
56
  SQLCOM_SHOW_INNODB_STATUS, SQLCOM_SHOW_NDBCLUSTER_STATUS, SQLCOM_SHOW_MUTEX_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
  SQLCOM_SHOW_TRIGGERS,
61

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

96
  SQLCOM_END
unknown's avatar
unknown committed
97 98
};

unknown's avatar
unknown committed
99 100 101 102
// describe/explain types
#define DESCRIBE_NORMAL		1
#define DESCRIBE_EXTENDED	2

103
enum enum_sp_suid_behaviour
unknown's avatar
unknown committed
104
{
105 106 107
  SP_IS_DEFAULT_SUID= 0,
  SP_IS_NOT_SUID,
  SP_IS_SUID
unknown's avatar
unknown committed
108
};
109

110 111 112 113 114 115 116 117 118
enum enum_sp_data_access
{
  SP_DEFAULT_ACCESS= 0,
  SP_CONTAINS_SQL,
  SP_NO_SQL,
  SP_READS_SQL_DATA,
  SP_MODIFIES_SQL_DATA
};

119 120 121 122 123 124 125 126
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") }
};
127

unknown's avatar
VIEW  
unknown committed
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
#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
145 146 147 148
typedef List<Item> List_item;

typedef struct st_lex_master_info
{
149
  char *host, *user, *password, *log_file_name;
unknown's avatar
unknown committed
150 151
  uint port, connect_retry;
  ulonglong pos;
unknown's avatar
unknown committed
152
  ulong server_id;
unknown's avatar
unknown committed
153 154 155 156 157 158 159
  /* 
     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;
160
  char *relay_log_name;
161
  ulong relay_log_pos;
unknown's avatar
unknown committed
162 163
} LEX_MASTER_INFO;

164

165 166
enum sub_select_type
{
unknown's avatar
unknown committed
167 168
  UNSPECIFIED_TYPE,UNION_TYPE, INTERSECT_TYPE,
  EXCEPT_TYPE, GLOBAL_OPTIONS_TYPE, DERIVED_TABLE_TYPE, OLAP_TYPE
169 170 171 172
};

enum olap_type 
{
173
  UNSPECIFIED_OLAP_TYPE, CUBE_TYPE, ROLLUP_TYPE
174
};
175

unknown's avatar
unknown committed
176 177 178 179 180
enum tablespace_op_type
{
  NO_TABLESPACE_OP, DISCARD_TABLESPACE, IMPORT_TABLESPACE
};

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

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

241 242 243 244 245
   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
246 247

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


   relation in main unit will be following:
268 269 270 271 272 273
   (bigger picture for:
      main unit
      fake0
      select1 select2 select3
   in the above picture)

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

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

309
  ulonglong options;
310 311 312 313
  /*
    result of this query can't be cached, bit field, can be :
      UNCACHEABLE_DEPENDENT
      UNCACHEABLE_RAND
314
      UNCACHEABLE_SIDEEFFECT
315
      UNCACHEABLE_EXPLAIN
316
      UNCACHEABLE_PREPARE
317 318
  */
  uint8 uncacheable;
319
  enum sub_select_type linkage;
unknown's avatar
unknown committed
320
  bool no_table_names_allowed; /* used for global order by */
321
  bool no_error; /* suppress error message (convert it to warnings) */
322 323 324

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

  virtual st_select_lex_unit* master_unit()= 0;
  virtual st_select_lex* outer_select()= 0;
unknown's avatar
unknown committed
344
  virtual st_select_lex* return_after_parsing()= 0;
345 346 347 348 349 350 351 352

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

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

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

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

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

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

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

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

  void print(String *str);
452

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

459
  friend void lex_start(THD *thd, uchar *buf, uint length);
460
  friend int subselect_union_engine::exec();
461 462

  List<Item> *get_unit_column_types();
unknown's avatar
unknown committed
463
};
464

unknown's avatar
unknown committed
465
typedef class st_select_lex_unit SELECT_LEX_UNIT;
unknown's avatar
unknown committed
466 467

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

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

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

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

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

unknown's avatar
unknown committed
583 584
  void mark_as_dependent(st_select_lex *last);

585 586 587
  bool set_braces(bool value);
  bool inc_in_sum_expr();
  uint get_in_sum_expr();
unknown's avatar
unknown committed
588

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

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

651 652 653 654 655 656 657 658
#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
659 660 661
#define ALTER_CHANGE_COLUMN_DEFAULT 256
#define ALTER_KEYS_ONOFF        512
#define ALTER_CONVERT          1024
662
#define ALTER_FORCE		2048
663

664 665 666 667 668 669 670 671 672 673 674 675 676
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;

677 678 679
struct st_sp_chistics
{
  LEX_STRING comment;
680
  enum enum_sp_suid_behaviour suid;
681
  bool detistic;
682
  enum enum_sp_data_access daccess;
683 684
};

685 686 687 688 689 690 691 692 693

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;

694 695 696
enum xa_option_words {XA_NONE, XA_JOIN, XA_RESUME, XA_ONE_PHASE,
                      XA_SUSPEND, XA_FOR_MIGRATE};

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

699 700
typedef struct st_lex
{
unknown's avatar
unknown committed
701 702
  uint	 yylineno,yytoklen;			/* Simulate lex */
  LEX_YYSTYPE yylval;
unknown's avatar
unknown committed
703
  SELECT_LEX_UNIT unit;                         /* most upper unit */
704 705
  SELECT_LEX select_lex;                        /* first SELECT_LEX */
  /* current SELECT_LEX in parsing */
unknown's avatar
unknown committed
706
  SELECT_LEX *current_select;
707 708
  /* list of all SELECT_LEX */
  SELECT_LEX *all_selects_list;
709
  uchar *buf;			/* The beginning of string, used by SPs */
unknown's avatar
unknown committed
710
  uchar *ptr,*tok_start,*tok_end,*end_of_query;
711 712 713 714
  
  /* The values of tok_start/tok_end as they were one call of yylex before */
  uchar *tok_start_prev, *tok_end_prev;

unknown's avatar
unknown committed
715
  char *length,*dec,*change,*name;
unknown's avatar
unknown committed
716
  char *help_arg;
717
  char *backup_dir;				/* For RESTORE/BACKUP */
unknown's avatar
unknown committed
718
  char* to_log;                                 /* For PURGE MASTER LOGS TO */
719
  char* x509_subject,*x509_issuer,*ssl_cipher;
720
  char* found_semicolon;                        /* For multi queries - next query */
unknown's avatar
unknown committed
721 722
  String *wild;
  sql_exchange *exchange;
723
  select_result *result;
724
  Item *default_value, *on_update_value;
725
  LEX_STRING comment, ident;
unknown's avatar
unknown committed
726
  LEX_USER *grant_user;
unknown's avatar
unknown committed
727
  XID *xid;
unknown's avatar
unknown committed
728 729 730
  gptr yacc_yyss,yacc_yyvs;
  THD *thd;
  CHARSET_INFO *charset;
unknown's avatar
VIEW  
unknown committed
731
  TABLE_LIST *query_tables;	/* global list of all tables in this query */
732 733
  /*
    last element next_global of previous list (used only for list building
734 735 736
    during parsing and VIEW processing. This pointer could be invalid during
    processing of information schema tables(see get_schema_tables_result
    function)
737
  */
unknown's avatar
VIEW  
unknown committed
738
  TABLE_LIST **query_tables_last;
739 740
  /* store original leaf_tables for INSERT SELECT and PS/SP */
  TABLE_LIST *leaf_tables_insert;
741
  char *create_view_start;
742
  char *create_view_select_start;
unknown's avatar
unknown committed
743

744 745 746 747 748 749
  /*
    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
750
  List<key_part_spec> col_list;
751
  List<key_part_spec> ref_list;
752
  List<String>	      interval_list;
unknown's avatar
unknown committed
753
  List<LEX_USER>      users_list;
unknown's avatar
unknown committed
754 755 756
  List<LEX_COLUMN>    columns;
  List<Key>	      key_list;
  List<create_field>  create_list;
unknown's avatar
unknown committed
757
  List<Item>	      *insert_list,field_list,value_list,update_list;
758
  List<List_item>     many_values;
unknown's avatar
unknown committed
759
  List<set_var_base>  var_list;
760
  List<Item_param>    param_list;
unknown's avatar
VIEW  
unknown committed
761
  List<LEX_STRING>    view_list; // view list (list of field names in view)
unknown's avatar
unknown committed
762 763 764 765 766 767 768 769 770 771 772 773 774 775 776
  /*
    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;

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

874
  st_sp_chistics sp_chistics;
unknown's avatar
VIEW  
unknown committed
875 876 877 878 879 880
  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;
881 882 883 884
  /*
    view created to be run from definer (standard behaviour)
  */
  bool create_view_suid;
885 886 887
  /* Characterstics of trigger being created */
  st_trg_chistics trg_chistics;
  /*
888 889 890 891 892
    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).
893
  */
894
  SQL_LIST trg_table_fields;
895

896 897 898 899 900 901 902 903
  /*
    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;

904 905 906 907 908 909 910 911
  /*
    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
912 913 914 915 916
  /*
    Pointers to part of LOAD DATA statement that should be rewritten
    during replication ("LOCAL 'filename' REPLACE INTO" part).
  */
  uchar *fname_start, *fname_end;
917 918
  
  bool escape_used;
unknown's avatar
unknown committed
919

920
  st_lex();
921 922

  virtual ~st_lex()
923
  {
924
    hash_free(&sroutines);
925
  }
926

927
  inline void uncacheable(uint8 cause)
928 929
  {
    safe_to_cache_query= 0;
930 931 932 933 934 935

    /*
      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
936
    SELECT_LEX *sl;
unknown's avatar
unknown committed
937 938 939 940
    SELECT_LEX_UNIT *un;
    for (sl= current_select, un= sl->master_unit();
	 un != &unit;
	 sl= sl->outer_select(), un= sl->master_unit())
941
    {
942 943
      sl->uncacheable|= cause;
      un->uncacheable|= cause;
944
    }
945
  }
unknown's avatar
VIEW  
unknown committed
946 947 948
  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();
949 950 951 952 953
  inline void add_to_query_tables(TABLE_LIST *table)
  {
    *(table->prev_global= query_tables_last)= table;
    query_tables_last= &table->next_global;
  }
954
  bool add_time_zone_tables_to_query_tables(THD *thd);
unknown's avatar
VIEW  
unknown committed
955 956 957

  bool can_be_merged();
  bool can_use_merged();
958
  bool can_not_use_merged();
unknown's avatar
VIEW  
unknown committed
959
  bool only_view_structure();
unknown's avatar
unknown committed
960
  bool need_correct_ident();
961 962 963
  uint8 get_effective_with_check(st_table_list *view);
  /*
    Is this update command where 'WHITH CHECK OPTION' clause is important
964

965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984
    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;
    }
  }
985 986
  inline bool requires_prelocking()
  {
unknown's avatar
unknown committed
987
    return test(query_tables_own_last);
988 989 990 991 992 993 994 995 996 997
  }
  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);
  }
998 999 1000 1001 1002 1003 1004 1005 1006
  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;
    }
  }
1007
  void cleanup_after_one_table_open();
unknown's avatar
unknown committed
1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022

  void push_context(Name_resolution_context *context)
  {
    context_stack.push_front(context);
  }

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

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

unknown's avatar
unknown committed
1025 1026 1027 1028 1029 1030 1031 1032 1033 1034
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
1035 1036
  static void operator delete(void *ptr,size_t size)
  { TRASH(ptr, size); }
1037 1038
  static void operator delete(void *ptr, MEM_ROOT *mem_root)
  { /* Never called */ }
unknown's avatar
unknown committed
1039
};
unknown's avatar
unknown committed
1040

unknown's avatar
unknown committed
1041 1042 1043 1044 1045
extern void lex_init(void);
extern void lex_free(void);
extern void lex_start(THD *thd, uchar *buf,uint length);
extern void lex_end(LEX *lex);
extern int yylex(void *arg, void *yythd);
unknown's avatar
unknown committed
1046 1047 1048

extern pthread_key(LEX*,THR_LEX);

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