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

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

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

unknown's avatar
unknown committed
13 14 15 16 17 18 19 20 21 22 23 24
   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;

25 26 27 28
/*
  The following hack is needed because mysql_yacc.cc does not define
  YYSTYPE before including this file
*/
unknown's avatar
unknown committed
29

unknown's avatar
unknown committed
30 31
#include "set_var.h"

unknown's avatar
unknown committed
32 33 34 35 36 37 38 39 40
#ifdef MYSQL_YACC
#define LEX_YYSTYPE void *
#else
#include "lex_symbol.h"
#include "sql_yacc.h"
#define LEX_YYSTYPE YYSTYPE *
#endif

enum enum_sql_command {
41 42 43 44 45
  SQLCOM_SELECT, SQLCOM_CREATE_TABLE, SQLCOM_CREATE_INDEX, SQLCOM_ALTER_TABLE,
  SQLCOM_UPDATE, SQLCOM_INSERT, SQLCOM_INSERT_SELECT,
  SQLCOM_DELETE, SQLCOM_TRUNCATE, SQLCOM_DROP_TABLE, SQLCOM_DROP_INDEX,

  SQLCOM_SHOW_DATABASES, SQLCOM_SHOW_TABLES, SQLCOM_SHOW_FIELDS,
unknown's avatar
unknown committed
46
  SQLCOM_SHOW_KEYS, SQLCOM_SHOW_VARIABLES, SQLCOM_SHOW_LOGS, SQLCOM_SHOW_STATUS,
unknown's avatar
unknown committed
47
  SQLCOM_SHOW_INNODB_STATUS,
48
  SQLCOM_SHOW_PROCESSLIST, SQLCOM_SHOW_MASTER_STAT, SQLCOM_SHOW_SLAVE_STAT,
49
  SQLCOM_SHOW_GRANTS, SQLCOM_SHOW_CREATE, SQLCOM_SHOW_CHARSETS,
unknown's avatar
unknown committed
50
  SQLCOM_SHOW_CREATE_DB,
51

unknown's avatar
unknown committed
52
  SQLCOM_LOAD,SQLCOM_SET_OPTION,SQLCOM_LOCK_TABLES,SQLCOM_UNLOCK_TABLES,
53 54
  SQLCOM_GRANT, 
  SQLCOM_CHANGE_DB, SQLCOM_CREATE_DB, SQLCOM_DROP_DB, SQLCOM_ALTER_DB,
55 56 57 58
  SQLCOM_REPAIR, SQLCOM_REPLACE, SQLCOM_REPLACE_SELECT, 
  SQLCOM_CREATE_FUNCTION, SQLCOM_DROP_FUNCTION,
  SQLCOM_REVOKE,SQLCOM_OPTIMIZE, SQLCOM_CHECK,
  SQLCOM_FLUSH, SQLCOM_KILL,  SQLCOM_ANALYZE,
unknown's avatar
unknown committed
59
  SQLCOM_ROLLBACK, SQLCOM_COMMIT, SQLCOM_SLAVE_START, SQLCOM_SLAVE_STOP,
60
  SQLCOM_BEGIN, SQLCOM_LOAD_MASTER_TABLE, SQLCOM_CHANGE_MASTER,
unknown's avatar
unknown committed
61
  SQLCOM_RENAME_TABLE, SQLCOM_BACKUP_TABLE, SQLCOM_RESTORE_TABLE,
62
  SQLCOM_RESET, SQLCOM_PURGE, SQLCOM_SHOW_BINLOGS,
63
  SQLCOM_SHOW_OPEN_TABLES, SQLCOM_LOAD_MASTER_DATA,
64
  SQLCOM_HA_OPEN, SQLCOM_HA_CLOSE, SQLCOM_HA_READ,
65
  SQLCOM_SHOW_SLAVE_HOSTS, SQLCOM_DELETE_MULTI, SQLCOM_MULTI_UPDATE,
unknown's avatar
unknown committed
66
  SQLCOM_SHOW_BINLOG_EVENTS, SQLCOM_SHOW_NEW_MASTER, SQLCOM_DO,
unknown's avatar
unknown committed
67 68
  SQLCOM_SHOW_WARNS, SQLCOM_EMPTY_QUERY, SQLCOM_SHOW_ERRORS,
  SQLCOM_SHOW_COLUMN_TYPES, SQLCOM_SHOW_TABLE_TYPES, SQLCOM_SHOW_PRIVILEGES,
unknown's avatar
unknown committed
69
  SQLCOM_END, SQLCOM_HELP
unknown's avatar
unknown committed
70 71
};

unknown's avatar
unknown committed
72 73 74 75 76 77 78 79
enum lex_states
{
  STATE_START, STATE_CHAR, STATE_IDENT, STATE_IDENT_SEP, STATE_IDENT_START,
  STATE_FOUND_IDENT, STATE_SIGNED_NUMBER, STATE_REAL, STATE_HEX_NUMBER,
  STATE_CMP_OP, STATE_LONG_CMP_OP, STATE_STRING, STATE_COMMENT, STATE_END,
  STATE_OPERATOR_OR_IDENT, STATE_NUMBER_IDENT, STATE_INT_OR_REAL,
  STATE_REAL_OR_POINT, STATE_BOOL, STATE_EOL, STATE_ESCAPE, STATE_LONG_COMMENT,
  STATE_END_LONG_COMMENT, STATE_COLON, STATE_SET_VAR, STATE_USER_END,
unknown's avatar
unknown committed
80 81
  STATE_HOSTNAME, STATE_SKIP, STATE_USER_VARIABLE_DELIMITER, STATE_SYSTEM_VAR,
  STATE_IDENT_OR_KEYWORD
unknown's avatar
unknown committed
82 83
};

unknown's avatar
unknown committed
84

unknown's avatar
unknown committed
85 86 87 88
typedef List<Item> List_item;

typedef struct st_lex_master_info
{
89
  char *host, *user, *password, *log_file_name;
unknown's avatar
unknown committed
90 91
  uint port, connect_retry;
  ulonglong pos;
unknown's avatar
unknown committed
92
  ulong server_id;
93
  char *relay_log_name;
94
  ulong relay_log_pos;
unknown's avatar
unknown committed
95 96
} LEX_MASTER_INFO;

97

98 99
enum sub_select_type
{
unknown's avatar
unknown committed
100 101
  UNSPECIFIED_TYPE,UNION_TYPE, INTERSECT_TYPE,
  EXCEPT_TYPE, GLOBAL_OPTIONS_TYPE, DERIVED_TABLE_TYPE, OLAP_TYPE
102 103 104 105
};

enum olap_type 
{
106
  UNSPECIFIED_OLAP_TYPE, CUBE_TYPE, ROLLUP_TYPE
107
};
108

unknown's avatar
unknown committed
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
/* 
  The state of the lex parsing for selects 
   
   All select describing structures linked with following pointers:
   - list of neighbors (next/prev) (prev of first element point to slave 
     pointer of upper structure)
     - one level units for unit (union) structure
     - member of one union(unit) for ordinary select_lex
   - pointer to master
     - outer select_lex for unit (union)
     - unit structure for ordinary select_lex
   - pointer to slave
     - first list element of select_lex belonged to this unit for unit
     - first unit in list of units that belong to this select_lex (as
       subselects or derived tables) for ordinary select_lex
   - list of all select_lex (for group operation like correcting list of opened
     tables)
   for example for following query:
127

unknown's avatar
unknown committed
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
   select *
     from table1
     where table1.field IN (select * from table1_1_1 union
                            select * from table1_1_2)
     union
   select *
     from table2
     where table2.field=(select (select f1 from table2_1_1_1_1
                                   where table2_1_1_1_1.f2=table2_1_1.f3)
                           from table2_1_1
                           where table2_1_1.f1=table2.f2)
     union
   select * from table3;

   we will have following structure:


     main unit
     select1 select2 select3
     |^^     |^
    s|||     ||master
    l|||     |+---------------------------------+
    a|||     +---------------------------------+|
    v|||master                         slave   ||
    e||+-------------------------+             ||
     V|            neighbor      |             V|
     unit 1.1<==================>unit1.2       unit2.1
     select1.1.1 select 1.1.2    select1.2.1   select2.1.1 select2.1.2
                                               |^
                                               ||
                                               V|
                                               unit2.1.1.1
                                               select2.1.1.1.1


   relation in main unit will be following:
                          
         main unit
         |^^^
         ||||
         |||+------------------------------+
         ||+--------------+                |
    slave||master         |                |
         V|      neighbor |       neighbor |
         select1<========>select2<========>select3

    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)
*/
189 190
class st_select_lex;
class st_select_lex_unit;
191 192
class st_select_lex_node {
protected:
unknown's avatar
unknown committed
193 194 195
  st_select_lex_node *next, **prev,   /* neighbor list */
    *master, *slave,                  /* vertical links */
    *link_next, **link_prev;          /* list of whole SELECT_LEX */
196 197
public:
  ulong options;
198
  enum sub_select_type linkage;
unknown's avatar
unknown committed
199
  SQL_LIST order_list;                /* ORDER clause */
200 201
  List<List_item>     expr_list;
  List<List_item>     when_list;      /* WHEN clause (expression) */
unknown's avatar
unknown committed
202
  ha_rows select_limit, offset_limit; /* LIMIT clause parameters */
203 204 205 206 207 208 209 210 211 212 213 214
  bool	create_refs;
  bool dependent;	/* dependent from outer select subselect */

  static void *operator new(size_t size)
  {
    return (void*) sql_calloc((uint) size);
  }
  static void operator delete(void *ptr,size_t size) {}
  virtual ~st_select_lex_node() {}
  inline st_select_lex_node* get_master() { return master; }
  virtual void init_query();
  virtual void init_select();
unknown's avatar
unknown committed
215 216 217 218
  void include_down(st_select_lex_node *upper);
  void include_neighbour(st_select_lex_node *before);
  void include_global(st_select_lex_node **plink);
  void exclude();
219

unknown's avatar
unknown committed
220
  virtual st_select_lex* select_lex();
221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241
  virtual bool add_item_to_list(Item *item);
  bool add_order_to_list(Item *item, bool asc);
  virtual bool add_group_to_list(Item *item, bool asc);
  virtual bool add_ftfunc_to_list(Item_func_match *func);

  virtual st_select_lex_unit* master_unit()= 0;
  virtual st_select_lex* outer_select()= 0;

  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();
  virtual TABLE_LIST *add_table_to_list(Table_ident *table,
					LEX_STRING *alias,
					bool updating,
					thr_lock_type flags= TL_UNLOCK,
					List<String> *use_index= 0,
					List<String> *ignore_index= 0);
unknown's avatar
unknown committed
242 243

  void mark_as_dependent(st_select_lex *last);
unknown's avatar
unknown committed
244 245 246
private:
  void fast_exclude();
};
247
typedef class st_select_lex_node SELECT_LEX_NODE;
unknown's avatar
unknown committed
248 249 250 251 252

/* 
   SELECT_LEX_UNIT - unit of selects (UNION, INTERSECT, ...) group 
   SELECT_LEXs
*/
253
struct st_lex;
unknown's avatar
unknown committed
254 255 256 257
class THD;
class select_result;
class JOIN;
class select_union;
258
class st_select_lex_unit: public st_select_lex_node {
unknown's avatar
unknown committed
259 260 261 262 263 264 265 266 267 268
protected:
  List<Item> item_list; 
  List<JOIN*> joins; /* list of *JOINs, to delete it in cleanup() */
  TABLE_LIST result_table_list;
  select_union *union_result;
  TABLE *table; /* temporary table using for appending UNION results */
  THD *thd;
  select_result *result;
  int res;
  bool describe, found_rows_for_union,
unknown's avatar
unknown committed
269 270 271
    prepared, // prepare phase already performed for UNION (unit)
    optimized, // optimize phase already performed for UNION (unit)
    executed; // already executed
272
public:
unknown's avatar
unknown committed
273 274 275 276 277 278 279
  /*
    Pointer to 'last' select or pointer to unit where stored
    global parameters for union
  */
  st_select_lex_node *global_parameters;
  /* LIMIT clause runtime counters */
  ha_rows select_limit_cnt, offset_limit_cnt;
unknown's avatar
unknown committed
280 281
  /* not NULL if union used in subselect, point to subselect item */
  Item_subselect *item;
unknown's avatar
unknown committed
282
  uint union_option;
unknown's avatar
unknown committed
283

unknown's avatar
unknown committed
284
  void init_query();
285
  bool create_total_list(THD *thd, st_lex *lex, TABLE_LIST **result);
286 287
  st_select_lex_unit* master_unit();
  st_select_lex* outer_select();
288 289
  st_select_lex* first_select() { return (st_select_lex*) slave; }
  st_select_lex_unit* next_unit() { return (st_select_lex_unit*) next; }
290

unknown's avatar
unknown committed
291 292 293 294 295
  /* UNION methods */
  int prepare(THD *thd, select_result *result);
  int exec();
  int cleanup();
  
296
  friend void mysql_init_query(THD *thd);
297 298 299
private:
  bool create_total_list_n_last_return(THD *thd, st_lex *lex,
				       TABLE_LIST ***result);
unknown's avatar
unknown committed
300
};
unknown's avatar
unknown committed
301
typedef class st_select_lex_unit SELECT_LEX_UNIT;
unknown's avatar
unknown committed
302 303 304 305

/*
  SELECT_LEX - store information of parsed SELECT_LEX statment
*/
306 307
class st_select_lex: public st_select_lex_node
{
308
public:
unknown's avatar
unknown committed
309 310
  char *db, *db1, *table1, *db2, *table2;      	/* For outer join using .. */
  Item *where, *having;                         /* WHERE & HAVING clauses */
311
  enum olap_type olap;
unknown's avatar
unknown committed
312 313 314
  SQL_LIST	      table_list, group_list;   /* FROM & GROUP BY clauses */
  List<Item>          item_list; /* list of fields & expressions */
  List<String>        interval_list, use_index, *use_index_ptr,
unknown's avatar
unknown committed
315
		      ignore_index, *ignore_index_ptr;
unknown's avatar
unknown committed
316 317 318 319 320 321
  /* 
    Usualy it is pointer to ftfunc_list_alloc, but in union used to create fake
    select_lex for calling mysql_select under results of union
  */
  List<Item_func_match> *ftfunc_list;
  List<Item_func_match> ftfunc_list_alloc;
unknown's avatar
unknown committed
322
  JOIN *join; /* after JOIN::prepare it is pointer to corresponding JOIN */
unknown's avatar
unknown committed
323
  const char *type; /* type of select for EXPLAIN */
324
  uint in_sum_expr;
unknown's avatar
unknown committed
325
  uint select_number; /* number of select (used for EXPLAIN) */
unknown's avatar
unknown committed
326 327 328
  bool  braces;   	/* SELECT ... UNION (SELECT ... ) <- this braces */
  /* TRUE when having fix field called in processing of this SELECT */
  bool having_fix_field;
unknown's avatar
unknown committed
329

unknown's avatar
unknown committed
330 331
  void init_query();
  void init_select();
332
  st_select_lex_unit* master_unit();
333 334 335 336
  st_select_lex_unit* first_inner_unit() 
  { 
    return (st_select_lex_unit*) slave; 
  }
337
  st_select_lex* outer_select();
338
  st_select_lex* next_select() { return (st_select_lex*) next; }
339
  st_select_lex* next_select_in_list() 
340 341 342 343 344 345 346 347
  {
    return (st_select_lex*) link_next;
  }
  st_select_lex_node** next_select_in_list_addr()
  {
    return &link_next;
  }

348 349 350
  bool set_braces(bool value);
  bool inc_in_sum_expr();
  uint get_in_sum_expr();
unknown's avatar
unknown committed
351 352

  st_select_lex* select_lex();
353 354 355 356 357 358 359 360 361 362 363 364 365 366
  bool add_item_to_list(Item *item);
  bool add_group_to_list(Item *item, bool asc);
  bool add_ftfunc_to_list(Item_func_match *func);

  TABLE_LIST* get_table_list();
  List<Item>* get_item_list();
  List<String>* get_use_index();
  List<String>* get_ignore_index();
  TABLE_LIST* add_table_to_list(Table_ident *table,
				LEX_STRING *alias,
				bool updating,
				thr_lock_type flags= TL_UNLOCK,
				List<String> *use_index= 0,
				List<String> *ignore_index= 0);
367 368 369 370 371 372
  inline void init_order()
  {
    order_list.elements= 0;
    order_list.first= 0;
    order_list.next= (byte**) &order_list.first;
  }
373
  
374
  friend void mysql_init_query(THD *thd);
unknown's avatar
unknown committed
375
};
unknown's avatar
unknown committed
376
typedef class st_select_lex SELECT_LEX;
377 378


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

381 382
typedef struct st_lex
{
unknown's avatar
unknown committed
383 384
  uint	 yylineno,yytoklen;			/* Simulate lex */
  LEX_YYSTYPE yylval;
unknown's avatar
unknown committed
385
  SELECT_LEX_UNIT unit;                         /* most upper unit */
386 387 388
  SELECT_LEX select_lex;                        /* first SELECT_LEX */
  /* current SELECT_LEX in parsing */
  SELECT_LEX_NODE *current_select;
unknown's avatar
unknown committed
389 390
  uchar *ptr,*tok_start,*tok_end,*end_of_query;
  char *length,*dec,*change,*name;
391
  char *backup_dir;				/* For RESTORE/BACKUP */
unknown's avatar
unknown committed
392
  char* to_log;                                 /* For PURGE MASTER LOGS TO */
393
  char* x509_subject,*x509_issuer,*ssl_cipher;
394
  enum SSL_type ssl_type;			/* defined in violite.h */
unknown's avatar
unknown committed
395 396
  String *wild;
  sql_exchange *exchange;
397
  select_result *result;
unknown's avatar
unknown committed
398 399

  List<key_part_spec> col_list;
400
  List<key_part_spec> ref_list;
unknown's avatar
unknown committed
401 402
  List<Alter_drop>    drop_list;
  List<Alter_column>  alter_list;
403
  List<String>	      interval_list;
unknown's avatar
unknown committed
404
  List<LEX_USER>      users_list;
unknown's avatar
unknown committed
405 406 407
  List<LEX_COLUMN>    columns;
  List<Key>	      key_list;
  List<create_field>  create_list;
408 409
  List<Item>	      *insert_list,field_list,value_list;
  List<List_item>     many_values;
unknown's avatar
unknown committed
410
  List<set_var_base>  var_list;
unknown's avatar
unknown committed
411
  List<Item>          param_list;
412
  SQL_LIST	      proc_list, auxilliary_table_list;
unknown's avatar
unknown committed
413 414
  TYPELIB	      *interval;
  create_field	      *last_field;
415
  Item *default_value, *comment;
unknown's avatar
unknown committed
416
  CONVERT *convert_set;
unknown's avatar
unknown committed
417
  CONVERT *thd_convert_set;			// Set with SET CHAR SET
418
  LEX_USER *grant_user;
unknown's avatar
unknown committed
419
  gptr yacc_yyss,yacc_yyvs;
unknown's avatar
unknown committed
420
  THD *thd;
unknown's avatar
unknown committed
421
  udf_func udf;
422 423
  HA_CHECK_OPT   check_opt;			// check/repair options
  HA_CREATE_INFO create_info;
unknown's avatar
unknown committed
424
  LEX_MASTER_INFO mi;				// used by CHANGE MASTER
425
  USER_RESOURCES mqh;
426 427
  ulong thread_id,type;
  enum_sql_command sql_command;
428
  thr_lock_type lock_option;
429 430
  enum lex_states next_state;
  enum enum_duplicates duplicates;
unknown's avatar
unknown committed
431
  enum enum_tx_isolation tx_isolation;
432 433
  enum enum_ha_read_modes ha_read_mode;
  enum ha_rkey_function ha_rkey_mode;
434
  enum enum_enable_or_disable alter_keys_onoff;
unknown's avatar
unknown committed
435
  enum enum_var_type option_type;
unknown's avatar
unknown committed
436
  uint grant, grant_tot_col, which_columns;
437
  uint fk_delete_opt, fk_update_opt, fk_match_option;
438
  uint param_count;
unknown's avatar
unknown committed
439 440
  bool drop_primary, drop_if_exists, local_file, olap;
  bool in_comment, ignore_space, verbose, simple_alter;
unknown's avatar
unknown committed
441
  bool derived_tables, describe;
442
  uint slave_thd_opt;
443
  CHARSET_INFO *charset;
unknown's avatar
unknown committed
444
  char *help_arg;
unknown's avatar
unknown committed
445 446 447 448 449 450 451 452 453 454 455 456 457
} LEX;


void lex_init(void);
void lex_free(void);
LEX *lex_start(THD *thd, uchar *buf,uint length);
void lex_end(LEX *lex);

extern pthread_key(LEX*,THR_LEX);

extern LEX_STRING tmp_table_alias;

#define current_lex (&current_thd->lex)