sql_lex.h 62.1 KB
Newer Older
1
/* Copyright 2000-2008 MySQL AB, 2008 Sun Microsystems, Inc.
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
   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 */

16 17 18
/**
  @defgroup Semantic_Analysis Semantic Analysis
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
19

20 21 22
#ifndef SQL_LEX_INCLUDED
#define SQL_LEX_INCLUDED

bk@work.mysql.com's avatar
bk@work.mysql.com committed
23 24 25 26 27 28
/* YACC and LEX Definitions */

/* These may not be declared yet */
class Table_ident;
class sql_exchange;
class LEX_COLUMN;
29
class sp_head;
30
class sp_name;
31 32
class sp_instr;
class sp_pcontext;
33
class st_alter_tablespace;
34
class partition_info;
35
class Event_parse_data;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
36

37
#ifdef MYSQL_SERVER
38 39 40 41
/*
  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
42

43 44
#include "set_var.h"

bk@work.mysql.com's avatar
bk@work.mysql.com committed
45 46 47 48
#ifdef MYSQL_YACC
#define LEX_YYSTYPE void *
#else
#include "lex_symbol.h"
49
#if MYSQL_LEX
bk@work.mysql.com's avatar
bk@work.mysql.com committed
50 51
#include "sql_yacc.h"
#define LEX_YYSTYPE YYSTYPE *
52 53 54
#else
#define LEX_YYSTYPE void *
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
55
#endif
56
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
57

58 59 60
/*
  When a command is added here, be sure it's also added in mysqld.cc
  in "struct show_var_st status_vars[]= {" ...
61 62 63 64 65

  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_.
66 67
*/

bk@work.mysql.com's avatar
bk@work.mysql.com committed
68
enum enum_sql_command {
69 70 71 72 73
  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,
74 75
  SQLCOM_SHOW_KEYS, SQLCOM_SHOW_VARIABLES, SQLCOM_SHOW_STATUS,
  SQLCOM_SHOW_ENGINE_LOGS, SQLCOM_SHOW_ENGINE_STATUS, SQLCOM_SHOW_ENGINE_MUTEX,
76
  SQLCOM_SHOW_PROCESSLIST, SQLCOM_SHOW_MASTER_STAT, SQLCOM_SHOW_SLAVE_STAT,
77
  SQLCOM_SHOW_GRANTS, SQLCOM_SHOW_CREATE, SQLCOM_SHOW_CHARSETS,
78
  SQLCOM_SHOW_COLLATIONS, SQLCOM_SHOW_CREATE_DB, SQLCOM_SHOW_TABLE_STATUS,
79
  SQLCOM_SHOW_TRIGGERS,
80

bk@work.mysql.com's avatar
bk@work.mysql.com committed
81
  SQLCOM_LOAD,SQLCOM_SET_OPTION,SQLCOM_LOCK_TABLES,SQLCOM_UNLOCK_TABLES,
82
  SQLCOM_GRANT,
83
  SQLCOM_CHANGE_DB, SQLCOM_CREATE_DB, SQLCOM_DROP_DB, SQLCOM_ALTER_DB,
84
  SQLCOM_REPAIR, SQLCOM_REPLACE, SQLCOM_REPLACE_SELECT,
85
  SQLCOM_CREATE_FUNCTION, SQLCOM_DROP_FUNCTION,
86
  SQLCOM_REVOKE,SQLCOM_OPTIMIZE, SQLCOM_CHECK,
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
87
  SQLCOM_ASSIGN_TO_KEYCACHE, SQLCOM_PRELOAD_KEYS,
88
  SQLCOM_FLUSH, SQLCOM_KILL, SQLCOM_ANALYZE,
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
89
  SQLCOM_ROLLBACK, SQLCOM_ROLLBACK_TO_SAVEPOINT,
90
  SQLCOM_COMMIT, SQLCOM_SAVEPOINT, SQLCOM_RELEASE_SAVEPOINT,
91
  SQLCOM_SLAVE_START, SQLCOM_SLAVE_STOP,
92
  SQLCOM_BEGIN, SQLCOM_LOAD_MASTER_TABLE, SQLCOM_CHANGE_MASTER,
monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
93
  SQLCOM_RENAME_TABLE, SQLCOM_BACKUP_TABLE, SQLCOM_RESTORE_TABLE,
94
  SQLCOM_RESET, SQLCOM_PURGE, SQLCOM_PURGE_BEFORE, SQLCOM_SHOW_BINLOGS,
95
  SQLCOM_SHOW_OPEN_TABLES, SQLCOM_LOAD_MASTER_DATA,
96
  SQLCOM_HA_OPEN, SQLCOM_HA_CLOSE, SQLCOM_HA_READ,
97
  SQLCOM_SHOW_SLAVE_HOSTS, SQLCOM_DELETE_MULTI, SQLCOM_UPDATE_MULTI,
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
98
  SQLCOM_SHOW_BINLOG_EVENTS, SQLCOM_SHOW_NEW_MASTER, SQLCOM_DO,
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
99
  SQLCOM_SHOW_WARNS, SQLCOM_EMPTY_QUERY, SQLCOM_SHOW_ERRORS,
100
  SQLCOM_SHOW_STORAGE_ENGINES, SQLCOM_SHOW_PRIVILEGES,
101 102
  SQLCOM_HELP, SQLCOM_CREATE_USER, SQLCOM_DROP_USER, SQLCOM_RENAME_USER,
  SQLCOM_REVOKE_ALL, SQLCOM_CHECKSUM,
103
  SQLCOM_CREATE_PROCEDURE, SQLCOM_CREATE_SPFUNCTION, SQLCOM_CALL,
104
  SQLCOM_DROP_PROCEDURE, SQLCOM_ALTER_PROCEDURE,SQLCOM_ALTER_FUNCTION,
105 106
  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
107
  SQLCOM_PREPARE, SQLCOM_EXECUTE, SQLCOM_DEALLOCATE_PREPARE,
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
108
  SQLCOM_CREATE_VIEW, SQLCOM_DROP_VIEW,
109
  SQLCOM_CREATE_TRIGGER, SQLCOM_DROP_TRIGGER,
110 111
  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
112
  SQLCOM_SHOW_PROC_CODE, SQLCOM_SHOW_FUNC_CODE,
113
  SQLCOM_ALTER_TABLESPACE,
114
  SQLCOM_INSTALL_PLUGIN, SQLCOM_UNINSTALL_PLUGIN,
115 116
  SQLCOM_SHOW_AUTHORS, SQLCOM_BINLOG_BASE64_EVENT,
  SQLCOM_SHOW_PLUGINS,
117
  SQLCOM_SHOW_CONTRIBUTORS,
patg@radha.tangent.org's avatar
patg@radha.tangent.org committed
118
  SQLCOM_CREATE_SERVER, SQLCOM_DROP_SERVER, SQLCOM_ALTER_SERVER,
119
  SQLCOM_CREATE_EVENT, SQLCOM_ALTER_EVENT, SQLCOM_DROP_EVENT,
120 121
  SQLCOM_SHOW_CREATE_EVENT, SQLCOM_SHOW_EVENTS,
  SQLCOM_SHOW_CREATE_TRIGGER,
122
  SQLCOM_ALTER_DB_UPGRADE,
123
  SQLCOM_SHOW_PROFILE, SQLCOM_SHOW_PROFILES,
Marc Alff's avatar
Marc Alff committed
124
  SQLCOM_SIGNAL, SQLCOM_RESIGNAL,
125
  SQLCOM_SHOW_RELAYLOG_EVENTS, 
126 127 128 129
  /*
    When a command is added here, be sure it's also added in mysqld.cc
    in "struct show_var_st status_vars[]= {" ...
  */
130 131
  /* This should be the last !!! */
  SQLCOM_END
bk@work.mysql.com's avatar
bk@work.mysql.com committed
132 133
};

134 135 136
// describe/explain types
#define DESCRIBE_NORMAL		1
#define DESCRIBE_EXTENDED	2
137
/*
138
  This is not within #ifdef because we want "EXPLAIN PARTITIONS ..." to produce
139 140 141
  additional "partitions" column even if partitioning is not compiled in.
*/
#define DESCRIBE_PARTITIONS	4
142

143 144
#ifdef MYSQL_SERVER

145
enum enum_sp_suid_behaviour
146
{
147 148 149
  SP_IS_DEFAULT_SUID= 0,
  SP_IS_NOT_SUID,
  SP_IS_SUID
150
};
151

152 153 154 155 156 157 158 159 160
enum enum_sp_data_access
{
  SP_DEFAULT_ACCESS= 0,
  SP_CONTAINS_SQL,
  SP_NO_SQL,
  SP_READS_SQL_DATA,
  SP_MODIFIES_SQL_DATA
};

161 162
const LEX_STRING sp_data_access_name[]=
{
andrey@example.com's avatar
andrey@example.com committed
163 164 165 166 167
  { 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") }
168
};
169

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
#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
187 188
typedef List<Item> List_item;

patg@radha.tangent.org's avatar
patg@radha.tangent.org committed
189 190 191 192 193 194 195 196
/* 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;

197 198 199 200 201 202 203 204 205

/**
  Structure to hold parameters for CHANGE MASTER or START/STOP SLAVE
  or SHOW NEW MASTER.

  Remark: this should not be confused with Master_info (and perhaps
  would better be renamed to st_lex_replication_info).  Some fields,
  e.g., delay, are saved in Relay_log_info, not in Master_info.
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
206 207
typedef struct st_lex_master_info
{
208
  char *host, *user, *password, *log_file_name;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
209
  uint port, connect_retry;
Andrei Elkin's avatar
Andrei Elkin committed
210
  float heartbeat_period;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
211
  ulonglong pos;
212
  ulong server_id;
213 214 215 216
  /*
    Enum is used for making it possible to detect if the user
    changed variable or if it should be left at old value
   */
Andrei Elkin's avatar
Andrei Elkin committed
217
  enum {LEX_MI_UNCHANGED, LEX_MI_DISABLE, LEX_MI_ENABLE}
Andrei Elkin's avatar
Andrei Elkin committed
218
    ssl, ssl_verify_server_cert, heartbeat_opt, repl_ignore_server_ids_opt;
219
  char *ssl_key, *ssl_cert, *ssl_ca, *ssl_capath, *ssl_cipher;
220
  char *relay_log_name;
221
  ulong relay_log_pos;
Andrei Elkin's avatar
Andrei Elkin committed
222
  DYNAMIC_ARRAY repl_ignore_server_ids;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
223 224
} LEX_MASTER_INFO;

225

226 227
enum sub_select_type
{
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
228 229
  UNSPECIFIED_TYPE,UNION_TYPE, INTERSECT_TYPE,
  EXCEPT_TYPE, GLOBAL_OPTIONS_TYPE, DERIVED_TABLE_TYPE, OLAP_TYPE
230 231 232 233
};

enum olap_type 
{
234
  UNSPECIFIED_OLAP_TYPE, CUBE_TYPE, ROLLUP_TYPE
235
};
236

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
237 238 239 240 241
enum tablespace_op_type
{
  NO_TABLESPACE_OP, DISCARD_TABLESPACE, IMPORT_TABLESPACE
};

242 243 244 245 246
/* 
  String names used to print a statement with index hints.
  Keep in sync with index_hint_type.
*/
extern const char * index_hint_type_name[];
247
typedef uchar index_clause_map;
248 249 250 251 252 253 254 255 256 257 258 259 260

/*
  Bits in index_clause_map : one for each possible FOR clause in
  USE/FORCE/IGNORE INDEX index hint specification
*/
#define INDEX_HINT_MASK_JOIN  (1)
#define INDEX_HINT_MASK_GROUP (1 << 1)
#define INDEX_HINT_MASK_ORDER (1 << 2)

#define INDEX_HINT_MASK_ALL (INDEX_HINT_MASK_JOIN | INDEX_HINT_MASK_GROUP | \
                             INDEX_HINT_MASK_ORDER)

/* Single element of an USE/FORCE/IGNORE INDEX list specified as a SQL hint  */
261
class Index_hint : public Sql_alloc
262 263 264 265 266 267 268 269 270 271 272 273
{
public:
  /* The type of the hint : USE/FORCE/IGNORE */
  enum index_hint_type type;
  /* Where the hit applies to. A bitmask of INDEX_HINT_MASK_<place> values */
  index_clause_map clause;
  /* 
    The index name. Empty (str=NULL) name represents an empty list 
    USE INDEX () clause 
  */ 
  LEX_STRING key_name;

274
  Index_hint (enum index_hint_type type_arg, index_clause_map clause_arg,
275 276 277 278 279 280
              char *str, uint length) :
    type(type_arg), clause(clause_arg)
  {
    key_name.str= str;
    key_name.length= length;
  }
281 282

  void print(THD *thd, String *str);
283 284
}; 

285 286 287
/* 
  The state of the lex parsing for selects 
   
288 289 290 291 292 293 294 295 296 297
   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

298
   All select describing structures linked with following pointers:
299
   - list of neighbors (next/prev) (prev of first element point to slave
300
     pointer of upper structure)
301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327
     - 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:
328

329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
   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:

345 346 347 348 349
   select1: (select * from table1 ...)
   select2: (select * from table2 ...)
   select3: (select * from table3)
   select1.1.1: (select * from table1_1_1)
   ...
350 351

     main unit
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
352
     fake0
353 354 355 356 357 358 359 360
     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
361
     unit1.1<+==================>unit1.2       unit2.1
362 363
     fake1.1
     select1.1.1 select 1.1.2    select1.2.1   select2.1.1
364 365 366 367 368 369 370 371
                                               |^
                                               ||
                                               V|
                                               unit2.1.1.1
                                               select2.1.1.1.1


   relation in main unit will be following:
372 373 374 375 376 377
   (bigger picture for:
      main unit
      fake0
      select1 select2 select3
   in the above picture)

378
         main unit
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
379 380 381 382 383 384 385 386
         |^^^^|fake_select_lex
         |||||+--------------------------------------------+
         ||||+--------------------------------------------+|
         |||+------------------------------+              ||
         ||+--------------+                |              ||
    slave||master         |                |              ||
         V|      neighbor |       neighbor |        master|V
         select1<========>select2<========>select3        fake0
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402

    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)
*/
Konstantin Osipov's avatar
Konstantin Osipov committed
403
struct LEX;
404 405
class st_select_lex;
class st_select_lex_unit;
Tor Didriksen's avatar
Tor Didriksen committed
406 407


408 409
class st_select_lex_node {
protected:
410 411 412
  st_select_lex_node *next, **prev,   /* neighbor list */
    *master, *slave,                  /* vertical links */
    *link_next, **link_prev;          /* list of whole SELECT_LEX */
413
public:
414

415
  ulonglong options;
416 417 418 419 420 421 422 423

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

424 425 426 427
  /*
    result of this query can't be cached, bit field, can be :
      UNCACHEABLE_DEPENDENT
      UNCACHEABLE_RAND
428
      UNCACHEABLE_SIDEEFFECT
429
      UNCACHEABLE_EXPLAIN
430
      UNCACHEABLE_PREPARE
431 432
  */
  uint8 uncacheable;
433
  enum sub_select_type linkage;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
434
  bool no_table_names_allowed; /* used for global order by */
435
  bool no_error; /* suppress error message (convert it to warnings) */
436

437
  static void *operator new(size_t size) throw ()
438
  {
439
    return sql_alloc(size);
440
  }
441
  static void *operator new(size_t size, MEM_ROOT *mem_root) throw ()
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
442
  { return (void*) alloc_root(mem_root, (uint) size); }
443
  static void operator delete(void *ptr,size_t size) { TRASH(ptr, size); }
444
  static void operator delete(void *ptr, MEM_ROOT *mem_root) {}
Tor Didriksen's avatar
Tor Didriksen committed
445 446 447 448 449 450 451 452 453

  // Ensures that at least all members used during cleanup() are initialized.
  st_select_lex_node()
    : next(NULL), prev(NULL),
      master(NULL), slave(NULL),
      link_next(NULL), link_prev(NULL),
      linkage(UNSPECIFIED_TYPE)
  {
  }
454
  virtual ~st_select_lex_node() {}
Tor Didriksen's avatar
Tor Didriksen committed
455

456 457 458
  inline st_select_lex_node* get_master() { return master; }
  virtual void init_query();
  virtual void init_select();
459 460
  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
461
  void include_standalone(st_select_lex_node *sel, st_select_lex_node **ref);
462 463
  void include_global(st_select_lex_node **plink);
  void exclude();
464 465 466

  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
467
  virtual st_select_lex* return_after_parsing()= 0;
468 469 470 471 472 473

  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();
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
474
  virtual ulong get_table_join_options();
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
475
  virtual TABLE_LIST *add_table_to_list(THD *thd, Table_ident *table,
476
					LEX_STRING *alias,
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
477
					ulong table_options,
478
					thr_lock_type flags= TL_UNLOCK,
479
					List<Index_hint> *hints= 0,
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
480
                                        LEX_STRING *option= 0);
481
  virtual void set_lock_for_tables(thr_lock_type lock_type) {}
482

483
  friend class st_select_lex_unit;
Konstantin Osipov's avatar
Konstantin Osipov committed
484
  friend bool mysql_new_select(LEX *lex, bool move_down);
485
  friend bool mysql_make_view(THD *thd, File_parser *parser,
486
                              TABLE_LIST *table, uint flags);
487 488 489
private:
  void fast_exclude();
};
490
typedef class st_select_lex_node SELECT_LEX_NODE;
491 492 493 494 495

/* 
   SELECT_LEX_UNIT - unit of selects (UNION, INTERSECT, ...) group 
   SELECT_LEXs
*/
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
496 497 498 499
class THD;
class select_result;
class JOIN;
class select_union;
500
class Procedure;
Tor Didriksen's avatar
Tor Didriksen committed
501 502


503
class st_select_lex_unit: public st_select_lex_node {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
504 505 506 507
protected:
  TABLE_LIST result_table_list;
  select_union *union_result;
  TABLE *table; /* temporary table using for appending UNION results */
508

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
509
  select_result *result;
510
  ulonglong found_rows_for_union;
511 512
  bool saved_error;

513
public:
Tor Didriksen's avatar
Tor Didriksen committed
514 515 516 517 518 519 520 521
  // Ensures that at least all members used during cleanup() are initialized.
  st_select_lex_unit()
    : union_result(NULL), table(NULL), result(NULL),
      cleaned(false),
      fake_select_lex(NULL)
  {
  }

Sinisa@sinisa.nasamreza.org's avatar
Sinisa@sinisa.nasamreza.org committed
522
  bool  prepared, // prepare phase already performed for UNION (unit)
523
    optimized, // optimize phase already performed for UNION (unit)
524 525
    executed, // already executed
    cleaned;
526 527 528

  // 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
529 530 531 532 533 534 535
  /*
    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
  */
536
  List<Item> types;
537 538 539 540
  /*
    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
541
  st_select_lex *global_parameters;
542
  //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
543
  st_select_lex *return_to;
544 545
  /* LIMIT clause runtime counters */
  ha_rows select_limit_cnt, offset_limit_cnt;
546
  /* not NULL if unit used in subselect, point to subselect item */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
547
  Item_subselect *item;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
548
  /* thread handler */
549
  THD *thd;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
550 551 552 553
  /*
    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
554
  st_select_lex *fake_select_lex;
555

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

560
  void init_query();
561 562
  st_select_lex_unit* master_unit();
  st_select_lex* outer_select();
563 564 565 566 567 568 569
  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);
570
  }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
571
  st_select_lex* return_after_parsing() { return return_to; }
572
  void exclude_level();
573
  void exclude_tree();
574

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
575
  /* UNION methods */
576
  bool prepare(THD *thd, select_result *result, ulong additional_options);
577 578
  bool exec();
  bool cleanup();
579
  inline void unclean() { cleaned= 0; }
580
  void reinit_exec_mechanism();
581

582
  void print(String *str, enum_query_type query_type);
583

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
584
  bool add_fake_select_lex(THD *thd);
585
  void init_prepare_fake_select_lex(THD *thd);
586
  inline bool is_prepared() { return prepared; }
587
  bool change_result(select_subselect *result, select_subselect *old_result);
588
  void set_limit(st_select_lex *values);
589
  void set_thd(THD *thd_arg) { thd= thd_arg; }
gkodinov/kgeorge@magare.gmz's avatar
gkodinov/kgeorge@magare.gmz committed
590
  inline bool is_union (); 
591

592
  friend void lex_start(THD *thd);
593
  friend int subselect_union_engine::exec();
594 595

  List<Item> *get_unit_column_types();
596
};
597

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
598
typedef class st_select_lex_unit SELECT_LEX_UNIT;
599 600

/*
601
  SELECT_LEX - store information of parsed SELECT statment
602
*/
603 604
class st_select_lex: public st_select_lex_node
{
605
public:
606
  Name_resolution_context context;
607
  char *db;
608
  Item *where, *having;                         /* WHERE & HAVING clauses */
609
  Item *prep_where; /* saved WHERE clause for prepared statement processing */
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
610
  Item *prep_having;/* saved HAVING clause for prepared statement processing */
611 612
  /* Saved values of the WHERE and HAVING clauses*/
  Item::cond_result cond_value, having_value;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
613
  /* point on lex in which it was created, used in view subquery detection */
Konstantin Osipov's avatar
Konstantin Osipov committed
614
  LEX *parent_lex;
615
  enum olap_type olap;
616 617 618 619
  /* 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 */
620
  List<String>        interval_list;
621
  bool	              is_item_list_lookup;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
622 623 624 625 626 627
  /* 
    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
628
  JOIN *join; /* after JOIN::prepare it is pointer to corresponding JOIN */
629
  List<TABLE_LIST> top_join_list; /* join list of the top level          */
630
  List<TABLE_LIST> *join_list;    /* list for the currently parsed join  */
631
  TABLE_LIST *embedding;          /* table embedding to the above list   */
632 633 634 635 636 637
  /*
    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;
638
  const char *type;               /* type of select for EXPLAIN          */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
639 640

  SQL_LIST order_list;                /* ORDER clause */
641
  SQL_LIST *gorder_list;
642
  Item *select_limit, *offset_limit;  /* LIMIT clause parameters */
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
643 644 645
  // 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
646 647 648 649 650 651
  /*
    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;
652
  uint cond_count;    /* number of arguments of and/or/xor in where/having/on */
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
653 654
  uint between_count; /* number of between predicates in where/having/on      */
  uint max_equal_elems; /* maximal number of elements in multiple equalities  */   
evgen@moonbone.local's avatar
evgen@moonbone.local committed
655 656 657 658 659
  /*
    Number of fields used in select list or where clause of current select
    and all inner subselects.
  */
  uint select_n_where_fields;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
660 661
  enum_parsing_place parsing_place; /* where we are parsing expression */
  bool with_sum_func;   /* sum function indicator */
662 663 664 665 666
  /* 
    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
667

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
668
  ulong table_join_options;
669
  uint in_sum_expr;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
670
  uint select_number; /* number of select (used for EXPLAIN) */
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
671 672
  int nest_level;     /* nesting level of select */
  Item_sum *inner_sum_func_list; /* list of sum func in nested selects */ 
673
  uint with_wild; /* item list contain '*' */
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
674 675 676
  bool  braces;   	/* SELECT ... UNION (SELECT ... ) <- this braces */
  /* TRUE when having fix field called in processing of this SELECT */
  bool having_fix_field;
677 678
  /* List of references to fields referenced from inner selects */
  List<Item_outer_ref> inner_refs_list;
679 680 681 682 683
  /* 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;

684 685
  /* explicit LIMIT clause was used */
  bool explicit_limit;
686 687 688 689 690
  /*
    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;
691 692
  /* TRUE <=> this SELECT is correlated w.r.t. some ancestor select */
  bool is_correlated;
693 694 695 696 697 698 699 700 701 702 703 704 705
  /*
    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;
706
  bool first_natural_join_processing;
707
  bool first_cond_optimization;
708 709
  /* do not wrap view fields with Item_ref */
  bool no_wrap_view_item;
710 711
  /* exclude this select from check of unique_table() */
  bool exclude_from_table_unique_test;
712 713 714 715
  /* 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;
716

717
  List<udf_func>     udf_list;                  /* udf function calls stack */
718 719 720 721 722 723 724 725 726

  /**
    Per sub-query locking strategy.
    Note: This variable might interfer with the corresponding statement-level
    variable Lex::lock_option because on how different parser rules depend
    on eachother.
  */
  thr_lock_type lock_option;

727 728 729 730 731 732 733 734 735 736 737 738 739 740
  /* 
    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;
741 742 743 744 745 746 747 748 749 750
  /*
    Bitmap used in the ONLY_FULL_GROUP_BY_MODE to prevent mixture of aggregate
    functions and non aggregated fields when GROUP BY list is absent.
    Bits:
      0 - non aggregated fields are used in this select,
          defined as NON_AGG_FIELD_USED.
      1 - aggregate functions are used in this select,
          defined as SUM_FUNC_USED.
  */
  uint8 full_group_by_flag;
751 752
  void init_query();
  void init_select();
753
  st_select_lex_unit* master_unit();
754 755 756 757
  st_select_lex_unit* first_inner_unit() 
  { 
    return (st_select_lex_unit*) slave; 
  }
758
  st_select_lex* outer_select();
759
  st_select_lex* next_select() { return (st_select_lex*) next; }
760
  st_select_lex* next_select_in_list() 
761 762 763 764 765 766 767
  {
    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
768
  st_select_lex* return_after_parsing()
769 770 771
  {
    return master_unit()->return_after_parsing();
  }
772

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

775 776 777
  bool set_braces(bool value);
  bool inc_in_sum_expr();
  uint get_in_sum_expr();
778

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
779 780
  bool add_item_to_list(THD *thd, Item *item);
  bool add_group_to_list(THD *thd, Item *item, bool asc);
781
  bool add_ftfunc_to_list(Item_func_match *func);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
782
  bool add_order_to_list(THD *thd, Item *item, bool asc);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
783
  TABLE_LIST* add_table_to_list(THD *thd, Table_ident *table,
784
				LEX_STRING *alias,
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
785
				ulong table_options,
786
				thr_lock_type flags= TL_UNLOCK,
787
				List<Index_hint> *hints= 0,
788
                                LEX_STRING *option= 0);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
789
  TABLE_LIST* get_table_list();
790 791 792 793 794
  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
795 796
  List<Item>* get_item_list();
  ulong get_table_join_options();
797
  void set_lock_for_tables(thr_lock_type lock_type);
798 799 800 801
  inline void init_order()
  {
    order_list.elements= 0;
    order_list.first= 0;
802
    order_list.next= (uchar**) &order_list.first;
803
  }
804 805 806 807 808 809 810
  /*
    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
811 812
  bool test_limit();

813
  friend void lex_start(THD *thd);
814
  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
815
  void make_empty_select()
816 817 818 819
  {
    init_query();
    init_select();
  }
bell@laptop.sanja.is.com.ua's avatar
bell@laptop.sanja.is.com.ua committed
820
  bool setup_ref_array(THD *thd, uint order_group_num);
821 822 823 824 825
  void print(THD *thd, String *str, enum_query_type query_type);
  static void print_order(String *str,
                          ORDER *order,
                          enum_query_type query_type);
  void print_limit(THD *thd, String *str, enum_query_type query_type);
826
  void fix_prepare_information(THD *thd, Item **conds, Item **having_conds);
827 828 829 830 831
  /*
    Destroy the used execution plan (JOIN) of this subtree (this
    SELECT_LEX and all nested SELECT_LEXes and SELECT_LEX_UNITs).
  */
  bool cleanup();
832 833 834 835 836
  /*
    Recursively cleanup the join of this select lex and of all nested
    select lexes.
  */
  void cleanup_all_joins(bool full);
837 838 839 840 841 842 843 844 845 846 847 848

  void set_index_hint_type(enum index_hint_type type, index_clause_map clause);

  /* 
   Add a index hint to the tagged list of hints. The type and clause of the
   hint will be the current ones (set by set_index_hint()) 
  */
  bool add_index_hint (THD *thd, char *str, uint length);

  /* make a list to hold index hints */
  void alloc_index_hints (THD *thd);
  /* read and clear the index hints */
849
  List<Index_hint>* pop_index_hints(void) 
850
  {
851
    List<Index_hint> *hints= index_hints;
852 853 854 855 856 857 858 859 860 861 862
    index_hints= NULL;
    return hints;
  }

  void clear_index_hints(void) { index_hints= NULL; }

private:  
  /* current index hint kind. used in filling up index_hints */
  enum index_hint_type current_index_hint_type;
  index_clause_map current_index_hint_clause;
  /* a list of USE/FORCE/IGNORE INDEX */
863
  List<Index_hint> *index_hints;
864
};
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
865
typedef class st_select_lex SELECT_LEX;
866

gkodinov/kgeorge@magare.gmz's avatar
gkodinov/kgeorge@magare.gmz committed
867 868 869 870 871 872
inline bool st_select_lex_unit::is_union ()
{ 
  return first_select()->next_select() && 
    first_select()->next_select()->linkage == UNION_TYPE;
}

873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890
#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)
891
#define ALTER_ADMIN_PARTITION    (1L << 18)
892 893 894
#define ALTER_TABLE_REORG        (1L << 19)
#define ALTER_REBUILD_PARTITION  (1L << 20)
#define ALTER_ALL_PARTITION      (1L << 21)
895 896
#define ALTER_REMOVE_PARTITIONING (1L << 22)
#define ALTER_FOREIGN_KEY        (1L << 23)
897

igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
898 899 900 901 902 903 904
enum enum_alter_table_change_level
{
  ALTER_TABLE_METADATA_ONLY= 0,
  ALTER_TABLE_DATA_CHANGED= 1,
  ALTER_TABLE_INDEX_CHANGED= 2
};

905 906 907 908 909 910 911 912
/**
  @brief Parsing data for CREATE or ALTER TABLE.

  This structure contains a list of columns or indexes to be created,
  altered or dropped.
*/

class Alter_info
913
{
914
public:
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
915 916 917
  List<Alter_drop>              drop_list;
  List<Alter_column>            alter_list;
  List<Key>                     key_list;
918
  List<Create_field>            create_list;
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
919 920 921 922
  uint                          flags;
  enum enum_enable_or_disable   keys_onoff;
  enum tablespace_op_type       tablespace_op;
  List<char>                    partition_names;
923
  uint                          num_parts;
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
924
  enum_alter_table_change_level change_level;
925
  Create_field                 *datetime_field;
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
926 927
  bool                          error_if_not_empty;

928

929 930 931 932
  Alter_info() :
    flags(0),
    keys_onoff(LEAVE_AS_IS),
    tablespace_op(NO_TABLESPACE_OP),
933
    num_parts(0),
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
934 935 936
    change_level(ALTER_TABLE_METADATA_ONLY),
    datetime_field(NULL),
    error_if_not_empty(FALSE)
937 938 939
  {}

  void reset()
940
  {
941 942 943 944 945
    drop_list.empty();
    alter_list.empty();
    key_list.empty();
    create_list.empty();
    flags= 0;
946 947
    keys_onoff= LEAVE_AS_IS;
    tablespace_op= NO_TABLESPACE_OP;
948
    num_parts= 0;
949
    partition_names.empty();
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
950 951 952
    change_level= ALTER_TABLE_METADATA_ONLY;
    datetime_field= 0;
    error_if_not_empty= FALSE;
953
  }
954 955 956 957 958
  Alter_info(const Alter_info &rhs, MEM_ROOT *mem_root);
private:
  Alter_info &operator=(const Alter_info &rhs); // not implemented
  Alter_info(const Alter_info &rhs);            // not implemented
};
959

960 961 962
struct st_sp_chistics
{
  LEX_STRING comment;
963
  enum enum_sp_suid_behaviour suid;
964
  bool detistic;
965
  enum enum_sp_data_access daccess;
966 967
};

968 969 970 971 972 973 974

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

975
extern sys_var *trg_new_row_fake_var;
976

977 978 979
enum xa_option_words {XA_NONE, XA_JOIN, XA_RESUME, XA_ONE_PHASE,
                      XA_SUSPEND, XA_FOR_MIGRATE};

980
extern const LEX_STRING null_lex_str;
981
extern const LEX_STRING empty_lex_str;
982

983 984 985 986 987 988 989 990

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

Konstantin Osipov's avatar
Konstantin Osipov committed
991
  Also used by LEX::reset_n_backup/restore_backup_query_tables_list()
992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008
  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;
1009 1010 1011 1012 1013
  /*
    Set of stored routines called by statement.
    (Note that we use lazy-initialization for this hash).
  */
  enum { START_SROUTINES_HASH_SIZE= 16 };
1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024
  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;
1025
  uchar    **sroutines_list_own_last;
1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042
  uint     sroutines_list_own_elements;

  /*
    These constructor and destructor serve for creation/destruction
    of Query_tables_list instances which are used as backup storage.
  */
  Query_tables_list() {}
  ~Query_tables_list() {}

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

1043 1044 1045 1046 1047
  /*
    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.
  */
1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
  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;
    }
  }
1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096

  /**
     Has the parser/scanner detected that this statement is unsafe?
   */
  inline bool is_stmt_unsafe() const {
    return binlog_stmt_flags & (1U << BINLOG_STMT_FLAG_UNSAFE);
  }

  /**
     Flag the current (top-level) statement as unsafe.

     The flag will be reset after the statement has finished.

   */
  inline void set_stmt_unsafe() {
    binlog_stmt_flags|= (1U << BINLOG_STMT_FLAG_UNSAFE);
  }

  inline void clear_stmt_unsafe() {
    binlog_stmt_flags&= ~(1U << BINLOG_STMT_FLAG_UNSAFE);
  }

1097 1098 1099 1100 1101 1102
  /**
    true if the parsed tree contains references to stored procedures
    or functions, false otherwise
  */
  bool uses_stored_routines() const
  { return sroutines_list.elements != 0; }
1103

1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116
private:
  enum enum_binlog_stmt_flag {
    BINLOG_STMT_FLAG_UNSAFE,
    BINLOG_STMT_FLAG_COUNT
  };

  /*
    Tells if the parsing stage detected properties of the statement,
    for example: 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.
  */
  uint32 binlog_stmt_flags;
1117 1118 1119
};


1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
/*
  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;

1132 1133
  st_parsing_options() { reset(); }
  void reset();
1134 1135 1136
};


1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160
/**
  The state of the lexical parser, when parsing comments.
*/
enum enum_comment_state
{
  /**
    Not parsing comments.
  */
  NO_COMMENT,
  /**
    Parsing comments that need to be preserved.
    Typically, these are user comments '/' '*' ... '*' '/'.
  */
  PRESERVE_COMMENT,
  /**
    Parsing comments that need to be discarded.
    Typically, these are special comments '/' '*' '!' ... '*' '/',
    or '/' '*' '!' 'M' 'M' 'm' 'm' 'm' ... '*' '/', where the comment
    markers should not be expanded.
  */
  DISCARD_COMMENT
};


1161
/**
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1162
  @brief This class represents the character input stream consumed during
1163
  lexical analysis.
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1164

1165 1166 1167 1168 1169 1170 1171 1172
  In addition to consuming the input stream, this class performs some
  comment pre processing, by filtering out out of bound special text
  from the query input stream.
  Two buffers, with pointers inside each buffers, are maintained in
  parallel. The 'raw' buffer is the original query text, which may
  contain out-of-bound comments. The 'cpp' (for comments pre processor)
  is the pre-processed buffer that contains only the query text that
  should be seen once out-of-bound data is removed.
1173
*/
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1174

1175 1176 1177 1178 1179 1180
class Lex_input_stream
{
public:
  Lex_input_stream(THD *thd, const char* buff, unsigned int length);
  ~Lex_input_stream();

1181 1182
  /**
    Set the echo mode.
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1183

1184 1185 1186 1187 1188 1189 1190 1191 1192
    When echo is true, characters parsed from the raw input stream are
    preserved. When false, characters parsed are silently ignored.
    @param echo the echo mode.
  */
  void set_echo(bool echo)
  {
    m_echo= echo;
  }

1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204
  void save_in_comment_state()
  {
    m_echo_saved= m_echo;
    in_comment_saved= in_comment;
  }

  void restore_in_comment_state()
  {
    m_echo= m_echo_saved;
    in_comment= in_comment_saved;
  }

1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222
  /**
    Skip binary from the input stream.
    @param n number of bytes to accept.
  */
  void skip_binary(int n)
  {
    if (m_echo)
    {
      memcpy(m_cpp_ptr, m_ptr, n);
      m_cpp_ptr += n;
    }
    m_ptr += n;
  }

  /**
    Get a character, and advance in the stream.
    @return the next character to parse.
  */
Davi Arnaut's avatar
Davi Arnaut committed
1223
  unsigned char yyGet()
1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234
  {
    char c= *m_ptr++;
    if (m_echo)
      *m_cpp_ptr++ = c;
    return c;
  }

  /**
    Get the last character accepted.
    @return the last character accepted.
  */
Davi Arnaut's avatar
Davi Arnaut committed
1235
  unsigned char yyGetLast()
1236 1237 1238 1239 1240 1241 1242
  {
    return m_ptr[-1];
  }

  /**
    Look at the next character to parse, but do not accept it.
  */
Davi Arnaut's avatar
Davi Arnaut committed
1243
  unsigned char yyPeek()
1244 1245 1246 1247 1248 1249 1250 1251
  {
    return m_ptr[0];
  }

  /**
    Look ahead at some character to parse.
    @param n offset of the character to look up
  */
Davi Arnaut's avatar
Davi Arnaut committed
1252
  unsigned char yyPeekn(int n)
1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313
  {
    return m_ptr[n];
  }

  /**
    Cancel the effect of the last yyGet() or yySkip().
    Note that the echo mode should not change between calls to yyGet / yySkip
    and yyUnget. The caller is responsible for ensuring that.
  */
  void yyUnget()
  {
    m_ptr--;
    if (m_echo)
      m_cpp_ptr--;
  }

  /**
    Accept a character, by advancing the input stream.
  */
  void yySkip()
  {
    if (m_echo)
      *m_cpp_ptr++ = *m_ptr++;
    else
      m_ptr++;
  }

  /**
    Accept multiple characters at once.
    @param n the number of characters to accept.
  */
  void yySkipn(int n)
  {
    if (m_echo)
    {
      memcpy(m_cpp_ptr, m_ptr, n);
      m_cpp_ptr += n;
    }
    m_ptr += n;
  }

  /**
    End of file indicator for the query text to parse.
    @return true if there are no more characters to parse
  */
  bool eof()
  {
    return (m_ptr >= m_end_of_query);
  }

  /**
    End of file indicator for the query text to parse.
    @param n number of characters expected
    @return true if there are less than n characters to parse
  */
  bool eof(int n)
  {
    return ((m_ptr + n) >= m_end_of_query);
  }

  /** Get the raw query buffer. */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1314
  const char *get_buf()
1315 1316 1317 1318 1319
  {
    return m_buf;
  }

  /** Get the pre-processed query buffer. */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1320
  const char *get_cpp_buf()
1321 1322 1323 1324 1325
  {
    return m_cpp_buf;
  }

  /** Get the end of the raw query buffer. */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1326
  const char *get_end_of_query()
1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353
  {
    return m_end_of_query;
  }

  /** Mark the stream position as the start of a new token. */
  void start_token()
  {
    m_tok_start_prev= m_tok_start;
    m_tok_start= m_ptr;
    m_tok_end= m_ptr;

    m_cpp_tok_start_prev= m_cpp_tok_start;
    m_cpp_tok_start= m_cpp_ptr;
    m_cpp_tok_end= m_cpp_ptr;
  }

  /**
    Adjust the starting position of the current token.
    This is used to compensate for starting whitespace.
  */
  void restart_token()
  {
    m_tok_start= m_ptr;
    m_cpp_tok_start= m_cpp_ptr;
  }

  /** Get the token start position, in the raw buffer. */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1354
  const char *get_tok_start()
1355 1356 1357 1358 1359
  {
    return m_tok_start;
  }

  /** Get the token start position, in the pre-processed buffer. */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1360
  const char *get_cpp_tok_start()
1361 1362 1363 1364 1365
  {
    return m_cpp_tok_start;
  }

  /** Get the token end position, in the raw buffer. */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1366
  const char *get_tok_end()
1367 1368 1369 1370 1371
  {
    return m_tok_end;
  }

  /** Get the token end position, in the pre-processed buffer. */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1372
  const char *get_cpp_tok_end()
1373 1374 1375 1376 1377
  {
    return m_cpp_tok_end;
  }

  /** Get the previous token start position, in the raw buffer. */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1378
  const char *get_tok_start_prev()
1379 1380 1381 1382 1383
  {
    return m_tok_start_prev;
  }

  /** Get the current stream pointer, in the raw buffer. */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1384
  const char *get_ptr()
1385 1386 1387 1388 1389
  {
    return m_ptr;
  }

  /** Get the current stream pointer, in the pre-processed buffer. */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1390
  const char *get_cpp_ptr()
1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405
  {
    return m_cpp_ptr;
  }

  /** Get the length of the current token, in the raw buffer. */
  uint yyLength()
  {
    /*
      The assumption is that the lexical analyser is always 1 character ahead,
      which the -1 account for.
    */
    DBUG_ASSERT(m_ptr > m_tok_start);
    return (uint) ((m_ptr - m_tok_start) - 1);
  }

1406 1407 1408 1409 1410 1411 1412 1413 1414
  /** Get the utf8-body string. */
  const char *get_body_utf8_str()
  {
    return m_body_utf8;
  }

  /** Get the utf8-body length. */
  uint get_body_utf8_length()
  {
1415
    return (uint) (m_body_utf8_ptr - m_body_utf8);
1416 1417 1418 1419 1420 1421 1422 1423 1424 1425
  }

  void body_utf8_start(THD *thd, const char *begin_ptr);
  void body_utf8_append(const char *ptr);
  void body_utf8_append(const char *ptr, const char *end_ptr);
  void body_utf8_append_literal(THD *thd,
                                const LEX_STRING *txt,
                                CHARSET_INFO *txt_cs,
                                const char *end_ptr);

1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437
  /** Current thread. */
  THD *m_thd;

  /** Current line number. */
  uint yylineno;

  /** Length of the last token parsed. */
  uint yytoklen;

  /** Interface with bison, value of the last token parsed. */
  LEX_YYSTYPE yylval;

1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448
  /**
    LALR(2) resolution, look ahead token.
    Value of the next token to return, if any,
    or -1, if no token was parsed in advance.
    Note: 0 is a legal token, and represents YYEOF.
  */
  int lookahead_token;

  /** LALR(2) resolution, value of the look ahead token.*/
  LEX_YYSTYPE lookahead_yylval;

1449 1450
private:
  /** Pointer to the current position in the raw input stream. */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1451
  const char *m_ptr;
1452 1453

  /** Starting position of the last token parsed, in the raw buffer. */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1454
  const char *m_tok_start;
1455

1456
  /** Ending position of the previous token parsed, in the raw buffer. */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1457
  const char *m_tok_end;
1458

1459
  /** End of the query text in the input stream, in the raw buffer. */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1460
  const char *m_end_of_query;
1461

1462
  /** Starting position of the previous token parsed, in the raw buffer. */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1463
  const char *m_tok_start_prev;
1464

1465
  /** Begining of the query text in the input stream, in the raw buffer. */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1466
  const char *m_buf;
1467

1468 1469 1470
  /** Length of the raw buffer. */
  uint m_buf_length;

1471 1472
  /** Echo the parsed stream to the pre-processed buffer. */
  bool m_echo;
1473
  bool m_echo_saved;
1474 1475

  /** Pre-processed buffer. */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1476
  char *m_cpp_buf;
1477 1478

  /** Pointer to the current position in the pre-processed input stream. */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1479
  char *m_cpp_ptr;
1480 1481 1482 1483 1484

  /**
    Starting position of the last token parsed,
    in the pre-processed buffer.
  */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1485
  const char *m_cpp_tok_start;
1486 1487 1488 1489 1490

  /**
    Starting position of the previous token parsed,
    in the pre-procedded buffer.
  */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1491
  const char *m_cpp_tok_start_prev;
1492 1493 1494 1495 1496

  /**
    Ending position of the previous token parsed,
    in the pre-processed buffer.
  */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1497
  const char *m_cpp_tok_end;
1498

1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510
  /** UTF8-body buffer created during parsing. */
  char *m_body_utf8;

  /** Pointer to the current position in the UTF8-body buffer. */
  char *m_body_utf8_ptr;

  /**
    Position in the pre-processed buffer. The query from m_cpp_buf to
    m_cpp_utf_processed_ptr is converted to UTF8-body.
  */
  const char *m_cpp_utf8_processed_ptr;

1511
public:
1512 1513 1514 1515

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

1516 1517 1518 1519
  /**
    Position of ';' in the stream, to delimit multiple queries.
    This delimiter is in the raw buffer.
  */
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1520
  const char *found_semicolon;
1521

1522 1523
  /** Token character bitmaps, to detect 7bit strings. */
  uchar tok_bitmap;
1524

1525 1526
  /** SQL_MODE = IGNORE_SPACE. */
  bool ignore_space;
1527 1528

  /**
1529
    TRUE if we're parsing a prepared statement: in this mode
1530
    we should allow placeholders.
1531 1532
  */
  bool stmt_prepare_mode;
1533 1534 1535 1536
  /**
    TRUE if we should allow multi-statements.
  */
  bool multi_statements;
1537 1538 1539

  /** State of the lexical analyser for comments. */
  enum_comment_state in_comment;
1540
  enum_comment_state in_comment_saved;
1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563

  /**
    Starting position of the TEXT_STRING or IDENT in the pre-processed
    buffer.

    NOTE: this member must be used within MYSQLlex() function only.
  */
  const char *m_cpp_text_start;

  /**
    Ending position of the TEXT_STRING or IDENT in the pre-processed
    buffer.

    NOTE: this member must be used within MYSQLlex() function only.
    */
  const char *m_cpp_text_end;

  /**
    Character set specified by the character-set-introducer.

    NOTE: this member must be used within MYSQLlex() function only.
  */
  CHARSET_INFO *m_underscore_cs;
1564 1565
};

Marc Alff's avatar
Marc Alff committed
1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594
/**
  Abstract representation of a statement.
  This class is an interface between the parser and the runtime.
  The parser builds the appropriate sub classes of Sql_statement
  to represent a SQL statement in the parsed tree.
  The execute() method in the sub classes contain the runtime implementation.
  Note that this interface is used for SQL statement recently implemented,
  the code for older statements tend to load the LEX structure with more
  attributes instead.
  The recommended way to implement new statements is to sub-class
  Sql_statement, as this improves code modularity (see the 'big switch' in
  dispatch_command()), and decrease the total size of the LEX structure
  (therefore saving memory in stored programs).
*/
class Sql_statement : public Sql_alloc
{
public:
  /**
    Execute this SQL statement.
    @param thd the current thread.
    @return 0 on success.
  */
  virtual bool execute(THD *thd) = 0;

protected:
  /**
    Constructor.
    @param lex the LEX structure that represents parts of this statement.
  */
Konstantin Osipov's avatar
Konstantin Osipov committed
1595
  Sql_statement(LEX *lex)
Marc Alff's avatar
Marc Alff committed
1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619
    : m_lex(lex)
  {}

  /** Destructor. */
  virtual ~Sql_statement()
  {
    /*
      Sql_statement objects are allocated in thd->mem_root.
      In MySQL, the C++ destructor is never called, the underlying MEM_ROOT is
      simply destroyed instead.
      Do not rely on the destructor for any cleanup.
    */
    DBUG_ASSERT(FALSE);
  }

protected:
  /**
    The legacy LEX structure for this statement.
    The LEX structure contains the existing properties of the parsed tree.
    TODO: with time, attributes from LEX should move to sub classes of
    Sql_statement, so that the parser only builds Sql_statement objects
    with the minimum set of attributes, instead of a LEX structure that
    contains the collection of every possible attribute.
  */
Konstantin Osipov's avatar
Konstantin Osipov committed
1620
  LEX *m_lex;
Marc Alff's avatar
Marc Alff committed
1621
};
1622

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

Konstantin Osipov's avatar
Konstantin Osipov committed
1625
struct LEX: public Query_tables_list
1626
{
1627
  SELECT_LEX_UNIT unit;                         /* most upper unit */
1628 1629
  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
1630
  SELECT_LEX *current_select;
1631 1632
  /* list of all SELECT_LEX */
  SELECT_LEX *all_selects_list;
1633

1634 1635
  char *length,*dec,*change;
  LEX_STRING name;
serg@serg.mylan's avatar
serg@serg.mylan committed
1636
  char *help_arg;
1637
  char *backup_dir;				/* For RESTORE/BACKUP */
1638
  char* to_log;                                 /* For PURGE MASTER LOGS TO */
1639
  char* x509_subject,*x509_issuer,*ssl_cipher;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1640 1641
  String *wild;
  sql_exchange *exchange;
1642
  select_result *result;
1643
  Item *default_value, *on_update_value;
1644
  LEX_STRING comment, ident;
serg@serg.mylan's avatar
serg@serg.mylan committed
1645
  LEX_USER *grant_user;
serg@serg.mylan's avatar
serg@serg.mylan committed
1646
  XID *xid;
serg@serg.mylan's avatar
serg@serg.mylan committed
1647
  THD *thd;
antony@ppcg5.local's avatar
antony@ppcg5.local committed
1648 1649 1650 1651

  /* maintain a list of used plugins for this LEX */
  DYNAMIC_ARRAY plugins;
  plugin_ref plugins_static_buffer[INITIAL_LEX_PLUGIN_LIST_SIZE];
1652

1653
  CHARSET_INFO *charset;
1654
  bool text_string_is_7bit;
1655 1656
  /* store original leaf_tables for INSERT SELECT and PS/SP */
  TABLE_LIST *leaf_tables_insert;
1657

1658 1659
  /** SELECT of CREATE VIEW statement */
  LEX_STRING create_view_select;
1660

kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1661
  /** Start of 'ON table', in trigger statements.  */
1662
  const char* raw_trg_on_table_name_begin;
kostja@bodhi.(none)'s avatar
kostja@bodhi.(none) committed
1663
  /** End of 'ON table', in trigger statements. */
1664 1665
  const char* raw_trg_on_table_name_end;

1666 1667
  /* 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
1668

1669 1670 1671 1672 1673 1674
  /*
    The definer of the object being created (view, trigger, stored routine).
    I.e. the value of DEFINER clause.
  */
  LEX_USER *definer;

1675 1676
  List<Key_part_spec> col_list;
  List<Key_part_spec> ref_list;
1677
  List<String>	      interval_list;
1678
  List<LEX_USER>      users_list;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1679
  List<LEX_COLUMN>    columns;
1680
  List<Item>	      *insert_list,field_list,value_list,update_list;
1681
  List<List_item>     many_values;
1682
  List<set_var_base>  var_list;
1683
  List<Item_func_set_user_var> set_var_list; // in-query assignment list
1684
  List<Item_param>    param_list;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1685
  List<LEX_STRING>    view_list; // view list (list of field names in view)
1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700
  /*
    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;

1701
  SQL_LIST	      proc_list, auxiliary_table_list, save_list;
1702
  Create_field	      *last_field;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1703
  Item_sum *in_sum_func;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1704
  udf_func udf;
1705 1706
  HA_CHECK_OPT   check_opt;			// check/repair options
  HA_CREATE_INFO create_info;
1707
  KEY_CREATE_INFO key_create_info;
sasha@mysql.sashanet.com's avatar
sasha@mysql.sashanet.com committed
1708
  LEX_MASTER_INFO mi;				// used by CHANGE MASTER
patg@radha.tangent.org's avatar
patg@radha.tangent.org committed
1709
  LEX_SERVER_OPTIONS server_options;
1710
  USER_RESOURCES mqh;
1711
  ulong type;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1712 1713 1714 1715 1716 1717 1718 1719 1720 1721
  /*
    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;
1722
  enum_sql_command sql_command;
Marc Alff's avatar
Marc Alff committed
1723 1724 1725

  Sql_statement *m_stmt;

1726 1727 1728 1729 1730 1731 1732 1733
  /*
    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;

1734
  thr_lock_type lock_option;
serg@serg.mylan's avatar
serg@serg.mylan committed
1735
  enum SSL_type ssl_type;			/* defined in violite.h */
1736
  enum enum_duplicates duplicates;
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
1737
  enum enum_tx_isolation tx_isolation;
1738
  enum enum_ha_read_modes ha_read_mode;
1739
  union {
serg@serg.mylan's avatar
serg@serg.mylan committed
1740
    enum ha_rkey_function ha_rkey_mode;
1741 1742
    enum xa_option_words xa_opt;
  };
1743
  enum enum_var_type option_type;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1744 1745
  enum enum_view_create_mode create_view_mode;
  enum enum_drop_mode drop_mode;
1746

1747
  uint profile_query_id;
1748
  uint profile_options;
serg@serg.mylan's avatar
serg@serg.mylan committed
1749
  uint uint_geom_type;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1750
  uint grant, grant_tot_col, which_columns;
1751
  uint fk_delete_opt, fk_update_opt, fk_match_option;
1752
  uint slave_thd_opt, start_transaction_opt;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1753
  int nest_level;
1754 1755 1756 1757 1758 1759
  /*
    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;
1760
  uint8 describe;
1761 1762 1763
  /*
    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
1764
    DERIVED_SUBQUERY and DERIVED_VIEW).
1765
  */
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1766 1767
  uint8 derived_tables;
  uint8 create_view_algorithm;
1768
  uint8 create_view_check;
1769
  bool drop_if_exists, drop_temporary, local_file, one_shot_set;
1770
  bool autocommit;
1771 1772
  bool verbose, no_write_to_binlog;

1773
  bool tx_chain, tx_release;
1774 1775 1776 1777 1778 1779 1780
  /*
    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
1781
  bool view_prepare_mode;
1782
  bool safe_to_cache_query;
1783
  bool subqueries, ignore;
1784
  st_parsing_options parsing_options;
1785
  Alter_info alter_info;
sergefp@mysql.com's avatar
sergefp@mysql.com committed
1786 1787
  /* Prepared statements SQL syntax:*/
  LEX_STRING prepared_stmt_name; /* Statement name (in all queries) */
serg@serg.mylan's avatar
serg@serg.mylan committed
1788
  /*
1789 1790 1791
    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
1792
  LEX_STRING prepared_stmt_code;
1793 1794
  /* 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
1795
  /* Names of user variables holding parameters (in EXECUTE) */
serg@serg.mylan's avatar
serg@serg.mylan committed
1796
  List<LEX_STRING> prepared_stmt_params;
1797
  sp_head *sphead;
1798
  sp_name *spname;
1799
  bool sp_lex_in_use;	/* Keep track on lex usage in SPs for error handling */
1800
  bool all_privileges;
1801
  sp_pcontext *spcont;
1802

1803
  st_sp_chistics sp_chistics;
1804

1805
  Event_parse_data *event_parse_data;
1806

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1807 1808 1809 1810 1811 1812
  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;
1813 1814 1815
  /*
    view created to be run from definer (standard behaviour)
  */
1816
  uint8 create_view_suid;
1817 1818 1819
  /* Characterstics of trigger being created */
  st_trg_chistics trg_chistics;
  /*
1820 1821 1822 1823 1824
    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).
1825
  */
1826
  SQL_LIST trg_table_fields;
1827

1828
  /*
1829 1830 1831 1832 1833 1834 1835
    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
1836
    DDL-statement before dumping it to the binlog.
1837
  */
1838
  const char *stmt_definition_begin;
1839

1840 1841
  const char *stmt_definition_end;

1842 1843 1844 1845 1846 1847 1848
  /**
    During name resolution search only in the table list given by 
    Name_resolution_context::first_name_resolution_table and
    Name_resolution_context::last_name_resolution_table
    (see Item_field::fix_fields()). 
  */
  bool use_only_table_context;
1849 1850 1851 1852 1853 1854

  /*
    Reference to a struct that contains information in various commands
    to add/create/drop/change table spaces.
  */
  st_alter_tablespace *alter_tablespace_info;
1855 1856
  
  bool escape_used;
1857
  bool is_lex_started; /* If lex_start() did run. For debugging. */
1858

1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874
  /*
    Special case for SELECT .. FOR UPDATE and LOCK TABLES .. WRITE.

    Protect from a impending GRL as otherwise the thread might deadlock
    if it starts waiting for the GRL in mysql_lock_tables.

    The protection is needed because there is a race between setting
    the global read lock and waiting for all open tables to be closed.
    The problem is a circular wait where a thread holding "old" open
    tables will wait for the global read lock to be released while the
    thread holding the global read lock will wait for all "old" open
    tables to be closed -- the flush part of flush tables with read
    lock.
  */
  bool protect_against_global_read_lock;

Konstantin Osipov's avatar
Konstantin Osipov committed
1875
  LEX();
1876

Konstantin Osipov's avatar
Konstantin Osipov committed
1877
  virtual ~LEX()
1878
  {
1879
    destroy_query_tables_list();
antony@ppcg5.local's avatar
antony@ppcg5.local committed
1880 1881
    plugin_unlock_list(NULL, (plugin_ref *)plugins.buffer, plugins.elements);
    delete_dynamic(&plugins);
1882
  }
1883

1884
  inline void uncacheable(uint8 cause)
1885 1886
  {
    safe_to_cache_query= 0;
1887 1888 1889 1890 1891 1892

    /*
      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
1893
    SELECT_LEX *sl;
1894 1895 1896 1897
    SELECT_LEX_UNIT *un;
    for (sl= current_select, un= sl->master_unit();
	 un != &unit;
	 sl= sl->outer_select(), un= sl->master_unit())
1898
    {
1899 1900
      sl->uncacheable|= cause;
      un->uncacheable|= cause;
1901
    }
1902
  }
1903 1904
  void set_trg_event_type_for_tables();

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1905 1906 1907 1908 1909 1910
  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();

  bool can_be_merged();
  bool can_use_merged();
1911
  bool can_not_use_merged();
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1912
  bool only_view_structure();
1913
  bool need_correct_ident();
1914
  uint8 get_effective_with_check(TABLE_LIST *view);
1915 1916
  /*
    Is this update command where 'WHITH CHECK OPTION' clause is important
1917

1918
    SYNOPSIS
Konstantin Osipov's avatar
Konstantin Osipov committed
1919
      LEX::which_check_option_applicable()
1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931

    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:
1932 1933
    case SQLCOM_REPLACE:
    case SQLCOM_REPLACE_SELECT:
1934 1935 1936 1937 1938 1939
    case SQLCOM_LOAD:
      return TRUE;
    default:
      return FALSE;
    }
  }
1940

1941
  void cleanup_after_one_table_open();
1942

1943
  bool push_context(Name_resolution_context *context)
1944
  {
1945
    return context_stack.push_front(context);
1946 1947 1948 1949 1950 1951 1952
  }

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

1953
  bool copy_db_to(char **p_db, size_t *p_db_length) const;
1954

1955 1956 1957 1958
  Name_resolution_context *current_context()
  {
    return context_stack.head();
  }
1959 1960 1961 1962
  /*
    Restore the LEX and THD in case of a parse error.
  */
  static void cleanup_lex_after_parse_error(THD *thd);
1963 1964 1965

  void reset_n_backup_query_tables_list(Query_tables_list *backup);
  void restore_backup_query_tables_list(Query_tables_list *backup);
1966 1967

  bool table_or_sp_used();
1968
  bool is_partition_management() const;
1969

1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990
  /**
    @brief check if the statement is a single-level join
    @return result of the check
      @retval TRUE  The statement doesn't contain subqueries, unions and 
                    stored procedure calls.
      @retval FALSE There are subqueries, UNIONs or stored procedure calls.
  */
  bool is_single_level_stmt() 
  { 
    /* 
      This check exploits the fact that the last added to all_select_list is
      on its top. So select_lex (as the first added) will be at the tail 
      of the list.
    */ 
    if (&select_lex == all_selects_list && !sroutines.records)
    {
      DBUG_ASSERT(!all_selects_list->next_select_in_list());
      return TRUE;
    }
    return FALSE;
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
1991
};
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1992

1993

Marc Alff's avatar
Marc Alff committed
1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023
/**
  Set_signal_information is a container used in the parsed tree to represent
  the collection of assignments to condition items in the SIGNAL and RESIGNAL
  statements.
*/
class Set_signal_information
{
public:
  /** Constructor. */
  Set_signal_information();

  /** Copy constructor. */
  Set_signal_information(const Set_signal_information& set);

  /** Destructor. */
  ~Set_signal_information()
  {}

  /** Clear all items. */
  void clear();

  /**
    For each contition item assignment, m_item[] contains the parsed tree
    that represents the expression assigned, if any.
    m_item[] is an array indexed by Diag_condition_item_name.
  */
  Item *m_item[LAST_DIAG_SET_PROPERTY+1];
};


2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041
/**
  The internal state of the syntax parser.
  This object is only available during parsing,
  and is private to the syntax parser implementation (sql_yacc.yy).
*/
class Yacc_state
{
public:
  Yacc_state()
    : yacc_yyss(NULL), yacc_yyvs(NULL)
  {}

  ~Yacc_state();

  /**
    Bison internal state stack, yyss, when dynamically allocated using
    my_yyoverflow().
  */
2042
  uchar *yacc_yyss;
2043 2044 2045 2046 2047

  /**
    Bison internal semantic value stack, yyvs, when dynamically allocated using
    my_yyoverflow().
  */
2048
  uchar *yacc_yyvs;
2049

Marc Alff's avatar
Marc Alff committed
2050 2051 2052 2053 2054 2055
  /**
    Fragments of parsed tree,
    used during the parsing of SIGNAL and RESIGNAL.
  */
  Set_signal_information m_set_signal_info;

2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081
  /*
    TODO: move more attributes from the LEX structure here.
  */
};

/**
  Internal state of the parser.
  The complete state consist of:
  - state data used during lexical parsing,
  - state data used during syntactic parsing.
*/
class Parser_state
{
public:
  Parser_state(THD *thd, const char* buff, unsigned int length)
    : m_lip(thd, buff, length), m_yacc()
  {}

  ~Parser_state()
  {}

  Lex_input_stream m_lip;
  Yacc_state m_yacc;
};


Konstantin Osipov's avatar
Konstantin Osipov committed
2082
struct st_lex_local: public LEX
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2083
{
2084
  static void *operator new(size_t size) throw()
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2085
  {
2086
    return sql_alloc(size);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2087
  }
2088
  static void *operator new(size_t size, MEM_ROOT *mem_root) throw()
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2089 2090 2091
  {
    return (void*) alloc_root(mem_root, (uint) size);
  }
2092 2093
  static void operator delete(void *ptr,size_t size)
  { TRASH(ptr, size); }
2094 2095
  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
2096
};
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2097

monty@mysql.com's avatar
monty@mysql.com committed
2098 2099
extern void lex_init(void);
extern void lex_free(void);
2100
extern void lex_start(THD *thd);
monty@mysql.com's avatar
monty@mysql.com committed
2101
extern void lex_end(LEX *lex);
2102
extern int MYSQLlex(void *arg, void *yythd);
2103 2104

extern void trim_whitespace(CHARSET_INFO *cs, LEX_STRING *str);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2105

2106 2107
extern bool is_lex_native_function(const LEX_STRING *name);

2108 2109 2110 2111
/**
  @} (End of group Semantic_Analysis)
*/

Marc Alff's avatar
Marc Alff committed
2112
void my_missing_function_error(const LEX_STRING &token, const char *name);
2113

2114
#endif /* MYSQL_SERVER */
2115
#endif /* SQL_LEX_INCLUDED */