← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to sql/sql_lex.h

Renamed more stuff to drizzle.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sql/sql_lex.h
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; version 2 of the License.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
 
 */
19
 
 
20
 
#ifndef DRIZZLED_SQL_LEX_H
21
 
#define DRIZZLED_SQL_LEX_H
 
1
/* Copyright (C) 2000-2006 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
22
15
 
23
16
/**
24
17
  @defgroup Semantic_Analysis Semantic Analysis
25
18
*/
26
 
#include <drizzled/message/table.pb.h>
27
 
 
28
 
#include "drizzled/plugin/function.h"
29
 
#include "drizzled/name_resolution_context.h"
30
 
#include "drizzled/item/subselect.h"
31
 
#include "drizzled/table_list.h"
32
 
#include "drizzled/function/math/real.h"
33
 
#include "drizzled/alter_drop.h"
34
 
#include "drizzled/alter_column.h"
35
 
#include "drizzled/alter_info.h"
36
 
#include "drizzled/key_part_spec.h"
37
 
#include "drizzled/index_hint.h"
38
 
#include "drizzled/statement.h"
39
 
#include "drizzled/optimizer/explain_plan.h"
40
 
 
41
 
#include <bitset>
42
 
#include <string>
43
 
 
44
 
namespace drizzled
45
 
{
46
 
 
47
 
class select_result_interceptor;
48
19
 
49
20
/* YACC and LEX Definitions */
50
21
 
51
22
/* These may not be declared yet */
52
23
class Table_ident;
53
 
class file_exchange;
54
 
class Lex_Column;
55
 
class Item_outer_ref;
56
 
 
57
 
} /* namespace drizzled */
58
 
 
 
24
class sql_exchange;
 
25
class LEX_COLUMN;
 
26
 
 
27
#ifdef MYSQL_SERVER
59
28
/*
60
29
  The following hack is needed because mysql_yacc.cc does not define
61
30
  YYSTYPE before including this file
62
31
*/
63
32
 
64
 
#ifdef DRIZZLE_SERVER
65
 
# include <drizzled/set_var.h>
66
 
# include <drizzled/item/func.h>
67
 
# ifdef DRIZZLE_YACC
68
 
#  define LEX_YYSTYPE void *
69
 
# else
70
 
#  if defined(DRIZZLE_LEX)
71
 
#   include <drizzled/foreign_key.h>
72
 
#   include <drizzled/lex_symbol.h>
73
 
#   include <drizzled/sql_yacc.h>
74
 
#   define LEX_YYSTYPE YYSTYPE *
75
 
#  else
76
 
#   define LEX_YYSTYPE void *
77
 
#  endif /* defined(DRIZZLE_LEX) */
78
 
# endif /* DRIZZLE_YACC */
79
 
#endif /* DRIZZLE_SERVER */
 
33
#include "set_var.h"
 
34
 
 
35
#ifdef MYSQL_YACC
 
36
#define LEX_YYSTYPE void *
 
37
#else
 
38
#if defined(MYSQL_LEX)
 
39
#include "lex_symbol.h"
 
40
#include "sql_yacc.h"
 
41
#define LEX_YYSTYPE YYSTYPE *
 
42
#else
 
43
#define LEX_YYSTYPE void *
 
44
#endif
 
45
#endif
 
46
#endif
 
47
 
 
48
/*
 
49
  When a command is added here, be sure it's also added in mysqld.cc
 
50
  in "struct show_var_st status_vars[]= {" ...
 
51
 
 
52
  If the command returns a result set or is not allowed in stored
 
53
  functions or triggers, please also make sure that
 
54
  sp_get_flags_for_command (sp_head.cc) returns proper flags for the
 
55
  added SQLCOM_.
 
56
*/
 
57
 
 
58
enum enum_sql_command {
 
59
  SQLCOM_SELECT, SQLCOM_CREATE_TABLE, SQLCOM_CREATE_INDEX, SQLCOM_ALTER_TABLE,
 
60
  SQLCOM_UPDATE, SQLCOM_INSERT, SQLCOM_INSERT_SELECT,
 
61
  SQLCOM_DELETE, SQLCOM_TRUNCATE, SQLCOM_DROP_TABLE, SQLCOM_DROP_INDEX,
 
62
  SQLCOM_SHOW_DATABASES, SQLCOM_SHOW_TABLES, SQLCOM_SHOW_FIELDS,
 
63
  SQLCOM_SHOW_KEYS, SQLCOM_SHOW_VARIABLES, SQLCOM_SHOW_STATUS,
 
64
  SQLCOM_SHOW_ENGINE_LOGS, SQLCOM_SHOW_ENGINE_STATUS, SQLCOM_SHOW_ENGINE_MUTEX,
 
65
  SQLCOM_SHOW_PROCESSLIST, SQLCOM_SHOW_MASTER_STAT, SQLCOM_SHOW_SLAVE_STAT,
 
66
  SQLCOM_SHOW_CREATE, SQLCOM_SHOW_CHARSETS,
 
67
  SQLCOM_SHOW_COLLATIONS, SQLCOM_SHOW_CREATE_DB, SQLCOM_SHOW_TABLE_STATUS,
 
68
  SQLCOM_LOAD,SQLCOM_SET_OPTION,SQLCOM_LOCK_TABLES,SQLCOM_UNLOCK_TABLES,
 
69
  SQLCOM_CHANGE_DB, SQLCOM_CREATE_DB, SQLCOM_DROP_DB, SQLCOM_ALTER_DB,
 
70
  SQLCOM_REPAIR, SQLCOM_REPLACE, SQLCOM_REPLACE_SELECT,
 
71
  SQLCOM_OPTIMIZE, SQLCOM_CHECK,
 
72
  SQLCOM_ASSIGN_TO_KEYCACHE,
 
73
  SQLCOM_FLUSH, SQLCOM_KILL, SQLCOM_ANALYZE,
 
74
  SQLCOM_ROLLBACK, SQLCOM_ROLLBACK_TO_SAVEPOINT,
 
75
  SQLCOM_COMMIT, SQLCOM_SAVEPOINT, SQLCOM_RELEASE_SAVEPOINT,
 
76
  SQLCOM_SLAVE_START, SQLCOM_SLAVE_STOP,
 
77
  SQLCOM_BEGIN, SQLCOM_CHANGE_MASTER,
 
78
  SQLCOM_RENAME_TABLE,  
 
79
  SQLCOM_RESET, SQLCOM_PURGE, SQLCOM_PURGE_BEFORE, SQLCOM_SHOW_BINLOGS,
 
80
  SQLCOM_SHOW_OPEN_TABLES,
 
81
  SQLCOM_SHOW_SLAVE_HOSTS, SQLCOM_DELETE_MULTI, SQLCOM_UPDATE_MULTI,
 
82
  SQLCOM_SHOW_BINLOG_EVENTS,
 
83
  SQLCOM_SHOW_WARNS, SQLCOM_EMPTY_QUERY, SQLCOM_SHOW_ERRORS,
 
84
  SQLCOM_CHECKSUM,
 
85
  SQLCOM_BINLOG_BASE64_EVENT,
 
86
  SQLCOM_SHOW_PLUGINS,
 
87
  SQLCOM_ALTER_DB_UPGRADE,
 
88
  /*
 
89
    When a command is added here, be sure it's also added in mysqld.cc
 
90
    in "struct show_var_st status_vars[]= {" ...
 
91
  */
 
92
  /* This should be the last !!! */
 
93
  SQLCOM_END
 
94
};
80
95
 
81
96
// describe/explain types
82
97
#define DESCRIBE_NORMAL         1
83
98
#define DESCRIBE_EXTENDED       2
84
99
 
85
 
#ifdef DRIZZLE_SERVER
 
100
#ifdef MYSQL_SERVER
 
101
 
 
102
enum enum_sp_data_access
 
103
{
 
104
  SP_DEFAULT_ACCESS= 0,
 
105
  SP_CONTAINS_SQL,
 
106
  SP_NO_SQL,
 
107
  SP_READS_SQL_DATA,
 
108
  SP_MODIFIES_SQL_DATA
 
109
};
 
110
 
 
111
const LEX_STRING sp_data_access_name[]=
 
112
{
 
113
  { C_STRING_WITH_LEN("") },
 
114
  { C_STRING_WITH_LEN("CONTAINS SQL") },
 
115
  { C_STRING_WITH_LEN("NO SQL") },
 
116
  { C_STRING_WITH_LEN("READS SQL DATA") },
 
117
  { C_STRING_WITH_LEN("MODIFIES SQL DATA") }
 
118
};
86
119
 
87
120
#define DERIVED_NONE    0
88
121
#define DERIVED_SUBQUERY        1
89
122
 
90
 
namespace drizzled
 
123
enum enum_drop_mode
91
124
{
 
125
  DROP_DEFAULT, // mode is not specified
 
126
  DROP_CASCADE, // CASCADE option
 
127
  DROP_RESTRICT // RESTRICT option
 
128
};
92
129
 
93
130
typedef List<Item> List_item;
94
131
 
 
132
/* SERVERS CACHE CHANGES */
 
133
typedef struct st_lex_server_options
 
134
{
 
135
  long port;
 
136
  uint server_name_length;
 
137
  char *server_name, *host, *db, *username, *password, *scheme, *socket, *owner;
 
138
} LEX_SERVER_OPTIONS;
 
139
 
 
140
typedef struct st_lex_master_info
 
141
{
 
142
  char *host, *user, *password, *log_file_name;
 
143
  uint port, connect_retry;
 
144
  float heartbeat_period;
 
145
  ulonglong pos;
 
146
  ulong server_id;
 
147
  /*
 
148
    Enum is used for making it possible to detect if the user
 
149
    changed variable or if it should be left at old value
 
150
   */
 
151
  enum {LEX_MI_UNCHANGED, LEX_MI_DISABLE, LEX_MI_ENABLE}
 
152
    ssl, ssl_verify_server_cert, heartbeat_opt;
 
153
  char *ssl_key, *ssl_cert, *ssl_ca, *ssl_capath, *ssl_cipher;
 
154
  char *relay_log_name;
 
155
  ulong relay_log_pos;
 
156
} LEX_MASTER_INFO;
 
157
 
 
158
 
95
159
enum sub_select_type
96
160
{
97
 
  UNSPECIFIED_TYPE,
98
 
  UNION_TYPE,
99
 
  INTERSECT_TYPE,
100
 
  EXCEPT_TYPE,
101
 
  GLOBAL_OPTIONS_TYPE,
102
 
  DERIVED_TABLE_TYPE,
103
 
  OLAP_TYPE
104
 
};
105
 
 
106
 
enum olap_type
107
 
{
108
 
  UNSPECIFIED_OLAP_TYPE,
109
 
  CUBE_TYPE,
110
 
  ROLLUP_TYPE
111
 
};
 
161
  UNSPECIFIED_TYPE,UNION_TYPE, INTERSECT_TYPE,
 
162
  EXCEPT_TYPE, GLOBAL_OPTIONS_TYPE, DERIVED_TABLE_TYPE, OLAP_TYPE
 
163
};
 
164
 
 
165
enum olap_type 
 
166
{
 
167
  UNSPECIFIED_OLAP_TYPE, CUBE_TYPE, ROLLUP_TYPE
 
168
};
 
169
 
 
170
enum tablespace_op_type
 
171
{
 
172
  NO_TABLESPACE_OP, DISCARD_TABLESPACE, IMPORT_TABLESPACE
 
173
};
 
174
 
 
175
/* 
 
176
  String names used to print a statement with index hints.
 
177
  Keep in sync with index_hint_type.
 
178
*/
 
179
extern const char * index_hint_type_name[];
 
180
typedef uchar index_clause_map;
112
181
 
113
182
/*
114
 
  The state of the lex parsing for selects
115
 
 
 
183
  Bits in index_clause_map : one for each possible FOR clause in
 
184
  USE/FORCE/IGNORE INDEX index hint specification
 
185
*/
 
186
#define INDEX_HINT_MASK_JOIN  (1)
 
187
#define INDEX_HINT_MASK_GROUP (1 << 1)
 
188
#define INDEX_HINT_MASK_ORDER (1 << 2)
 
189
 
 
190
#define INDEX_HINT_MASK_ALL (INDEX_HINT_MASK_JOIN | INDEX_HINT_MASK_GROUP | \
 
191
                             INDEX_HINT_MASK_ORDER)
 
192
 
 
193
/* Single element of an USE/FORCE/IGNORE INDEX list specified as a SQL hint  */
 
194
class Index_hint : public Sql_alloc
 
195
{
 
196
public:
 
197
  /* The type of the hint : USE/FORCE/IGNORE */
 
198
  enum index_hint_type type;
 
199
  /* Where the hit applies to. A bitmask of INDEX_HINT_MASK_<place> values */
 
200
  index_clause_map clause;
 
201
  /* 
 
202
    The index name. Empty (str=NULL) name represents an empty list 
 
203
    USE INDEX () clause 
 
204
  */ 
 
205
  LEX_STRING key_name;
 
206
 
 
207
  Index_hint (enum index_hint_type type_arg, index_clause_map clause_arg,
 
208
              char *str, uint length) :
 
209
    type(type_arg), clause(clause_arg)
 
210
  {
 
211
    key_name.str= str;
 
212
    key_name.length= length;
 
213
  }
 
214
 
 
215
  void print(THD *thd, String *str);
 
216
}; 
 
217
 
 
218
/* 
 
219
  The state of the lex parsing for selects 
 
220
   
116
221
   master and slaves are pointers to select_lex.
117
222
   master is pointer to upper level node.
118
223
   slave is pointer to lower level node
224
329
 
225
330
*/
226
331
 
227
 
/*
228
 
    Base class for Select_Lex (Select_Lex) &
229
 
    Select_Lex_Unit (Select_Lex_Unit)
 
332
/* 
 
333
    Base class for st_select_lex (SELECT_LEX) & 
 
334
    st_select_lex_unit (SELECT_LEX_UNIT)
230
335
*/
231
 
class LEX;
232
 
class Select_Lex;
233
 
class Select_Lex_Unit;
234
 
class Select_Lex_Node {
 
336
struct st_lex;
 
337
class st_select_lex;
 
338
class st_select_lex_unit;
 
339
class st_select_lex_node {
235
340
protected:
236
 
  Select_Lex_Node *next, **prev,   /* neighbor list */
 
341
  st_select_lex_node *next, **prev,   /* neighbor list */
237
342
    *master, *slave,                  /* vertical links */
238
 
    *link_next, **link_prev;          /* list of whole Select_Lex */
 
343
    *link_next, **link_prev;          /* list of whole SELECT_LEX */
239
344
public:
240
345
 
241
 
  uint64_t options;
 
346
  ulonglong options;
242
347
 
243
348
  /*
244
349
    result of this query can't be cached, bit field, can be :
248
353
      UNCACHEABLE_EXPLAIN
249
354
      UNCACHEABLE_PREPARE
250
355
  */
251
 
  uint8_t uncacheable;
 
356
  uint8 uncacheable;
252
357
  enum sub_select_type linkage;
253
358
  bool no_table_names_allowed; /* used for global order by */
254
359
  bool no_error; /* suppress error message (convert it to warnings) */
255
360
 
256
361
  static void *operator new(size_t size)
257
362
  {
258
 
    return memory::sql_alloc(size);
 
363
    return sql_alloc(size);
259
364
  }
260
 
  static void *operator new(size_t size, memory::Root *mem_root)
261
 
  { return (void*) mem_root->alloc_root((uint32_t) size); }
262
 
  static void operator delete(void *, size_t)
263
 
  {  }
264
 
  static void operator delete(void *, memory::Root *)
 
365
  static void *operator new(size_t size, MEM_ROOT *mem_root)
 
366
  { return (void*) alloc_root(mem_root, (uint) size); }
 
367
  static void operator delete(void *ptr __attribute__((__unused__)),
 
368
                              size_t size __attribute__((__unused__)))
 
369
  { TRASH(ptr, size); }
 
370
  static void operator delete(void *ptr __attribute__((__unused__)),
 
371
                              MEM_ROOT *mem_root __attribute__((__unused__)))
265
372
  {}
266
 
  Select_Lex_Node(): linkage(UNSPECIFIED_TYPE) {}
267
 
  virtual ~Select_Lex_Node() {}
268
 
  inline Select_Lex_Node* get_master() { return master; }
 
373
  st_select_lex_node(): linkage(UNSPECIFIED_TYPE) {}
 
374
  virtual ~st_select_lex_node() {}
 
375
  inline st_select_lex_node* get_master() { return master; }
269
376
  virtual void init_query();
270
377
  virtual void init_select();
271
 
  void include_down(Select_Lex_Node *upper);
272
 
  void include_neighbour(Select_Lex_Node *before);
273
 
  void include_standalone(Select_Lex_Node *sel, Select_Lex_Node **ref);
274
 
  void include_global(Select_Lex_Node **plink);
 
378
  void include_down(st_select_lex_node *upper);
 
379
  void include_neighbour(st_select_lex_node *before);
 
380
  void include_standalone(st_select_lex_node *sel, st_select_lex_node **ref);
 
381
  void include_global(st_select_lex_node **plink);
275
382
  void exclude();
276
383
 
277
 
  virtual Select_Lex_Unit* master_unit()= 0;
278
 
  virtual Select_Lex* outer_select()= 0;
279
 
  virtual Select_Lex* return_after_parsing()= 0;
 
384
  virtual st_select_lex_unit* master_unit()= 0;
 
385
  virtual st_select_lex* outer_select()= 0;
 
386
  virtual st_select_lex* return_after_parsing()= 0;
280
387
 
281
388
  virtual bool set_braces(bool value);
282
389
  virtual bool inc_in_sum_expr();
283
 
  virtual uint32_t get_in_sum_expr();
284
 
  virtual TableList* get_table_list();
 
390
  virtual uint get_in_sum_expr();
 
391
  virtual TABLE_LIST* get_table_list();
285
392
  virtual List<Item>* get_item_list();
286
 
  virtual uint32_t get_table_join_options();
287
 
  virtual TableList *add_table_to_list(Session *session, Table_ident *table,
 
393
  virtual ulong get_table_join_options();
 
394
  virtual TABLE_LIST *add_table_to_list(THD *thd, Table_ident *table,
288
395
                                        LEX_STRING *alias,
289
 
                                        uint32_t table_options,
 
396
                                        ulong table_options,
290
397
                                        thr_lock_type flags= TL_UNLOCK,
291
398
                                        List<Index_hint> *hints= 0,
292
399
                                        LEX_STRING *option= 0);
293
 
  virtual void set_lock_for_tables(thr_lock_type)
 
400
  virtual void set_lock_for_tables(thr_lock_type lock_type __attribute__((__unused__)))
294
401
  {}
295
402
 
296
 
  friend class Select_Lex_Unit;
297
 
  friend bool mysql_new_select(LEX *lex, bool move_down);
 
403
  friend class st_select_lex_unit;
 
404
  friend bool mysql_new_select(struct st_lex *lex, bool move_down);
298
405
private:
299
406
  void fast_exclude();
300
407
};
 
408
typedef class st_select_lex_node SELECT_LEX_NODE;
301
409
 
302
 
/*
303
 
   Select_Lex_Unit - unit of selects (UNION, INTERSECT, ...) group
304
 
   Select_Lexs
 
410
/* 
 
411
   SELECT_LEX_UNIT - unit of selects (UNION, INTERSECT, ...) group 
 
412
   SELECT_LEXs
305
413
*/
306
 
class Session;
 
414
class THD;
307
415
class select_result;
308
 
class Join;
 
416
class JOIN;
309
417
class select_union;
310
 
class Select_Lex_Unit: public Select_Lex_Node {
 
418
class st_select_lex_unit: public st_select_lex_node {
311
419
protected:
312
 
  TableList result_table_list;
 
420
  TABLE_LIST result_table_list;
313
421
  select_union *union_result;
314
 
  Table *table; /* temporary table using for appending UNION results */
 
422
  TABLE *table; /* temporary table using for appending UNION results */
315
423
 
316
424
  select_result *result;
317
 
  uint64_t found_rows_for_union;
 
425
  ulonglong found_rows_for_union;
318
426
  bool saved_error;
319
427
 
320
428
public:
327
435
  List<Item> item_list;
328
436
  /*
329
437
    list of types of items inside union (used for union & derived tables)
330
 
 
 
438
    
331
439
    Item_type_holders from which this list consist may have pointers to Field,
332
440
    pointers is valid only after preparing SELECTS of this unit and before
333
441
    any SELECT of this unit execution
341
449
    Pointer to 'last' select or pointer to unit where stored
342
450
    global parameters for union
343
451
  */
344
 
  Select_Lex *global_parameters;
 
452
  st_select_lex *global_parameters;
345
453
  //node on wich we should return current_select pointer after parsing subquery
346
 
  Select_Lex *return_to;
 
454
  st_select_lex *return_to;
347
455
  /* LIMIT clause runtime counters */
348
456
  ha_rows select_limit_cnt, offset_limit_cnt;
349
457
  /* not NULL if unit used in subselect, point to subselect item */
350
458
  Item_subselect *item;
351
459
  /* thread handler */
352
 
  Session *session;
 
460
  THD *thd;
353
461
  /*
354
 
    Select_Lex for hidden SELECT in onion which process global
 
462
    SELECT_LEX for hidden SELECT in onion which process global
355
463
    ORDER BY and LIMIT
356
464
  */
357
 
  Select_Lex *fake_select_lex;
 
465
  st_select_lex *fake_select_lex;
358
466
 
359
 
  Select_Lex *union_distinct; /* pointer to the last UNION DISTINCT */
 
467
  st_select_lex *union_distinct; /* pointer to the last UNION DISTINCT */
360
468
  bool describe; /* union exec() called for EXPLAIN */
361
469
 
362
470
  void init_query();
363
 
  Select_Lex_Unit* master_unit();
364
 
  Select_Lex* outer_select();
365
 
  Select_Lex* first_select()
366
 
  {
367
 
    return reinterpret_cast<Select_Lex*>(slave);
368
 
  }
369
 
  Select_Lex_Unit* next_unit()
370
 
  {
371
 
    return reinterpret_cast<Select_Lex_Unit*>(next);
372
 
  }
373
 
  Select_Lex* return_after_parsing() { return return_to; }
 
471
  st_select_lex_unit* master_unit();
 
472
  st_select_lex* outer_select();
 
473
  st_select_lex* first_select()
 
474
  {
 
475
    return my_reinterpret_cast(st_select_lex*)(slave);
 
476
  }
 
477
  st_select_lex_unit* next_unit()
 
478
  {
 
479
    return my_reinterpret_cast(st_select_lex_unit*)(next);
 
480
  }
 
481
  st_select_lex* return_after_parsing() { return return_to; }
374
482
  void exclude_level();
375
483
  void exclude_tree();
376
484
 
377
485
  /* UNION methods */
378
 
  bool prepare(Session *session, select_result *result,
379
 
               uint64_t additional_options);
 
486
  bool prepare(THD *thd, select_result *result, ulong additional_options);
380
487
  bool exec();
381
488
  bool cleanup();
382
489
  inline void unclean() { cleaned= 0; }
384
491
 
385
492
  void print(String *str, enum_query_type query_type);
386
493
 
387
 
  bool add_fake_select_lex(Session *session);
388
 
  void init_prepare_fake_select_lex(Session *session);
 
494
  bool add_fake_select_lex(THD *thd);
 
495
  void init_prepare_fake_select_lex(THD *thd);
389
496
  bool change_result(select_result_interceptor *result,
390
497
                     select_result_interceptor *old_result);
391
 
  void set_limit(Select_Lex *values);
392
 
  void set_session(Session *session_arg) { session= session_arg; }
393
 
  inline bool is_union ();
 
498
  void set_limit(st_select_lex *values);
 
499
  void set_thd(THD *thd_arg) { thd= thd_arg; }
 
500
  inline bool is_union (); 
394
501
 
395
 
  friend void lex_start(Session *session);
 
502
  friend void lex_start(THD *thd);
396
503
  friend int subselect_union_engine::exec();
397
504
 
398
505
  List<Item> *get_unit_column_types();
399
506
};
400
507
 
 
508
typedef class st_select_lex_unit SELECT_LEX_UNIT;
 
509
 
401
510
/*
402
 
  Select_Lex - store information of parsed SELECT statment
 
511
  SELECT_LEX - store information of parsed SELECT statment
403
512
*/
404
 
class Select_Lex: public Select_Lex_Node
 
513
class st_select_lex: public st_select_lex_node
405
514
{
406
515
public:
407
516
  Name_resolution_context context;
408
517
  char *db;
409
 
  /* An Item representing the WHERE clause */
410
 
  Item *where;
411
 
  /* An Item representing the HAVING clause */
412
 
  Item *having;
 
518
  Item *where, *having;                         /* WHERE & HAVING clauses */
 
519
  Item *prep_where; /* saved WHERE clause for prepared statement processing */
 
520
  Item *prep_having;/* saved HAVING clause for prepared statement processing */
413
521
  /* Saved values of the WHERE and HAVING clauses*/
414
 
  Item::cond_result cond_value;
415
 
  Item::cond_result having_value;
 
522
  Item::cond_result cond_value, having_value;
416
523
  /* point on lex in which it was created, used in view subquery detection */
417
 
  LEX *parent_lex;
 
524
  st_lex *parent_lex;
418
525
  enum olap_type olap;
419
 
  /* FROM clause - points to the beginning of the TableList::next_local list. */
420
 
  SQL_LIST table_list;
421
 
  SQL_LIST group_list; /* GROUP BY clause. */
422
 
  List<Item> item_list;  /* list of fields & expressions */
423
 
  List<String> interval_list;
424
 
  bool is_item_list_lookup;
425
 
  Join *join; /* after Join::prepare it is pointer to corresponding JOIN */
426
 
  List<TableList> top_join_list; /* join list of the top level          */
427
 
  List<TableList> *join_list;    /* list for the currently parsed join  */
428
 
  TableList *embedding;          /* table embedding to the above list   */
429
 
  List<TableList> sj_nests;
 
526
  /* FROM clause - points to the beginning of the TABLE_LIST::next_local list. */
 
527
  SQL_LIST            table_list;
 
528
  SQL_LIST            group_list; /* GROUP BY clause. */
 
529
  List<Item>          item_list;  /* list of fields & expressions */
 
530
  List<String>        interval_list;
 
531
  bool                is_item_list_lookup;
 
532
  /* 
 
533
    Despite their names, the following are used in unions. This should 
 
534
    be rewritten. -Brian
 
535
  */
 
536
  List<Item_real_func> *ftfunc_list;
 
537
  List<Item_real_func> ftfunc_list_alloc;
 
538
  JOIN *join; /* after JOIN::prepare it is pointer to corresponding JOIN */
 
539
  List<TABLE_LIST> top_join_list; /* join list of the top level          */
 
540
  List<TABLE_LIST> *join_list;    /* list for the currently parsed join  */
 
541
  TABLE_LIST *embedding;          /* table embedding to the above list   */
 
542
  List<TABLE_LIST> sj_nests;
430
543
  /*
431
544
    Beginning of the list of leaves in a FROM clause, where the leaves
432
545
    inlcude all base tables including view tables. The tables are connected
433
 
    by TableList::next_leaf, so leaf_tables points to the left-most leaf.
 
546
    by TABLE_LIST::next_leaf, so leaf_tables points to the left-most leaf.
434
547
  */
435
 
  TableList *leaf_tables;
436
 
  enum drizzled::optimizer::select_type type; /* type of select for EXPLAIN */
 
548
  TABLE_LIST *leaf_tables;
 
549
  const char *type;               /* type of select for EXPLAIN          */
437
550
 
438
551
  SQL_LIST order_list;                /* ORDER clause */
439
552
  SQL_LIST *gorder_list;
440
553
  Item *select_limit, *offset_limit;  /* LIMIT clause parameters */
441
 
  /* Arrays of pointers to top elements of all_fields list */
 
554
  // Arrays of pointers to top elements of all_fields list
442
555
  Item **ref_pointer_array;
443
556
 
444
557
  /*
446
559
    bigger then can be number of entries that will be added to all item
447
560
    list during split_sum_func
448
561
  */
449
 
  uint32_t select_n_having_items;
450
 
  uint32_t cond_count;    /* number of arguments of and/or/xor in where/having/on */
451
 
  uint32_t between_count; /* number of between predicates in where/having/on      */
452
 
  uint32_t max_equal_elems; /* maximal number of elements in multiple equalities  */
 
562
  uint select_n_having_items;
 
563
  uint cond_count;    /* number of arguments of and/or/xor in where/having/on */
 
564
  uint between_count; /* number of between predicates in where/having/on      */
 
565
  uint max_equal_elems; /* maximal number of elements in multiple equalities  */   
453
566
  /*
454
567
    Number of fields used in select list or where clause of current select
455
568
    and all inner subselects.
456
569
  */
457
 
  uint32_t select_n_where_fields;
 
570
  uint select_n_where_fields;
458
571
  enum_parsing_place parsing_place; /* where we are parsing expression */
459
572
  bool with_sum_func;   /* sum function indicator */
 
573
  /* 
 
574
    PS or SP cond natural joins was alredy processed with permanent
 
575
    arena and all additional items which we need alredy stored in it
 
576
  */
 
577
  bool conds_processed_with_permanent_arena;
460
578
 
461
 
  uint32_t table_join_options;
462
 
  uint32_t in_sum_expr;
463
 
  uint32_t select_number; /* number of select (used for EXPLAIN) */
464
 
  int8_t nest_level;     /* nesting level of select */
465
 
  Item_sum *inner_sum_func_list; /* list of sum func in nested selects */
466
 
  uint32_t with_wild; /* item list contain '*' */
467
 
  bool braces;          /* SELECT ... UNION (SELECT ... ) <- this braces */
468
 
  /* true when having fix field called in processing of this SELECT */
 
579
  ulong table_join_options;
 
580
  uint in_sum_expr;
 
581
  uint select_number; /* number of select (used for EXPLAIN) */
 
582
  int nest_level;     /* nesting level of select */
 
583
  Item_sum *inner_sum_func_list; /* list of sum func in nested selects */ 
 
584
  uint with_wild; /* item list contain '*' */
 
585
  bool  braces;         /* SELECT ... UNION (SELECT ... ) <- this braces */
 
586
  /* TRUE when having fix field called in processing of this SELECT */
469
587
  bool having_fix_field;
470
588
  /* List of references to fields referenced from inner selects */
471
589
  List<Item_outer_ref> inner_refs_list;
472
590
  /* Number of Item_sum-derived objects in this SELECT */
473
 
  uint32_t n_sum_items;
 
591
  uint n_sum_items;
474
592
  /* Number of Item_sum-derived objects in children and descendant SELECTs */
475
 
  uint32_t n_child_sum_items;
 
593
  uint n_child_sum_items;
476
594
 
477
595
  /* explicit LIMIT clause was used */
478
596
  bool explicit_limit;
481
599
    query processing end even if we use temporary table
482
600
  */
483
601
  bool subquery_in_having;
484
 
  /* true <=> this SELECT is correlated w.r.t. some ancestor select */
 
602
  /* TRUE <=> this SELECT is correlated w.r.t. some ancestor select */
485
603
  bool is_correlated;
 
604
  /*
 
605
    This variable is required to ensure proper work of subqueries and
 
606
    stored procedures. Generally, one should use the states of
 
607
    Query_arena to determine if it's a statement prepare or first
 
608
    execution of a stored procedure. However, in case when there was an
 
609
    error during the first execution of a stored procedure, the SP body
 
610
    is not expelled from the SP cache. Therefore, a deeply nested
 
611
    subquery might be left unoptimized. So we need this per-subquery
 
612
    variable to inidicate the optimization/execution state of every
 
613
    subquery. Prepared statements work OK in that regard, as in
 
614
    case of an error during prepare the PS is not created.
 
615
  */
 
616
  bool first_execution;
 
617
  bool first_cond_optimization;
 
618
  /* do not wrap view fields with Item_ref */
 
619
  bool no_wrap_view_item;
486
620
  /* exclude this select from check of unique_table() */
487
621
  bool exclude_from_table_unique_test;
488
622
  /* List of fields that aren't under an aggregate function */
490
624
  /* index in the select list of the expression currently being fixed */
491
625
  int cur_pos_in_select_list;
492
626
 
493
 
  /*
 
627
  List<udf_func>     udf_list;                  /* udf function calls stack */
 
628
  /* 
494
629
    This is a copy of the original JOIN USING list that comes from
495
630
    the parser. The parser :
496
 
      1. Sets the natural_join of the second TableList in the join
497
 
         and the Select_Lex::prev_join_using.
498
 
      2. Makes a parent TableList and sets its is_natural_join/
 
631
      1. Sets the natural_join of the second TABLE_LIST in the join
 
632
         and the st_select_lex::prev_join_using.
 
633
      2. Makes a parent TABLE_LIST and sets its is_natural_join/
499
634
       join_using_fields members.
500
 
      3. Uses the wrapper TableList as a table in the upper level.
 
635
      3. Uses the wrapper TABLE_LIST as a table in the upper level.
501
636
    We cannot assign directly to join_using_fields in the parser because
502
 
    at stage (1.) the parent TableList is not constructed yet and
 
637
    at stage (1.) the parent TABLE_LIST is not constructed yet and
503
638
    the assignment will override the JOIN USING fields of the lower level
504
639
    joins on the right.
505
640
  */
513
648
      1 - aggregate functions are used in this select,
514
649
          defined as SUM_FUNC_USED.
515
650
  */
516
 
  std::bitset<2> full_group_by_flag;
517
 
 
 
651
  uint8 full_group_by_flag;
518
652
  void init_query();
519
653
  void init_select();
520
 
  Select_Lex_Unit* master_unit();
521
 
  Select_Lex_Unit* first_inner_unit()
522
 
  {
523
 
    return (Select_Lex_Unit*) slave;
524
 
  }
525
 
  Select_Lex* outer_select();
526
 
  Select_Lex* next_select()
527
 
  {
528
 
    return (Select_Lex*) next;
529
 
  }
530
 
  Select_Lex* next_select_in_list()
531
 
  {
532
 
    return (Select_Lex*) link_next;
533
 
  }
534
 
  Select_Lex_Node** next_select_in_list_addr()
 
654
  st_select_lex_unit* master_unit();
 
655
  st_select_lex_unit* first_inner_unit() 
 
656
  { 
 
657
    return (st_select_lex_unit*) slave; 
 
658
  }
 
659
  st_select_lex* outer_select();
 
660
  st_select_lex* next_select() { return (st_select_lex*) next; }
 
661
  st_select_lex* next_select_in_list() 
 
662
  {
 
663
    return (st_select_lex*) link_next;
 
664
  }
 
665
  st_select_lex_node** next_select_in_list_addr()
535
666
  {
536
667
    return &link_next;
537
668
  }
538
 
  Select_Lex* return_after_parsing()
 
669
  st_select_lex* return_after_parsing()
539
670
  {
540
671
    return master_unit()->return_after_parsing();
541
672
  }
542
673
 
543
 
  void mark_as_dependent(Select_Lex *last);
 
674
  void mark_as_dependent(st_select_lex *last);
544
675
 
545
676
  bool set_braces(bool value);
546
677
  bool inc_in_sum_expr();
547
 
  uint32_t get_in_sum_expr();
 
678
  uint get_in_sum_expr();
548
679
 
549
 
  bool add_item_to_list(Session *session, Item *item);
550
 
  bool add_group_to_list(Session *session, Item *item, bool asc);
551
 
  bool add_order_to_list(Session *session, Item *item, bool asc);
552
 
  TableList* add_table_to_list(Session *session,
553
 
                               Table_ident *table,
554
 
                               LEX_STRING *alias,
555
 
                               uint32_t table_options,
556
 
                               thr_lock_type flags= TL_UNLOCK,
557
 
                               List<Index_hint> *hints= 0,
558
 
                               LEX_STRING *option= 0);
559
 
  TableList* get_table_list();
560
 
  bool init_nested_join(Session *session);
561
 
  TableList *end_nested_join(Session *session);
562
 
  TableList *nest_last_join(Session *session);
563
 
  void add_joined_table(TableList *table);
564
 
  TableList *convert_right_join();
 
680
  bool add_item_to_list(THD *thd, Item *item);
 
681
  bool add_group_to_list(THD *thd, Item *item, bool asc);
 
682
  bool add_order_to_list(THD *thd, Item *item, bool asc);
 
683
  TABLE_LIST* add_table_to_list(THD *thd, Table_ident *table,
 
684
                                LEX_STRING *alias,
 
685
                                ulong table_options,
 
686
                                thr_lock_type flags= TL_UNLOCK,
 
687
                                List<Index_hint> *hints= 0,
 
688
                                LEX_STRING *option= 0);
 
689
  TABLE_LIST* get_table_list();
 
690
  bool init_nested_join(THD *thd);
 
691
  TABLE_LIST *end_nested_join(THD *thd);
 
692
  TABLE_LIST *nest_last_join(THD *thd);
 
693
  void add_joined_table(TABLE_LIST *table);
 
694
  TABLE_LIST *convert_right_join();
565
695
  List<Item>* get_item_list();
566
 
  uint32_t get_table_join_options();
 
696
  ulong get_table_join_options();
567
697
  void set_lock_for_tables(thr_lock_type lock_type);
568
698
  inline void init_order()
569
699
  {
570
700
    order_list.elements= 0;
571
701
    order_list.first= 0;
572
 
    order_list.next= (unsigned char**) &order_list.first;
 
702
    order_list.next= (uchar**) &order_list.first;
573
703
  }
574
704
  /*
575
705
    This method created for reiniting LEX in mysql_admin_table() and can be
576
 
    used only if you are going remove all Select_Lex & units except belonger
 
706
    used only if you are going remove all SELECT_LEX & units except belonger
577
707
    to LEX (LEX::unit & LEX::select, for other purposes there are
578
 
    Select_Lex_Unit::exclude_level & Select_Lex_Unit::exclude_tree
 
708
    SELECT_LEX_UNIT::exclude_level & SELECT_LEX_UNIT::exclude_tree
579
709
  */
580
 
  void cut_subtree()
581
 
  {
582
 
    slave= 0;
583
 
  }
 
710
  void cut_subtree() { slave= 0; }
584
711
  bool test_limit();
585
712
 
586
 
  friend void lex_start(Session *session);
587
 
  Select_Lex() : n_sum_items(0), n_child_sum_items(0) {}
 
713
  friend void lex_start(THD *thd);
 
714
  st_select_lex() : n_sum_items(0), n_child_sum_items(0) {}
588
715
  void make_empty_select()
589
716
  {
590
717
    init_query();
591
718
    init_select();
592
719
  }
593
 
  bool setup_ref_array(Session *session, uint32_t order_group_num);
594
 
  void print(Session *session, String *str, enum_query_type query_type);
 
720
  bool setup_ref_array(THD *thd, uint order_group_num);
 
721
  void print(THD *thd, String *str, enum_query_type query_type);
595
722
  static void print_order(String *str,
596
 
                          order_st *order,
 
723
                          ORDER *order,
597
724
                          enum_query_type query_type);
598
 
  void print_limit(Session *session, String *str, enum_query_type query_type);
599
 
  void fix_prepare_information(Session *session, Item **conds, Item **having_conds);
 
725
  void print_limit(THD *thd, String *str, enum_query_type query_type);
 
726
  void fix_prepare_information(THD *thd, Item **conds, Item **having_conds);
600
727
  /*
601
728
    Destroy the used execution plan (JOIN) of this subtree (this
602
 
    Select_Lex and all nested Select_Lexes and Select_Lex_Units).
 
729
    SELECT_LEX and all nested SELECT_LEXes and SELECT_LEX_UNITs).
603
730
  */
604
731
  bool cleanup();
605
732
  /*
610
737
 
611
738
  void set_index_hint_type(enum index_hint_type type, index_clause_map clause);
612
739
 
613
 
  /*
 
740
  /* 
614
741
   Add a index hint to the tagged list of hints. The type and clause of the
615
 
   hint will be the current ones (set by set_index_hint())
 
742
   hint will be the current ones (set by set_index_hint()) 
616
743
  */
617
 
  bool add_index_hint (Session *session, char *str, uint32_t length);
 
744
  bool add_index_hint (THD *thd, char *str, uint length);
618
745
 
619
746
  /* make a list to hold index hints */
620
 
  void alloc_index_hints (Session *session);
 
747
  void alloc_index_hints (THD *thd);
621
748
  /* read and clear the index hints */
622
 
  List<Index_hint>* pop_index_hints(void)
 
749
  List<Index_hint>* pop_index_hints(void) 
623
750
  {
624
751
    List<Index_hint> *hints= index_hints;
625
752
    index_hints= NULL;
628
755
 
629
756
  void clear_index_hints(void) { index_hints= NULL; }
630
757
 
631
 
private:
 
758
private:  
632
759
  /* current index hint kind. used in filling up index_hints */
633
760
  enum index_hint_type current_index_hint_type;
634
761
  index_clause_map current_index_hint_clause;
635
762
  /* a list of USE/FORCE/IGNORE INDEX */
636
763
  List<Index_hint> *index_hints;
637
764
};
 
765
typedef class st_select_lex SELECT_LEX;
638
766
 
639
 
inline bool Select_Lex_Unit::is_union ()
640
 
{
641
 
  return first_select()->next_select() &&
 
767
inline bool st_select_lex_unit::is_union ()
 
768
{ 
 
769
  return first_select()->next_select() && 
642
770
    first_select()->next_select()->linkage == UNION_TYPE;
643
771
}
644
772
 
645
 
enum xa_option_words
 
773
#define ALTER_ADD_COLUMN        (1L << 0)
 
774
#define ALTER_DROP_COLUMN       (1L << 1)
 
775
#define ALTER_CHANGE_COLUMN     (1L << 2)
 
776
#define ALTER_COLUMN_STORAGE    (1L << 3)
 
777
#define ALTER_COLUMN_FORMAT     (1L << 4)
 
778
#define ALTER_COLUMN_ORDER      (1L << 5)
 
779
#define ALTER_ADD_INDEX         (1L << 6)
 
780
#define ALTER_DROP_INDEX        (1L << 7)
 
781
#define ALTER_RENAME            (1L << 8)
 
782
#define ALTER_ORDER             (1L << 9)
 
783
#define ALTER_OPTIONS           (1L << 10)
 
784
#define ALTER_COLUMN_DEFAULT    (1L << 11)
 
785
#define ALTER_KEYS_ONOFF        (1L << 12)
 
786
#define ALTER_STORAGE           (1L << 13)
 
787
#define ALTER_ROW_FORMAT        (1L << 14)
 
788
#define ALTER_CONVERT           (1L << 15)
 
789
#define ALTER_FORCE             (1L << 16)
 
790
#define ALTER_RECREATE          (1L << 17)
 
791
#define ALTER_TABLE_REORG        (1L << 24)
 
792
#define ALTER_FOREIGN_KEY         (1L << 31)
 
793
 
 
794
/**
 
795
  @brief Parsing data for CREATE or ALTER TABLE.
 
796
 
 
797
  This structure contains a list of columns or indexes to be created,
 
798
  altered or dropped.
 
799
*/
 
800
 
 
801
class Alter_info
646
802
{
647
 
  XA_NONE
648
 
, XA_JOIN
649
 
, XA_RESUME
650
 
, XA_ONE_PHASE
651
 
, XA_SUSPEND
652
 
, XA_FOR_MIGRATE
 
803
public:
 
804
  List<Alter_drop>              drop_list;
 
805
  List<Alter_column>            alter_list;
 
806
  List<Key>                     key_list;
 
807
  List<Create_field>            create_list;
 
808
  uint                          flags;
 
809
  enum enum_enable_or_disable   keys_onoff;
 
810
  enum tablespace_op_type       tablespace_op;
 
811
  uint                          no_parts;
 
812
  enum ha_build_method          build_method;
 
813
  Create_field                 *datetime_field;
 
814
  bool                          error_if_not_empty;
 
815
 
 
816
 
 
817
  Alter_info() :
 
818
    flags(0),
 
819
    keys_onoff(LEAVE_AS_IS),
 
820
    tablespace_op(NO_TABLESPACE_OP),
 
821
    no_parts(0),
 
822
    build_method(HA_BUILD_DEFAULT),
 
823
    datetime_field(NULL),
 
824
    error_if_not_empty(FALSE)
 
825
  {}
 
826
 
 
827
  void reset()
 
828
  {
 
829
    drop_list.empty();
 
830
    alter_list.empty();
 
831
    key_list.empty();
 
832
    create_list.empty();
 
833
    flags= 0;
 
834
    keys_onoff= LEAVE_AS_IS;
 
835
    tablespace_op= NO_TABLESPACE_OP;
 
836
    no_parts= 0;
 
837
    build_method= HA_BUILD_DEFAULT;
 
838
    datetime_field= 0;
 
839
    error_if_not_empty= FALSE;
 
840
  }
 
841
  Alter_info(const Alter_info &rhs, MEM_ROOT *mem_root);
 
842
private:
 
843
  Alter_info &operator=(const Alter_info &rhs); // not implemented
 
844
  Alter_info(const Alter_info &rhs);            // not implemented
653
845
};
654
846
 
 
847
enum xa_option_words {XA_NONE, XA_JOIN, XA_RESUME, XA_ONE_PHASE,
 
848
                      XA_SUSPEND, XA_FOR_MIGRATE};
 
849
 
655
850
extern const LEX_STRING null_lex_str;
656
851
 
 
852
 
657
853
/*
658
854
  Class representing list of all tables used by statement.
659
855
  It also contains information about stored functions used by statement
664
860
  Also used by st_lex::reset_n_backup/restore_backup_query_tables_list()
665
861
  methods to save and restore this information.
666
862
*/
 
863
 
667
864
class Query_tables_list
668
865
{
669
866
public:
670
867
  /* Global list of all tables used by this statement */
671
 
  TableList *query_tables;
 
868
  TABLE_LIST *query_tables;
672
869
  /* Pointer to next_global member of last element in the previous list. */
673
 
  TableList **query_tables_last;
 
870
  TABLE_LIST **query_tables_last;
674
871
  /*
675
872
    If non-0 then indicates that query requires prelocking and points to
676
873
    next_global member of last own element in query table list (i.e. last
677
874
    table which was not added to it as part of preparation to prelocking).
678
875
    0 - indicates that this query does not need prelocking.
679
876
  */
680
 
  TableList **query_tables_own_last;
 
877
  TABLE_LIST **query_tables_own_last;
 
878
  /*
 
879
    Set of stored routines called by statement.
 
880
    (Note that we use lazy-initialization for this hash).
 
881
  */
 
882
  enum { START_SROUTINES_HASH_SIZE= 16 };
 
883
  HASH sroutines;
 
884
  /*
 
885
    List linking elements of 'sroutines' set. Allows you to add new elements
 
886
    to this set as you iterate through the list of existing elements.
 
887
    'sroutines_list_own_last' is pointer to ::next member of last element of
 
888
    this list which represents routine which is explicitly used by query.
 
889
    'sroutines_list_own_elements' number of explicitly used routines.
 
890
    We use these two members for restoring of 'sroutines_list' to the state
 
891
    in which it was right after query parsing.
 
892
  */
 
893
  SQL_LIST sroutines_list;
 
894
  uchar    **sroutines_list_own_last;
 
895
  uint     sroutines_list_own_elements;
681
896
 
682
897
  /*
683
898
    These constructor and destructor serve for creation/destruction
684
899
    of Query_tables_list instances which are used as backup storage.
685
900
  */
686
901
  Query_tables_list() {}
687
 
  virtual ~Query_tables_list() {}
 
902
  ~Query_tables_list() {}
688
903
 
689
904
  /* Initializes (or resets) Query_tables_list object for "real" use. */
690
905
  void reset_query_tables_list(bool init);
 
906
  void destroy_query_tables_list();
 
907
  void set_query_tables_list(Query_tables_list *state)
 
908
  {
 
909
    *this= *state;
 
910
  }
691
911
 
692
912
  /*
693
913
    Direct addition to the list of query tables.
694
914
    If you are using this function, you must ensure that the table
695
915
    object, in particular table->db member, is initialized.
696
916
  */
697
 
  void add_to_query_tables(TableList *table)
 
917
  void add_to_query_tables(TABLE_LIST *table)
698
918
  {
699
919
    *(table->prev_global= query_tables_last)= table;
700
920
    query_tables_last= &table->next_global;
701
921
  }
702
922
  /* Return pointer to first not-own table in query-tables or 0 */
703
 
  TableList* first_not_own_table()
 
923
  TABLE_LIST* first_not_own_table()
704
924
  {
705
925
    return ( query_tables_own_last ? *query_tables_own_last : 0);
706
926
  }
713
933
      query_tables_own_last= 0;
714
934
    }
715
935
  }
716
 
};
 
936
 
 
937
  /**
 
938
     Has the parser/scanner detected that this statement is unsafe?
 
939
   */
 
940
  inline bool is_stmt_unsafe() const {
 
941
    return binlog_stmt_flags & (1U << BINLOG_STMT_FLAG_UNSAFE);
 
942
  }
 
943
 
 
944
  /**
 
945
     Flag the current (top-level) statement as unsafe.
 
946
 
 
947
     The flag will be reset after the statement has finished.
 
948
 
 
949
   */
 
950
  inline void set_stmt_unsafe() {
 
951
    binlog_stmt_flags|= (1U << BINLOG_STMT_FLAG_UNSAFE);
 
952
  }
 
953
 
 
954
  inline void clear_stmt_unsafe() {
 
955
    binlog_stmt_flags&= ~(1U << BINLOG_STMT_FLAG_UNSAFE);
 
956
  }
 
957
 
 
958
  /**
 
959
    true if the parsed tree contains references to stored procedures
 
960
    or functions, false otherwise
 
961
  */
 
962
  bool uses_stored_routines() const
 
963
  { return sroutines_list.elements != 0; }
 
964
 
 
965
private:
 
966
  enum enum_binlog_stmt_flag {
 
967
    BINLOG_STMT_FLAG_UNSAFE,
 
968
    BINLOG_STMT_FLAG_COUNT
 
969
  };
 
970
 
 
971
  /*
 
972
    Tells if the parsing stage detected properties of the statement,
 
973
    for example: that some items require row-based binlogging to give
 
974
    a reliable binlog/replication, or if we will use stored functions
 
975
    or triggers which themselves need require row-based binlogging.
 
976
  */
 
977
  uint32 binlog_stmt_flags;
 
978
};
 
979
 
 
980
 
 
981
/*
 
982
  st_parsing_options contains the flags for constructions that are
 
983
  allowed in the current statement.
 
984
*/
 
985
 
 
986
struct st_parsing_options
 
987
{
 
988
  bool allows_variable;
 
989
  bool allows_select_into;
 
990
  bool allows_select_procedure;
 
991
  bool allows_derived;
 
992
 
 
993
  st_parsing_options() { reset(); }
 
994
  void reset();
 
995
};
 
996
 
717
997
 
718
998
/**
719
999
  The state of the lexical parser, when parsing comments.
738
1018
  DISCARD_COMMENT
739
1019
};
740
1020
 
741
 
} /* namespace drizzled */
742
 
 
743
 
#include "drizzled/lex_input_stream.h"
744
 
 
745
 
namespace drizzled
746
 
{
747
 
 
748
 
/* The state of the lex parsing. This is saved in the Session struct */
749
 
class LEX : public Query_tables_list
750
 
{
751
 
public:
752
 
  Select_Lex_Unit unit;                         /* most upper unit */
753
 
  Select_Lex select_lex;                        /* first Select_Lex */
754
 
  /* current Select_Lex in parsing */
755
 
  Select_Lex *current_select;
756
 
  /* list of all Select_Lex */
757
 
  Select_Lex *all_selects_list;
758
 
 
759
 
  /* This is the "scale" for DECIMAL (S,P) notation */ 
760
 
  char *length;
761
 
  /* This is the decimal precision in DECIMAL(S,P) notation */
762
 
  char *dec;
763
 
  
764
 
  /**
765
 
   * This is used kind of like the "ident" member variable below, as 
766
 
   * a place to store certain names of identifiers.  Unfortunately, it
767
 
   * is used differently depending on the Command (SELECT on a derived
768
 
   * table vs CREATE)
769
 
   */
 
1021
 
 
1022
/**
 
1023
  @brief This class represents the character input stream consumed during
 
1024
  lexical analysis.
 
1025
 
 
1026
  In addition to consuming the input stream, this class performs some
 
1027
  comment pre processing, by filtering out out of bound special text
 
1028
  from the query input stream.
 
1029
  Two buffers, with pointers inside each buffers, are maintained in
 
1030
  parallel. The 'raw' buffer is the original query text, which may
 
1031
  contain out-of-bound comments. The 'cpp' (for comments pre processor)
 
1032
  is the pre-processed buffer that contains only the query text that
 
1033
  should be seen once out-of-bound data is removed.
 
1034
*/
 
1035
 
 
1036
class Lex_input_stream
 
1037
{
 
1038
public:
 
1039
  Lex_input_stream(THD *thd, const char* buff, unsigned int length);
 
1040
  ~Lex_input_stream();
 
1041
 
 
1042
  /**
 
1043
    Set the echo mode.
 
1044
 
 
1045
    When echo is true, characters parsed from the raw input stream are
 
1046
    preserved. When false, characters parsed are silently ignored.
 
1047
    @param echo the echo mode.
 
1048
  */
 
1049
  void set_echo(bool echo)
 
1050
  {
 
1051
    m_echo= echo;
 
1052
  }
 
1053
 
 
1054
  /**
 
1055
    Skip binary from the input stream.
 
1056
    @param n number of bytes to accept.
 
1057
  */
 
1058
  void skip_binary(int n)
 
1059
  {
 
1060
    if (m_echo)
 
1061
    {
 
1062
      memcpy(m_cpp_ptr, m_ptr, n);
 
1063
      m_cpp_ptr += n;
 
1064
    }
 
1065
    m_ptr += n;
 
1066
  }
 
1067
 
 
1068
  /**
 
1069
    Get a character, and advance in the stream.
 
1070
    @return the next character to parse.
 
1071
  */
 
1072
  char yyGet()
 
1073
  {
 
1074
    char c= *m_ptr++;
 
1075
    if (m_echo)
 
1076
      *m_cpp_ptr++ = c;
 
1077
    return c;
 
1078
  }
 
1079
 
 
1080
  /**
 
1081
    Get the last character accepted.
 
1082
    @return the last character accepted.
 
1083
  */
 
1084
  char yyGetLast()
 
1085
  {
 
1086
    return m_ptr[-1];
 
1087
  }
 
1088
 
 
1089
  /**
 
1090
    Look at the next character to parse, but do not accept it.
 
1091
  */
 
1092
  char yyPeek()
 
1093
  {
 
1094
    return m_ptr[0];
 
1095
  }
 
1096
 
 
1097
  /**
 
1098
    Look ahead at some character to parse.
 
1099
    @param n offset of the character to look up
 
1100
  */
 
1101
  char yyPeekn(int n)
 
1102
  {
 
1103
    return m_ptr[n];
 
1104
  }
 
1105
 
 
1106
  /**
 
1107
    Cancel the effect of the last yyGet() or yySkip().
 
1108
    Note that the echo mode should not change between calls to yyGet / yySkip
 
1109
    and yyUnget. The caller is responsible for ensuring that.
 
1110
  */
 
1111
  void yyUnget()
 
1112
  {
 
1113
    m_ptr--;
 
1114
    if (m_echo)
 
1115
      m_cpp_ptr--;
 
1116
  }
 
1117
 
 
1118
  /**
 
1119
    Accept a character, by advancing the input stream.
 
1120
  */
 
1121
  void yySkip()
 
1122
  {
 
1123
    if (m_echo)
 
1124
      *m_cpp_ptr++ = *m_ptr++;
 
1125
    else
 
1126
      m_ptr++;
 
1127
  }
 
1128
 
 
1129
  /**
 
1130
    Accept multiple characters at once.
 
1131
    @param n the number of characters to accept.
 
1132
  */
 
1133
  void yySkipn(int n)
 
1134
  {
 
1135
    if (m_echo)
 
1136
    {
 
1137
      memcpy(m_cpp_ptr, m_ptr, n);
 
1138
      m_cpp_ptr += n;
 
1139
    }
 
1140
    m_ptr += n;
 
1141
  }
 
1142
 
 
1143
  /**
 
1144
    End of file indicator for the query text to parse.
 
1145
    @return true if there are no more characters to parse
 
1146
  */
 
1147
  bool eof()
 
1148
  {
 
1149
    return (m_ptr >= m_end_of_query);
 
1150
  }
 
1151
 
 
1152
  /**
 
1153
    End of file indicator for the query text to parse.
 
1154
    @param n number of characters expected
 
1155
    @return true if there are less than n characters to parse
 
1156
  */
 
1157
  bool eof(int n)
 
1158
  {
 
1159
    return ((m_ptr + n) >= m_end_of_query);
 
1160
  }
 
1161
 
 
1162
  /** Get the raw query buffer. */
 
1163
  const char *get_buf()
 
1164
  {
 
1165
    return m_buf;
 
1166
  }
 
1167
 
 
1168
  /** Get the pre-processed query buffer. */
 
1169
  const char *get_cpp_buf()
 
1170
  {
 
1171
    return m_cpp_buf;
 
1172
  }
 
1173
 
 
1174
  /** Get the end of the raw query buffer. */
 
1175
  const char *get_end_of_query()
 
1176
  {
 
1177
    return m_end_of_query;
 
1178
  }
 
1179
 
 
1180
  /** Mark the stream position as the start of a new token. */
 
1181
  void start_token()
 
1182
  {
 
1183
    m_tok_start_prev= m_tok_start;
 
1184
    m_tok_start= m_ptr;
 
1185
    m_tok_end= m_ptr;
 
1186
 
 
1187
    m_cpp_tok_start_prev= m_cpp_tok_start;
 
1188
    m_cpp_tok_start= m_cpp_ptr;
 
1189
    m_cpp_tok_end= m_cpp_ptr;
 
1190
  }
 
1191
 
 
1192
  /**
 
1193
    Adjust the starting position of the current token.
 
1194
    This is used to compensate for starting whitespace.
 
1195
  */
 
1196
  void restart_token()
 
1197
  {
 
1198
    m_tok_start= m_ptr;
 
1199
    m_cpp_tok_start= m_cpp_ptr;
 
1200
  }
 
1201
 
 
1202
  /** Get the token start position, in the raw buffer. */
 
1203
  const char *get_tok_start()
 
1204
  {
 
1205
    return m_tok_start;
 
1206
  }
 
1207
 
 
1208
  /** Get the token start position, in the pre-processed buffer. */
 
1209
  const char *get_cpp_tok_start()
 
1210
  {
 
1211
    return m_cpp_tok_start;
 
1212
  }
 
1213
 
 
1214
  /** Get the token end position, in the raw buffer. */
 
1215
  const char *get_tok_end()
 
1216
  {
 
1217
    return m_tok_end;
 
1218
  }
 
1219
 
 
1220
  /** Get the token end position, in the pre-processed buffer. */
 
1221
  const char *get_cpp_tok_end()
 
1222
  {
 
1223
    return m_cpp_tok_end;
 
1224
  }
 
1225
 
 
1226
  /** Get the previous token start position, in the raw buffer. */
 
1227
  const char *get_tok_start_prev()
 
1228
  {
 
1229
    return m_tok_start_prev;
 
1230
  }
 
1231
 
 
1232
  /** Get the current stream pointer, in the raw buffer. */
 
1233
  const char *get_ptr()
 
1234
  {
 
1235
    return m_ptr;
 
1236
  }
 
1237
 
 
1238
  /** Get the current stream pointer, in the pre-processed buffer. */
 
1239
  const char *get_cpp_ptr()
 
1240
  {
 
1241
    return m_cpp_ptr;
 
1242
  }
 
1243
 
 
1244
  /** Get the length of the current token, in the raw buffer. */
 
1245
  uint yyLength()
 
1246
  {
 
1247
    /*
 
1248
      The assumption is that the lexical analyser is always 1 character ahead,
 
1249
      which the -1 account for.
 
1250
    */
 
1251
    DBUG_ASSERT(m_ptr > m_tok_start);
 
1252
    return (uint) ((m_ptr - m_tok_start) - 1);
 
1253
  }
 
1254
 
 
1255
  /** Get the utf8-body string. */
 
1256
  const char *get_body_utf8_str()
 
1257
  {
 
1258
    return m_body_utf8;
 
1259
  }
 
1260
 
 
1261
  /** Get the utf8-body length. */
 
1262
  uint get_body_utf8_length()
 
1263
  {
 
1264
    return m_body_utf8_ptr - m_body_utf8;
 
1265
  }
 
1266
 
 
1267
  void body_utf8_start(THD *thd, const char *begin_ptr);
 
1268
  void body_utf8_append(const char *ptr);
 
1269
  void body_utf8_append(const char *ptr, const char *end_ptr);
 
1270
  void body_utf8_append_literal(THD *thd,
 
1271
                                const LEX_STRING *txt,
 
1272
                                CHARSET_INFO *txt_cs,
 
1273
                                const char *end_ptr);
 
1274
 
 
1275
  /** Current thread. */
 
1276
  THD *m_thd;
 
1277
 
 
1278
  /** Current line number. */
 
1279
  uint yylineno;
 
1280
 
 
1281
  /** Length of the last token parsed. */
 
1282
  uint yytoklen;
 
1283
 
 
1284
  /** Interface with bison, value of the last token parsed. */
 
1285
  LEX_YYSTYPE yylval;
 
1286
 
 
1287
  /** LALR(2) resolution, look ahead token.*/
 
1288
  int lookahead_token;
 
1289
 
 
1290
  /** LALR(2) resolution, value of the look ahead token.*/
 
1291
  LEX_YYSTYPE lookahead_yylval;
 
1292
 
 
1293
private:
 
1294
  /** Pointer to the current position in the raw input stream. */
 
1295
  const char *m_ptr;
 
1296
 
 
1297
  /** Starting position of the last token parsed, in the raw buffer. */
 
1298
  const char *m_tok_start;
 
1299
 
 
1300
  /** Ending position of the previous token parsed, in the raw buffer. */
 
1301
  const char *m_tok_end;
 
1302
 
 
1303
  /** End of the query text in the input stream, in the raw buffer. */
 
1304
  const char *m_end_of_query;
 
1305
 
 
1306
  /** Starting position of the previous token parsed, in the raw buffer. */
 
1307
  const char *m_tok_start_prev;
 
1308
 
 
1309
  /** Begining of the query text in the input stream, in the raw buffer. */
 
1310
  const char *m_buf;
 
1311
 
 
1312
  /** Length of the raw buffer. */
 
1313
  uint m_buf_length;
 
1314
 
 
1315
  /** Echo the parsed stream to the pre-processed buffer. */
 
1316
  bool m_echo;
 
1317
 
 
1318
  /** Pre-processed buffer. */
 
1319
  char *m_cpp_buf;
 
1320
 
 
1321
  /** Pointer to the current position in the pre-processed input stream. */
 
1322
  char *m_cpp_ptr;
 
1323
 
 
1324
  /**
 
1325
    Starting position of the last token parsed,
 
1326
    in the pre-processed buffer.
 
1327
  */
 
1328
  const char *m_cpp_tok_start;
 
1329
 
 
1330
  /**
 
1331
    Starting position of the previous token parsed,
 
1332
    in the pre-procedded buffer.
 
1333
  */
 
1334
  const char *m_cpp_tok_start_prev;
 
1335
 
 
1336
  /**
 
1337
    Ending position of the previous token parsed,
 
1338
    in the pre-processed buffer.
 
1339
  */
 
1340
  const char *m_cpp_tok_end;
 
1341
 
 
1342
  /** UTF8-body buffer created during parsing. */
 
1343
  char *m_body_utf8;
 
1344
 
 
1345
  /** Pointer to the current position in the UTF8-body buffer. */
 
1346
  char *m_body_utf8_ptr;
 
1347
 
 
1348
  /**
 
1349
    Position in the pre-processed buffer. The query from m_cpp_buf to
 
1350
    m_cpp_utf_processed_ptr is converted to UTF8-body.
 
1351
  */
 
1352
  const char *m_cpp_utf8_processed_ptr;
 
1353
 
 
1354
public:
 
1355
 
 
1356
  /** Current state of the lexical analyser. */
 
1357
  enum my_lex_states next_state;
 
1358
 
 
1359
  /**
 
1360
    Position of ';' in the stream, to delimit multiple queries.
 
1361
    This delimiter is in the raw buffer.
 
1362
  */
 
1363
  const char *found_semicolon;
 
1364
 
 
1365
  /** Token character bitmaps, to detect 7bit strings. */
 
1366
  uchar tok_bitmap;
 
1367
 
 
1368
  /** SQL_MODE = IGNORE_SPACE. */
 
1369
  bool ignore_space;
 
1370
 
 
1371
  /**
 
1372
    TRUE if we're parsing a prepared statement: in this mode
 
1373
    we should allow placeholders and disallow multi-statements.
 
1374
  */
 
1375
  bool stmt_prepare_mode;
 
1376
 
 
1377
  /** State of the lexical analyser for comments. */
 
1378
  enum_comment_state in_comment;
 
1379
 
 
1380
  /**
 
1381
    Starting position of the TEXT_STRING or IDENT in the pre-processed
 
1382
    buffer.
 
1383
 
 
1384
    NOTE: this member must be used within MYSQLlex() function only.
 
1385
  */
 
1386
  const char *m_cpp_text_start;
 
1387
 
 
1388
  /**
 
1389
    Ending position of the TEXT_STRING or IDENT in the pre-processed
 
1390
    buffer.
 
1391
 
 
1392
    NOTE: this member must be used within MYSQLlex() function only.
 
1393
    */
 
1394
  const char *m_cpp_text_end;
 
1395
 
 
1396
  /**
 
1397
    Character set specified by the character-set-introducer.
 
1398
 
 
1399
    NOTE: this member must be used within MYSQLlex() function only.
 
1400
  */
 
1401
  CHARSET_INFO *m_underscore_cs;
 
1402
};
 
1403
 
 
1404
 
 
1405
/* The state of the lex parsing. This is saved in the THD struct */
 
1406
 
 
1407
typedef struct st_lex : public Query_tables_list
 
1408
{
 
1409
  SELECT_LEX_UNIT unit;                         /* most upper unit */
 
1410
  SELECT_LEX select_lex;                        /* first SELECT_LEX */
 
1411
  /* current SELECT_LEX in parsing */
 
1412
  SELECT_LEX *current_select;
 
1413
  /* list of all SELECT_LEX */
 
1414
  SELECT_LEX *all_selects_list;
 
1415
 
 
1416
  char *length,*dec,*change;
770
1417
  LEX_STRING name;
771
 
  /* The string literal used in a LIKE expression */
 
1418
  char *help_arg;
 
1419
  LEX_STRING backup_dir;                                /* For RESTORE/BACKUP */
 
1420
  char* to_log;                                 /* For PURGE MASTER LOGS TO */
 
1421
  char* x509_subject,*x509_issuer,*ssl_cipher;
772
1422
  String *wild;
773
 
  file_exchange *exchange;
 
1423
  sql_exchange *exchange;
774
1424
  select_result *result;
775
 
 
776
 
  /**
777
 
   * This is current used to store the name of a named key cache
778
 
   * or a named savepoint.  It should probably be refactored out into
779
 
   * the eventual Command class built for the Keycache and Savepoint
780
 
   * commands.
781
 
   */ 
782
 
  LEX_STRING ident;
783
 
 
784
 
  unsigned char* yacc_yyss, *yacc_yyvs;
785
 
  /* The owning Session of this LEX */
786
 
  Session *session;
787
 
  const CHARSET_INFO *charset;
 
1425
  Item *default_value, *on_update_value;
 
1426
  LEX_STRING comment, ident;
 
1427
  XID *xid;
 
1428
  uchar* yacc_yyss, *yacc_yyvs;
 
1429
  THD *thd;
 
1430
 
 
1431
  /* maintain a list of used plugins for this LEX */
 
1432
  DYNAMIC_ARRAY plugins;
 
1433
  plugin_ref plugins_static_buffer[INITIAL_LEX_PLUGIN_LIST_SIZE];
 
1434
 
 
1435
  CHARSET_INFO *charset;
788
1436
  bool text_string_is_7bit;
789
1437
  /* store original leaf_tables for INSERT SELECT and PS/SP */
790
 
  TableList *leaf_tables_insert;
 
1438
  TABLE_LIST *leaf_tables_insert;
791
1439
 
792
1440
  List<Key_part_spec> col_list;
793
1441
  List<Key_part_spec> ref_list;
794
1442
  List<String>        interval_list;
795
 
  List<Lex_Column>    columns;
 
1443
  List<LEX_USER>      users_list;
 
1444
  List<LEX_COLUMN>    columns;
796
1445
  List<Item>          *insert_list,field_list,value_list,update_list;
797
1446
  List<List_item>     many_values;
798
1447
  List<set_var_base>  var_list;
 
1448
  List<Item_param>    param_list;
 
1449
  List<LEX_STRING>    view_list; // view list (list of field names in view)
799
1450
  /*
800
1451
    A stack of name resolution contexts for the query. This stack is used
801
1452
    at parse time to set local name resolution contexts for various parts
810
1461
    required a local context, the parser pops the top-most context.
811
1462
  */
812
1463
  List<Name_resolution_context> context_stack;
 
1464
  List<LEX_STRING>     db_list;
813
1465
 
814
 
  SQL_LIST auxiliary_table_list;
815
 
  SQL_LIST save_list;
816
 
  CreateField *last_field;
 
1466
  SQL_LIST            proc_list, auxiliary_table_list, save_list;
 
1467
  Create_field        *last_field;
817
1468
  Item_sum *in_sum_func;
818
 
  plugin::Function *udf;
819
 
  uint32_t type;
 
1469
  udf_func udf;
 
1470
  HA_CHECK_OPT   check_opt;                     // check/repair options
 
1471
  HA_CREATE_INFO create_info;
 
1472
  KEY_CREATE_INFO key_create_info;
 
1473
  LEX_MASTER_INFO mi;                           // used by CHANGE MASTER
 
1474
  LEX_SERVER_OPTIONS server_options;
 
1475
  USER_RESOURCES mqh;
 
1476
  ulong type;
820
1477
  /*
821
1478
    This variable is used in post-parse stage to declare that sum-functions,
822
1479
    or functions which have sense only if GROUP BY is present, are allowed.
828
1485
  */
829
1486
  nesting_map allow_sum_func;
830
1487
  enum_sql_command sql_command;
831
 
  statement::Statement *statement;
832
1488
  /*
833
1489
    Usually `expr` rule of yacc is quite reused but some commands better
834
1490
    not support subqueries which comes standard with this rule, like
839
1495
 
840
1496
  thr_lock_type lock_option;
841
1497
  enum enum_duplicates duplicates;
 
1498
  enum enum_tx_isolation tx_isolation;
 
1499
  enum enum_ha_read_modes ha_read_mode;
842
1500
  union {
843
1501
    enum ha_rkey_function ha_rkey_mode;
844
1502
    enum xa_option_words xa_opt;
 
1503
    bool lock_transactional;            /* For LOCK TABLE ... IN ... MODE */
845
1504
  };
846
 
  sql_var_t option_type;
 
1505
  enum enum_var_type option_type;
 
1506
  enum enum_drop_mode drop_mode;
847
1507
 
 
1508
  uint profile_query_id;
 
1509
  uint profile_options;
 
1510
  enum column_format_type column_format;
 
1511
  uint which_columns;
 
1512
  enum Foreign_key::fk_match_opt fk_match_option;
 
1513
  enum Foreign_key::fk_option fk_update_opt;
 
1514
  enum Foreign_key::fk_option fk_delete_opt;
 
1515
  uint slave_thd_opt, start_transaction_opt;
848
1516
  int nest_level;
849
 
  uint8_t describe;
 
1517
  /*
 
1518
    In LEX representing update which were transformed to multi-update
 
1519
    stores total number of tables. For LEX representing multi-delete
 
1520
    holds number of tables from which we will delete records.
 
1521
  */
 
1522
  uint table_count;
 
1523
  uint8 describe;
850
1524
  /*
851
1525
    A flag that indicates what kinds of derived tables are present in the
852
1526
    query (0 if no derived tables, otherwise DERIVED_SUBQUERY).
853
1527
  */
854
 
  uint8_t derived_tables;
855
 
 
856
 
  /* Was the IGNORE symbol found in statement */
857
 
  bool ignore;
858
 
 
 
1528
  uint8 derived_tables;
 
1529
  bool drop_if_exists, drop_temporary, local_file, one_shot_set;
 
1530
  bool autocommit;
 
1531
  bool verbose, no_write_to_binlog;
 
1532
 
 
1533
  bool tx_chain, tx_release;
 
1534
  /*
 
1535
    Special JOIN::prepare mode: changing of query is prohibited.
 
1536
    When creating a view, we need to just check its syntax omitting
 
1537
    any optimizations: afterwards definition of the view will be
 
1538
    reconstructed by means of ::print() methods and written to
 
1539
    to an .frm file. We need this definition to stay untouched.
 
1540
  */
 
1541
  bool view_prepare_mode;
 
1542
  bool subqueries, ignore;
 
1543
  st_parsing_options parsing_options;
 
1544
  Alter_info alter_info;
 
1545
 
 
1546
  /*
 
1547
    field_list was created for view and should be removed before PS/SP
 
1548
    rexecuton
 
1549
  */
 
1550
  bool empty_field_list_on_rset;
 
1551
 
 
1552
  /*
 
1553
    Pointers to part of LOAD DATA statement that should be rewritten
 
1554
    during replication ("LOCAL 'filename' REPLACE INTO" part).
 
1555
  */
 
1556
  const char *fname_start;
 
1557
  const char *fname_end;
 
1558
  
859
1559
  /**
860
 
    During name resolution search only in the table list given by
 
1560
    During name resolution search only in the table list given by 
861
1561
    Name_resolution_context::first_name_resolution_table and
862
1562
    Name_resolution_context::last_name_resolution_table
863
 
    (see Item_field::fix_fields()).
 
1563
    (see Item_field::fix_fields()). 
864
1564
  */
865
1565
  bool use_only_table_context;
866
 
 
867
 
  /* Was the ESCAPE keyword used? */
 
1566
  
868
1567
  bool escape_used;
869
1568
  bool is_lex_started; /* If lex_start() did run. For debugging. */
870
1569
 
871
 
  LEX();
 
1570
  st_lex();
872
1571
 
873
 
  /* Note that init and de-init mostly happen in lex_start and lex_end
874
 
     and not here. This is because LEX isn't delete/new for each new
875
 
     statement in a session. It's re-used by doing lex_end, lex_start
876
 
     in sql_lex.cc
877
 
  */
878
 
  virtual ~LEX()
 
1572
  virtual ~st_lex()
879
1573
  {
 
1574
    destroy_query_tables_list();
 
1575
    plugin_unlock_list(NULL, (plugin_ref *)plugins.buffer, plugins.elements);
 
1576
    delete_dynamic(&plugins);
880
1577
  }
881
1578
 
882
 
  TableList *unlink_first_table(bool *link_to_local);
883
 
  void link_first_table_back(TableList *first, bool link_to_local);
 
1579
  TABLE_LIST *unlink_first_table(bool *link_to_local);
 
1580
  void link_first_table_back(TABLE_LIST *first, bool link_to_local);
884
1581
  void first_lists_tables_same();
885
1582
 
 
1583
  bool can_be_merged();
 
1584
  bool can_use_merged();
 
1585
  bool can_not_use_merged();
886
1586
  bool only_view_structure();
887
1587
  bool need_correct_ident();
 
1588
  uint8 get_effective_with_check(TABLE_LIST *view);
 
1589
  /*
 
1590
    Is this update command where 'WHITH CHECK OPTION' clause is important
 
1591
 
 
1592
    SYNOPSIS
 
1593
      st_lex::which_check_option_applicable()
 
1594
 
 
1595
    RETURN
 
1596
      TRUE   have to take 'WHITH CHECK OPTION' clause into account
 
1597
      FALSE  'WHITH CHECK OPTION' clause do not need
 
1598
  */
 
1599
  inline bool which_check_option_applicable()
 
1600
  {
 
1601
    switch (sql_command) {
 
1602
    case SQLCOM_UPDATE:
 
1603
    case SQLCOM_UPDATE_MULTI:
 
1604
    case SQLCOM_INSERT:
 
1605
    case SQLCOM_INSERT_SELECT:
 
1606
    case SQLCOM_REPLACE:
 
1607
    case SQLCOM_REPLACE_SELECT:
 
1608
    case SQLCOM_LOAD:
 
1609
      return TRUE;
 
1610
    default:
 
1611
      return FALSE;
 
1612
    }
 
1613
  }
888
1614
 
889
1615
  void cleanup_after_one_table_open();
890
1616
 
905
1631
    return context_stack.head();
906
1632
  }
907
1633
  /*
908
 
    Restore the LEX and Session in case of a parse error.
 
1634
    Restore the LEX and THD in case of a parse error.
909
1635
  */
910
 
  static void cleanup_lex_after_parse_error(Session *session);
 
1636
  static void cleanup_lex_after_parse_error(THD *thd);
 
1637
 
 
1638
  void reset_n_backup_query_tables_list(Query_tables_list *backup);
 
1639
  void restore_backup_query_tables_list(Query_tables_list *backup);
 
1640
 
 
1641
  bool table_or_sp_used();
911
1642
 
912
1643
  /**
913
1644
    @brief check if the statement is a single-level join
914
1645
    @return result of the check
915
 
      @retval true  The statement doesn't contain subqueries, unions and
 
1646
      @retval TRUE  The statement doesn't contain subqueries, unions and 
916
1647
                    stored procedure calls.
917
 
      @retval false There are subqueries, UNIONs or stored procedure calls.
 
1648
      @retval FALSE There are subqueries, UNIONs or stored procedure calls.
918
1649
  */
919
 
  bool is_single_level_stmt()
920
 
  {
921
 
    /*
 
1650
  bool is_single_level_stmt() 
 
1651
  { 
 
1652
    /* 
922
1653
      This check exploits the fact that the last added to all_select_list is
923
 
      on its top. So select_lex (as the first added) will be at the tail
 
1654
      on its top. So select_lex (as the first added) will be at the tail 
924
1655
      of the list.
925
 
    */
926
 
    if (&select_lex == all_selects_list)
 
1656
    */ 
 
1657
    if (&select_lex == all_selects_list && !sroutines.records)
927
1658
    {
928
 
      assert(!all_selects_list->next_select_in_list());
929
 
      return true;
 
1659
      DBUG_ASSERT(!all_selects_list->next_select_in_list());
 
1660
      return TRUE;
930
1661
    }
931
 
    return false;
932
 
  }
933
 
  bool is_cross; // CROSS keyword was used
934
 
  bool isCacheable()
935
 
  {
936
 
    return cacheable;
937
 
  }
938
 
  void setCacheable(bool val)
939
 
  {
940
 
    cacheable= val;
941
 
  }
942
 
 
943
 
  void reset()
944
 
  {
945
 
    sum_expr_used= false;
946
 
  }
947
 
 
948
 
  void setSumExprUsed()
949
 
  {
950
 
    sum_expr_used= true;
951
 
  }
952
 
 
953
 
  bool isSumExprUsed()
954
 
  {
955
 
    return sum_expr_used;
956
 
  }
957
 
private: 
958
 
  bool cacheable;
959
 
  bool sum_expr_used;
 
1662
    return FALSE;
 
1663
  }
 
1664
} LEX;
 
1665
 
 
1666
struct st_lex_local: public st_lex
 
1667
{
 
1668
  static void *operator new(size_t size) throw()
 
1669
  {
 
1670
    return sql_alloc(size);
 
1671
  }
 
1672
  static void *operator new(size_t size, MEM_ROOT *mem_root) throw()
 
1673
  {
 
1674
    return (void*) alloc_root(mem_root, (uint) size);
 
1675
  }
 
1676
  static void operator delete(void *ptr __attribute__((__unused__)),
 
1677
                              size_t size __attribute__((__unused__)))
 
1678
  { TRASH(ptr, size); }
 
1679
  static void operator delete(void *ptr __attribute__((__unused__)),
 
1680
                              MEM_ROOT *mem_root __attribute__((__unused__)))
 
1681
  { /* Never called */ }
960
1682
};
961
1683
 
962
 
extern void lex_start(Session *session);
 
1684
extern void lex_init(void);
 
1685
extern void lex_free(void);
 
1686
extern void lex_start(THD *thd);
963
1687
extern void lex_end(LEX *lex);
964
 
extern void trim_whitespace(const CHARSET_INFO * const cs, LEX_STRING *str);
 
1688
extern int MYSQLlex(void *arg, void *yythd);
 
1689
 
 
1690
extern void trim_whitespace(CHARSET_INFO *cs, LEX_STRING *str);
 
1691
 
965
1692
extern bool is_lex_native_function(const LEX_STRING *name);
966
1693
 
967
1694
/**
968
1695
  @} (End of group Semantic_Analysis)
969
1696
*/
970
1697
 
971
 
} /* namespace drizzled */
972
 
 
973
 
#endif /* DRIZZLE_SERVER */
974
 
#endif /* DRIZZLED_SQL_LEX_H */
 
1698
#endif /* MYSQL_SERVER */