← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_lex.cc

  • Committer: Mark Atwood
  • Date: 2008-10-03 01:39:40 UTC
  • mto: This revision was merged to the branch mainline in revision 437.
  • Revision ID: mark@fallenpegasus.com-20081003013940-mvefjo725dltz41h
rename logging_noop to logging_query

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_lex.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
 
17
17
/* A lexical scanner on a temporary buffer with a yacc interface */
18
18
 
19
 
#include "config.h"
20
19
#define DRIZZLE_LEX 1
21
 
#include "drizzled/configmake.h"
22
 
#include "drizzled/item/num.h"
23
 
#include "drizzled/error.h"
24
 
#include "drizzled/session.h"
25
 
#include "drizzled/sql_base.h"
26
 
#include "drizzled/lookup_symbol.h"
27
 
#include "drizzled/index_hint.h"
28
 
 
29
 
#include <cstdio>
30
 
#include <ctype.h>
31
 
 
32
 
using namespace std;
33
 
 
34
 
/* Stay outside of the namespace because otherwise bison goes nuts */
35
 
int DRIZZLElex(void *arg, void *yysession);
36
 
 
37
 
namespace drizzled
38
 
{
39
 
 
40
 
static int lex_one_token(void *arg, void *yysession);
41
 
 
42
 
/**
43
 
  save order by and tables in own lists.
 
20
#include <drizzled/server_includes.h>
 
21
 
 
22
static int lex_one_token(void *arg, void *yythd);
 
23
 
 
24
/*
 
25
  We are using pointer to this variable for distinguishing between assignment
 
26
  to NEW row field (when parsing trigger definition) and structured variable.
44
27
*/
45
 
static bool add_to_list(Session *session, SQL_LIST &list, Item *item, bool asc)
46
 
{
47
 
  Order *order;
48
 
  if (!(order = (Order *) session->alloc(sizeof(Order))))
49
 
    return(1);
50
 
  order->item_ptr= item;
51
 
  order->item= &order->item_ptr;
52
 
  order->asc = asc;
53
 
  order->free_me=0;
54
 
  order->used=0;
55
 
  order->counter_used= 0;
56
 
  list.link_in_list((unsigned char*) order,(unsigned char**) &order->next);
57
 
  return(0);
58
 
}
 
28
 
 
29
sys_var *trg_new_row_fake_var= (sys_var*) 0x01;
59
30
 
60
31
/**
61
32
  LEX_STRING constant for null-string to be used in parser and other places.
62
33
*/
63
34
const LEX_STRING null_lex_str= {NULL, 0};
64
35
 
65
 
Lex_input_stream::Lex_input_stream(Session *session,
 
36
/* Longest standard keyword name */
 
37
 
 
38
#define TOCK_NAME_LENGTH 24
 
39
 
 
40
/*
 
41
  The following data is based on the latin1 character set, and is only
 
42
  used when comparing keywords
 
43
*/
 
44
 
 
45
static uchar to_upper_lex[]=
 
46
{
 
47
    0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
 
48
   16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
 
49
   32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
 
50
   48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
 
51
   64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
 
52
   80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
 
53
   96, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
 
54
   80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,123,124,125,126,127,
 
55
  128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
 
56
  144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
 
57
  160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
 
58
  176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
 
59
  192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
 
60
  208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
 
61
  192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
 
62
  208,209,210,211,212,213,214,247,216,217,218,219,220,221,222,255
 
63
};
 
64
 
 
65
/* 
 
66
  Names of the index hints (for error messages). Keep in sync with 
 
67
  index_hint_type 
 
68
*/
 
69
 
 
70
const char * index_hint_type_name[] =
 
71
{
 
72
  "IGNORE INDEX", 
 
73
  "USE INDEX", 
 
74
  "FORCE INDEX"
 
75
};
 
76
 
 
77
inline int lex_casecmp(const char *s, const char *t, uint len)
 
78
{
 
79
  while (len-- != 0 &&
 
80
         to_upper_lex[(uchar) *s++] == to_upper_lex[(uchar) *t++]) ;
 
81
  return (int) len+1;
 
82
}
 
83
 
 
84
#include <lex_hash.h>
 
85
 
 
86
 
 
87
void lex_init(void)
 
88
{
 
89
  uint i;
 
90
  for (i=0 ; i < array_elements(symbols) ; i++)
 
91
    symbols[i].length=(uchar) strlen(symbols[i].name);
 
92
  for (i=0 ; i < array_elements(sql_functions) ; i++)
 
93
    sql_functions[i].length=(uchar) strlen(sql_functions[i].name);
 
94
 
 
95
  return;
 
96
}
 
97
 
 
98
 
 
99
void lex_free(void)
 
100
{                                       // Call this when daemon ends
 
101
  return;
 
102
}
 
103
 
 
104
 
 
105
void
 
106
st_parsing_options::reset()
 
107
{
 
108
  allows_variable= true;
 
109
  allows_select_into= true;
 
110
  allows_select_procedure= true;
 
111
  allows_derived= true;
 
112
}
 
113
 
 
114
Lex_input_stream::Lex_input_stream(THD *thd,
66
115
                                   const char* buffer,
67
116
                                   unsigned int length)
68
 
: m_session(session),
 
117
: m_thd(thd),
69
118
  yylineno(1),
70
119
  yytoklen(0),
71
120
  yylval(NULL),
85
134
  m_body_utf8(NULL),
86
135
  m_cpp_utf8_processed_ptr(NULL),
87
136
  next_state(MY_LEX_START),
 
137
  found_semicolon(NULL),
88
138
  ignore_space(1),
89
 
  in_comment(NO_COMMENT)
 
139
  in_comment(NO_COMMENT),
 
140
  m_underscore_cs(NULL)
90
141
{
91
 
  m_cpp_buf= (char*) session->alloc(length + 1);
 
142
  m_cpp_buf= (char*) thd->alloc(length + 1);
92
143
  m_cpp_ptr= m_cpp_buf;
93
144
}
94
145
 
102
153
     statement;
103
154
  2) Determine the beginning of the body.
104
155
 
105
 
  @param session        Thread context.
 
156
  @param thd        Thread context.
106
157
  @param begin_ptr  Pointer to the start of the body in the pre-processed
107
158
                    buffer.
108
159
*/
109
 
void Lex_input_stream::body_utf8_start(Session *session, const char *begin_ptr)
 
160
 
 
161
void Lex_input_stream::body_utf8_start(THD *thd, const char *begin_ptr)
110
162
{
111
163
  assert(begin_ptr);
112
164
  assert(m_cpp_buf <= begin_ptr && begin_ptr <= m_cpp_buf + m_buf_length);
113
165
 
114
 
  uint32_t body_utf8_length=
115
 
    (m_buf_length / default_charset_info->mbminlen) *
 
166
  uint body_utf8_length=
 
167
    (m_buf_length / thd->variables.character_set_client->mbminlen) *
116
168
    my_charset_utf8_bin.mbmaxlen;
117
169
 
118
 
  m_body_utf8= (char *) session->alloc(body_utf8_length + 1);
 
170
  m_body_utf8= (char *) thd->alloc(body_utf8_length + 1);
119
171
  m_body_utf8_ptr= m_body_utf8;
120
172
  *m_body_utf8_ptr= 0;
121
173
 
142
194
                  m_cpp_utf8_processed_ptr will be set in the end of the
143
195
                  operation.
144
196
*/
 
197
 
145
198
void Lex_input_stream::body_utf8_append(const char *ptr,
146
199
                                        const char *end_ptr)
147
200
{
170
223
  @param ptr  Pointer in the pre-processed buffer, which specifies the end
171
224
              of the chunk, which should be appended to the utf8 body.
172
225
*/
 
226
 
173
227
void Lex_input_stream::body_utf8_append(const char *ptr)
174
228
{
175
229
  body_utf8_append(ptr, ptr);
179
233
  The operation converts the specified text literal to the utf8 and appends
180
234
  the result to the utf8-body.
181
235
 
182
 
  @param session      Thread context.
 
236
  @param thd      Thread context.
183
237
  @param txt      Text literal.
184
238
  @param txt_cs   Character set of the text literal.
185
239
  @param end_ptr  Pointer in the pre-processed buffer, to which
186
240
                  m_cpp_utf8_processed_ptr will be set in the end of the
187
241
                  operation.
188
242
*/
189
 
void Lex_input_stream::body_utf8_append_literal(const LEX_STRING *txt,
 
243
 
 
244
void Lex_input_stream::body_utf8_append_literal(THD *thd,
 
245
                                                const LEX_STRING *txt,
 
246
                                                const CHARSET_INFO * const txt_cs,
190
247
                                                const char *end_ptr)
191
248
{
192
249
  if (!m_cpp_utf8_processed_ptr)
193
250
    return;
194
251
 
 
252
  LEX_STRING utf_txt;
 
253
 
 
254
  if (!my_charset_same(txt_cs, &my_charset_utf8_general_ci))
 
255
  {
 
256
    thd->convert_string(&utf_txt,
 
257
                        &my_charset_utf8_general_ci,
 
258
                        txt->str, txt->length,
 
259
                        txt_cs);
 
260
  }
 
261
  else
 
262
  {
 
263
    utf_txt.str= txt->str;
 
264
    utf_txt.length= txt->length;
 
265
  }
 
266
 
195
267
  /* NOTE: utf_txt.length is in bytes, not in symbols. */
196
268
 
197
 
  memcpy(m_body_utf8_ptr, txt->str, txt->length);
198
 
  m_body_utf8_ptr += txt->length;
 
269
  memcpy(m_body_utf8_ptr, utf_txt.str, utf_txt.length);
 
270
  m_body_utf8_ptr += utf_txt.length;
199
271
  *m_body_utf8_ptr= 0;
200
272
 
201
273
  m_cpp_utf8_processed_ptr= end_ptr;
202
274
}
203
275
 
 
276
 
204
277
/*
205
278
  This is called before every query that is to be parsed.
206
279
  Because of this, it's critical to not do too much things here.
207
280
  (We already do too much here)
208
281
*/
209
 
void LEX::start(Session *arg)
210
 
{
211
 
  lex_start(arg);
212
 
}
213
 
 
214
 
void lex_start(Session *session)
215
 
{
216
 
  LEX *lex= session->lex;
217
 
 
218
 
  lex->session= lex->unit.session= session;
 
282
 
 
283
void lex_start(THD *thd)
 
284
{
 
285
  LEX *lex= thd->lex;
 
286
 
 
287
  lex->thd= lex->unit.thd= thd;
219
288
 
220
289
  lex->context_stack.empty();
221
290
  lex->unit.init_query();
225
294
  lex->select_lex.init_query();
226
295
  lex->value_list.empty();
227
296
  lex->update_list.empty();
 
297
  lex->param_list.empty();
228
298
  lex->auxiliary_table_list.empty();
229
299
  lex->unit.next= lex->unit.master=
230
300
    lex->unit.link_next= lex->unit.return_to= 0;
234
304
  lex->select_lex.master= &lex->unit;
235
305
  lex->select_lex.prev= &lex->unit.slave;
236
306
  lex->select_lex.link_next= lex->select_lex.slave= lex->select_lex.next= 0;
237
 
  lex->select_lex.link_prev= (Select_Lex_Node**)&(lex->all_selects_list);
 
307
  lex->select_lex.link_prev= (st_select_lex_node**)&(lex->all_selects_list);
238
308
  lex->select_lex.options= 0;
239
309
  lex->select_lex.init_order();
240
310
  lex->select_lex.group_list.empty();
241
311
  lex->describe= 0;
 
312
  lex->subqueries= false;
242
313
  lex->derived_tables= 0;
243
314
  lex->lock_option= TL_READ;
244
315
  lex->leaf_tables_insert= 0;
 
316
  lex->parsing_options.reset();
 
317
  lex->empty_field_list_on_rset= 0;
245
318
  lex->select_lex.select_number= 1;
246
319
  lex->length=0;
247
320
  lex->select_lex.in_sum_expr=0;
 
321
  lex->select_lex.ftfunc_list_alloc.empty();
 
322
  lex->select_lex.ftfunc_list= &lex->select_lex.ftfunc_list_alloc;
248
323
  lex->select_lex.group_list.empty();
249
324
  lex->select_lex.order_list.empty();
250
325
  lex->sql_command= SQLCOM_END;
251
326
  lex->duplicates= DUP_ERROR;
252
327
  lex->ignore= 0;
 
328
  lex->proc_list.first= 0;
253
329
  lex->escape_used= false;
254
330
  lex->query_tables= 0;
255
331
  lex->reset_query_tables_list(false);
261
337
  lex->nest_level=0 ;
262
338
  lex->allow_sum_func= 0;
263
339
  lex->in_sum_func= NULL;
 
340
  /*
 
341
    ok, there must be a better solution for this, long-term
 
342
    I tried "memset" in the sql_yacc.yy code, but that for
 
343
    some reason made the values zero, even if they were set
 
344
  */
 
345
  lex->server_options.server_name= 0;
 
346
  lex->server_options.server_name_length= 0;
 
347
  lex->server_options.host= 0;
 
348
  lex->server_options.db= 0;
 
349
  lex->server_options.username= 0;
 
350
  lex->server_options.password= 0;
 
351
  lex->server_options.scheme= 0;
 
352
  lex->server_options.owner= 0;
 
353
  lex->server_options.port= -1;
264
354
 
265
355
  lex->is_lex_started= true;
266
 
  lex->statement= NULL;
267
 
  
268
 
  lex->is_cross= false;
269
 
 
270
 
  lex->reset();
 
356
  return;
271
357
}
272
358
 
273
 
void LEX::end()
 
359
void lex_end(LEX *lex)
274
360
{
275
 
  if (yacc_yyss)
 
361
  if (lex->yacc_yyss)
276
362
  {
277
 
    free(yacc_yyss);
278
 
    free(yacc_yyvs);
279
 
    yacc_yyss= 0;
280
 
    yacc_yyvs= 0;
 
363
    my_free(lex->yacc_yyss, MYF(0));
 
364
    my_free(lex->yacc_yyvs, MYF(0));
 
365
    lex->yacc_yyss= 0;
 
366
    lex->yacc_yyvs= 0;
281
367
  }
282
368
 
283
 
  delete result;
284
 
 
285
 
  result= 0;
286
 
  setCacheable(true);
287
 
 
288
 
  delete statement;
289
 
  statement= NULL;
 
369
  /* release used plugins */
 
370
  plugin_unlock_list(0, (plugin_ref*)lex->plugins.buffer, 
 
371
                     lex->plugins.elements);
 
372
  reset_dynamic(&lex->plugins);
 
373
 
 
374
  return;
290
375
}
291
376
 
292
 
static int find_keyword(Lex_input_stream *lip, uint32_t len, bool function)
 
377
 
 
378
static int find_keyword(Lex_input_stream *lip, uint len, bool function)
293
379
{
294
 
  /* Plenty of memory for the largest lex symbol we have */
295
 
  char tok_upper[64];
296
380
  const char *tok= lip->get_tok_start();
297
 
  uint32_t tok_pos= 0;
298
 
  for (;tok_pos<len && tok_pos<63;tok_pos++)
299
 
    tok_upper[tok_pos]=my_toupper(system_charset_info, tok[tok_pos]);
300
 
  tok_upper[tok_pos]=0;
301
381
 
302
 
  const SYMBOL *symbol= lookup_symbol(tok_upper, len, function);
 
382
  SYMBOL *symbol= get_hash_symbol(tok, len, function);
303
383
  if (symbol)
304
384
  {
305
385
    lip->yylval->symbol.symbol=symbol;
308
388
 
309
389
    return symbol->tok;
310
390
  }
311
 
 
312
391
  return 0;
313
392
}
314
393
 
 
394
/*
 
395
  Check if name is a keyword
 
396
 
 
397
  SYNOPSIS
 
398
    is_keyword()
 
399
    name      checked name (must not be empty)
 
400
    len       length of checked name
 
401
 
 
402
  RETURN VALUES
 
403
    0         name is a keyword
 
404
    1         name isn't a keyword
 
405
*/
 
406
 
 
407
bool is_keyword(const char *name, uint len)
 
408
{
 
409
  assert(len != 0);
 
410
  return get_hash_symbol(name,len,0)!=0;
 
411
}
 
412
 
315
413
bool is_lex_native_function(const LEX_STRING *name)
316
414
{
317
415
  assert(name != NULL);
318
 
  return (lookup_symbol(name->str, name->length, 1) != 0);
 
416
  return (get_hash_symbol(name->str, name->length, 1) != 0);
319
417
}
320
418
 
321
419
/* make a copy of token before ptr and set yytoklen */
322
 
static LEX_STRING get_token(Lex_input_stream *lip, uint32_t skip, uint32_t length)
 
420
 
 
421
static LEX_STRING get_token(Lex_input_stream *lip, uint skip, uint length)
323
422
{
324
423
  LEX_STRING tmp;
325
424
  lip->yyUnget();                       // ptr points now after last token char
326
425
  tmp.length=lip->yytoklen=length;
327
 
  tmp.str= lip->m_session->strmake(lip->get_tok_start() + skip, tmp.length);
 
426
  tmp.str= lip->m_thd->strmake(lip->get_tok_start() + skip, tmp.length);
328
427
 
329
428
  lip->m_cpp_text_start= lip->get_cpp_tok_start() + skip;
330
429
  lip->m_cpp_text_end= lip->m_cpp_text_start + tmp.length;
332
431
  return tmp;
333
432
}
334
433
 
335
 
/*
336
 
 todo:
337
 
   There are no dangerous charsets in mysql for function
338
 
   get_quoted_token yet. But it should be fixed in the
 
434
/* 
 
435
 todo: 
 
436
   There are no dangerous charsets in mysql for function 
 
437
   get_quoted_token yet. But it should be fixed in the 
339
438
   future to operate multichar strings (like ucs2)
340
439
*/
 
440
 
341
441
static LEX_STRING get_quoted_token(Lex_input_stream *lip,
342
 
                                   uint32_t skip,
343
 
                                   uint32_t length, char quote)
 
442
                                   uint skip,
 
443
                                   uint length, char quote)
344
444
{
345
445
  LEX_STRING tmp;
346
446
  const char *from, *end;
347
447
  char *to;
348
448
  lip->yyUnget();                       // ptr points now after last token char
349
449
  tmp.length= lip->yytoklen=length;
350
 
  tmp.str=(char*) lip->m_session->alloc(tmp.length+1);
 
450
  tmp.str=(char*) lip->m_thd->alloc(tmp.length+1);
351
451
  from= lip->get_tok_start() + skip;
352
452
  to= tmp.str;
353
453
  end= to+length;
372
472
  Return an unescaped text literal without quotes
373
473
  Fix sometimes to do only one scan of the string
374
474
*/
 
475
 
375
476
static char *get_text(Lex_input_stream *lip, int pre_skip, int post_skip)
376
477
{
377
 
  register unsigned char c,sep;
378
 
  bool found_escape= false;
379
 
  const CHARSET_INFO * const cs= lip->m_session->charset();
 
478
  register uchar c,sep;
 
479
  uint found_escape=0;
 
480
  const CHARSET_INFO * const cs= lip->m_thd->charset();
380
481
 
381
482
  lip->tok_bitmap= 0;
382
483
  sep= lip->yyGetLast();                        // String should end with this
384
485
  {
385
486
    c= lip->yyGet();
386
487
    lip->tok_bitmap|= c;
 
488
#ifdef USE_MB
387
489
    {
388
 
      if (use_mb(cs))
389
 
      {
390
 
        int l= my_ismbchar(cs, lip->get_ptr() -1, lip->get_end_of_query());
391
 
        if (l != 0) 
392
 
        {
393
 
          lip->skip_binary(l-1);
394
 
          continue;
395
 
        }
 
490
      int l;
 
491
      if (use_mb(cs) &&
 
492
          (l = my_ismbchar(cs,
 
493
                           lip->get_ptr() -1,
 
494
                           lip->get_end_of_query()))) {
 
495
        lip->skip_binary(l-1);
 
496
        continue;
396
497
      }
397
498
    }
 
499
#endif
398
500
    if (c == '\\')
399
501
    {                                   // Escaped character
400
 
      found_escape= true;
 
502
      found_escape=1;
401
503
      if (lip->eof())
402
 
        return 0;
 
504
        return 0;
403
505
      lip->yySkip();
404
506
    }
405
507
    else if (c == sep)
406
508
    {
407
509
      if (c == lip->yyGet())            // Check if two separators in a row
408
510
      {
409
 
        found_escape= true;                 // duplicate. Remember for delete
410
 
        continue;
 
511
        found_escape=1;                 // duplicate. Remember for delete
 
512
        continue;
411
513
      }
412
514
      else
413
515
        lip->yyUnget();
419
521
      str= lip->get_tok_start();
420
522
      end= lip->get_ptr();
421
523
      /* Extract the text from the token */
422
 
      str+= pre_skip;
423
 
      end-= post_skip;
 
524
      str += pre_skip;
 
525
      end -= post_skip;
424
526
      assert(end >= str);
425
527
 
426
 
      if (!(start= (char*) lip->m_session->alloc((uint32_t) (end-str)+1)))
427
 
        return (char*) "";              // memory::SqlAlloc has set error flag
 
528
      if (!(start= (char*) lip->m_thd->alloc((uint) (end-str)+1)))
 
529
        return (char*) "";              // Sql_alloc has set error flag
428
530
 
429
531
      lip->m_cpp_text_start= lip->get_cpp_tok_start() + pre_skip;
430
532
      lip->m_cpp_text_end= lip->get_cpp_ptr() - post_skip;
431
533
 
432
 
      if (! found_escape)
 
534
      if (!found_escape)
433
535
      {
434
 
        lip->yytoklen= (uint32_t) (end-str);
435
 
        memcpy(start, str, lip->yytoklen);
436
 
        start[lip->yytoklen]= 0;
 
536
        lip->yytoklen=(uint) (end-str);
 
537
        memcpy(start,str,lip->yytoklen);
 
538
        start[lip->yytoklen]=0;
437
539
      }
438
540
      else
439
541
      {
440
542
        char *to;
441
543
 
442
 
        for (to= start; str != end; str++)
443
 
        {
444
 
          if (use_mb(cs))
445
 
          {
446
 
            int l= my_ismbchar(cs, str, end);
447
 
            if (l != 0)
448
 
            {
449
 
              while (l--)
450
 
                *to++= *str++;
451
 
              str--;
452
 
              continue;
453
 
            }
454
 
          }
455
 
          if (*str == '\\' && (str + 1) != end)
456
 
          {
457
 
            switch (*++str) {
458
 
            case 'n':
459
 
              *to++= '\n';
460
 
              break;
461
 
            case 't':
462
 
              *to++= '\t';
463
 
              break;
464
 
            case 'r':
465
 
              *to++= '\r';
466
 
              break;
467
 
            case 'b':
468
 
              *to++= '\b';
469
 
              break;
470
 
            case '0':
471
 
              *to++= 0;                 // Ascii null
472
 
              break;
473
 
            case 'Z':                   // ^Z must be escaped on Win32
474
 
              *to++= '\032';
475
 
              break;
476
 
            case '_':
477
 
            case '%':
478
 
              *to++= '\\';              // remember prefix for wildcard
479
 
              /* Fall through */
480
 
            default:
 
544
        for (to=start ; str != end ; str++)
 
545
        {
 
546
#ifdef USE_MB
 
547
          int l;
 
548
          if (use_mb(cs) &&
 
549
              (l = my_ismbchar(cs, str, end))) {
 
550
              while (l--)
 
551
                  *to++ = *str++;
 
552
              str--;
 
553
              continue;
 
554
          }
 
555
#endif
 
556
          if (*str == '\\' && str+1 != end)
 
557
          {
 
558
            switch(*++str) {
 
559
            case 'n':
 
560
              *to++='\n';
 
561
              break;
 
562
            case 't':
 
563
              *to++= '\t';
 
564
              break;
 
565
            case 'r':
 
566
              *to++ = '\r';
 
567
              break;
 
568
            case 'b':
 
569
              *to++ = '\b';
 
570
              break;
 
571
            case '0':
 
572
              *to++= 0;                 // Ascii null
 
573
              break;
 
574
            case 'Z':                   // ^Z must be escaped on Win32
 
575
              *to++='\032';
 
576
              break;
 
577
            case '_':
 
578
            case '%':
 
579
              *to++= '\\';              // remember prefix for wildcard
 
580
              /* Fall through */
 
581
            default:
481
582
              *to++= *str;
482
 
              break;
483
 
            }
484
 
          }
485
 
          else if (*str == sep)
486
 
            *to++= *str++;              // Two ' or "
487
 
          else
488
 
            *to++ = *str;
489
 
        }
490
 
        *to= 0;
491
 
        lip->yytoklen= (uint32_t) (to - start);
 
583
              break;
 
584
            }
 
585
          }
 
586
          else if (*str == sep)
 
587
            *to++= *str++;              // Two ' or "
 
588
          else
 
589
            *to++ = *str;
 
590
        }
 
591
        *to=0;
 
592
        lip->yytoklen=(uint) (to-start);
492
593
      }
493
594
      return start;
494
595
    }
500
601
/*
501
602
** Calc type of integer; long integer, int64_t integer or real.
502
603
** Returns smallest type that match the string.
503
 
** When using uint64_t values the result is converted to a real
 
604
** When using unsigned long long values the result is converted to a real
504
605
** because else they will be unexpected sign changes because all calculation
505
606
** is done with int64_t or double.
506
607
*/
507
608
 
508
 
static const char *long_str= "2147483647";
509
 
static const uint32_t long_len= 10;
510
 
static const char *signed_long_str= "-2147483648";
511
 
static const char *int64_t_str= "9223372036854775807";
512
 
static const uint32_t int64_t_len= 19;
513
 
static const char *signed_int64_t_str= "-9223372036854775808";
514
 
static const uint32_t signed_int64_t_len= 19;
515
 
static const char *unsigned_int64_t_str= "18446744073709551615";
516
 
static const uint32_t unsigned_int64_t_len= 20;
 
609
static const char *long_str="2147483647";
 
610
static const uint long_len=10;
 
611
static const char *signed_long_str="-2147483648";
 
612
static const char *int64_t_str="9223372036854775807";
 
613
static const uint int64_t_len=19;
 
614
static const char *signed_int64_t_str="-9223372036854775808";
 
615
static const uint signed_int64_t_len=19;
 
616
static const char *unsigned_int64_t_str="18446744073709551615";
 
617
static const uint unsigned_int64_t_len=20;
517
618
 
518
 
static inline uint32_t int_token(const char *str,uint32_t length)
 
619
static inline uint int_token(const char *str,uint length)
519
620
{
520
621
  if (length < long_len)                        // quick normal case
521
622
    return NUM;
537
638
  if (length < long_len)
538
639
    return NUM;
539
640
 
540
 
  uint32_t smaller,bigger;
 
641
  uint smaller,bigger;
541
642
  const char *cmp;
542
643
  if (neg)
543
644
  {
584
685
    }
585
686
  }
586
687
  while (*cmp && *cmp++ == *str++) ;
587
 
  return ((unsigned char) str[-1] <= (unsigned char) cmp[-1]) ? smaller : bigger;
 
688
  return ((uchar) str[-1] <= (uchar) cmp[-1]) ? smaller : bigger;
588
689
}
589
690
 
590
 
} /* namespace drizzled */
 
691
 
591
692
/*
592
 
  DRIZZLElex remember the following states from the following DRIZZLElex()
 
693
  MYSQLlex remember the following states from the following MYSQLlex()
593
694
 
594
695
  - MY_LEX_EOQ                  Found end of query
595
696
  - MY_LEX_OPERATOR_OR_IDENT    Last state was an ident, text or number
596
697
                                (which can't be followed by a signed number)
597
698
*/
598
 
int DRIZZLElex(void *arg, void *yysession)
 
699
 
 
700
int MYSQLlex(void *arg, void *yythd)
599
701
{
600
 
  drizzled::Session *session= (drizzled::Session *)yysession;
601
 
  drizzled::Lex_input_stream *lip= session->m_lip;
 
702
  THD *thd= (THD *)yythd;
 
703
  Lex_input_stream *lip= thd->m_lip;
602
704
  YYSTYPE *yylval=(YYSTYPE*) arg;
603
705
  int token;
604
706
 
615
717
    return token;
616
718
  }
617
719
 
618
 
  token= drizzled::lex_one_token(arg, yysession);
 
720
  token= lex_one_token(arg, yythd);
619
721
 
620
722
  switch(token) {
621
723
  case WITH:
622
724
    /*
623
 
      Parsing 'WITH' 'ROLLUP' requires 2 look ups,
 
725
      Parsing 'WITH' 'ROLLUP' or 'WITH' 'CUBE' requires 2 look ups,
624
726
      which makes the grammar LALR(2).
625
727
      Replace by a single 'WITH_ROLLUP' or 'WITH_CUBE' token,
626
728
      to transform the grammar into a LALR(1) grammar,
627
729
      which sql_yacc.yy can process.
628
730
    */
629
 
    token= drizzled::lex_one_token(arg, yysession);
630
 
    if (token == ROLLUP_SYM)
631
 
    {
 
731
    token= lex_one_token(arg, yythd);
 
732
    switch(token) {
 
733
    case CUBE_SYM:
 
734
      return WITH_CUBE_SYM;
 
735
    case ROLLUP_SYM:
632
736
      return WITH_ROLLUP_SYM;
633
 
    }
634
 
    else
635
 
    {
 
737
    default:
636
738
      /*
637
739
        Save the token following 'WITH'
638
740
      */
641
743
      lip->lookahead_token= token;
642
744
      return WITH;
643
745
    }
 
746
    break;
644
747
  default:
645
748
    break;
646
749
  }
648
751
  return token;
649
752
}
650
753
 
651
 
namespace drizzled
652
 
{
653
 
 
654
 
int lex_one_token(void *arg, void *yysession)
 
754
int lex_one_token(void *arg, void *yythd)
655
755
{
656
756
  register unsigned char c= 0; /* Just set to shutup GCC */
657
757
  bool comment_closed;
658
758
  int   tokval, result_state;
659
759
  unsigned int length;
660
760
  enum my_lex_states state;
661
 
  Session *session= (Session *)yysession;
662
 
  Lex_input_stream *lip= session->m_lip;
663
 
  LEX *lex= session->lex;
 
761
  THD *thd= (THD *)yythd;
 
762
  Lex_input_stream *lip= thd->m_lip;
 
763
  LEX *lex= thd->lex;
664
764
  YYSTYPE *yylval=(YYSTYPE*) arg;
665
 
  const CHARSET_INFO * const cs= session->charset();
666
 
  unsigned char *state_map= cs->state_map;
667
 
  unsigned char *ident_map= cs->ident_map;
 
765
  const CHARSET_INFO * const cs= thd->charset();
 
766
  uchar *state_map= cs->state_map;
 
767
  uchar *ident_map= cs->ident_map;
668
768
 
669
769
  lip->yylval=yylval;                   // The global state
670
770
 
679
779
      // Skip starting whitespace
680
780
      while(state_map[c= lip->yyPeek()] == MY_LEX_SKIP)
681
781
      {
682
 
        if (c == '\n')
683
 
          lip->yylineno++;
 
782
        if (c == '\n')
 
783
          lip->yylineno++;
684
784
 
685
785
        lip->yySkip();
686
786
      }
693
793
    case MY_LEX_ESCAPE:
694
794
      if (lip->yyGet() == 'N')
695
795
      {                                 // Allow \N as shortcut for NULL
696
 
        yylval->lex_str.str=(char*) "\\N";
697
 
        yylval->lex_str.length=2;
698
 
        return NULL_SYM;
 
796
        yylval->lex_str.str=(char*) "\\N";
 
797
        yylval->lex_str.length=2;
 
798
        return NULL_SYM;
699
799
      }
700
800
    case MY_LEX_CHAR:                   // Unknown or single char token
701
801
    case MY_LEX_SKIP:                   // This should not happen
708
808
      }
709
809
 
710
810
      if (c != ')')
711
 
        lip->next_state= MY_LEX_START;  // Allow signed numbers
 
811
        lip->next_state= MY_LEX_START;  // Allow signed numbers
712
812
 
713
813
      if (c == ',')
714
814
      {
729
829
    case MY_LEX_IDENT_OR_HEX:
730
830
      if (lip->yyPeek() == '\'')
731
831
      {                                 // Found x'hex-number'
732
 
        state= MY_LEX_HEX_NUMBER;
733
 
        break;
 
832
        state= MY_LEX_HEX_NUMBER;
 
833
        break;
734
834
      }
735
835
    case MY_LEX_IDENT_OR_BIN:
736
836
      if (lip->yyPeek() == '\'')
740
840
      }
741
841
    case MY_LEX_IDENT:
742
842
      const char *start;
 
843
#if defined(USE_MB) && defined(USE_MB_IDENT)
743
844
      if (use_mb(cs))
744
845
      {
745
 
        result_state= IDENT_QUOTED;
 
846
        result_state= IDENT_QUOTED;
746
847
        if (my_mbcharlen(cs, lip->yyGetLast()) > 1)
747
848
        {
748
849
          int l = my_ismbchar(cs,
758
859
        {
759
860
          if (my_mbcharlen(cs, c) > 1)
760
861
          {
761
 
            int l= my_ismbchar(cs, lip->get_ptr() -1, lip->get_end_of_query());
762
 
            if (l == 0)
 
862
            int l;
 
863
            if ((l = my_ismbchar(cs,
 
864
                                 lip->get_ptr() -1,
 
865
                                 lip->get_end_of_query())) == 0)
763
866
              break;
764
867
            lip->skip_binary(l-1);
765
868
          }
766
869
        }
767
870
      }
768
871
      else
 
872
#endif
769
873
      {
770
874
        for (result_state= c; ident_map[c= lip->yyGet()]; result_state|= c) {};
771
875
        /* If there were non-ASCII characters, mark that we must convert */
782
886
        for (; state_map[c] == MY_LEX_SKIP ; c= lip->yyGet()) {};
783
887
      }
784
888
      if (start == lip->get_ptr() && c == '.' && ident_map[(uint8_t)lip->yyPeek()])
785
 
              lip->next_state=MY_LEX_IDENT_SEP;
 
889
        lip->next_state=MY_LEX_IDENT_SEP;
786
890
      else
787
891
      {                                 // '(' must follow directly if function
788
892
        lip->yyUnget();
789
 
        if ((tokval = find_keyword(lip, length, c == '(')))
790
 
        {
791
 
          lip->next_state= MY_LEX_START;        // Allow signed numbers
792
 
          return(tokval);               // Was keyword
793
 
        }
 
893
        if ((tokval = find_keyword(lip, length, c == '(')))
 
894
        {
 
895
          lip->next_state= MY_LEX_START;        // Allow signed numbers
 
896
          return(tokval);               // Was keyword
 
897
        }
794
898
        lip->yySkip();                  // next state does a unget
795
899
      }
796
900
      yylval->lex_str=get_token(lip, 0, length);
797
901
 
 
902
      /*
 
903
         Note: "SELECT _bla AS 'alias'"
 
904
         _bla should be considered as a IDENT if charset haven't been found.
 
905
         So we don't use MYF(MY_WME) with get_charset_by_csname to avoid
 
906
         producing an error.
 
907
      */
 
908
 
 
909
      if (yylval->lex_str.str[0] == '_')
 
910
      {
 
911
        const CHARSET_INFO * const cs= get_charset_by_csname(yylval->lex_str.str + 1,
 
912
                                                             MY_CS_PRIMARY, MYF(0));
 
913
        if (cs)
 
914
        {
 
915
          yylval->charset= cs;
 
916
          lip->m_underscore_cs= cs;
 
917
 
 
918
          lip->body_utf8_append(lip->m_cpp_text_start,
 
919
                                lip->get_cpp_tok_start() + length);
 
920
          return(UNDERSCORE_CHARSET);
 
921
        }
 
922
      }
 
923
 
798
924
      lip->body_utf8_append(lip->m_cpp_text_start);
799
925
 
800
 
      lip->body_utf8_append_literal(&yylval->lex_str, lip->m_cpp_text_end);
 
926
      lip->body_utf8_append_literal(thd, &yylval->lex_str, cs,
 
927
                                    lip->m_cpp_text_end);
801
928
 
802
929
      return(result_state);                     // IDENT or IDENT_QUOTED
803
930
 
807
934
      c= lip->yyGet();                  // should be '.'
808
935
      lip->next_state= MY_LEX_IDENT_START;// Next is an ident (not a keyword)
809
936
      if (!ident_map[(uint8_t)lip->yyPeek()])            // Probably ` or "
810
 
        lip->next_state= MY_LEX_START;
 
937
        lip->next_state= MY_LEX_START;
811
938
      return((int) c);
812
939
 
813
940
    case MY_LEX_NUMBER_IDENT:           // number or ident which num-start
846
973
      while (my_isdigit(cs, (c = lip->yyGet()))) ;
847
974
      if (!ident_map[c])
848
975
      {                                 // Can't be identifier
849
 
        state=MY_LEX_INT_OR_REAL;
850
 
        break;
 
976
        state=MY_LEX_INT_OR_REAL;
 
977
        break;
851
978
      }
852
979
      if (c == 'e' || c == 'E')
853
980
      {
854
 
        // The following test is written this way to allow numbers of type 1e1
 
981
        // The following test is written this way to allow numbers of type 1e1
855
982
        if (my_isdigit(cs,lip->yyPeek()) ||
856
983
            (c=(lip->yyGet())) == '+' || c == '-')
857
 
        {                               // Allow 1E+10
 
984
        {                               // Allow 1E+10
858
985
          if (my_isdigit(cs,lip->yyPeek()))     // Number must have digit after sign
859
 
          {
 
986
          {
860
987
            lip->yySkip();
861
988
            while (my_isdigit(cs,lip->yyGet())) ;
862
989
            yylval->lex_str=get_token(lip, 0, lip->yyLength());
863
 
            return(FLOAT_NUM);
864
 
          }
865
 
        }
 
990
            return(FLOAT_NUM);
 
991
          }
 
992
        }
866
993
        lip->yyUnget();
867
994
      }
868
995
      // fall through
869
996
    case MY_LEX_IDENT_START:                    // We come here after '.'
870
997
      result_state= IDENT;
 
998
#if defined(USE_MB) && defined(USE_MB_IDENT)
871
999
      if (use_mb(cs))
872
1000
      {
873
 
        result_state= IDENT_QUOTED;
 
1001
        result_state= IDENT_QUOTED;
874
1002
        while (ident_map[c=lip->yyGet()])
875
1003
        {
876
1004
          if (my_mbcharlen(cs, c) > 1)
877
1005
          {
878
 
            int l= my_ismbchar(cs, lip->get_ptr() -1, lip->get_end_of_query());
879
 
            if (l == 0)
 
1006
            int l;
 
1007
            if ((l = my_ismbchar(cs,
 
1008
                                 lip->get_ptr() -1,
 
1009
                                 lip->get_end_of_query())) == 0)
880
1010
              break;
881
1011
            lip->skip_binary(l-1);
882
1012
          }
883
1013
        }
884
1014
      }
885
1015
      else
 
1016
#endif
886
1017
      {
887
1018
        for (result_state=0; ident_map[c= lip->yyGet()]; result_state|= c) {};
888
1019
        /* If there were non-ASCII characters, mark that we must convert */
889
1020
        result_state= result_state & 0x80 ? IDENT_QUOTED : IDENT;
890
1021
      }
891
1022
      if (c == '.' && ident_map[(uint8_t)lip->yyPeek()])
892
 
        lip->next_state=MY_LEX_IDENT_SEP;// Next is '.'
 
1023
        lip->next_state=MY_LEX_IDENT_SEP;// Next is '.'
893
1024
 
894
1025
      yylval->lex_str= get_token(lip, 0, lip->yyLength());
895
1026
 
896
1027
      lip->body_utf8_append(lip->m_cpp_text_start);
897
1028
 
898
 
      lip->body_utf8_append_literal(&yylval->lex_str, lip->m_cpp_text_end);
 
1029
      lip->body_utf8_append_literal(thd, &yylval->lex_str, cs,
 
1030
                                    lip->m_cpp_text_end);
899
1031
 
900
1032
      return(result_state);
901
1033
 
902
1034
    case MY_LEX_USER_VARIABLE_DELIMITER:        // Found quote char
903
1035
    {
904
 
      uint32_t double_quotes= 0;
 
1036
      uint double_quotes= 0;
905
1037
      char quote_char= c;                       // Used char
906
1038
      while ((c=lip->yyGet()))
907
1039
      {
908
 
        int var_length;
909
 
        if ((var_length= my_mbcharlen(cs, c)) == 1)
910
 
        {
911
 
          if (c == quote_char)
912
 
          {
913
 
                  if (lip->yyPeek() != quote_char)
914
 
              break;
915
 
                  c=lip->yyGet();
916
 
            double_quotes++;
917
 
            continue;
918
 
          }
919
 
        }
920
 
        else if (var_length < 1)
921
 
          break;                                // Error
 
1040
        int var_length;
 
1041
        if ((var_length= my_mbcharlen(cs, c)) == 1)
 
1042
        {
 
1043
          if (c == quote_char)
 
1044
          {
 
1045
            if (lip->yyPeek() != quote_char)
 
1046
              break;
 
1047
            c=lip->yyGet();
 
1048
            double_quotes++;
 
1049
            continue;
 
1050
          }
 
1051
        }
 
1052
#ifdef USE_MB
 
1053
        else if (var_length < 1)
 
1054
          break;                                // Error
922
1055
        lip->skip_binary(var_length-1);
 
1056
#endif
923
1057
      }
924
1058
      if (double_quotes)
925
 
              yylval->lex_str=get_quoted_token(lip, 1, lip->yyLength() - double_quotes -1, quote_char);
 
1059
        yylval->lex_str=get_quoted_token(lip, 1,
 
1060
                                         lip->yyLength() - double_quotes -1,
 
1061
                                         quote_char);
926
1062
      else
927
1063
        yylval->lex_str=get_token(lip, 1, lip->yyLength() -1);
928
1064
      if (c == quote_char)
929
1065
        lip->yySkip();                  // Skip end `
930
1066
      lip->next_state= MY_LEX_START;
 
1067
 
931
1068
      lip->body_utf8_append(lip->m_cpp_text_start);
932
 
      lip->body_utf8_append_literal(&yylval->lex_str, lip->m_cpp_text_end);
 
1069
 
 
1070
      lip->body_utf8_append_literal(thd, &yylval->lex_str, cs,
 
1071
                                    lip->m_cpp_text_end);
 
1072
 
933
1073
      return(IDENT_QUOTED);
934
1074
    }
935
1075
    case MY_LEX_INT_OR_REAL:            // Complete int or incomplete real
936
1076
      if (c != '.')
937
1077
      {                                 // Found complete integer number.
938
1078
        yylval->lex_str=get_token(lip, 0, lip->yyLength());
939
 
        return int_token(yylval->lex_str.str,yylval->lex_str.length);
 
1079
        return int_token(yylval->lex_str.str,yylval->lex_str.length);
940
1080
      }
941
1081
      // fall through
942
1082
    case MY_LEX_REAL:                   // Incomplete real number
945
1085
      if (c == 'e' || c == 'E')
946
1086
      {
947
1087
        c = lip->yyGet();
948
 
        if (c == '-' || c == '+')
949
 
                c = lip->yyGet();                     // Skip sign
950
 
        if (!my_isdigit(cs,c))
951
 
        {                               // No digit after sign
952
 
          state= MY_LEX_CHAR;
953
 
          break;
954
 
        }
 
1088
        if (c == '-' || c == '+')
 
1089
          c = lip->yyGet();                     // Skip sign
 
1090
        if (!my_isdigit(cs,c))
 
1091
        {                               // No digit after sign
 
1092
          state= MY_LEX_CHAR;
 
1093
          break;
 
1094
        }
955
1095
        while (my_isdigit(cs,lip->yyGet())) ;
956
1096
        yylval->lex_str=get_token(lip, 0, lip->yyLength());
957
 
        return(FLOAT_NUM);
 
1097
        return(FLOAT_NUM);
958
1098
      }
959
1099
      yylval->lex_str=get_token(lip, 0, lip->yyLength());
960
1100
      return(DECIMAL_NUM);
991
1131
        lip->yySkip();
992
1132
      if ((tokval = find_keyword(lip, lip->yyLength() + 1, 0)))
993
1133
      {
994
 
        lip->next_state= MY_LEX_START;  // Allow signed numbers
995
 
        return(tokval);
 
1134
        lip->next_state= MY_LEX_START;  // Allow signed numbers
 
1135
        return(tokval);
996
1136
      }
997
1137
      state = MY_LEX_CHAR;              // Something fishy found
998
1138
      break;
1007
1147
      }
1008
1148
      if ((tokval = find_keyword(lip, lip->yyLength() + 1, 0)))
1009
1149
      {
1010
 
        lip->next_state= MY_LEX_START;  // Found long op
1011
 
        return(tokval);
 
1150
        lip->next_state= MY_LEX_START;  // Found long op
 
1151
        return(tokval);
1012
1152
      }
1013
1153
      state = MY_LEX_CHAR;              // Something fishy found
1014
1154
      break;
1016
1156
    case MY_LEX_BOOL:
1017
1157
      if (c != lip->yyPeek())
1018
1158
      {
1019
 
        state=MY_LEX_CHAR;
1020
 
        break;
 
1159
        state=MY_LEX_CHAR;
 
1160
        break;
1021
1161
      }
1022
1162
      lip->yySkip();
1023
1163
      tokval = find_keyword(lip,2,0);   // Is a bool operator
1034
1174
    case MY_LEX_STRING:                 // Incomplete text string
1035
1175
      if (!(yylval->lex_str.str = get_text(lip, 1, 1)))
1036
1176
      {
1037
 
        state= MY_LEX_CHAR;             // Read char by char
1038
 
        break;
 
1177
        state= MY_LEX_CHAR;             // Read char by char
 
1178
        break;
1039
1179
      }
1040
1180
      yylval->lex_str.length=lip->yytoklen;
1041
1181
 
1042
1182
      lip->body_utf8_append(lip->m_cpp_text_start);
1043
1183
 
1044
 
      lip->body_utf8_append_literal(&yylval->lex_str, lip->m_cpp_text_end);
 
1184
      lip->body_utf8_append_literal(thd, &yylval->lex_str,
 
1185
        lip->m_underscore_cs ? lip->m_underscore_cs : cs,
 
1186
        lip->m_cpp_text_end);
 
1187
 
 
1188
      lip->m_underscore_cs= NULL;
1045
1189
 
1046
1190
      lex->text_string_is_7bit= (lip->tok_bitmap & 0x80) ? 0 : 1;
1047
1191
      return(TEXT_STRING);
1055
1199
    case MY_LEX_LONG_COMMENT:           /* Long C comment? */
1056
1200
      if (lip->yyPeek() != '*')
1057
1201
      {
1058
 
        state=MY_LEX_CHAR;              // Probable division
1059
 
        break;
 
1202
        state=MY_LEX_CHAR;              // Probable division
 
1203
        break;
1060
1204
      }
1061
1205
      lex->select_lex.options|= OPTION_FOUND_COMMENT;
1062
1206
      /* Reject '/' '*', since we might need to turn off the echo */
1073
1217
 
1074
1218
        /*
1075
1219
          The special comment format is very strict:
1076
 
          '/' '*' '!', followed by digits ended by a non-digit.
1077
 
          There must be at least 5 digits for it to count
 
1220
          '/' '*' '!', followed by exactly
 
1221
          1 digit (major), 2 digits (minor), then 2 digits (dot).
 
1222
          32302 -> 3.23.02
 
1223
          50032 -> 5.0.32
 
1224
          50114 -> 5.1.14
1078
1225
        */
1079
 
        const int MAX_VERSION_SIZE= 16;
1080
 
        char version_str[MAX_VERSION_SIZE];
1081
 
 
1082
 
        int pos= 0;
1083
 
        do
1084
 
        {
1085
 
          version_str[pos]= lip->yyPeekn(pos);
1086
 
          pos++;
1087
 
        } while ((pos < MAX_VERSION_SIZE-1) && isdigit(version_str[pos-1]));
1088
 
        version_str[pos]= 0;
1089
 
 
1090
 
        /* To keep some semblance of compatibility, we impose a 5 digit floor */
1091
 
        if (pos > 4)
1092
 
        {
1093
 
          uint64_t version;
1094
 
          version=strtoll(version_str, NULL, 10);
 
1226
        char version_str[6];
 
1227
        version_str[0]= lip->yyPeekn(0);
 
1228
        version_str[1]= lip->yyPeekn(1);
 
1229
        version_str[2]= lip->yyPeekn(2);
 
1230
        version_str[3]= lip->yyPeekn(3);
 
1231
        version_str[4]= lip->yyPeekn(4);
 
1232
        version_str[5]= 0;
 
1233
        if (  my_isdigit(cs, version_str[0])
 
1234
           && my_isdigit(cs, version_str[1])
 
1235
           && my_isdigit(cs, version_str[2])
 
1236
           && my_isdigit(cs, version_str[3])
 
1237
           && my_isdigit(cs, version_str[4])
 
1238
           )
 
1239
        {
 
1240
          ulong version;
 
1241
          version=strtol(version_str, NULL, 10);
1095
1242
 
1096
1243
          /* Accept 'M' 'm' 'm' 'd' 'd' */
1097
 
          lip->yySkipn(pos-1);
 
1244
          lip->yySkipn(5);
1098
1245
 
1099
1246
          if (version <= DRIZZLE_VERSION_ID)
1100
1247
          {
1163
1310
        state=MY_LEX_START;
1164
1311
      }
1165
1312
      else
1166
 
        state=MY_LEX_CHAR;              // Return '*'
 
1313
        state=MY_LEX_CHAR;              // Return '*'
1167
1314
      break;
1168
1315
    case MY_LEX_SET_VAR:                // Check if ':='
1169
1316
      if (lip->yyPeek() != '=')
1170
1317
      {
1171
 
        state=MY_LEX_CHAR;              // Return ':'
1172
 
        break;
 
1318
        state=MY_LEX_CHAR;              // Return ':'
 
1319
        break;
1173
1320
      }
1174
1321
      lip->yySkip();
1175
1322
      return (SET_VAR);
1176
1323
    case MY_LEX_SEMICOLON:                      // optional line terminator
1177
1324
      if (lip->yyPeek())
1178
1325
      {
 
1326
        if ((thd->client_capabilities & CLIENT_MULTI_STATEMENTS))
 
1327
        {
 
1328
          lip->found_semicolon= lip->get_ptr();
 
1329
          thd->server_status|= SERVER_MORE_RESULTS_EXISTS;
 
1330
          lip->next_state= MY_LEX_END;
 
1331
          lip->set_echo(true);
 
1332
          return (END_OF_INPUT);
 
1333
        }
1179
1334
        state= MY_LEX_CHAR;             // Return ';'
1180
 
        break;
 
1335
        break;
1181
1336
      }
1182
1337
      lip->next_state=MY_LEX_END;       // Mark for next loop
1183
1338
      return(END_OF_INPUT);
1198
1353
      break;
1199
1354
    case MY_LEX_END:
1200
1355
      lip->next_state=MY_LEX_END;
1201
 
      return false;                     // We found end of input last time
1202
 
 
 
1356
      return(0);                        // We found end of input last time
 
1357
      
1203
1358
      /* Actually real shouldn't start with . but allow them anyhow */
1204
1359
    case MY_LEX_REAL_OR_POINT:
1205
1360
      if (my_isdigit(cs,lip->yyPeek()))
1206
 
        state= MY_LEX_REAL;             // Real
 
1361
        state = MY_LEX_REAL;            // Real
1207
1362
      else
1208
1363
      {
1209
 
        state= MY_LEX_IDENT_SEP;        // return '.'
 
1364
        state= MY_LEX_IDENT_SEP;        // return '.'
1210
1365
        lip->yyUnget();                 // Put back '.'
1211
1366
      }
1212
1367
      break;
1215
1370
      case MY_LEX_STRING:
1216
1371
      case MY_LEX_USER_VARIABLE_DELIMITER:
1217
1372
      case MY_LEX_STRING_OR_DELIMITER:
1218
 
        break;
 
1373
        break;
1219
1374
      case MY_LEX_USER_END:
1220
 
        lip->next_state=MY_LEX_SYSTEM_VAR;
1221
 
        break;
 
1375
        lip->next_state=MY_LEX_SYSTEM_VAR;
 
1376
        break;
1222
1377
      default:
1223
 
        lip->next_state=MY_LEX_HOSTNAME;
1224
 
        break;
 
1378
        lip->next_state=MY_LEX_HOSTNAME;
 
1379
        break;
1225
1380
      }
1226
1381
      yylval->lex_str.str=(char*) lip->get_ptr();
1227
1382
      yylval->lex_str.length=1;
1228
1383
      return((int) '@');
1229
1384
    case MY_LEX_HOSTNAME:               // end '@' of user@hostname
1230
1385
      for (c=lip->yyGet() ;
1231
 
           my_isalnum(cs,c) || c == '.' || c == '_' ||  c == '$';
 
1386
           my_isalnum(cs,c) || c == '.' || c == '_' ||  c == '$';
1232
1387
           c= lip->yyGet()) ;
1233
1388
      yylval->lex_str=get_token(lip, 0, lip->yyLength());
1234
1389
      return(LEX_HOSTNAME);
1243
1398
      return((int) '@');
1244
1399
    case MY_LEX_IDENT_OR_KEYWORD:
1245
1400
      /*
1246
 
        We come here when we have found two '@' in a row.
1247
 
        We should now be able to handle:
1248
 
        [(global | local | session) .]variable_name
 
1401
        We come here when we have found two '@' in a row.
 
1402
        We should now be able to handle:
 
1403
        [(global | local | session) .]variable_name
1249
1404
      */
1250
1405
 
1251
1406
      for (result_state= 0; ident_map[c= lip->yyGet()]; result_state|= c) {};
1253
1408
      result_state= result_state & 0x80 ? IDENT_QUOTED : IDENT;
1254
1409
 
1255
1410
      if (c == '.')
1256
 
        lip->next_state=MY_LEX_IDENT_SEP;
 
1411
        lip->next_state=MY_LEX_IDENT_SEP;
1257
1412
      length= lip->yyLength();
1258
1413
      if (length == 0)
1259
1414
        return(ABORT_SYM);              // Names must be nonempty.
1260
1415
      if ((tokval= find_keyword(lip, length,0)))
1261
1416
      {
1262
1417
        lip->yyUnget();                         // Put back 'c'
1263
 
        return(tokval);                         // Was keyword
 
1418
        return(tokval);                         // Was keyword
1264
1419
      }
1265
1420
      yylval->lex_str=get_token(lip, 0, length);
1266
1421
 
1267
1422
      lip->body_utf8_append(lip->m_cpp_text_start);
1268
1423
 
1269
 
      lip->body_utf8_append_literal(&yylval->lex_str, lip->m_cpp_text_end);
 
1424
      lip->body_utf8_append_literal(thd, &yylval->lex_str, cs,
 
1425
                                    lip->m_cpp_text_end);
1270
1426
 
1271
1427
      return(result_state);
1272
1428
    }
1273
1429
  }
1274
1430
}
1275
1431
 
 
1432
 
 
1433
/**
 
1434
  Construct a copy of this object to be used for mysql_alter_table
 
1435
  and mysql_create_table.
 
1436
 
 
1437
  Historically, these two functions modify their Alter_info
 
1438
  arguments. This behaviour breaks re-execution of prepared
 
1439
  statements and stored procedures and is compensated by always
 
1440
  supplying a copy of Alter_info to these functions.
 
1441
 
 
1442
  @return You need to use check the error in THD for out
 
1443
  of memory condition after calling this function.
 
1444
*/
 
1445
 
 
1446
Alter_info::Alter_info(const Alter_info &rhs, MEM_ROOT *mem_root)
 
1447
  :drop_list(rhs.drop_list, mem_root),
 
1448
  alter_list(rhs.alter_list, mem_root),
 
1449
  key_list(rhs.key_list, mem_root),
 
1450
  create_list(rhs.create_list, mem_root),
 
1451
  flags(rhs.flags),
 
1452
  keys_onoff(rhs.keys_onoff),
 
1453
  tablespace_op(rhs.tablespace_op),
 
1454
  no_parts(rhs.no_parts),
 
1455
  build_method(rhs.build_method),
 
1456
  datetime_field(rhs.datetime_field),
 
1457
  error_if_not_empty(rhs.error_if_not_empty)
 
1458
{
 
1459
  /*
 
1460
    Make deep copies of used objects.
 
1461
    This is not a fully deep copy - clone() implementations
 
1462
    of Alter_drop, Alter_column, Key, foreign_key, Key_part_spec
 
1463
    do not copy string constants. At the same length the only
 
1464
    reason we make a copy currently is that ALTER/CREATE TABLE
 
1465
    code changes input Alter_info definitions, but string
 
1466
    constants never change.
 
1467
  */
 
1468
  list_copy_and_replace_each_value(drop_list, mem_root);
 
1469
  list_copy_and_replace_each_value(alter_list, mem_root);
 
1470
  list_copy_and_replace_each_value(key_list, mem_root);
 
1471
  list_copy_and_replace_each_value(create_list, mem_root);
 
1472
}
 
1473
 
 
1474
 
1276
1475
void trim_whitespace(const CHARSET_INFO * const cs, LEX_STRING *str)
1277
1476
{
1278
1477
  /*
1280
1479
    This code assumes that there are no multi-bytes characters
1281
1480
    that can be considered white-space.
1282
1481
  */
 
1482
 
1283
1483
  while ((str->length > 0) && (my_isspace(cs, str->str[0])))
1284
1484
  {
1285
 
    str->length--;
1286
 
    str->str++;
 
1485
    str->length --;
 
1486
    str->str ++;
1287
1487
  }
1288
1488
 
1289
1489
  /*
1292
1492
  */
1293
1493
  while ((str->length > 0) && (my_isspace(cs, str->str[str->length-1])))
1294
1494
  {
1295
 
    str->length--;
 
1495
    str->length --;
1296
1496
  }
1297
1497
}
1298
1498
 
 
1499
 
1299
1500
/*
1300
 
  Select_Lex structures initialisations
 
1501
  st_select_lex structures initialisations
1301
1502
*/
1302
 
void Select_Lex_Node::init_query()
 
1503
 
 
1504
void st_select_lex_node::init_query()
1303
1505
{
1304
1506
  options= 0;
1305
1507
  linkage= UNSPECIFIED_TYPE;
1306
1508
  no_error= no_table_names_allowed= 0;
1307
 
  uncacheable.reset();
1308
 
}
1309
 
 
1310
 
void Select_Lex_Node::init_select()
1311
 
{
1312
 
}
1313
 
 
1314
 
void Select_Lex_Unit::init_query()
1315
 
{
1316
 
  Select_Lex_Node::init_query();
 
1509
  uncacheable= 0;
 
1510
}
 
1511
 
 
1512
void st_select_lex_node::init_select()
 
1513
{
 
1514
}
 
1515
 
 
1516
void st_select_lex_unit::init_query()
 
1517
{
 
1518
  st_select_lex_node::init_query();
1317
1519
  linkage= GLOBAL_OPTIONS_TYPE;
1318
1520
  global_parameters= first_select();
1319
1521
  select_limit_cnt= HA_POS_ERROR;
1330
1532
  found_rows_for_union= 0;
1331
1533
}
1332
1534
 
1333
 
void Select_Lex::init_query()
 
1535
void st_select_lex::init_query()
1334
1536
{
1335
 
  Select_Lex_Node::init_query();
 
1537
  st_select_lex_node::init_query();
1336
1538
  table_list.empty();
1337
1539
  top_join_list.empty();
1338
1540
  join_list= &top_join_list;
1356
1558
  parent_lex->push_context(&context);
1357
1559
  cond_count= between_count= with_wild= 0;
1358
1560
  max_equal_elems= 0;
 
1561
  conds_processed_with_permanent_arena= 0;
1359
1562
  ref_pointer_array= 0;
1360
1563
  select_n_where_fields= 0;
1361
1564
  select_n_having_items= 0;
1362
1565
  subquery_in_having= explicit_limit= 0;
1363
1566
  is_item_list_lookup= 0;
 
1567
  first_execution= 1;
 
1568
  first_cond_optimization= 1;
1364
1569
  parsing_place= NO_MATTER;
1365
1570
  exclude_from_table_unique_test= false;
1366
1571
  nest_level= 0;
1367
1572
  link_next= 0;
1368
1573
}
1369
1574
 
1370
 
void Select_Lex::init_select()
 
1575
void st_select_lex::init_select()
1371
1576
{
 
1577
  st_select_lex_node::init_select();
1372
1578
  sj_nests.empty();
1373
1579
  group_list.empty();
1374
 
  db= 0;
 
1580
  type= db= 0;
1375
1581
  having= 0;
 
1582
  table_join_options= 0;
1376
1583
  in_sum_expr= with_wild= 0;
1377
1584
  options= 0;
1378
1585
  braces= 0;
1379
1586
  interval_list.empty();
 
1587
  ftfunc_list_alloc.empty();
1380
1588
  inner_sum_func_list= 0;
 
1589
  ftfunc_list= &ftfunc_list_alloc;
1381
1590
  linkage= UNSPECIFIED_TYPE;
1382
1591
  order_list.elements= 0;
1383
1592
  order_list.first= 0;
1384
 
  order_list.next= (unsigned char**) &order_list.first;
 
1593
  order_list.next= (uchar**) &order_list.first;
1385
1594
  /* Set limit and offset to default values */
1386
1595
  select_limit= 0;      /* denotes the default limit = HA_POS_ERROR */
1387
1596
  offset_limit= 0;      /* denotes the default offset = 0 */
1391
1600
  non_agg_fields.empty();
1392
1601
  cond_value= having_value= Item::COND_UNDEF;
1393
1602
  inner_refs_list.empty();
1394
 
  full_group_by_flag.reset();
 
1603
  full_group_by_flag= 0;
1395
1604
}
1396
1605
 
1397
1606
/*
1398
 
  Select_Lex structures linking
 
1607
  st_select_lex structures linking
1399
1608
*/
1400
1609
 
1401
1610
/* include on level down */
1402
 
void Select_Lex_Node::include_down(Select_Lex_Node *upper)
 
1611
void st_select_lex_node::include_down(st_select_lex_node *upper)
1403
1612
{
1404
1613
  if ((next= upper->slave))
1405
1614
    next->prev= &next;
1413
1622
  include on level down (but do not link)
1414
1623
 
1415
1624
  SYNOPSYS
1416
 
    Select_Lex_Node::include_standalone()
 
1625
    st_select_lex_node::include_standalone()
1417
1626
    upper - reference on node underr which this node should be included
1418
1627
    ref - references on reference on this node
1419
1628
*/
1420
 
void Select_Lex_Node::include_standalone(Select_Lex_Node *upper,
1421
 
                                            Select_Lex_Node **ref)
 
1629
void st_select_lex_node::include_standalone(st_select_lex_node *upper,
 
1630
                                            st_select_lex_node **ref)
1422
1631
{
1423
1632
  next= 0;
1424
1633
  prev= ref;
1427
1636
}
1428
1637
 
1429
1638
/* include neighbour (on same level) */
1430
 
void Select_Lex_Node::include_neighbour(Select_Lex_Node *before)
 
1639
void st_select_lex_node::include_neighbour(st_select_lex_node *before)
1431
1640
{
1432
1641
  if ((next= before->next))
1433
1642
    next->prev= &next;
1437
1646
  slave= 0;
1438
1647
}
1439
1648
 
1440
 
/* including in global Select_Lex list */
1441
 
void Select_Lex_Node::include_global(Select_Lex_Node **plink)
 
1649
/* including in global SELECT_LEX list */
 
1650
void st_select_lex_node::include_global(st_select_lex_node **plink)
1442
1651
{
1443
1652
  if ((link_next= *plink))
1444
1653
    link_next->link_prev= &link_next;
1447
1656
}
1448
1657
 
1449
1658
//excluding from global list (internal function)
1450
 
void Select_Lex_Node::fast_exclude()
 
1659
void st_select_lex_node::fast_exclude()
1451
1660
{
1452
1661
  if (link_prev)
1453
1662
  {
1457
1666
  // Remove slave structure
1458
1667
  for (; slave; slave= slave->next)
1459
1668
    slave->fast_exclude();
1460
 
 
 
1669
  
1461
1670
}
1462
1671
 
1463
1672
/*
1464
1673
  excluding select_lex structure (except first (first select can't be
1465
1674
  deleted, because it is most upper select))
1466
1675
*/
1467
 
void Select_Lex_Node::exclude()
 
1676
void st_select_lex_node::exclude()
1468
1677
{
1469
1678
  //exclude from global list
1470
1679
  fast_exclude();
1471
1680
  //exclude from other structures
1472
1681
  if ((*prev= next))
1473
1682
    next->prev= prev;
1474
 
  /*
1475
 
     We do not need following statements, because prev pointer of first
 
1683
  /* 
 
1684
     We do not need following statements, because prev pointer of first 
1476
1685
     list element point to master->slave
1477
1686
     if (master->slave == this)
1478
1687
       master->slave= next;
1484
1693
  Exclude level of current unit from tree of SELECTs
1485
1694
 
1486
1695
  SYNOPSYS
1487
 
    Select_Lex_Unit::exclude_level()
 
1696
    st_select_lex_unit::exclude_level()
1488
1697
 
1489
1698
  NOTE: units which belong to current will be brought up on level of
1490
 
  currernt unit
 
1699
  currernt unit 
1491
1700
*/
1492
 
void Select_Lex_Unit::exclude_level()
 
1701
void st_select_lex_unit::exclude_level()
1493
1702
{
1494
 
  Select_Lex_Unit *units= 0, **units_last= &units;
1495
 
  for (Select_Lex *sl= first_select(); sl; sl= sl->next_select())
 
1703
  SELECT_LEX_UNIT *units= 0, **units_last= &units;
 
1704
  for (SELECT_LEX *sl= first_select(); sl; sl= sl->next_select())
1496
1705
  {
1497
1706
    // unlink current level from global SELECTs list
1498
1707
    if (sl->link_prev && (*sl->link_prev= sl->link_next))
1499
1708
      sl->link_next->link_prev= sl->link_prev;
1500
1709
 
1501
1710
    // bring up underlay levels
1502
 
    Select_Lex_Unit **last= 0;
1503
 
    for (Select_Lex_Unit *u= sl->first_inner_unit(); u; u= u->next_unit())
 
1711
    SELECT_LEX_UNIT **last= 0;
 
1712
    for (SELECT_LEX_UNIT *u= sl->first_inner_unit(); u; u= u->next_unit())
1504
1713
    {
1505
1714
      u->master= master;
1506
 
      last= (Select_Lex_Unit**)&(u->next);
 
1715
      last= (SELECT_LEX_UNIT**)&(u->next);
1507
1716
    }
1508
1717
    if (last)
1509
1718
    {
1515
1724
  {
1516
1725
    // include brought up levels in place of current
1517
1726
    (*prev)= units;
1518
 
    (*units_last)= (Select_Lex_Unit*)next;
 
1727
    (*units_last)= (SELECT_LEX_UNIT*)next;
1519
1728
    if (next)
1520
 
      next->prev= (Select_Lex_Node**)units_last;
 
1729
      next->prev= (SELECT_LEX_NODE**)units_last;
1521
1730
    units->prev= prev;
1522
1731
  }
1523
1732
  else
1529
1738
  }
1530
1739
}
1531
1740
 
 
1741
 
1532
1742
/*
1533
1743
  Exclude subtree of current unit from tree of SELECTs
 
1744
 
 
1745
  SYNOPSYS
 
1746
    st_select_lex_unit::exclude_tree()
1534
1747
*/
1535
 
void Select_Lex_Unit::exclude_tree()
 
1748
void st_select_lex_unit::exclude_tree()
1536
1749
{
1537
 
  for (Select_Lex *sl= first_select(); sl; sl= sl->next_select())
 
1750
  for (SELECT_LEX *sl= first_select(); sl; sl= sl->next_select())
1538
1751
  {
1539
1752
    // unlink current level from global SELECTs list
1540
1753
    if (sl->link_prev && (*sl->link_prev= sl->link_next))
1541
1754
      sl->link_next->link_prev= sl->link_prev;
1542
1755
 
1543
1756
    // unlink underlay levels
1544
 
    for (Select_Lex_Unit *u= sl->first_inner_unit(); u; u= u->next_unit())
 
1757
    for (SELECT_LEX_UNIT *u= sl->first_inner_unit(); u; u= u->next_unit())
1545
1758
    {
1546
1759
      u->exclude_level();
1547
1760
    }
1552
1765
    next->prev= prev;
1553
1766
}
1554
1767
 
1555
 
/**
1556
 
 * Mark all Select_Lex struct from this to 'last' as dependent
1557
 
 *
1558
 
 * @param Pointer to last Select_Lex struct, before wich all
1559
 
 *        Select_Lex have to be marked as dependent
1560
 
 * @note 'last' should be reachable from this Select_Lex_Node
1561
 
 */
1562
 
void Select_Lex::mark_as_dependent(Select_Lex *last)
 
1768
 
 
1769
/*
 
1770
  st_select_lex_node::mark_as_dependent mark all st_select_lex struct from 
 
1771
  this to 'last' as dependent
 
1772
 
 
1773
  SYNOPSIS
 
1774
    last - pointer to last st_select_lex struct, before wich all 
 
1775
           st_select_lex have to be marked as dependent
 
1776
 
 
1777
  NOTE
 
1778
    'last' should be reachable from this st_select_lex_node
 
1779
*/
 
1780
 
 
1781
void st_select_lex::mark_as_dependent(st_select_lex *last)
1563
1782
{
1564
1783
  /*
1565
1784
    Mark all selects from resolved to 1 before select where was
1566
1785
    found table as depended (of select where was found table)
1567
1786
  */
1568
 
  for (Select_Lex *s= this;
 
1787
  for (SELECT_LEX *s= this;
1569
1788
       s && s != last;
1570
1789
       s= s->outer_select())
1571
1790
  {
1572
 
    if (! (s->uncacheable.test(UNCACHEABLE_DEPENDENT)))
 
1791
    if (!(s->uncacheable & UNCACHEABLE_DEPENDENT))
1573
1792
    {
1574
1793
      // Select is dependent of outer select
1575
 
      s->uncacheable.set(UNCACHEABLE_DEPENDENT);
1576
 
      s->uncacheable.set(UNCACHEABLE_UNITED);
1577
 
      Select_Lex_Unit *munit= s->master_unit();
1578
 
      munit->uncacheable.set(UNCACHEABLE_UNITED);
1579
 
      munit->uncacheable.set(UNCACHEABLE_DEPENDENT);
1580
 
      for (Select_Lex *sl= munit->first_select(); sl ; sl= sl->next_select())
 
1794
      s->uncacheable= (s->uncacheable & ~UNCACHEABLE_UNITED) |
 
1795
                       UNCACHEABLE_DEPENDENT;
 
1796
      SELECT_LEX_UNIT *munit= s->master_unit();
 
1797
      munit->uncacheable= (munit->uncacheable & ~UNCACHEABLE_UNITED) |
 
1798
                       UNCACHEABLE_DEPENDENT;
 
1799
      for (SELECT_LEX *sl= munit->first_select(); sl ; sl= sl->next_select())
1581
1800
      {
1582
1801
        if (sl != s &&
1583
 
            ! (sl->uncacheable.test(UNCACHEABLE_DEPENDENT) && sl->uncacheable.test(UNCACHEABLE_UNITED)))
1584
 
          sl->uncacheable.set(UNCACHEABLE_UNITED);
 
1802
            !(sl->uncacheable & (UNCACHEABLE_DEPENDENT | UNCACHEABLE_UNITED)))
 
1803
          sl->uncacheable|= UNCACHEABLE_UNITED;
1585
1804
      }
1586
1805
    }
1587
1806
    s->is_correlated= true;
1591
1810
  }
1592
1811
}
1593
1812
 
1594
 
bool Select_Lex_Node::set_braces(bool)
1595
 
{ return true; }
1596
 
 
1597
 
bool Select_Lex_Node::inc_in_sum_expr()
1598
 
{ return true; }
1599
 
 
1600
 
uint32_t Select_Lex_Node::get_in_sum_expr() 
1601
 
{ return 0; }
1602
 
 
1603
 
TableList* Select_Lex_Node::get_table_list()
1604
 
{ return NULL; }
1605
 
 
1606
 
List<Item>* Select_Lex_Node::get_item_list()
1607
 
{ return NULL; }
1608
 
 
1609
 
TableList *Select_Lex_Node::add_table_to_list(Session *, 
1610
 
                                              Table_ident *, 
1611
 
                                              LEX_STRING *, 
1612
 
                                              const bitset<NUM_OF_TABLE_OPTIONS>&,
1613
 
                                              thr_lock_type, 
1614
 
                                              List<Index_hint> *, 
1615
 
                                              LEX_STRING *)
1616
 
{
1617
 
  return 0;
1618
 
}
1619
 
 
 
1813
bool st_select_lex_node::set_braces(bool value __attribute__((unused)))
 
1814
{ return 1; }
 
1815
bool st_select_lex_node::inc_in_sum_expr()           { return 1; }
 
1816
uint st_select_lex_node::get_in_sum_expr()           { return 0; }
 
1817
TableList* st_select_lex_node::get_table_list()     { return 0; }
 
1818
List<Item>* st_select_lex_node::get_item_list()      { return 0; }
 
1819
TableList *st_select_lex_node::add_table_to_list (THD *thd __attribute__((unused)),
 
1820
                                                   Table_ident *table __attribute__((unused)),
 
1821
                                                  LEX_STRING *alias __attribute__((unused)),
 
1822
                                                  uint32_t table_join_options __attribute__((unused)),
 
1823
                                                  thr_lock_type flags __attribute__((unused)),
 
1824
                                                  List<Index_hint> *hints __attribute__((unused)),
 
1825
                                                  LEX_STRING *option __attribute__((unused)))
 
1826
{
 
1827
  return 0;
 
1828
}
 
1829
uint32_t st_select_lex_node::get_table_join_options()
 
1830
{
 
1831
  return 0;
 
1832
}
1620
1833
 
1621
1834
/*
1622
1835
  prohibit using LIMIT clause
1623
1836
*/
1624
 
bool Select_Lex::test_limit()
 
1837
bool st_select_lex::test_limit()
1625
1838
{
1626
1839
  if (select_limit != 0)
1627
1840
  {
1628
1841
    my_error(ER_NOT_SUPPORTED_YET, MYF(0),
1629
1842
             "LIMIT & IN/ALL/ANY/SOME subquery");
1630
 
    return true;
 
1843
    return(1);
1631
1844
  }
1632
 
  return false;
1633
 
}
1634
 
 
1635
 
Select_Lex_Unit* Select_Lex_Unit::master_unit()
1636
 
{
1637
 
  return this;
1638
 
}
1639
 
 
1640
 
Select_Lex* Select_Lex_Unit::outer_select()
1641
 
{
1642
 
  return (Select_Lex*) master;
1643
 
}
1644
 
 
1645
 
bool Select_Lex::add_order_to_list(Session *session, Item *item, bool asc)
1646
 
{
1647
 
  return add_to_list(session, order_list, item, asc);
1648
 
}
1649
 
 
1650
 
bool Select_Lex::add_item_to_list(Session *, Item *item)
 
1845
  return(0);
 
1846
}
 
1847
 
 
1848
 
 
1849
st_select_lex_unit* st_select_lex_unit::master_unit()
 
1850
{
 
1851
    return this;
 
1852
}
 
1853
 
 
1854
 
 
1855
st_select_lex* st_select_lex_unit::outer_select()
 
1856
{
 
1857
  return (st_select_lex*) master;
 
1858
}
 
1859
 
 
1860
 
 
1861
bool st_select_lex::add_order_to_list(THD *thd, Item *item, bool asc)
 
1862
{
 
1863
  return add_to_list(thd, order_list, item, asc);
 
1864
}
 
1865
 
 
1866
 
 
1867
bool st_select_lex::add_item_to_list(THD *thd __attribute__((unused)),
 
1868
                                     Item *item)
1651
1869
{
1652
1870
  return(item_list.push_back(item));
1653
1871
}
1654
1872
 
1655
 
bool Select_Lex::add_group_to_list(Session *session, Item *item, bool asc)
1656
 
{
1657
 
  return add_to_list(session, group_list, item, asc);
1658
 
}
1659
 
 
1660
 
Select_Lex_Unit* Select_Lex::master_unit()
1661
 
{
1662
 
  return (Select_Lex_Unit*) master;
1663
 
}
1664
 
 
1665
 
Select_Lex* Select_Lex::outer_select()
1666
 
{
1667
 
  return (Select_Lex*) master->get_master();
1668
 
}
1669
 
 
1670
 
bool Select_Lex::set_braces(bool value)
 
1873
 
 
1874
bool st_select_lex::add_group_to_list(THD *thd, Item *item, bool asc)
 
1875
{
 
1876
  return add_to_list(thd, group_list, item, asc);
 
1877
}
 
1878
 
 
1879
 
 
1880
st_select_lex_unit* st_select_lex::master_unit()
 
1881
{
 
1882
  return (st_select_lex_unit*) master;
 
1883
}
 
1884
 
 
1885
 
 
1886
st_select_lex* st_select_lex::outer_select()
 
1887
{
 
1888
  return (st_select_lex*) master->get_master();
 
1889
}
 
1890
 
 
1891
 
 
1892
bool st_select_lex::set_braces(bool value)
1671
1893
{
1672
1894
  braces= value;
1673
 
  return false;
 
1895
  return 0; 
1674
1896
}
1675
1897
 
1676
 
bool Select_Lex::inc_in_sum_expr()
 
1898
 
 
1899
bool st_select_lex::inc_in_sum_expr()
1677
1900
{
1678
1901
  in_sum_expr++;
1679
 
  return false;
 
1902
  return 0;
1680
1903
}
1681
1904
 
1682
 
uint32_t Select_Lex::get_in_sum_expr()
 
1905
 
 
1906
uint st_select_lex::get_in_sum_expr()
1683
1907
{
1684
1908
  return in_sum_expr;
1685
1909
}
1686
1910
 
1687
 
TableList* Select_Lex::get_table_list()
 
1911
 
 
1912
TableList* st_select_lex::get_table_list()
1688
1913
{
1689
1914
  return (TableList*) table_list.first;
1690
1915
}
1691
1916
 
1692
 
List<Item>* Select_Lex::get_item_list()
 
1917
List<Item>* st_select_lex::get_item_list()
1693
1918
{
1694
1919
  return &item_list;
1695
1920
}
1696
1921
 
1697
 
 
1698
 
bool Select_Lex::setup_ref_array(Session *session, uint32_t order_group_num)
 
1922
uint32_t st_select_lex::get_table_join_options()
 
1923
{
 
1924
  return table_join_options;
 
1925
}
 
1926
 
 
1927
 
 
1928
bool st_select_lex::setup_ref_array(THD *thd, uint order_group_num)
1699
1929
{
1700
1930
  if (ref_pointer_array)
1701
 
    return false;
 
1931
    return 0;
1702
1932
 
 
1933
  /*
 
1934
    We have to create array in prepared statement memory if it is
 
1935
    prepared statement
 
1936
  */
 
1937
  Query_arena *arena= thd->stmt_arena;
1703
1938
  return (ref_pointer_array=
1704
 
          (Item **)session->alloc(sizeof(Item*) * (n_child_sum_items +
 
1939
          (Item **)arena->alloc(sizeof(Item*) * (n_child_sum_items +
1705
1940
                                                 item_list.elements +
1706
1941
                                                 select_n_having_items +
1707
1942
                                                 select_n_where_fields +
1708
1943
                                                 order_group_num)*5)) == 0;
1709
1944
}
1710
1945
 
1711
 
void Select_Lex_Unit::print(String *str, enum_query_type query_type)
 
1946
 
 
1947
void st_select_lex_unit::print(String *str, enum_query_type query_type)
1712
1948
{
1713
1949
  bool union_all= !union_distinct;
1714
 
  for (Select_Lex *sl= first_select(); sl; sl= sl->next_select())
 
1950
  for (SELECT_LEX *sl= first_select(); sl; sl= sl->next_select())
1715
1951
  {
1716
1952
    if (sl != first_select())
1717
1953
    {
1723
1959
    }
1724
1960
    if (sl->braces)
1725
1961
      str->append('(');
1726
 
    sl->print(session, str, query_type);
 
1962
    sl->print(thd, str, query_type);
1727
1963
    if (sl->braces)
1728
1964
      str->append(')');
1729
1965
  }
1734
1970
      str->append(STRING_WITH_LEN(" order by "));
1735
1971
      fake_select_lex->print_order(
1736
1972
        str,
1737
 
        (Order *) fake_select_lex->order_list.first,
 
1973
        (order_st *) fake_select_lex->order_list.first,
1738
1974
        query_type);
1739
1975
    }
1740
 
    fake_select_lex->print_limit(session, str, query_type);
 
1976
    fake_select_lex->print_limit(thd, str, query_type);
1741
1977
  }
1742
1978
}
1743
1979
 
1744
 
void Select_Lex::print_order(String *str,
1745
 
                                Order *order,
 
1980
 
 
1981
void st_select_lex::print_order(String *str,
 
1982
                                order_st *order,
1746
1983
                                enum_query_type query_type)
1747
1984
{
1748
1985
  for (; order; order= order->next)
1750
1987
    if (order->counter_used)
1751
1988
    {
1752
1989
      char buffer[20];
1753
 
      uint32_t length= snprintf(buffer, 20, "%d", order->counter);
 
1990
      uint length= snprintf(buffer, 20, "%d", order->counter);
1754
1991
      str->append(buffer, length);
1755
1992
    }
1756
1993
    else
1761
1998
      str->append(',');
1762
1999
  }
1763
2000
}
 
2001
 
1764
2002
 
1765
 
void Select_Lex::print_limit(Session *, String *str,
 
2003
void st_select_lex::print_limit(THD *thd __attribute__((unused)),
 
2004
                                String *str,
1766
2005
                                enum_query_type query_type)
1767
2006
{
1768
 
  Select_Lex_Unit *unit= master_unit();
 
2007
  SELECT_LEX_UNIT *unit= master_unit();
1769
2008
  Item_subselect *item= unit->item;
1770
2009
 
1771
2010
  if (item && unit->global_parameters == this)
1784
2023
                    ((Item_in_subselect*)item)->exec_method ==
1785
2024
                    Item_in_subselect::MATERIALIZATION) ?
1786
2025
                   true :
1787
 
                   (select_limit->val_int() == 1L) &&
 
2026
                   (select_limit->val_int() == 1LL) &&
1788
2027
                   offset_limit == 0));
1789
2028
      return;
1790
2029
    }
1802
2041
}
1803
2042
 
1804
2043
/**
1805
 
  @brief Restore the LEX and Session in case of a parse error.
 
2044
  @brief Restore the LEX and THD in case of a parse error.
1806
2045
 
1807
2046
  This is a clean up call that is invoked by the Bison generated
1808
 
  parser before returning an error from DRIZZLEparse. If your
 
2047
  parser before returning an error from MYSQLparse. If your
1809
2048
  semantic actions manipulate with the global thread state (which
1810
2049
  is a very bad practice and should not normally be employed) and
1811
2050
  need a clean-up in case of error, and you can not use %destructor
1812
2051
  rule in the grammar file itself, this function should be used
1813
2052
  to implement the clean up.
1814
2053
*/
1815
 
void LEX::cleanup_lex_after_parse_error(Session *)
 
2054
 
 
2055
void st_lex::cleanup_lex_after_parse_error(THD *thd __attribute__((unused)))
1816
2056
{
1817
2057
}
1818
2058
 
1833
2073
    this method to reset state of already initialized Query_tables_list
1834
2074
    so it can be used for processing of new statement.
1835
2075
*/
 
2076
 
1836
2077
void Query_tables_list::reset_query_tables_list(bool init)
1837
2078
{
1838
2079
  if (!init && query_tables)
1848
2089
  query_tables= 0;
1849
2090
  query_tables_last= &query_tables;
1850
2091
  query_tables_own_last= 0;
1851
 
}
 
2092
  if (init)
 
2093
  {
 
2094
    /*
 
2095
      We delay real initialization of hash (and therefore related
 
2096
      memory allocation) until first insertion into this hash.
 
2097
    */
 
2098
    hash_clear(&sroutines);
 
2099
  }
 
2100
  else if (sroutines.records)
 
2101
  {
 
2102
    /* Non-zero sroutines.records means that hash was initialized. */
 
2103
    my_hash_reset(&sroutines);
 
2104
  }
 
2105
  sroutines_list.empty();
 
2106
  sroutines_list_own_last= sroutines_list.next;
 
2107
  sroutines_list_own_elements= 0;
 
2108
  binlog_stmt_flags= 0;
 
2109
}
 
2110
 
 
2111
 
 
2112
/*
 
2113
  Destroy Query_tables_list object with freeing all resources used by it.
 
2114
 
 
2115
  SYNOPSIS
 
2116
    destroy_query_tables_list()
 
2117
*/
 
2118
 
 
2119
void Query_tables_list::destroy_query_tables_list()
 
2120
{
 
2121
  hash_free(&sroutines);
 
2122
}
 
2123
 
1852
2124
 
1853
2125
/*
1854
2126
  Initialize LEX object.
1855
2127
 
1856
2128
  SYNOPSIS
1857
 
    LEX::LEX()
 
2129
    st_lex::st_lex()
1858
2130
 
1859
2131
  NOTE
1860
2132
    LEX object initialized with this constructor can be used as part of
1861
 
    Session object for which one can safely call open_tables(), lock_tables()
 
2133
    THD object for which one can safely call open_tables(), lock_tables()
1862
2134
    and close_thread_tables() functions. But it is not yet ready for
1863
2135
    statement parsing. On should use lex_start() function to prepare LEX
1864
2136
    for this.
1865
2137
*/
1866
 
LEX::LEX()
1867
 
  :
1868
 
    result(0), 
1869
 
    yacc_yyss(0), 
1870
 
    yacc_yyvs(0),
1871
 
    charset(NULL),
1872
 
    sql_command(SQLCOM_END), 
1873
 
    option_type(OPT_DEFAULT), 
1874
 
    is_lex_started(0),
1875
 
    cacheable(true),
1876
 
    sum_expr_used(false)
 
2138
 
 
2139
st_lex::st_lex()
 
2140
  :result(0), yacc_yyss(0), yacc_yyvs(0),
 
2141
   sql_command(SQLCOM_END), option_type(OPT_DEFAULT), is_lex_started(0)
1877
2142
{
 
2143
 
 
2144
  my_init_dynamic_array2(&plugins, sizeof(plugin_ref),
 
2145
                         plugins_static_buffer,
 
2146
                         INITIAL_LEX_PLUGIN_LIST_SIZE, 
 
2147
                         INITIAL_LEX_PLUGIN_LIST_SIZE);
1878
2148
  reset_query_tables_list(true);
1879
 
  statement= NULL;
1880
 
}
 
2149
}
 
2150
 
 
2151
 
 
2152
/*
 
2153
  Check whether the merging algorithm can be used on this VIEW
 
2154
 
 
2155
  SYNOPSIS
 
2156
    st_lex::can_be_merged()
 
2157
 
 
2158
  DESCRIPTION
 
2159
    We can apply merge algorithm if it is single SELECT view  with
 
2160
    subqueries only in WHERE clause (we do not count SELECTs of underlying
 
2161
    views, and second level subqueries) and we have not grpouping, ordering,
 
2162
    HAVING clause, aggregate functions, DISTINCT clause, LIMIT clause and
 
2163
    several underlying tables.
 
2164
 
 
2165
  RETURN
 
2166
    false - only temporary table algorithm can be used
 
2167
    true  - merge algorithm can be used
 
2168
*/
 
2169
 
 
2170
bool st_lex::can_be_merged()
 
2171
{
 
2172
  // TODO: do not forget implement case when select_lex.table_list.elements==0
 
2173
 
 
2174
  /* find non VIEW subqueries/unions */
 
2175
  bool selects_allow_merge= select_lex.next_select() == 0;
 
2176
  if (selects_allow_merge)
 
2177
  {
 
2178
    for (SELECT_LEX_UNIT *tmp_unit= select_lex.first_inner_unit();
 
2179
         tmp_unit;
 
2180
         tmp_unit= tmp_unit->next_unit())
 
2181
    {
 
2182
      if (tmp_unit->first_select()->parent_lex == this &&
 
2183
          (tmp_unit->item == 0 ||
 
2184
           (tmp_unit->item->place() != IN_WHERE &&
 
2185
            tmp_unit->item->place() != IN_ON)))
 
2186
      {
 
2187
        selects_allow_merge= 0;
 
2188
        break;
 
2189
      }
 
2190
    }
 
2191
  }
 
2192
 
 
2193
  return (selects_allow_merge &&
 
2194
          select_lex.group_list.elements == 0 &&
 
2195
          select_lex.having == 0 &&
 
2196
          select_lex.with_sum_func == 0 &&
 
2197
          select_lex.table_list.elements >= 1 &&
 
2198
          !(select_lex.options & SELECT_DISTINCT) &&
 
2199
          select_lex.select_limit == 0);
 
2200
}
 
2201
 
 
2202
 
 
2203
/*
 
2204
  check if command can use VIEW with MERGE algorithm (for top VIEWs)
 
2205
 
 
2206
  SYNOPSIS
 
2207
    st_lex::can_use_merged()
 
2208
 
 
2209
  DESCRIPTION
 
2210
    Only listed here commands can use merge algorithm in top level
 
2211
    SELECT_LEX (for subqueries will be used merge algorithm if
 
2212
    st_lex::can_not_use_merged() is not true).
 
2213
 
 
2214
  RETURN
 
2215
    false - command can't use merged VIEWs
 
2216
    true  - VIEWs with MERGE algorithms can be used
 
2217
*/
 
2218
 
 
2219
bool st_lex::can_use_merged()
 
2220
{
 
2221
  switch (sql_command)
 
2222
  {
 
2223
  case SQLCOM_SELECT:
 
2224
  case SQLCOM_CREATE_TABLE:
 
2225
  case SQLCOM_UPDATE:
 
2226
  case SQLCOM_UPDATE_MULTI:
 
2227
  case SQLCOM_DELETE:
 
2228
  case SQLCOM_DELETE_MULTI:
 
2229
  case SQLCOM_INSERT:
 
2230
  case SQLCOM_INSERT_SELECT:
 
2231
  case SQLCOM_REPLACE:
 
2232
  case SQLCOM_REPLACE_SELECT:
 
2233
  case SQLCOM_LOAD:
 
2234
    return true;
 
2235
  default:
 
2236
    return false;
 
2237
  }
 
2238
}
 
2239
 
 
2240
/*
 
2241
  Check if command can't use merged views in any part of command
 
2242
 
 
2243
  SYNOPSIS
 
2244
    st_lex::can_not_use_merged()
 
2245
 
 
2246
  DESCRIPTION
 
2247
    Temporary table algorithm will be used on all SELECT levels for queries
 
2248
    listed here (see also st_lex::can_use_merged()).
 
2249
 
 
2250
  RETURN
 
2251
    false - command can't use merged VIEWs
 
2252
    true  - VIEWs with MERGE algorithms can be used
 
2253
*/
 
2254
 
 
2255
bool st_lex::can_not_use_merged()
 
2256
{
 
2257
  switch (sql_command)
 
2258
  {
 
2259
  /*
 
2260
    SQLCOM_SHOW_FIELDS is necessary to make 
 
2261
    information schema tables working correctly with views.
 
2262
    see get_schema_tables_result function
 
2263
  */
 
2264
  case SQLCOM_SHOW_FIELDS:
 
2265
    return true;
 
2266
  default:
 
2267
    return false;
 
2268
  }
 
2269
}
 
2270
 
 
2271
/*
 
2272
  Detect that we need only table structure of derived table/view
 
2273
 
 
2274
  SYNOPSIS
 
2275
    only_view_structure()
 
2276
 
 
2277
  RETURN
 
2278
    true yes, we need only structure
 
2279
    false no, we need data
 
2280
*/
 
2281
 
 
2282
bool st_lex::only_view_structure()
 
2283
{
 
2284
  switch (sql_command) {
 
2285
  case SQLCOM_SHOW_CREATE:
 
2286
  case SQLCOM_SHOW_TABLES:
 
2287
  case SQLCOM_SHOW_FIELDS:
 
2288
    return true;
 
2289
  default:
 
2290
    return false;
 
2291
  }
 
2292
}
 
2293
 
 
2294
 
 
2295
/*
 
2296
  Should Items_ident be printed correctly
 
2297
 
 
2298
  SYNOPSIS
 
2299
    need_correct_ident()
 
2300
 
 
2301
  RETURN
 
2302
    true yes, we need only structure
 
2303
    false no, we need data
 
2304
*/
 
2305
 
 
2306
 
 
2307
bool st_lex::need_correct_ident()
 
2308
{
 
2309
  switch(sql_command)
 
2310
  {
 
2311
  case SQLCOM_SHOW_CREATE:
 
2312
  case SQLCOM_SHOW_TABLES:
 
2313
    return true;
 
2314
  default:
 
2315
    return false;
 
2316
  }
 
2317
}
 
2318
 
1881
2319
 
1882
2320
/**
1883
2321
  This method should be called only during parsing.
1885
2323
  and will initialize the destination with the default
1886
2324
  database of the stored routine, rather than the default
1887
2325
  database of the connection it is parsed in.
1888
 
  E.g. if one has no current database selected, or current database
 
2326
  E.g. if one has no current database selected, or current database 
1889
2327
  set to 'bar' and then issues:
1890
2328
 
1891
2329
  CREATE PROCEDURE foo.p1() BEGIN SELECT * FROM t1 END//
1897
2335
  @return true in case of error (parsing should be aborted, false in
1898
2336
  case of success
1899
2337
*/
1900
 
bool LEX::copy_db_to(char **p_db, size_t *p_db_length) const
 
2338
 
 
2339
bool
 
2340
st_lex::copy_db_to(char **p_db, size_t *p_db_length) const
1901
2341
{
1902
 
  return session->copy_db_to(p_db, p_db_length);
 
2342
  return thd->copy_db_to(p_db, p_db_length);
1903
2343
}
1904
2344
 
1905
2345
/*
1906
2346
  initialize limit counters
1907
2347
 
1908
2348
  SYNOPSIS
1909
 
    Select_Lex_Unit::set_limit()
1910
 
    values      - Select_Lex with initial values for counters
 
2349
    st_select_lex_unit::set_limit()
 
2350
    values      - SELECT_LEX with initial values for counters
1911
2351
*/
1912
 
void Select_Lex_Unit::set_limit(Select_Lex *sl)
 
2352
 
 
2353
void st_select_lex_unit::set_limit(st_select_lex *sl)
1913
2354
{
1914
2355
  ha_rows select_limit_val;
1915
2356
  uint64_t val;
1916
2357
 
1917
2358
  val= sl->select_limit ? sl->select_limit->val_uint() : HA_POS_ERROR;
1918
2359
  select_limit_val= (ha_rows)val;
1919
 
  /*
 
2360
#ifndef BIG_TABLES
 
2361
  /* 
1920
2362
    Check for overflow : ha_rows can be smaller then uint64_t if
1921
2363
    BIG_TABLES is off.
1922
2364
    */
1923
2365
  if (val != (uint64_t)select_limit_val)
1924
2366
    select_limit_val= HA_POS_ERROR;
 
2367
#endif
1925
2368
  offset_limit_cnt= (ha_rows)(sl->offset_limit ? sl->offset_limit->val_uint() :
1926
 
                                                 0UL);
 
2369
                                                 0ULL);
1927
2370
  select_limit_cnt= select_limit_val + offset_limit_cnt;
1928
2371
  if (select_limit_cnt < select_limit_val)
1929
2372
    select_limit_cnt= HA_POS_ERROR;             // no limit
1930
2373
}
1931
2374
 
 
2375
 
1932
2376
/*
1933
2377
  Unlink the first table from the global table list and the first table from
1934
2378
  outer select (lex->select_lex) local list
1947
2391
      In this case link_to_local is set.
1948
2392
 
1949
2393
*/
1950
 
TableList *LEX::unlink_first_table(bool *link_to_local)
 
2394
TableList *st_lex::unlink_first_table(bool *link_to_local)
1951
2395
{
1952
2396
  TableList *first;
1953
2397
  if ((first= query_tables))
1966
2410
    */
1967
2411
    if ((*link_to_local= test(select_lex.table_list.first)))
1968
2412
    {
1969
 
      select_lex.context.table_list=
 
2413
      select_lex.context.table_list= 
1970
2414
        select_lex.context.first_name_resolution_table= first->next_local;
1971
 
      select_lex.table_list.first= (unsigned char*) (first->next_local);
 
2415
      select_lex.table_list.first= (uchar*) (first->next_local);
1972
2416
      select_lex.table_list.elements--; //safety
1973
2417
      first->next_local= 0;
1974
2418
      /*
1981
2425
  return first;
1982
2426
}
1983
2427
 
 
2428
 
1984
2429
/*
1985
2430
  Bring first local table of first most outer select to first place in global
1986
2431
  table list
1987
2432
 
1988
2433
  SYNOPSYS
1989
 
     LEX::first_lists_tables_same()
 
2434
     st_lex::first_lists_tables_same()
1990
2435
 
1991
2436
  NOTES
1992
2437
    In many cases (for example, usual INSERT/DELETE/...) the first table of
1993
 
    main Select_Lex have special meaning => check that it is the first table
 
2438
    main SELECT_LEX have special meaning => check that it is the first table
1994
2439
    in global list and re-link to be first in the global list if it is
1995
2440
    necessary.  We need such re-linking only for queries with sub-queries in
1996
2441
    the select list, as only in this case tables of sub-queries will go to
1997
2442
    the global list first.
1998
2443
*/
1999
 
void LEX::first_lists_tables_same()
 
2444
 
 
2445
void st_lex::first_lists_tables_same()
2000
2446
{
2001
2447
  TableList *first_table= (TableList*) select_lex.table_list.first;
2002
2448
  if (query_tables != first_table && first_table != 0)
2020
2466
  }
2021
2467
}
2022
2468
 
 
2469
 
2023
2470
/*
2024
2471
  Link table back that was unlinked with unlink_first_table()
2025
2472
 
2030
2477
  RETURN
2031
2478
    global list
2032
2479
*/
2033
 
void LEX::link_first_table_back(TableList *first, bool link_to_local)
 
2480
 
 
2481
void st_lex::link_first_table_back(TableList *first,
 
2482
                                   bool link_to_local)
2034
2483
{
2035
2484
  if (first)
2036
2485
  {
2044
2493
    {
2045
2494
      first->next_local= (TableList*) select_lex.table_list.first;
2046
2495
      select_lex.context.table_list= first;
2047
 
      select_lex.table_list.first= (unsigned char*) first;
 
2496
      select_lex.table_list.first= (uchar*) first;
2048
2497
      select_lex.table_list.elements++; //safety
2049
2498
    }
2050
2499
  }
2051
2500
}
2052
2501
 
 
2502
 
 
2503
 
2053
2504
/*
2054
2505
  cleanup lex for case when we open table by table for processing
2055
2506
 
2056
2507
  SYNOPSIS
2057
 
    LEX::cleanup_after_one_table_open()
 
2508
    st_lex::cleanup_after_one_table_open()
2058
2509
 
2059
2510
  NOTE
2060
2511
    This method is mostly responsible for cleaning up of selects lists and
2061
2512
    derived tables state. To rollback changes in Query_tables_list one has
2062
2513
    to call Query_tables_list::reset_query_tables_list(false).
2063
2514
*/
2064
 
void LEX::cleanup_after_one_table_open()
 
2515
 
 
2516
void st_lex::cleanup_after_one_table_open()
2065
2517
{
2066
2518
  /*
2067
 
    session->lex->derived_tables & additional units may be set if we open
2068
 
    a view. It is necessary to clear session->lex->derived_tables flag
2069
 
    to prevent processing of derived tables during next openTablesLock
 
2519
    thd->lex->derived_tables & additional units may be set if we open
 
2520
    a view. It is necessary to clear thd->lex->derived_tables flag
 
2521
    to prevent processing of derived tables during next open_and_lock_tables
2070
2522
    if next table is a real table and cleanup & remove underlying units
2071
 
    NOTE: all units will be connected to session->lex->select_lex, because we
 
2523
    NOTE: all units will be connected to thd->lex->select_lex, because we
2072
2524
    have not UNION on most upper level.
2073
2525
    */
2074
2526
  if (all_selects_list != &select_lex)
2075
2527
  {
2076
2528
    derived_tables= 0;
2077
2529
    /* cleunup underlying units (units of VIEW) */
2078
 
    for (Select_Lex_Unit *un= select_lex.first_inner_unit();
 
2530
    for (SELECT_LEX_UNIT *un= select_lex.first_inner_unit();
2079
2531
         un;
2080
2532
         un= un->next_unit())
2081
2533
      un->cleanup();
2086
2538
  }
2087
2539
}
2088
2540
 
2089
 
/*
2090
 
  There are Select_Lex::add_table_to_list &
2091
 
  Select_Lex::set_lock_for_tables are in sql_parse.cc
2092
 
 
2093
 
  Select_Lex::print is in sql_select.cc
2094
 
 
2095
 
  Select_Lex_Unit::prepare, Select_Lex_Unit::exec,
2096
 
  Select_Lex_Unit::cleanup, Select_Lex_Unit::reinit_exec_mechanism,
2097
 
  Select_Lex_Unit::change_result
 
2541
 
 
2542
/*
 
2543
  Save current state of Query_tables_list for this LEX, and prepare it
 
2544
  for processing of new statemnt.
 
2545
 
 
2546
  SYNOPSIS
 
2547
    reset_n_backup_query_tables_list()
 
2548
      backup  Pointer to Query_tables_list instance to be used for backup
 
2549
*/
 
2550
 
 
2551
void st_lex::reset_n_backup_query_tables_list(Query_tables_list *backup __attribute__((unused)))
 
2552
{
 
2553
}
 
2554
 
 
2555
 
 
2556
/*
 
2557
  Restore state of Query_tables_list for this LEX from backup.
 
2558
 
 
2559
  SYNOPSIS
 
2560
    restore_backup_query_tables_list()
 
2561
      backup  Pointer to Query_tables_list instance used for backup
 
2562
*/
 
2563
 
 
2564
void st_lex::restore_backup_query_tables_list(Query_tables_list *backup __attribute__((unused)))
 
2565
{
 
2566
}
 
2567
 
 
2568
 
 
2569
/*
 
2570
  Checks for usage of routines and/or tables in a parsed statement
 
2571
 
 
2572
  SYNOPSIS
 
2573
    st_lex:table_or_sp_used()
 
2574
 
 
2575
  RETURN
 
2576
    false  No routines and tables used
 
2577
    true   Either or both routines and tables are used.
 
2578
*/
 
2579
 
 
2580
bool st_lex::table_or_sp_used()
 
2581
{
 
2582
  if (sroutines.records || query_tables)
 
2583
    return(true);
 
2584
 
 
2585
  return(false);
 
2586
}
 
2587
 
 
2588
 
 
2589
/*
 
2590
  Do end-of-prepare fixup for list of tables and their merge-VIEWed tables
 
2591
 
 
2592
  SYNOPSIS
 
2593
    fix_prepare_info_in_table_list()
 
2594
      thd  Thread handle
 
2595
      tbl  List of tables to process
 
2596
 
 
2597
  DESCRIPTION
 
2598
    Perform end-end-of prepare fixup for list of tables, if any of the tables
 
2599
    is a merge-algorithm VIEW, recursively fix up its underlying tables as
 
2600
    well.
 
2601
 
 
2602
*/
 
2603
 
 
2604
static void fix_prepare_info_in_table_list(THD *thd, TableList *tbl)
 
2605
{
 
2606
  for (; tbl; tbl= tbl->next_local)
 
2607
  {
 
2608
    if (tbl->on_expr)
 
2609
    {
 
2610
      tbl->prep_on_expr= tbl->on_expr;
 
2611
      tbl->on_expr= tbl->on_expr->copy_andor_structure(thd);
 
2612
    }
 
2613
    fix_prepare_info_in_table_list(thd, tbl->merge_underlying_list);
 
2614
  }
 
2615
}
 
2616
 
 
2617
 
 
2618
/*
 
2619
  There are st_select_lex::add_table_to_list &
 
2620
  st_select_lex::set_lock_for_tables are in sql_parse.cc
 
2621
 
 
2622
  st_select_lex::print is in sql_select.cc
 
2623
 
 
2624
  st_select_lex_unit::prepare, st_select_lex_unit::exec,
 
2625
  st_select_lex_unit::cleanup, st_select_lex_unit::reinit_exec_mechanism,
 
2626
  st_select_lex_unit::change_result
2098
2627
  are in sql_union.cc
2099
2628
*/
2100
2629
 
2108
2637
 
2109
2638
  DESCRIPTION
2110
2639
    Used in filling up the tagged hints list.
2111
 
    This list is filled by first setting the kind of the hint as a
 
2640
    This list is filled by first setting the kind of the hint as a 
2112
2641
    context variable and then adding hints of the current kind.
2113
2642
    Then the context variable index_hint_type can be reset to the
2114
2643
    next hint type.
2115
2644
*/
2116
 
void Select_Lex::set_index_hint_type(enum index_hint_type type_arg, index_clause_map clause)
2117
 
{
 
2645
void st_select_lex::set_index_hint_type(enum index_hint_type type_arg,
 
2646
                                        index_clause_map clause)
 
2647
{ 
2118
2648
  current_index_hint_type= type_arg;
2119
2649
  current_index_hint_clause= clause;
2120
2650
}
2121
2651
 
 
2652
 
2122
2653
/*
2123
2654
  Makes an array to store index usage hints (ADD/FORCE/IGNORE INDEX).
2124
2655
 
2125
2656
  SYNOPSIS
2126
2657
    alloc_index_hints()
2127
 
      session         current thread.
 
2658
      thd         current thread.
2128
2659
*/
2129
 
void Select_Lex::alloc_index_hints (Session *session)
2130
 
{
2131
 
  index_hints= new (session->mem_root) List<Index_hint>();
 
2660
 
 
2661
void st_select_lex::alloc_index_hints (THD *thd)
 
2662
{ 
 
2663
  index_hints= new (thd->mem_root) List<Index_hint>(); 
2132
2664
}
2133
2665
 
 
2666
 
 
2667
 
2134
2668
/*
2135
 
  adds an element to the array storing index usage hints
 
2669
  adds an element to the array storing index usage hints 
2136
2670
  (ADD/FORCE/IGNORE INDEX).
2137
2671
 
2138
2672
  SYNOPSIS
2139
2673
    add_index_hint()
2140
 
      session         current thread.
 
2674
      thd         current thread.
2141
2675
      str         name of the index.
2142
2676
      length      number of characters in str.
2143
2677
 
2144
2678
  RETURN VALUE
2145
2679
    0 on success, non-zero otherwise
2146
2680
*/
2147
 
bool Select_Lex::add_index_hint (Session *session, char *str, uint32_t length)
 
2681
bool st_select_lex::add_index_hint (THD *thd, char *str, uint length)
2148
2682
{
2149
 
  return index_hints->push_front (new (session->mem_root)
 
2683
  return index_hints->push_front (new (thd->mem_root) 
2150
2684
                                 Index_hint(current_index_hint_type,
2151
2685
                                            current_index_hint_clause,
2152
2686
                                            str, length));
2153
2687
}
2154
 
 
2155
 
} /* namespace drizzled */