sql_lex.h 41.6 KB
Newer Older
1
/* Copyright (C) 2000-2006 MySQL AB
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3 4
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
5
   the Free Software Foundation; version 2 of the License.
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6

bk@work.mysql.com's avatar
bk@work.mysql.com committed
7 8 9 10
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
11

bk@work.mysql.com's avatar
bk@work.mysql.com committed
12 13 14 15 16 17 18 19 20 21 22
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


/* YACC and LEX Definitions */

/* These may not be declared yet */
class Table_ident;
class sql_exchange;
class LEX_COLUMN;
23
class sp_head;
24
class sp_name;
25 26
class sp_instr;
class sp_pcontext;
27
class st_alter_tablespace;
28
class partition_info;
29
class Event_parse_data;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
30

31
#ifdef MYSQL_SERVER
32 33 34 35
/*
  The following hack is needed because mysql_yacc.cc does not define
  YYSTYPE before including this file
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
36

37 38
#include "set_var.h"

bk@work.mysql.com's avatar
bk@work.mysql.com committed
39 40 41 42
#ifdef MYSQL_YACC
#define LEX_YYSTYPE void *
#else
#include "lex_symbol.h"
43
#if MYSQL_LEX
bk@work.mysql.com's avatar
bk@work.mysql.com committed
44 45
#include "sql_yacc.h"
#define LEX_YYSTYPE YYSTYPE *
46 47 48
#else
#define LEX_YYSTYPE void *
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
49
#endif
50
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
51

52 53 54
/*
  When a command is added here, be sure it's also added in mysqld.cc
  in "struct show_var_st status_vars[]= {" ...
55 56 57 58 59

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
62
enum enum_sql_command {
63 64 65 66 67
  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,
68 69
  SQLCOM_SHOW_KEYS, SQLCOM_SHOW_VARIABLES, SQLCOM_SHOW_STATUS,
  SQLCOM_SHOW_ENGINE_LOGS, SQLCOM_SHOW_ENGINE_STATUS, SQLCOM_SHOW_ENGINE_MUTEX,
70
  SQLCOM_SHOW_PROCESSLIST, SQLCOM_SHOW_MASTER_STAT, SQLCOM_SHOW_SLAVE_STAT,
71
  SQLCOM_SHOW_GRANTS, SQLCOM_SHOW_CREATE, SQLCOM_SHOW_CHARSETS,
72
  SQLCOM_SHOW_COLLATIONS, SQLCOM_SHOW_CREATE_DB, SQLCOM_SHOW_TABLE_STATUS,
73
  SQLCOM_SHOW_TRIGGERS,
74

bk@work.mysql.com's avatar
bk@work.mysql.com committed
75
  SQLCOM_LOAD,SQLCOM_SET_OPTION,SQLCOM_LOCK_TABLES,SQLCOM_UNLOCK_TABLES,
76
  SQLCOM_GRANT,
77
  SQLCOM_CHANGE_DB, SQLCOM_CREATE_DB, SQLCOM_DROP_DB, SQLCOM_ALTER_DB,
78
  SQLCOM_RENAME_DB,
79
  SQLCOM_REPAIR, SQLCOM_REPLACE, SQLCOM_REPLACE_SELECT,
80
  SQLCOM_CREATE_FUNCTION, SQLCOM_DROP_FUNCTION,
81
  SQLCOM_REVOKE,SQLCOM_OPTIMIZE, SQLCOM_CHECK,
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
82
  SQLCOM_ASSIGN_TO_KEYCACHE, SQLCOM_PRELOAD_KEYS,
83
  SQLCOM_FLUSH, SQLCOM_KILL, SQLCOM_ANALYZE,
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
84
  SQLCOM_ROLLBACK, SQLCOM_ROLLBACK_TO_SAVEPOINT,
85
  SQLCOM_COMMIT, SQLCOM_SAVEPOINT, SQLCOM_RELEASE_SAVEPOINT,
86
  SQLCOM_SLAVE_START, SQLCOM_SLAVE_STOP,
87
  SQLCOM_BEGIN, SQLCOM_LOAD_MASTER_TABLE, SQLCOM_CHANGE_MASTER,
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
88
  SQLCOM_RENAME_TABLE, SQLCOM_BACKUP_TABLE, SQLCOM_RESTORE_TABLE,
89
  SQLCOM_RESET, SQLCOM_PURGE, SQLCOM_PURGE_BEFORE, SQLCOM_SHOW_BINLOGS,
90
  SQLCOM_SHOW_OPEN_TABLES, SQLCOM_LOAD_MASTER_DATA,
91
  SQLCOM_HA_OPEN, SQLCOM_HA_CLOSE, SQLCOM_HA_READ,
92
  SQLCOM_SHOW_SLAVE_HOSTS, SQLCOM_DELETE_MULTI, SQLCOM_UPDATE_MULTI,
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
93
  SQLCOM_SHOW_BINLOG_EVENTS, SQLCOM_SHOW_NEW_MASTER, SQLCOM_DO,
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
94
  SQLCOM_SHOW_WARNS, SQLCOM_EMPTY_QUERY, SQLCOM_SHOW_ERRORS,
95
  SQLCOM_SHOW_COLUMN_TYPES, SQLCOM_SHOW_STORAGE_ENGINES, SQLCOM_SHOW_PRIVILEGES,
96 97
  SQLCOM_HELP, SQLCOM_CREATE_USER, SQLCOM_DROP_USER, SQLCOM_RENAME_USER,
  SQLCOM_REVOKE_ALL, SQLCOM_CHECKSUM,
98
  SQLCOM_CREATE_PROCEDURE, SQLCOM_CREATE_SPFUNCTION, SQLCOM_CALL,
99
  SQLCOM_DROP_PROCEDURE, SQLCOM_ALTER_PROCEDURE,SQLCOM_ALTER_FUNCTION,
100 101
  SQLCOM_SHOW_CREATE_PROC, SQLCOM_SHOW_CREATE_FUNC,
  SQLCOM_SHOW_STATUS_PROC, SQLCOM_SHOW_STATUS_FUNC,
sergefp@mysql.com's avatar
sergefp@mysql.com committed
102
  SQLCOM_PREPARE, SQLCOM_EXECUTE, SQLCOM_DEALLOCATE_PREPARE,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
103
  SQLCOM_CREATE_VIEW, SQLCOM_DROP_VIEW,
104
  SQLCOM_CREATE_TRIGGER, SQLCOM_DROP_TRIGGER,
105 106
  SQLCOM_XA_START, SQLCOM_XA_END, SQLCOM_XA_PREPARE,
  SQLCOM_XA_COMMIT, SQLCOM_XA_ROLLBACK, SQLCOM_XA_RECOVER,
pem@mysql.com's avatar
pem@mysql.com committed
107
  SQLCOM_SHOW_PROC_CODE, SQLCOM_SHOW_FUNC_CODE,
108
  SQLCOM_ALTER_TABLESPACE,
109
  SQLCOM_INSTALL_PLUGIN, SQLCOM_UNINSTALL_PLUGIN,
110 111
  SQLCOM_SHOW_AUTHORS, SQLCOM_BINLOG_BASE64_EVENT,
  SQLCOM_SHOW_PLUGINS,
112
  SQLCOM_SHOW_CONTRIBUTORS,
patg@radha.tangent.org's avatar
patg@radha.tangent.org committed
113
  SQLCOM_CREATE_SERVER, SQLCOM_DROP_SERVER, SQLCOM_ALTER_SERVER,
114
  SQLCOM_CREATE_EVENT, SQLCOM_ALTER_EVENT, SQLCOM_DROP_EVENT,
115
  SQLCOM_SHOW_CREATE_EVENT, SQLCOM_SHOW_EVENTS, 
andrey@lmy004's avatar
andrey@lmy004 committed
116

117
  /* This should be the last !!! */
118

119
  SQLCOM_END
bk@work.mysql.com's avatar
bk@work.mysql.com committed
120 121
};

122 123 124
// describe/explain types
#define DESCRIBE_NORMAL		1
#define DESCRIBE_EXTENDED	2
125
/*
126
  This is not within #ifdef because we want "EXPLAIN PARTITIONS ..." to produce
127 128 129
  additional "partitions" column even if partitioning is not compiled in.
*/
#define DESCRIBE_PARTITIONS	4
130

131 132
#ifdef MYSQL_SERVER

133
enum enum_sp_suid_behaviour
134
{
135 136 137
  SP_IS_DEFAULT_SUID= 0,
  SP_IS_NOT_SUID,
  SP_IS_SUID
138
};
139

140 141 142 143 144 145 146 147 148
enum enum_sp_data_access
{
  SP_DEFAULT_ACCESS= 0,
  SP_CONTAINS_SQL,
  SP_NO_SQL,
  SP_READS_SQL_DATA,
  SP_MODIFIES_SQL_DATA
};

149 150
const LEX_STRING sp_data_access_name[]=
{
andrey@example.com's avatar
andrey@example.com committed
151 152 153 154 155
  { C_STRING_WITH_LEN("") },
  { C_STRING_WITH_LEN("CONTAINS SQL") },
  { C_STRING_WITH_LEN("NO SQL") },
  { C_STRING_WITH_LEN("READS SQL DATA") },
  { C_STRING_WITH_LEN("MODIFIES SQL DATA") }
156
};
157

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
#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
};

bk@work.mysql.com's avatar
bk@work.mysql.com committed
175 176
typedef List<Item> List_item;

patg@radha.tangent.org's avatar
patg@radha.tangent.org committed
177 178 179 180 181 182 183 184
/* SERVERS CACHE CHANGES */
typedef struct st_lex_server_options
{
  long port;
  uint server_name_length;
  char *server_name, *host, *db, *username, *password, *scheme, *socket, *owner;
} LEX_SERVER_OPTIONS;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
185 186
typedef struct st_lex_master_info
{
187
  char *host, *user, *password, *log_file_name;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
188 189
  uint port, connect_retry;
  ulonglong pos;
190
  ulong server_id;
191 192 193 194 195 196 197
  /* 
     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;
198
  char *relay_log_name;
199
  ulong relay_log_pos;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
200 201
} LEX_MASTER_INFO;

202

203 204
enum sub_select_type
{
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
205 206
  UNSPECIFIED_TYPE,UNION_TYPE, INTERSECT_TYPE,
  EXCEPT_TYPE, GLOBAL_OPTIONS_TYPE, DERIVED_TABLE_TYPE, OLAP_TYPE
207 208 209 210
};

enum olap_type 
{
211
  UNSPECIFIED_OLAP_TYPE, CUBE_TYPE, ROLLUP_TYPE
212
};
213

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
214 215 216 217 218
enum tablespace_op_type
{
  NO_TABLESPACE_OP, DISCARD_TABLESPACE, IMPORT_TABLESPACE
};

219 220 221
/* 
  The state of the lex parsing for selects 
   
222 223 224 225 226 227 228 229 230 231
   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

232
   All select describing structures linked with following pointers:
233
   - list of neighbors (next/prev) (prev of first element point to slave
234
     pointer of upper structure)
235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
     - 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:
262

263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278
   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:

279 280 281 282 283
   select1: (select * from table1 ...)
   select2: (select * from table2 ...)
   select3: (select * from table3)
   select1.1.1: (select * from table1_1_1)
   ...
284 285

     main unit
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
286
     fake0
287 288 289 290 291 292 293 294
     select1 select2 select3
     |^^     |^
    s|||     ||master
    l|||     |+---------------------------------+
    a|||     +---------------------------------+|
    v|||master                         slave   ||
    e||+-------------------------+             ||
     V|            neighbor      |             V|
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
295
     unit1.1<+==================>unit1.2       unit2.1
296 297
     fake1.1
     select1.1.1 select 1.1.2    select1.2.1   select2.1.1
298 299 300 301 302 303 304 305
                                               |^
                                               ||
                                               V|
                                               unit2.1.1.1
                                               select2.1.1.1.1


   relation in main unit will be following:
306 307 308 309 310 311
   (bigger picture for:
      main unit
      fake0
      select1 select2 select3
   in the above picture)

312
         main unit
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
313 314 315 316 317 318 319 320
         |^^^^|fake_select_lex
         |||||+--------------------------------------------+
         ||||+--------------------------------------------+|
         |||+------------------------------+              ||
         ||+--------------+                |              ||
    slave||master         |                |              ||
         V|      neighbor |       neighbor |        master|V
         select1<========>select2<========>select3        fake0
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336

    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)
*/
337
struct st_lex;
338 339
class st_select_lex;
class st_select_lex_unit;
340 341
class st_select_lex_node {
protected:
342 343 344
  st_select_lex_node *next, **prev,   /* neighbor list */
    *master, *slave,                  /* vertical links */
    *link_next, **link_prev;          /* list of whole SELECT_LEX */
345
public:
346

347
  ulonglong options;
348 349 350 351 352 353 354 355

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

356 357 358 359
  /*
    result of this query can't be cached, bit field, can be :
      UNCACHEABLE_DEPENDENT
      UNCACHEABLE_RAND
360
      UNCACHEABLE_SIDEEFFECT
361
      UNCACHEABLE_EXPLAIN
362
      UNCACHEABLE_PREPARE
363 364
  */
  uint8 uncacheable;
365
  enum sub_select_type linkage;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
366
  bool no_table_names_allowed; /* used for global order by */
367
  bool no_error; /* suppress error message (convert it to warnings) */
368 369 370

  static void *operator new(size_t size)
  {
371
    return (void*) sql_alloc((uint) size);
372
  }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
373 374
  static void *operator new(size_t size, MEM_ROOT *mem_root)
  { return (void*) alloc_root(mem_root, (uint) size); }
375
  static void operator delete(void *ptr,size_t size) { TRASH(ptr, size); }
376
  static void operator delete(void *ptr, MEM_ROOT *mem_root) {}
377
  st_select_lex_node(): linkage(UNSPECIFIED_TYPE) {}
378 379 380 381
  virtual ~st_select_lex_node() {}
  inline st_select_lex_node* get_master() { return master; }
  virtual void init_query();
  virtual void init_select();
382 383
  void include_down(st_select_lex_node *upper);
  void include_neighbour(st_select_lex_node *before);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
384
  void include_standalone(st_select_lex_node *sel, st_select_lex_node **ref);
385 386
  void include_global(st_select_lex_node **plink);
  void exclude();
387 388 389

  virtual st_select_lex_unit* master_unit()= 0;
  virtual st_select_lex* outer_select()= 0;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
390
  virtual st_select_lex* return_after_parsing()= 0;
391 392 393 394 395 396 397 398

  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();
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
399
  virtual ulong get_table_join_options();
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
400
  virtual TABLE_LIST *add_table_to_list(THD *thd, Table_ident *table,
401
					LEX_STRING *alias,
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
402
					ulong table_options,
403 404
					thr_lock_type flags= TL_UNLOCK,
					List<String> *use_index= 0,
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
405 406
					List<String> *ignore_index= 0,
                                        LEX_STRING *option= 0);
407
  virtual void set_lock_for_tables(thr_lock_type lock_type) {}
408

409
  friend class st_select_lex_unit;
410
  friend bool mysql_new_select(struct st_lex *lex, bool move_down);
411
  friend bool mysql_make_view(THD *thd, File_parser *parser,
412
                              TABLE_LIST *table, uint flags);
413 414 415
private:
  void fast_exclude();
};
416
typedef class st_select_lex_node SELECT_LEX_NODE;
417 418 419 420 421

/* 
   SELECT_LEX_UNIT - unit of selects (UNION, INTERSECT, ...) group 
   SELECT_LEXs
*/
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
422 423 424 425
class THD;
class select_result;
class JOIN;
class select_union;
426
class Procedure;
427
class st_select_lex_unit: public st_select_lex_node {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
428 429 430 431
protected:
  TABLE_LIST result_table_list;
  select_union *union_result;
  TABLE *table; /* temporary table using for appending UNION results */
432

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
433
  select_result *result;
434
  ulonglong found_rows_for_union;
435 436
  bool saved_error;

437
public:
Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
438
  bool  prepared, // prepare phase already performed for UNION (unit)
439
    optimized, // optimize phase already performed for UNION (unit)
440 441
    executed, // already executed
    cleaned;
442 443 444

  // list of fields which points to temporary table for union
  List<Item> item_list;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
445 446 447 448 449 450 451
  /*
    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
  */
452
  List<Item> types;
453 454 455 456
  /*
    Pointer to 'last' select or pointer to unit where stored
    global parameters for union
  */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
457
  st_select_lex *global_parameters;
458
  //node on wich we should return current_select pointer after parsing subquery
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
459
  st_select_lex *return_to;
460 461
  /* LIMIT clause runtime counters */
  ha_rows select_limit_cnt, offset_limit_cnt;
462
  /* not NULL if unit used in subselect, point to subselect item */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
463
  Item_subselect *item;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
464
  /* thread handler */
465
  THD *thd;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
466 467 468 469
  /*
    SELECT_LEX for hidden SELECT in onion which process global
    ORDER BY and LIMIT
  */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
470
  st_select_lex *fake_select_lex;
471

472
  st_select_lex *union_distinct; /* pointer to the last UNION DISTINCT */
473
  bool describe; /* union exec() called for EXPLAIN */
474
  Procedure *last_procedure;	 /* Pointer to procedure, if such exists */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
475

476
  void init_query();
477 478
  st_select_lex_unit* master_unit();
  st_select_lex* outer_select();
479 480 481 482 483 484 485
  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);
486
  }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
487
  st_select_lex* return_after_parsing() { return return_to; }
488
  void exclude_level();
489
  void exclude_tree();
490

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
491
  /* UNION methods */
492
  bool prepare(THD *thd, select_result *result, ulong additional_options);
493 494
  bool exec();
  bool cleanup();
495
  inline void unclean() { cleaned= 0; }
496
  void reinit_exec_mechanism();
497 498

  void print(String *str);
499

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
500
  bool add_fake_select_lex(THD *thd);
501
  void init_prepare_fake_select_lex(THD *thd);
502
  inline bool is_prepared() { return prepared; }
503
  bool change_result(select_subselect *result, select_subselect *old_result);
504
  void set_limit(st_select_lex *values);
505
  void set_thd(THD *thd_arg) { thd= thd_arg; }
506

507
  friend void lex_start(THD *thd, const uchar *buf, uint length);
508
  friend int subselect_union_engine::exec();
509 510

  List<Item> *get_unit_column_types();
511
};
512

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
513
typedef class st_select_lex_unit SELECT_LEX_UNIT;
514 515

/*
516
  SELECT_LEX - store information of parsed SELECT statment
517
*/
518 519
class st_select_lex: public st_select_lex_node
{
520
public:
521
  Name_resolution_context context;
522
  char *db;
523
  Item *where, *having;                         /* WHERE & HAVING clauses */
524
  Item *prep_where; /* saved WHERE clause for prepared statement processing */
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
525
  Item *prep_having;/* saved HAVING clause for prepared statement processing */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
526 527
  /* point on lex in which it was created, used in view subquery detection */
  st_lex *parent_lex;
528
  enum olap_type olap;
529 530 531 532
  /* 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 */
533
  List<String>        interval_list, use_index, *use_index_ptr,
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
534
		      ignore_index, *ignore_index_ptr;
535
  bool	              is_item_list_lookup;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
536 537 538 539 540 541
  /* 
    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;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
542
  JOIN *join; /* after JOIN::prepare it is pointer to corresponding JOIN */
543
  List<TABLE_LIST> top_join_list; /* join list of the top level          */
544
  List<TABLE_LIST> *join_list;    /* list for the currently parsed join  */
545
  TABLE_LIST *embedding;          /* table embedding to the above list   */
546 547 548 549 550 551
  /*
    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;
552
  const char *type;               /* type of select for EXPLAIN          */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
553 554 555

  SQL_LIST order_list;                /* ORDER clause */
  List<List_item>     expr_list;
556
  SQL_LIST *gorder_list;
557
  Item *select_limit, *offset_limit;  /* LIMIT clause parameters */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
558 559 560
  // Arrays of pointers to top elements of all_fields list
  Item **ref_pointer_array;

bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
561 562 563 564 565 566
  /*
    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;
567 568
  uint cond_count;    /* number of arguments of and/or/xor in where/having/on */
  uint between_count; /* number of between predicates in where/having/on      */   
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
569 570
  enum_parsing_place parsing_place; /* where we are parsing expression */
  bool with_sum_func;   /* sum function indicator */
571 572 573 574 575
  /* 
    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;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
576

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
577
  ulong table_join_options;
578
  uint in_sum_expr;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
579
  uint select_number; /* number of select (used for EXPLAIN) */
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
580 581
  int nest_level;     /* nesting level of select */
  Item_sum *inner_sum_func_list; /* list of sum func in nested selects */ 
582
  uint with_wild; /* item list contain '*' */
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
583 584 585
  bool  braces;   	/* SELECT ... UNION (SELECT ... ) <- this braces */
  /* TRUE when having fix field called in processing of this SELECT */
  bool having_fix_field;
586 587 588 589 590 591

  /* Number of Item_sum-derived objects in this SELECT */
  uint n_sum_items;
  /* Number of Item_sum-derived objects in children and descendant SELECTs */
  uint n_child_sum_items;

592 593
  /* explicit LIMIT clause was used */
  bool explicit_limit;
594 595 596 597 598
  /*
    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;
599 600
  /* TRUE <=> this SELECT is correlated w.r.t. some ancestor select */
  bool is_correlated;
601 602 603 604 605 606 607 608 609 610 611 612 613
  /*
    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;
614
  bool first_cond_optimization;
615 616
  /* do not wrap view fields with Item_ref */
  bool no_wrap_view_item;
617 618
  /* exclude this select from check of unique_table() */
  bool exclude_from_table_unique_test;
619 620 621 622
  /* List of fields that aren't under an aggregate function */
  List<Item_field> non_agg_fields;
  /* index in the select list of the expression currently being fixed */
  int cur_pos_in_select_list;
623

624
  List<udf_func>     udf_list;                  /* udf function calls stack */
625 626 627 628 629 630 631 632 633 634 635 636 637 638
  /* 
    This is a copy of the original JOIN USING list that comes from
    the parser. The parser :
      1. Sets the natural_join of the second TABLE_LIST in the join
         and the st_select_lex::prev_join_using.
      2. Makes a parent TABLE_LIST and sets its is_natural_join/
       join_using_fields members.
      3. Uses the wrapper TABLE_LIST as a table in the upper level.
    We cannot assign directly to join_using_fields in the parser because
    at stage (1.) the parent TABLE_LIST is not constructed yet and
    the assignment will override the JOIN USING fields of the lower level
    joins on the right.
  */
  List<String> *prev_join_using;
639 640
  void init_query();
  void init_select();
641
  st_select_lex_unit* master_unit();
642 643 644 645
  st_select_lex_unit* first_inner_unit() 
  { 
    return (st_select_lex_unit*) slave; 
  }
646
  st_select_lex* outer_select();
647
  st_select_lex* next_select() { return (st_select_lex*) next; }
648
  st_select_lex* next_select_in_list() 
649 650 651 652 653 654 655
  {
    return (st_select_lex*) link_next;
  }
  st_select_lex_node** next_select_in_list_addr()
  {
    return &link_next;
  }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
656
  st_select_lex* return_after_parsing()
657 658 659
  {
    return master_unit()->return_after_parsing();
  }
660

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
661 662
  void mark_as_dependent(st_select_lex *last);

663 664 665
  bool set_braces(bool value);
  bool inc_in_sum_expr();
  uint get_in_sum_expr();
666

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
667 668
  bool add_item_to_list(THD *thd, Item *item);
  bool add_group_to_list(THD *thd, Item *item, bool asc);
669
  bool add_ftfunc_to_list(Item_func_match *func);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
670
  bool add_order_to_list(THD *thd, Item *item, bool asc);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
671
  TABLE_LIST* add_table_to_list(THD *thd, Table_ident *table,
672
				LEX_STRING *alias,
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
673
				ulong table_options,
674 675
				thr_lock_type flags= TL_UNLOCK,
				List<String> *use_index= 0,
676 677
				List<String> *ignore_index= 0,
                                LEX_STRING *option= 0);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
678
  TABLE_LIST* get_table_list();
679 680 681 682 683
  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();
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
684 685 686 687
  List<Item>* get_item_list();
  List<String>* get_use_index();
  List<String>* get_ignore_index();
  ulong get_table_join_options();
688
  void set_lock_for_tables(thr_lock_type lock_type);
689 690 691 692 693 694
  inline void init_order()
  {
    order_list.elements= 0;
    order_list.first= 0;
    order_list.next= (byte**) &order_list.first;
  }
695 696 697 698 699 700 701
  /*
    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; }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
702 703
  bool test_limit();

704
  friend void lex_start(THD *thd, const uchar *buf, uint length);
705
  st_select_lex() : n_sum_items(0), n_child_sum_items(0) {}
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
706
  void make_empty_select()
707 708 709 710
  {
    init_query();
    init_select();
  }
bell@laptop.sanja.is.com.ua's avatar
bell@laptop.sanja.is.com.ua committed
711
  bool setup_ref_array(THD *thd, uint order_group_num);
712 713 714
  void print(THD *thd, String *str);
  static void print_order(String *str, ORDER *order);
  void print_limit(THD *thd, String *str);
715
  void fix_prepare_information(THD *thd, Item **conds, Item **having_conds);
716 717 718 719 720
  /*
    Destroy the used execution plan (JOIN) of this subtree (this
    SELECT_LEX and all nested SELECT_LEXes and SELECT_LEX_UNITs).
  */
  bool cleanup();
721 722 723 724 725
  /*
    Recursively cleanup the join of this select lex and of all nested
    select lexes.
  */
  void cleanup_all_joins(bool full);
726
};
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
727
typedef class st_select_lex SELECT_LEX;
728

729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753
#define ALTER_ADD_COLUMN	(1L << 0)
#define ALTER_DROP_COLUMN	(1L << 1)
#define ALTER_CHANGE_COLUMN	(1L << 2)
#define ALTER_ADD_INDEX		(1L << 3)
#define ALTER_DROP_INDEX	(1L << 4)
#define ALTER_RENAME		(1L << 5)
#define ALTER_ORDER		(1L << 6)
#define ALTER_OPTIONS		(1L << 7)
#define ALTER_CHANGE_COLUMN_DEFAULT (1L << 8)
#define ALTER_KEYS_ONOFF        (1L << 9)
#define ALTER_CONVERT           (1L << 10)
#define ALTER_FORCE		(1L << 11)
#define ALTER_RECREATE          (1L << 12)
#define ALTER_ADD_PARTITION     (1L << 13)
#define ALTER_DROP_PARTITION    (1L << 14)
#define ALTER_COALESCE_PARTITION (1L << 15)
#define ALTER_REORGANIZE_PARTITION (1L << 16) 
#define ALTER_PARTITION          (1L << 17)
#define ALTER_OPTIMIZE_PARTITION (1L << 18)
#define ALTER_TABLE_REORG        (1L << 19)
#define ALTER_REBUILD_PARTITION  (1L << 20)
#define ALTER_ALL_PARTITION      (1L << 21)
#define ALTER_ANALYZE_PARTITION  (1L << 22)
#define ALTER_CHECK_PARTITION    (1L << 23)
#define ALTER_REPAIR_PARTITION   (1L << 24)
754
#define ALTER_REMOVE_PARTITIONING (1L << 25)
755
#define ALTER_FOREIGN_KEY         (1L << 26)
756

757 758 759 760 761 762 763
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;
764 765
  List<char>                  partition_names;
  uint                        no_parts;
766 767

  st_alter_info(){clear();}
768 769 770 771 772 773 774
  void clear()
  {
    keys_onoff= LEAVE_AS_IS;
    tablespace_op= NO_TABLESPACE_OP;
    no_parts= 0;
    partition_names.empty();
  }
775 776 777
  void reset(){drop_list.empty();alter_list.empty();clear();}
} ALTER_INFO;

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

786 787 788 789 790 791 792

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

793
extern sys_var *trg_new_row_fake_var;
794

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

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

/*
  Class representing list of all tables used by statement.
  It also contains information about stored functions used by statement
  since during its execution we may have to add all tables used by its
  stored functions/triggers to this list in order to pre-open and lock
  them.

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

class Query_tables_list
{
public:
  /* Global list of all tables used by this statement */
  TABLE_LIST *query_tables;
  /* Pointer to next_global member of last element in the previous list. */
  TABLE_LIST **query_tables_last;
  /*
    If non-0 then indicates that query requires prelocking and points to
    next_global member of last own element in query table list (i.e. last
    table which was not added to it as part of preparation to prelocking).
    0 - indicates that this query does not need prelocking.
  */
  TABLE_LIST **query_tables_own_last;
824 825 826 827 828
  /*
    Set of stored routines called by statement.
    (Note that we use lazy-initialization for this hash).
  */
  enum { START_SROUTINES_HASH_SIZE= 16 };
829 830 831 832 833 834 835 836 837 838 839 840 841 842
  HASH sroutines;
  /*
    List linking elements of 'sroutines' set. Allows you to add new elements
    to this set as you iterate through the list of existing elements.
    'sroutines_list_own_last' is pointer to ::next member of last element of
    this list which represents routine which is explicitly used by query.
    'sroutines_list_own_elements' number of explicitly used routines.
    We use these two members for restoring of 'sroutines_list' to the state
    in which it was right after query parsing.
  */
  SQL_LIST sroutines_list;
  byte     **sroutines_list_own_last;
  uint     sroutines_list_own_elements;

843 844 845 846 847 848 849 850
  /*
    Tells if the parsing stage detected that some items require row-based
    binlogging to give a reliable binlog/replication, or if we will use
    stored functions or triggers which themselves need require row-based
    binlogging.
  */
  bool binlog_row_based_if_mixed;

851 852 853 854 855 856 857 858 859 860 861 862 863 864 865
  /*
    These constructor and destructor serve for creation/destruction
    of Query_tables_list instances which are used as backup storage.
  */
  Query_tables_list() {}
  ~Query_tables_list() {}

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

866 867 868 869 870
  /*
    Direct addition to the list of query tables.
    If you are using this function, you must ensure that the table
    object, in particular table->db member, is initialized.
  */
871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900
  void add_to_query_tables(TABLE_LIST *table)
  {
    *(table->prev_global= query_tables_last)= table;
    query_tables_last= &table->next_global;
  }
  bool requires_prelocking()
  {
    return test(query_tables_own_last);
  }
  void mark_as_requiring_prelocking(TABLE_LIST **tables_own_last)
  {
    query_tables_own_last= tables_own_last;
  }
  /* Return pointer to first not-own table in query-tables or 0 */
  TABLE_LIST* first_not_own_table()
  {
    return ( query_tables_own_last ? *query_tables_own_last : 0);
  }
  void chop_off_not_own_tables()
  {
    if (query_tables_own_last)
    {
      *query_tables_own_last= 0;
      query_tables_last= query_tables_own_last;
      query_tables_own_last= 0;
    }
  }
};


901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919
/*
  st_parsing_options contains the flags for constructions that are
  allowed in the current statement.
*/

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

  st_parsing_options()
    : allows_variable(TRUE), allows_select_into(TRUE),
      allows_select_procedure(TRUE), allows_derived(TRUE)
  {}
};


bk@work.mysql.com's avatar
bk@work.mysql.com committed
920 921
/* The state of the lex parsing. This is saved in the THD struct */

922
typedef struct st_lex : public Query_tables_list
923
{
bk@work.mysql.com's avatar
bk@work.mysql.com committed
924 925
  uint	 yylineno,yytoklen;			/* Simulate lex */
  LEX_YYSTYPE yylval;
926
  SELECT_LEX_UNIT unit;                         /* most upper unit */
927 928
  SELECT_LEX select_lex;                        /* first SELECT_LEX */
  /* current SELECT_LEX in parsing */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
929
  SELECT_LEX *current_select;
930 931
  /* list of all SELECT_LEX */
  SELECT_LEX *all_selects_list;
932 933
  const uchar *buf;		/* The beginning of string, used by SPs */
  const uchar *ptr,*tok_start,*tok_end,*end_of_query;
934
  
935
  /* The values of tok_start/tok_end as they were one call of MYSQLlex before */
936
  const uchar *tok_start_prev, *tok_end_prev;
937

938 939
  char *length,*dec,*change;
  LEX_STRING name;
mikael@zim.(none)'s avatar
mikael@zim.(none) committed
940
  Table_ident *like_name;
serg@serg.mylan's avatar
serg@serg.mylan committed
941
  char *help_arg;
942
  char *backup_dir;				/* For RESTORE/BACKUP */
943
  char* to_log;                                 /* For PURGE MASTER LOGS TO */
944
  char* x509_subject,*x509_issuer,*ssl_cipher;
945
  char* found_semicolon;                        /* For multi queries - next query */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
946 947
  String *wild;
  sql_exchange *exchange;
948
  select_result *result;
949
  Item *default_value, *on_update_value;
950
  LEX_STRING comment, ident;
serg@serg.mylan's avatar
serg@serg.mylan committed
951
  LEX_USER *grant_user;
serg@serg.mylan's avatar
serg@serg.mylan committed
952
  XID *xid;
serg@serg.mylan's avatar
serg@serg.mylan committed
953 954
  gptr yacc_yyss,yacc_yyvs;
  THD *thd;
955
  CHARSET_INFO *charset, *underscore_charset;
956 957
  /* store original leaf_tables for INSERT SELECT and PS/SP */
  TABLE_LIST *leaf_tables_insert;
958 959
  /* Position (first character index) of SELECT of CREATE VIEW statement */
  uint create_view_select_start;
960 961
  /* Partition info structure filled in by PARTITION BY parse part */
  partition_info *part_info;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
962

963 964 965 966 967 968
  /*
    The definer of the object being created (view, trigger, stored routine).
    I.e. the value of DEFINER clause.
  */
  LEX_USER *definer;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
969
  List<key_part_spec> col_list;
970
  List<key_part_spec> ref_list;
971
  List<String>	      interval_list;
972
  List<LEX_USER>      users_list;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
973 974 975
  List<LEX_COLUMN>    columns;
  List<Key>	      key_list;
  List<create_field>  create_list;
976
  List<Item>	      *insert_list,field_list,value_list,update_list;
977
  List<List_item>     many_values;
978
  List<set_var_base>  var_list;
979
  List<Item_param>    param_list;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
980
  List<LEX_STRING>    view_list; // view list (list of field names in view)
981 982 983 984 985 986 987 988 989 990 991 992 993 994
  /*
    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;
995
  List<LEX_STRING>     db_list;
996

997
  SQL_LIST	      proc_list, auxiliary_table_list, save_list;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
998
  create_field	      *last_field;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
999
  Item_sum *in_sum_func;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1000
  udf_func udf;
1001 1002
  HA_CHECK_OPT   check_opt;			// check/repair options
  HA_CREATE_INFO create_info;
1003
  KEY_CREATE_INFO key_create_info;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
1004
  LEX_MASTER_INFO mi;				// used by CHANGE MASTER
patg@radha.tangent.org's avatar
patg@radha.tangent.org committed
1005
  LEX_SERVER_OPTIONS server_options;
1006
  USER_RESOURCES mqh;
1007
  ulong type;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1008 1009 1010 1011 1012 1013 1014 1015 1016 1017
  /*
    This variable is used in post-parse stage to declare that sum-functions,
    or functions which have sense only if GROUP BY is present, are allowed.
    For example in a query
    SELECT ... FROM ...WHERE MIN(i) == 1 GROUP BY ... HAVING MIN(i) > 2
    MIN(i) in the WHERE clause is not allowed in the opposite to MIN(i)
    in the HAVING clause. Due to possible nesting of select construct
    the variable can contain 0 or 1 for each nest level.
  */
  nesting_map allow_sum_func;
1018
  enum_sql_command sql_command;
1019 1020 1021 1022 1023 1024 1025 1026
  /*
    Usually `expr` rule of yacc is quite reused but some commands better
    not support subqueries which comes standard with this rule, like
    KILL, HA_READ, CREATE/ALTER EVENT etc. Set this to `false` to get
    syntax error back.
  */
  bool expr_allows_subselect;

1027
  thr_lock_type lock_option;
serg@serg.mylan's avatar
serg@serg.mylan committed
1028
  enum SSL_type ssl_type;			/* defined in violite.h */
1029
  enum my_lex_states next_state;
1030
  enum enum_duplicates duplicates;
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1031
  enum enum_tx_isolation tx_isolation;
1032
  enum enum_ha_read_modes ha_read_mode;
1033
  union {
serg@serg.mylan's avatar
serg@serg.mylan committed
1034
    enum ha_rkey_function ha_rkey_mode;
1035 1036
    enum xa_option_words xa_opt;
  };
1037
  enum enum_var_type option_type;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1038 1039
  enum enum_view_create_mode create_view_mode;
  enum enum_drop_mode drop_mode;
serg@serg.mylan's avatar
serg@serg.mylan committed
1040
  uint uint_geom_type;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1041
  uint grant, grant_tot_col, which_columns;
1042
  uint fk_delete_opt, fk_update_opt, fk_match_option;
1043
  uint slave_thd_opt, start_transaction_opt;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1044
  int nest_level;
1045 1046 1047 1048 1049 1050
  /*
    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;
1051
  uint8 describe;
1052 1053 1054
  /*
    A flag that indicates what kinds of derived tables are present in the
    query (0 if no derived tables, otherwise a combination of flags
konstantin@mysql.com's avatar
konstantin@mysql.com committed
1055
    DERIVED_SUBQUERY and DERIVED_VIEW).
1056
  */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1057 1058
  uint8 derived_tables;
  uint8 create_view_algorithm;
1059
  uint8 create_view_check;
1060
  bool drop_if_exists, drop_temporary, local_file, one_shot_set;
1061
  bool in_comment, ignore_space, verbose, no_write_to_binlog;
1062
  bool tx_chain, tx_release;
1063 1064 1065 1066 1067 1068 1069
  /*
    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.
  */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1070
  bool view_prepare_mode;
1071 1072 1073 1074 1075
  /*
    TRUE if we're parsing a prepared statement: in this mode
    we should allow placeholders and disallow multistatements.
  */
  bool stmt_prepare_mode;
1076
  bool safe_to_cache_query;
1077
  bool subqueries, ignore;
1078
  st_parsing_options parsing_options;
1079
  ALTER_INFO alter_info;
sergefp@mysql.com's avatar
sergefp@mysql.com committed
1080 1081
  /* Prepared statements SQL syntax:*/
  LEX_STRING prepared_stmt_name; /* Statement name (in all queries) */
serg@serg.mylan's avatar
serg@serg.mylan committed
1082
  /*
1083 1084 1085
    Prepared statement query text or name of variable that holds the
    prepared statement (in PREPARE ... queries)
  */
serg@serg.mylan's avatar
serg@serg.mylan committed
1086
  LEX_STRING prepared_stmt_code;
1087 1088
  /* If true, prepared_stmt_code is a name of variable that holds the query */
  bool prepared_stmt_code_is_varref;
sergefp@mysql.com's avatar
sergefp@mysql.com committed
1089
  /* Names of user variables holding parameters (in EXECUTE) */
serg@serg.mylan's avatar
serg@serg.mylan committed
1090
  List<LEX_STRING> prepared_stmt_params;
1091
  /*
1092 1093
    Points to part of global table list which contains time zone tables
    implicitly used by the statement.
1094 1095
  */
  TABLE_LIST *time_zone_tables_used;
1096
  sp_head *sphead;
1097
  sp_name *spname;
1098
  bool sp_lex_in_use;	/* Keep track on lex usage in SPs for error handling */
1099
  bool all_privileges;
1100
  sp_pcontext *spcont;
1101

1102
  st_sp_chistics sp_chistics;
1103

1104
  Event_parse_data *event_parse_data;
1105

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1106 1107 1108 1109 1110 1111
  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;
1112 1113 1114
  /*
    view created to be run from definer (standard behaviour)
  */
1115
  uint8 create_view_suid;
1116 1117 1118
  /* Characterstics of trigger being created */
  st_trg_chistics trg_chistics;
  /*
1119 1120 1121 1122 1123
    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).
1124
  */
1125
  SQL_LIST trg_table_fields;
1126

1127
  /*
1128 1129 1130 1131 1132 1133 1134 1135
    stmt_definition_begin is intended to point to the next word after
    DEFINER-clause in the following statements:
      - CREATE TRIGGER (points to "TRIGGER");
      - CREATE PROCEDURE (points to "PROCEDURE");
      - CREATE FUNCTION (points to "FUNCTION" or "AGGREGATE");

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

1139 1140 1141 1142
  /*
    Pointers to part of LOAD DATA statement that should be rewritten
    during replication ("LOCAL 'filename' REPLACE INTO" part).
  */
1143
  const uchar *fname_start, *fname_end;
1144 1145 1146 1147 1148 1149

  /*
    Reference to a struct that contains information in various commands
    to add/create/drop/change table spaces.
  */
  st_alter_tablespace *alter_tablespace_info;
1150 1151
  
  bool escape_used;
1152

1153
  st_lex();
1154 1155

  virtual ~st_lex()
1156
  {
1157
    destroy_query_tables_list();
1158
  }
1159

1160
  inline void uncacheable(uint8 cause)
1161 1162
  {
    safe_to_cache_query= 0;
1163 1164 1165 1166 1167 1168

    /*
      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
    */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1169
    SELECT_LEX *sl;
1170 1171 1172 1173
    SELECT_LEX_UNIT *un;
    for (sl= current_select, un= sl->master_unit();
	 un != &unit;
	 sl= sl->outer_select(), un= sl->master_unit())
1174
    {
1175 1176
      sl->uncacheable|= cause;
      un->uncacheable|= cause;
1177
    }
1178
  }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1179 1180 1181
  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();
1182
  bool add_time_zone_tables_to_query_tables(THD *thd);
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1183 1184 1185

  bool can_be_merged();
  bool can_use_merged();
1186
  bool can_not_use_merged();
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1187
  bool only_view_structure();
1188
  bool need_correct_ident();
1189 1190 1191
  uint8 get_effective_with_check(st_table_list *view);
  /*
    Is this update command where 'WHITH CHECK OPTION' clause is important
1192

1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206
    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:
1207 1208
    case SQLCOM_REPLACE:
    case SQLCOM_REPLACE_SELECT:
1209 1210 1211 1212 1213 1214
    case SQLCOM_LOAD:
      return TRUE;
    default:
      return FALSE;
    }
  }
1215

1216
  void cleanup_after_one_table_open();
1217

1218
  bool push_context(Name_resolution_context *context)
1219
  {
1220
    return context_stack.push_front(context);
1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231
  }

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

  Name_resolution_context *current_context()
  {
    return context_stack.head();
  }
1232 1233 1234

  void reset_n_backup_query_tables_list(Query_tables_list *backup);
  void restore_backup_query_tables_list(Query_tables_list *backup);
1235 1236

  bool table_or_sp_used();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1237 1238
} LEX;

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1239 1240 1241 1242 1243 1244 1245 1246 1247 1248
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);
  }
1249 1250
  static void operator delete(void *ptr,size_t size)
  { TRASH(ptr, size); }
1251 1252
  static void operator delete(void *ptr, MEM_ROOT *mem_root)
  { /* Never called */ }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1253
};
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1254

monty@mysql.com's avatar
monty@mysql.com committed
1255 1256
extern void lex_init(void);
extern void lex_free(void);
1257
extern void lex_start(THD *thd, const uchar *buf, uint length);
monty@mysql.com's avatar
monty@mysql.com committed
1258
extern void lex_end(LEX *lex);
1259
extern int MYSQLlex(void *arg, void *yythd);
1260
extern const uchar *skip_rear_comments(const uchar *ubegin, const uchar *uend);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1261

1262 1263
extern bool is_lex_native_function(const LEX_STRING *name);

1264
#endif /* MYSQL_SERVER */