← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_lex.cc

  • Committer: Brian Aker
  • Date: 2008-10-12 01:59:02 UTC
  • Revision ID: brian@tangent.org-20081012015902-prhy6wsimdqr28om
Dead code around unsigned (first pass)

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 unsigned char 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, uint32_t len)
 
78
{
 
79
  while (len-- != 0 &&
 
80
         to_upper_lex[(unsigned char) *s++] == to_upper_lex[(unsigned char) *t++]) ;
 
81
  return (int) len+1;
 
82
}
 
83
 
 
84
#include <lex_hash.h>
 
85
 
 
86
 
 
87
void lex_init(void)
 
88
{
 
89
  uint32_t i;
 
90
  for (i=0 ; i < array_elements(symbols) ; i++)
 
91
    symbols[i].length=(unsigned char) strlen(symbols[i].name);
 
92
  for (i=0 ; i < array_elements(sql_functions) ; i++)
 
93
    sql_functions[i].length=(unsigned char) 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
166
  uint32_t body_utf8_length=
115
 
    (m_buf_length / default_charset_info->mbminlen) *
 
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
    free(lex->yacc_yyss);
 
364
    free(lex->yacc_yyvs);
 
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
  delete lex->result;
 
375
  lex->result= 0;
 
376
 
 
377
  return;
290
378
}
291
379
 
 
380
 
292
381
static int find_keyword(Lex_input_stream *lip, uint32_t len, bool function)
293
382
{
294
 
  /* Plenty of memory for the largest lex symbol we have */
295
 
  char tok_upper[64];
296
383
  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
384
 
302
 
  const SYMBOL *symbol= lookup_symbol(tok_upper, len, function);
 
385
  SYMBOL *symbol= get_hash_symbol(tok, len, function);
303
386
  if (symbol)
304
387
  {
305
388
    lip->yylval->symbol.symbol=symbol;
308
391
 
309
392
    return symbol->tok;
310
393
  }
311
 
 
312
394
  return 0;
313
395
}
314
396
 
 
397
/*
 
398
  Check if name is a keyword
 
399
 
 
400
  SYNOPSIS
 
401
    is_keyword()
 
402
    name      checked name (must not be empty)
 
403
    len       length of checked name
 
404
 
 
405
  RETURN VALUES
 
406
    0         name is a keyword
 
407
    1         name isn't a keyword
 
408
*/
 
409
 
 
410
bool is_keyword(const char *name, uint32_t len)
 
411
{
 
412
  assert(len != 0);
 
413
  return get_hash_symbol(name,len,0)!=0;
 
414
}
 
415
 
315
416
bool is_lex_native_function(const LEX_STRING *name)
316
417
{
317
418
  assert(name != NULL);
318
 
  return (lookup_symbol(name->str, name->length, 1) != 0);
 
419
  return (get_hash_symbol(name->str, name->length, 1) != 0);
319
420
}
320
421
 
321
422
/* make a copy of token before ptr and set yytoklen */
 
423
 
322
424
static LEX_STRING get_token(Lex_input_stream *lip, uint32_t skip, uint32_t length)
323
425
{
324
426
  LEX_STRING tmp;
325
427
  lip->yyUnget();                       // ptr points now after last token char
326
428
  tmp.length=lip->yytoklen=length;
327
 
  tmp.str= lip->m_session->strmake(lip->get_tok_start() + skip, tmp.length);
 
429
  tmp.str= lip->m_thd->strmake(lip->get_tok_start() + skip, tmp.length);
328
430
 
329
431
  lip->m_cpp_text_start= lip->get_cpp_tok_start() + skip;
330
432
  lip->m_cpp_text_end= lip->m_cpp_text_start + tmp.length;
332
434
  return tmp;
333
435
}
334
436
 
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
 
437
/* 
 
438
 todo: 
 
439
   There are no dangerous charsets in mysql for function 
 
440
   get_quoted_token yet. But it should be fixed in the 
339
441
   future to operate multichar strings (like ucs2)
340
442
*/
 
443
 
341
444
static LEX_STRING get_quoted_token(Lex_input_stream *lip,
342
445
                                   uint32_t skip,
343
446
                                   uint32_t length, char quote)
347
450
  char *to;
348
451
  lip->yyUnget();                       // ptr points now after last token char
349
452
  tmp.length= lip->yytoklen=length;
350
 
  tmp.str=(char*) lip->m_session->alloc(tmp.length+1);
 
453
  tmp.str=(char*) lip->m_thd->alloc(tmp.length+1);
351
454
  from= lip->get_tok_start() + skip;
352
455
  to= tmp.str;
353
456
  end= to+length;
372
475
  Return an unescaped text literal without quotes
373
476
  Fix sometimes to do only one scan of the string
374
477
*/
 
478
 
375
479
static char *get_text(Lex_input_stream *lip, int pre_skip, int post_skip)
376
480
{
377
481
  register unsigned char c,sep;
378
 
  bool found_escape= false;
379
 
  const CHARSET_INFO * const cs= lip->m_session->charset();
 
482
  uint32_t found_escape=0;
 
483
  const CHARSET_INFO * const cs= lip->m_thd->charset();
380
484
 
381
485
  lip->tok_bitmap= 0;
382
486
  sep= lip->yyGetLast();                        // String should end with this
384
488
  {
385
489
    c= lip->yyGet();
386
490
    lip->tok_bitmap|= c;
 
491
#ifdef USE_MB
387
492
    {
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
 
        }
 
493
      int l;
 
494
      if (use_mb(cs) &&
 
495
          (l = my_ismbchar(cs,
 
496
                           lip->get_ptr() -1,
 
497
                           lip->get_end_of_query()))) {
 
498
        lip->skip_binary(l-1);
 
499
        continue;
396
500
      }
397
501
    }
 
502
#endif
398
503
    if (c == '\\')
399
504
    {                                   // Escaped character
400
 
      found_escape= true;
 
505
      found_escape=1;
401
506
      if (lip->eof())
402
 
        return 0;
 
507
        return 0;
403
508
      lip->yySkip();
404
509
    }
405
510
    else if (c == sep)
406
511
    {
407
512
      if (c == lip->yyGet())            // Check if two separators in a row
408
513
      {
409
 
        found_escape= true;                 // duplicate. Remember for delete
410
 
        continue;
 
514
        found_escape=1;                 // duplicate. Remember for delete
 
515
        continue;
411
516
      }
412
517
      else
413
518
        lip->yyUnget();
419
524
      str= lip->get_tok_start();
420
525
      end= lip->get_ptr();
421
526
      /* Extract the text from the token */
422
 
      str+= pre_skip;
423
 
      end-= post_skip;
 
527
      str += pre_skip;
 
528
      end -= post_skip;
424
529
      assert(end >= str);
425
530
 
426
 
      if (!(start= (char*) lip->m_session->alloc((uint32_t) (end-str)+1)))
427
 
        return (char*) "";              // memory::SqlAlloc has set error flag
 
531
      if (!(start= (char*) lip->m_thd->alloc((uint) (end-str)+1)))
 
532
        return (char*) "";              // Sql_alloc has set error flag
428
533
 
429
534
      lip->m_cpp_text_start= lip->get_cpp_tok_start() + pre_skip;
430
535
      lip->m_cpp_text_end= lip->get_cpp_ptr() - post_skip;
431
536
 
432
 
      if (! found_escape)
 
537
      if (!found_escape)
433
538
      {
434
 
        lip->yytoklen= (uint32_t) (end-str);
435
 
        memcpy(start, str, lip->yytoklen);
436
 
        start[lip->yytoklen]= 0;
 
539
        lip->yytoklen=(uint) (end-str);
 
540
        memcpy(start,str,lip->yytoklen);
 
541
        start[lip->yytoklen]=0;
437
542
      }
438
543
      else
439
544
      {
440
545
        char *to;
441
546
 
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:
 
547
        for (to=start ; str != end ; str++)
 
548
        {
 
549
#ifdef USE_MB
 
550
          int l;
 
551
          if (use_mb(cs) &&
 
552
              (l = my_ismbchar(cs, str, end))) {
 
553
              while (l--)
 
554
                  *to++ = *str++;
 
555
              str--;
 
556
              continue;
 
557
          }
 
558
#endif
 
559
          if (*str == '\\' && str+1 != end)
 
560
          {
 
561
            switch(*++str) {
 
562
            case 'n':
 
563
              *to++='\n';
 
564
              break;
 
565
            case 't':
 
566
              *to++= '\t';
 
567
              break;
 
568
            case 'r':
 
569
              *to++ = '\r';
 
570
              break;
 
571
            case 'b':
 
572
              *to++ = '\b';
 
573
              break;
 
574
            case '0':
 
575
              *to++= 0;                 // Ascii null
 
576
              break;
 
577
            case 'Z':                   // ^Z must be escaped on Win32
 
578
              *to++='\032';
 
579
              break;
 
580
            case '_':
 
581
            case '%':
 
582
              *to++= '\\';              // remember prefix for wildcard
 
583
              /* Fall through */
 
584
            default:
481
585
              *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);
 
586
              break;
 
587
            }
 
588
          }
 
589
          else if (*str == sep)
 
590
            *to++= *str++;              // Two ' or "
 
591
          else
 
592
            *to++ = *str;
 
593
        }
 
594
        *to=0;
 
595
        lip->yytoklen=(uint) (to-start);
492
596
      }
493
597
      return start;
494
598
    }
505
609
** is done with int64_t or double.
506
610
*/
507
611
 
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;
 
612
static const char *long_str="2147483647";
 
613
static const uint32_t long_len=10;
 
614
static const char *signed_long_str="-2147483648";
 
615
static const char *int64_t_str="9223372036854775807";
 
616
static const uint32_t int64_t_len=19;
 
617
static const char *signed_int64_t_str="-9223372036854775808";
 
618
static const uint32_t signed_int64_t_len=19;
 
619
static const char *unsigned_int64_t_str="18446744073709551615";
 
620
static const uint32_t unsigned_int64_t_len=20;
517
621
 
518
622
static inline uint32_t int_token(const char *str,uint32_t length)
519
623
{
587
691
  return ((unsigned char) str[-1] <= (unsigned char) cmp[-1]) ? smaller : bigger;
588
692
}
589
693
 
590
 
} /* namespace drizzled */
 
694
 
591
695
/*
592
 
  DRIZZLElex remember the following states from the following DRIZZLElex()
 
696
  MYSQLlex remember the following states from the following MYSQLlex()
593
697
 
594
698
  - MY_LEX_EOQ                  Found end of query
595
699
  - MY_LEX_OPERATOR_OR_IDENT    Last state was an ident, text or number
596
700
                                (which can't be followed by a signed number)
597
701
*/
598
 
int DRIZZLElex(void *arg, void *yysession)
 
702
 
 
703
int MYSQLlex(void *arg, void *yythd)
599
704
{
600
 
  drizzled::Session *session= (drizzled::Session *)yysession;
601
 
  drizzled::Lex_input_stream *lip= session->m_lip;
 
705
  THD *thd= (THD *)yythd;
 
706
  Lex_input_stream *lip= thd->m_lip;
602
707
  YYSTYPE *yylval=(YYSTYPE*) arg;
603
708
  int token;
604
709
 
615
720
    return token;
616
721
  }
617
722
 
618
 
  token= drizzled::lex_one_token(arg, yysession);
 
723
  token= lex_one_token(arg, yythd);
619
724
 
620
725
  switch(token) {
621
726
  case WITH:
626
731
      to transform the grammar into a LALR(1) grammar,
627
732
      which sql_yacc.yy can process.
628
733
    */
629
 
    token= drizzled::lex_one_token(arg, yysession);
 
734
    token= lex_one_token(arg, yythd);
630
735
    if (token == ROLLUP_SYM)
631
736
    {
632
737
      return WITH_ROLLUP_SYM;
641
746
      lip->lookahead_token= token;
642
747
      return WITH;
643
748
    }
 
749
    break;
644
750
  default:
645
751
    break;
646
752
  }
648
754
  return token;
649
755
}
650
756
 
651
 
namespace drizzled
652
 
{
653
 
 
654
 
int lex_one_token(void *arg, void *yysession)
 
757
int lex_one_token(void *arg, void *yythd)
655
758
{
656
759
  register unsigned char c= 0; /* Just set to shutup GCC */
657
760
  bool comment_closed;
658
761
  int   tokval, result_state;
659
762
  unsigned int length;
660
763
  enum my_lex_states state;
661
 
  Session *session= (Session *)yysession;
662
 
  Lex_input_stream *lip= session->m_lip;
663
 
  LEX *lex= session->lex;
 
764
  THD *thd= (THD *)yythd;
 
765
  Lex_input_stream *lip= thd->m_lip;
 
766
  LEX *lex= thd->lex;
664
767
  YYSTYPE *yylval=(YYSTYPE*) arg;
665
 
  const CHARSET_INFO * const cs= session->charset();
 
768
  const CHARSET_INFO * const cs= thd->charset();
666
769
  unsigned char *state_map= cs->state_map;
667
770
  unsigned char *ident_map= cs->ident_map;
668
771
 
679
782
      // Skip starting whitespace
680
783
      while(state_map[c= lip->yyPeek()] == MY_LEX_SKIP)
681
784
      {
682
 
        if (c == '\n')
683
 
          lip->yylineno++;
 
785
        if (c == '\n')
 
786
          lip->yylineno++;
684
787
 
685
788
        lip->yySkip();
686
789
      }
693
796
    case MY_LEX_ESCAPE:
694
797
      if (lip->yyGet() == 'N')
695
798
      {                                 // Allow \N as shortcut for NULL
696
 
        yylval->lex_str.str=(char*) "\\N";
697
 
        yylval->lex_str.length=2;
698
 
        return NULL_SYM;
 
799
        yylval->lex_str.str=(char*) "\\N";
 
800
        yylval->lex_str.length=2;
 
801
        return NULL_SYM;
699
802
      }
700
803
    case MY_LEX_CHAR:                   // Unknown or single char token
701
804
    case MY_LEX_SKIP:                   // This should not happen
708
811
      }
709
812
 
710
813
      if (c != ')')
711
 
        lip->next_state= MY_LEX_START;  // Allow signed numbers
 
814
        lip->next_state= MY_LEX_START;  // Allow signed numbers
712
815
 
713
816
      if (c == ',')
714
817
      {
729
832
    case MY_LEX_IDENT_OR_HEX:
730
833
      if (lip->yyPeek() == '\'')
731
834
      {                                 // Found x'hex-number'
732
 
        state= MY_LEX_HEX_NUMBER;
733
 
        break;
 
835
        state= MY_LEX_HEX_NUMBER;
 
836
        break;
734
837
      }
735
838
    case MY_LEX_IDENT_OR_BIN:
736
839
      if (lip->yyPeek() == '\'')
740
843
      }
741
844
    case MY_LEX_IDENT:
742
845
      const char *start;
 
846
#if defined(USE_MB) && defined(USE_MB_IDENT)
743
847
      if (use_mb(cs))
744
848
      {
745
 
        result_state= IDENT_QUOTED;
 
849
        result_state= IDENT_QUOTED;
746
850
        if (my_mbcharlen(cs, lip->yyGetLast()) > 1)
747
851
        {
748
852
          int l = my_ismbchar(cs,
758
862
        {
759
863
          if (my_mbcharlen(cs, c) > 1)
760
864
          {
761
 
            int l= my_ismbchar(cs, lip->get_ptr() -1, lip->get_end_of_query());
762
 
            if (l == 0)
 
865
            int l;
 
866
            if ((l = my_ismbchar(cs,
 
867
                                 lip->get_ptr() -1,
 
868
                                 lip->get_end_of_query())) == 0)
763
869
              break;
764
870
            lip->skip_binary(l-1);
765
871
          }
766
872
        }
767
873
      }
768
874
      else
 
875
#endif
769
876
      {
770
877
        for (result_state= c; ident_map[c= lip->yyGet()]; result_state|= c) {};
771
878
        /* If there were non-ASCII characters, mark that we must convert */
782
889
        for (; state_map[c] == MY_LEX_SKIP ; c= lip->yyGet()) {};
783
890
      }
784
891
      if (start == lip->get_ptr() && c == '.' && ident_map[(uint8_t)lip->yyPeek()])
785
 
              lip->next_state=MY_LEX_IDENT_SEP;
 
892
        lip->next_state=MY_LEX_IDENT_SEP;
786
893
      else
787
894
      {                                 // '(' must follow directly if function
788
895
        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
 
        }
 
896
        if ((tokval = find_keyword(lip, length, c == '(')))
 
897
        {
 
898
          lip->next_state= MY_LEX_START;        // Allow signed numbers
 
899
          return(tokval);               // Was keyword
 
900
        }
794
901
        lip->yySkip();                  // next state does a unget
795
902
      }
796
903
      yylval->lex_str=get_token(lip, 0, length);
797
904
 
 
905
      /*
 
906
         Note: "SELECT _bla AS 'alias'"
 
907
         _bla should be considered as a IDENT if charset haven't been found.
 
908
         So we don't use MYF(MY_WME) with get_charset_by_csname to avoid
 
909
         producing an error.
 
910
      */
 
911
 
 
912
      if (yylval->lex_str.str[0] == '_')
 
913
      {
 
914
        const CHARSET_INFO * const cs= get_charset_by_csname(yylval->lex_str.str + 1,
 
915
                                                             MY_CS_PRIMARY, MYF(0));
 
916
        if (cs)
 
917
        {
 
918
          yylval->charset= cs;
 
919
          lip->m_underscore_cs= cs;
 
920
 
 
921
          lip->body_utf8_append(lip->m_cpp_text_start,
 
922
                                lip->get_cpp_tok_start() + length);
 
923
          return(UNDERSCORE_CHARSET);
 
924
        }
 
925
      }
 
926
 
798
927
      lip->body_utf8_append(lip->m_cpp_text_start);
799
928
 
800
 
      lip->body_utf8_append_literal(&yylval->lex_str, lip->m_cpp_text_end);
 
929
      lip->body_utf8_append_literal(thd, &yylval->lex_str, cs,
 
930
                                    lip->m_cpp_text_end);
801
931
 
802
932
      return(result_state);                     // IDENT or IDENT_QUOTED
803
933
 
807
937
      c= lip->yyGet();                  // should be '.'
808
938
      lip->next_state= MY_LEX_IDENT_START;// Next is an ident (not a keyword)
809
939
      if (!ident_map[(uint8_t)lip->yyPeek()])            // Probably ` or "
810
 
        lip->next_state= MY_LEX_START;
 
940
        lip->next_state= MY_LEX_START;
811
941
      return((int) c);
812
942
 
813
943
    case MY_LEX_NUMBER_IDENT:           // number or ident which num-start
846
976
      while (my_isdigit(cs, (c = lip->yyGet()))) ;
847
977
      if (!ident_map[c])
848
978
      {                                 // Can't be identifier
849
 
        state=MY_LEX_INT_OR_REAL;
850
 
        break;
 
979
        state=MY_LEX_INT_OR_REAL;
 
980
        break;
851
981
      }
852
982
      if (c == 'e' || c == 'E')
853
983
      {
854
 
        // The following test is written this way to allow numbers of type 1e1
 
984
        // The following test is written this way to allow numbers of type 1e1
855
985
        if (my_isdigit(cs,lip->yyPeek()) ||
856
986
            (c=(lip->yyGet())) == '+' || c == '-')
857
 
        {                               // Allow 1E+10
 
987
        {                               // Allow 1E+10
858
988
          if (my_isdigit(cs,lip->yyPeek()))     // Number must have digit after sign
859
 
          {
 
989
          {
860
990
            lip->yySkip();
861
991
            while (my_isdigit(cs,lip->yyGet())) ;
862
992
            yylval->lex_str=get_token(lip, 0, lip->yyLength());
863
 
            return(FLOAT_NUM);
864
 
          }
865
 
        }
 
993
            return(FLOAT_NUM);
 
994
          }
 
995
        }
866
996
        lip->yyUnget();
867
997
      }
868
998
      // fall through
869
999
    case MY_LEX_IDENT_START:                    // We come here after '.'
870
1000
      result_state= IDENT;
 
1001
#if defined(USE_MB) && defined(USE_MB_IDENT)
871
1002
      if (use_mb(cs))
872
1003
      {
873
 
        result_state= IDENT_QUOTED;
 
1004
        result_state= IDENT_QUOTED;
874
1005
        while (ident_map[c=lip->yyGet()])
875
1006
        {
876
1007
          if (my_mbcharlen(cs, c) > 1)
877
1008
          {
878
 
            int l= my_ismbchar(cs, lip->get_ptr() -1, lip->get_end_of_query());
879
 
            if (l == 0)
 
1009
            int l;
 
1010
            if ((l = my_ismbchar(cs,
 
1011
                                 lip->get_ptr() -1,
 
1012
                                 lip->get_end_of_query())) == 0)
880
1013
              break;
881
1014
            lip->skip_binary(l-1);
882
1015
          }
883
1016
        }
884
1017
      }
885
1018
      else
 
1019
#endif
886
1020
      {
887
1021
        for (result_state=0; ident_map[c= lip->yyGet()]; result_state|= c) {};
888
1022
        /* If there were non-ASCII characters, mark that we must convert */
889
1023
        result_state= result_state & 0x80 ? IDENT_QUOTED : IDENT;
890
1024
      }
891
1025
      if (c == '.' && ident_map[(uint8_t)lip->yyPeek()])
892
 
        lip->next_state=MY_LEX_IDENT_SEP;// Next is '.'
 
1026
        lip->next_state=MY_LEX_IDENT_SEP;// Next is '.'
893
1027
 
894
1028
      yylval->lex_str= get_token(lip, 0, lip->yyLength());
895
1029
 
896
1030
      lip->body_utf8_append(lip->m_cpp_text_start);
897
1031
 
898
 
      lip->body_utf8_append_literal(&yylval->lex_str, lip->m_cpp_text_end);
 
1032
      lip->body_utf8_append_literal(thd, &yylval->lex_str, cs,
 
1033
                                    lip->m_cpp_text_end);
899
1034
 
900
1035
      return(result_state);
901
1036
 
905
1040
      char quote_char= c;                       // Used char
906
1041
      while ((c=lip->yyGet()))
907
1042
      {
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
 
1043
        int var_length;
 
1044
        if ((var_length= my_mbcharlen(cs, c)) == 1)
 
1045
        {
 
1046
          if (c == quote_char)
 
1047
          {
 
1048
            if (lip->yyPeek() != quote_char)
 
1049
              break;
 
1050
            c=lip->yyGet();
 
1051
            double_quotes++;
 
1052
            continue;
 
1053
          }
 
1054
        }
 
1055
#ifdef USE_MB
 
1056
        else if (var_length < 1)
 
1057
          break;                                // Error
922
1058
        lip->skip_binary(var_length-1);
 
1059
#endif
923
1060
      }
924
1061
      if (double_quotes)
925
 
              yylval->lex_str=get_quoted_token(lip, 1, lip->yyLength() - double_quotes -1, quote_char);
 
1062
        yylval->lex_str=get_quoted_token(lip, 1,
 
1063
                                         lip->yyLength() - double_quotes -1,
 
1064
                                         quote_char);
926
1065
      else
927
1066
        yylval->lex_str=get_token(lip, 1, lip->yyLength() -1);
928
1067
      if (c == quote_char)
929
1068
        lip->yySkip();                  // Skip end `
930
1069
      lip->next_state= MY_LEX_START;
 
1070
 
931
1071
      lip->body_utf8_append(lip->m_cpp_text_start);
932
 
      lip->body_utf8_append_literal(&yylval->lex_str, lip->m_cpp_text_end);
 
1072
 
 
1073
      lip->body_utf8_append_literal(thd, &yylval->lex_str, cs,
 
1074
                                    lip->m_cpp_text_end);
 
1075
 
933
1076
      return(IDENT_QUOTED);
934
1077
    }
935
1078
    case MY_LEX_INT_OR_REAL:            // Complete int or incomplete real
936
1079
      if (c != '.')
937
1080
      {                                 // Found complete integer number.
938
1081
        yylval->lex_str=get_token(lip, 0, lip->yyLength());
939
 
        return int_token(yylval->lex_str.str,yylval->lex_str.length);
 
1082
        return int_token(yylval->lex_str.str,yylval->lex_str.length);
940
1083
      }
941
1084
      // fall through
942
1085
    case MY_LEX_REAL:                   // Incomplete real number
945
1088
      if (c == 'e' || c == 'E')
946
1089
      {
947
1090
        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
 
        }
 
1091
        if (c == '-' || c == '+')
 
1092
          c = lip->yyGet();                     // Skip sign
 
1093
        if (!my_isdigit(cs,c))
 
1094
        {                               // No digit after sign
 
1095
          state= MY_LEX_CHAR;
 
1096
          break;
 
1097
        }
955
1098
        while (my_isdigit(cs,lip->yyGet())) ;
956
1099
        yylval->lex_str=get_token(lip, 0, lip->yyLength());
957
 
        return(FLOAT_NUM);
 
1100
        return(FLOAT_NUM);
958
1101
      }
959
1102
      yylval->lex_str=get_token(lip, 0, lip->yyLength());
960
1103
      return(DECIMAL_NUM);
991
1134
        lip->yySkip();
992
1135
      if ((tokval = find_keyword(lip, lip->yyLength() + 1, 0)))
993
1136
      {
994
 
        lip->next_state= MY_LEX_START;  // Allow signed numbers
995
 
        return(tokval);
 
1137
        lip->next_state= MY_LEX_START;  // Allow signed numbers
 
1138
        return(tokval);
996
1139
      }
997
1140
      state = MY_LEX_CHAR;              // Something fishy found
998
1141
      break;
1007
1150
      }
1008
1151
      if ((tokval = find_keyword(lip, lip->yyLength() + 1, 0)))
1009
1152
      {
1010
 
        lip->next_state= MY_LEX_START;  // Found long op
1011
 
        return(tokval);
 
1153
        lip->next_state= MY_LEX_START;  // Found long op
 
1154
        return(tokval);
1012
1155
      }
1013
1156
      state = MY_LEX_CHAR;              // Something fishy found
1014
1157
      break;
1016
1159
    case MY_LEX_BOOL:
1017
1160
      if (c != lip->yyPeek())
1018
1161
      {
1019
 
        state=MY_LEX_CHAR;
1020
 
        break;
 
1162
        state=MY_LEX_CHAR;
 
1163
        break;
1021
1164
      }
1022
1165
      lip->yySkip();
1023
1166
      tokval = find_keyword(lip,2,0);   // Is a bool operator
1034
1177
    case MY_LEX_STRING:                 // Incomplete text string
1035
1178
      if (!(yylval->lex_str.str = get_text(lip, 1, 1)))
1036
1179
      {
1037
 
        state= MY_LEX_CHAR;             // Read char by char
1038
 
        break;
 
1180
        state= MY_LEX_CHAR;             // Read char by char
 
1181
        break;
1039
1182
      }
1040
1183
      yylval->lex_str.length=lip->yytoklen;
1041
1184
 
1042
1185
      lip->body_utf8_append(lip->m_cpp_text_start);
1043
1186
 
1044
 
      lip->body_utf8_append_literal(&yylval->lex_str, lip->m_cpp_text_end);
 
1187
      lip->body_utf8_append_literal(thd, &yylval->lex_str,
 
1188
        lip->m_underscore_cs ? lip->m_underscore_cs : cs,
 
1189
        lip->m_cpp_text_end);
 
1190
 
 
1191
      lip->m_underscore_cs= NULL;
1045
1192
 
1046
1193
      lex->text_string_is_7bit= (lip->tok_bitmap & 0x80) ? 0 : 1;
1047
1194
      return(TEXT_STRING);
1055
1202
    case MY_LEX_LONG_COMMENT:           /* Long C comment? */
1056
1203
      if (lip->yyPeek() != '*')
1057
1204
      {
1058
 
        state=MY_LEX_CHAR;              // Probable division
1059
 
        break;
 
1205
        state=MY_LEX_CHAR;              // Probable division
 
1206
        break;
1060
1207
      }
1061
1208
      lex->select_lex.options|= OPTION_FOUND_COMMENT;
1062
1209
      /* Reject '/' '*', since we might need to turn off the echo */
1073
1220
 
1074
1221
        /*
1075
1222
          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
 
1223
          '/' '*' '!', followed by exactly
 
1224
          1 digit (major), 2 digits (minor), then 2 digits (dot).
 
1225
          32302 -> 3.23.02
 
1226
          50032 -> 5.0.32
 
1227
          50114 -> 5.1.14
1078
1228
        */
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);
 
1229
        char version_str[6];
 
1230
        version_str[0]= lip->yyPeekn(0);
 
1231
        version_str[1]= lip->yyPeekn(1);
 
1232
        version_str[2]= lip->yyPeekn(2);
 
1233
        version_str[3]= lip->yyPeekn(3);
 
1234
        version_str[4]= lip->yyPeekn(4);
 
1235
        version_str[5]= 0;
 
1236
        if (  my_isdigit(cs, version_str[0])
 
1237
           && my_isdigit(cs, version_str[1])
 
1238
           && my_isdigit(cs, version_str[2])
 
1239
           && my_isdigit(cs, version_str[3])
 
1240
           && my_isdigit(cs, version_str[4])
 
1241
           )
 
1242
        {
 
1243
          ulong version;
 
1244
          version=strtol(version_str, NULL, 10);
1095
1245
 
1096
1246
          /* Accept 'M' 'm' 'm' 'd' 'd' */
1097
 
          lip->yySkipn(pos-1);
 
1247
          lip->yySkipn(5);
1098
1248
 
1099
1249
          if (version <= DRIZZLE_VERSION_ID)
1100
1250
          {
1163
1313
        state=MY_LEX_START;
1164
1314
      }
1165
1315
      else
1166
 
        state=MY_LEX_CHAR;              // Return '*'
 
1316
        state=MY_LEX_CHAR;              // Return '*'
1167
1317
      break;
1168
1318
    case MY_LEX_SET_VAR:                // Check if ':='
1169
1319
      if (lip->yyPeek() != '=')
1170
1320
      {
1171
 
        state=MY_LEX_CHAR;              // Return ':'
1172
 
        break;
 
1321
        state=MY_LEX_CHAR;              // Return ':'
 
1322
        break;
1173
1323
      }
1174
1324
      lip->yySkip();
1175
1325
      return (SET_VAR);
1176
1326
    case MY_LEX_SEMICOLON:                      // optional line terminator
1177
1327
      if (lip->yyPeek())
1178
1328
      {
 
1329
        if ((thd->client_capabilities & CLIENT_MULTI_STATEMENTS))
 
1330
        {
 
1331
          lip->found_semicolon= lip->get_ptr();
 
1332
          thd->server_status|= SERVER_MORE_RESULTS_EXISTS;
 
1333
          lip->next_state= MY_LEX_END;
 
1334
          lip->set_echo(true);
 
1335
          return (END_OF_INPUT);
 
1336
        }
1179
1337
        state= MY_LEX_CHAR;             // Return ';'
1180
 
        break;
 
1338
        break;
1181
1339
      }
1182
1340
      lip->next_state=MY_LEX_END;       // Mark for next loop
1183
1341
      return(END_OF_INPUT);
1198
1356
      break;
1199
1357
    case MY_LEX_END:
1200
1358
      lip->next_state=MY_LEX_END;
1201
 
      return false;                     // We found end of input last time
1202
 
 
 
1359
      return(0);                        // We found end of input last time
 
1360
      
1203
1361
      /* Actually real shouldn't start with . but allow them anyhow */
1204
1362
    case MY_LEX_REAL_OR_POINT:
1205
1363
      if (my_isdigit(cs,lip->yyPeek()))
1206
 
        state= MY_LEX_REAL;             // Real
 
1364
        state = MY_LEX_REAL;            // Real
1207
1365
      else
1208
1366
      {
1209
 
        state= MY_LEX_IDENT_SEP;        // return '.'
 
1367
        state= MY_LEX_IDENT_SEP;        // return '.'
1210
1368
        lip->yyUnget();                 // Put back '.'
1211
1369
      }
1212
1370
      break;
1215
1373
      case MY_LEX_STRING:
1216
1374
      case MY_LEX_USER_VARIABLE_DELIMITER:
1217
1375
      case MY_LEX_STRING_OR_DELIMITER:
1218
 
        break;
 
1376
        break;
1219
1377
      case MY_LEX_USER_END:
1220
 
        lip->next_state=MY_LEX_SYSTEM_VAR;
1221
 
        break;
 
1378
        lip->next_state=MY_LEX_SYSTEM_VAR;
 
1379
        break;
1222
1380
      default:
1223
 
        lip->next_state=MY_LEX_HOSTNAME;
1224
 
        break;
 
1381
        lip->next_state=MY_LEX_HOSTNAME;
 
1382
        break;
1225
1383
      }
1226
1384
      yylval->lex_str.str=(char*) lip->get_ptr();
1227
1385
      yylval->lex_str.length=1;
1228
1386
      return((int) '@');
1229
1387
    case MY_LEX_HOSTNAME:               // end '@' of user@hostname
1230
1388
      for (c=lip->yyGet() ;
1231
 
           my_isalnum(cs,c) || c == '.' || c == '_' ||  c == '$';
 
1389
           my_isalnum(cs,c) || c == '.' || c == '_' ||  c == '$';
1232
1390
           c= lip->yyGet()) ;
1233
1391
      yylval->lex_str=get_token(lip, 0, lip->yyLength());
1234
1392
      return(LEX_HOSTNAME);
1243
1401
      return((int) '@');
1244
1402
    case MY_LEX_IDENT_OR_KEYWORD:
1245
1403
      /*
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
 
1404
        We come here when we have found two '@' in a row.
 
1405
        We should now be able to handle:
 
1406
        [(global | local | session) .]variable_name
1249
1407
      */
1250
1408
 
1251
1409
      for (result_state= 0; ident_map[c= lip->yyGet()]; result_state|= c) {};
1253
1411
      result_state= result_state & 0x80 ? IDENT_QUOTED : IDENT;
1254
1412
 
1255
1413
      if (c == '.')
1256
 
        lip->next_state=MY_LEX_IDENT_SEP;
 
1414
        lip->next_state=MY_LEX_IDENT_SEP;
1257
1415
      length= lip->yyLength();
1258
1416
      if (length == 0)
1259
1417
        return(ABORT_SYM);              // Names must be nonempty.
1260
1418
      if ((tokval= find_keyword(lip, length,0)))
1261
1419
      {
1262
1420
        lip->yyUnget();                         // Put back 'c'
1263
 
        return(tokval);                         // Was keyword
 
1421
        return(tokval);                         // Was keyword
1264
1422
      }
1265
1423
      yylval->lex_str=get_token(lip, 0, length);
1266
1424
 
1267
1425
      lip->body_utf8_append(lip->m_cpp_text_start);
1268
1426
 
1269
 
      lip->body_utf8_append_literal(&yylval->lex_str, lip->m_cpp_text_end);
 
1427
      lip->body_utf8_append_literal(thd, &yylval->lex_str, cs,
 
1428
                                    lip->m_cpp_text_end);
1270
1429
 
1271
1430
      return(result_state);
1272
1431
    }
1273
1432
  }
1274
1433
}
1275
1434
 
 
1435
 
 
1436
/**
 
1437
  Construct a copy of this object to be used for mysql_alter_table
 
1438
  and mysql_create_table.
 
1439
 
 
1440
  Historically, these two functions modify their Alter_info
 
1441
  arguments. This behaviour breaks re-execution of prepared
 
1442
  statements and stored procedures and is compensated by always
 
1443
  supplying a copy of Alter_info to these functions.
 
1444
 
 
1445
  @return You need to use check the error in THD for out
 
1446
  of memory condition after calling this function.
 
1447
*/
 
1448
 
 
1449
Alter_info::Alter_info(const Alter_info &rhs, MEM_ROOT *mem_root)
 
1450
  :drop_list(rhs.drop_list, mem_root),
 
1451
  alter_list(rhs.alter_list, mem_root),
 
1452
  key_list(rhs.key_list, mem_root),
 
1453
  create_list(rhs.create_list, mem_root),
 
1454
  flags(rhs.flags),
 
1455
  keys_onoff(rhs.keys_onoff),
 
1456
  tablespace_op(rhs.tablespace_op),
 
1457
  no_parts(rhs.no_parts),
 
1458
  build_method(rhs.build_method),
 
1459
  datetime_field(rhs.datetime_field),
 
1460
  error_if_not_empty(rhs.error_if_not_empty)
 
1461
{
 
1462
  /*
 
1463
    Make deep copies of used objects.
 
1464
    This is not a fully deep copy - clone() implementations
 
1465
    of Alter_drop, Alter_column, Key, foreign_key, Key_part_spec
 
1466
    do not copy string constants. At the same length the only
 
1467
    reason we make a copy currently is that ALTER/CREATE TABLE
 
1468
    code changes input Alter_info definitions, but string
 
1469
    constants never change.
 
1470
  */
 
1471
  list_copy_and_replace_each_value(drop_list, mem_root);
 
1472
  list_copy_and_replace_each_value(alter_list, mem_root);
 
1473
  list_copy_and_replace_each_value(key_list, mem_root);
 
1474
  list_copy_and_replace_each_value(create_list, mem_root);
 
1475
}
 
1476
 
 
1477
 
1276
1478
void trim_whitespace(const CHARSET_INFO * const cs, LEX_STRING *str)
1277
1479
{
1278
1480
  /*
1280
1482
    This code assumes that there are no multi-bytes characters
1281
1483
    that can be considered white-space.
1282
1484
  */
 
1485
 
1283
1486
  while ((str->length > 0) && (my_isspace(cs, str->str[0])))
1284
1487
  {
1285
 
    str->length--;
1286
 
    str->str++;
 
1488
    str->length --;
 
1489
    str->str ++;
1287
1490
  }
1288
1491
 
1289
1492
  /*
1292
1495
  */
1293
1496
  while ((str->length > 0) && (my_isspace(cs, str->str[str->length-1])))
1294
1497
  {
1295
 
    str->length--;
 
1498
    str->length --;
1296
1499
  }
1297
1500
}
1298
1501
 
 
1502
 
1299
1503
/*
1300
 
  Select_Lex structures initialisations
 
1504
  st_select_lex structures initialisations
1301
1505
*/
1302
 
void Select_Lex_Node::init_query()
 
1506
 
 
1507
void st_select_lex_node::init_query()
1303
1508
{
1304
1509
  options= 0;
1305
1510
  linkage= UNSPECIFIED_TYPE;
1306
1511
  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();
 
1512
  uncacheable= 0;
 
1513
}
 
1514
 
 
1515
void st_select_lex_node::init_select()
 
1516
{
 
1517
}
 
1518
 
 
1519
void st_select_lex_unit::init_query()
 
1520
{
 
1521
  st_select_lex_node::init_query();
1317
1522
  linkage= GLOBAL_OPTIONS_TYPE;
1318
1523
  global_parameters= first_select();
1319
1524
  select_limit_cnt= HA_POS_ERROR;
1330
1535
  found_rows_for_union= 0;
1331
1536
}
1332
1537
 
1333
 
void Select_Lex::init_query()
 
1538
void st_select_lex::init_query()
1334
1539
{
1335
 
  Select_Lex_Node::init_query();
 
1540
  st_select_lex_node::init_query();
1336
1541
  table_list.empty();
1337
1542
  top_join_list.empty();
1338
1543
  join_list= &top_join_list;
1356
1561
  parent_lex->push_context(&context);
1357
1562
  cond_count= between_count= with_wild= 0;
1358
1563
  max_equal_elems= 0;
 
1564
  conds_processed_with_permanent_arena= 0;
1359
1565
  ref_pointer_array= 0;
1360
1566
  select_n_where_fields= 0;
1361
1567
  select_n_having_items= 0;
1367
1573
  link_next= 0;
1368
1574
}
1369
1575
 
1370
 
void Select_Lex::init_select()
 
1576
void st_select_lex::init_select()
1371
1577
{
 
1578
  st_select_lex_node::init_select();
1372
1579
  sj_nests.empty();
1373
1580
  group_list.empty();
1374
 
  db= 0;
 
1581
  type= db= 0;
1375
1582
  having= 0;
 
1583
  table_join_options= 0;
1376
1584
  in_sum_expr= with_wild= 0;
1377
1585
  options= 0;
1378
1586
  braces= 0;
1379
1587
  interval_list.empty();
 
1588
  ftfunc_list_alloc.empty();
1380
1589
  inner_sum_func_list= 0;
 
1590
  ftfunc_list= &ftfunc_list_alloc;
1381
1591
  linkage= UNSPECIFIED_TYPE;
1382
1592
  order_list.elements= 0;
1383
1593
  order_list.first= 0;
1391
1601
  non_agg_fields.empty();
1392
1602
  cond_value= having_value= Item::COND_UNDEF;
1393
1603
  inner_refs_list.empty();
1394
 
  full_group_by_flag.reset();
 
1604
  full_group_by_flag= 0;
1395
1605
}
1396
1606
 
1397
1607
/*
1398
 
  Select_Lex structures linking
 
1608
  st_select_lex structures linking
1399
1609
*/
1400
1610
 
1401
1611
/* include on level down */
1402
 
void Select_Lex_Node::include_down(Select_Lex_Node *upper)
 
1612
void st_select_lex_node::include_down(st_select_lex_node *upper)
1403
1613
{
1404
1614
  if ((next= upper->slave))
1405
1615
    next->prev= &next;
1413
1623
  include on level down (but do not link)
1414
1624
 
1415
1625
  SYNOPSYS
1416
 
    Select_Lex_Node::include_standalone()
 
1626
    st_select_lex_node::include_standalone()
1417
1627
    upper - reference on node underr which this node should be included
1418
1628
    ref - references on reference on this node
1419
1629
*/
1420
 
void Select_Lex_Node::include_standalone(Select_Lex_Node *upper,
1421
 
                                            Select_Lex_Node **ref)
 
1630
void st_select_lex_node::include_standalone(st_select_lex_node *upper,
 
1631
                                            st_select_lex_node **ref)
1422
1632
{
1423
1633
  next= 0;
1424
1634
  prev= ref;
1427
1637
}
1428
1638
 
1429
1639
/* include neighbour (on same level) */
1430
 
void Select_Lex_Node::include_neighbour(Select_Lex_Node *before)
 
1640
void st_select_lex_node::include_neighbour(st_select_lex_node *before)
1431
1641
{
1432
1642
  if ((next= before->next))
1433
1643
    next->prev= &next;
1437
1647
  slave= 0;
1438
1648
}
1439
1649
 
1440
 
/* including in global Select_Lex list */
1441
 
void Select_Lex_Node::include_global(Select_Lex_Node **plink)
 
1650
/* including in global SELECT_LEX list */
 
1651
void st_select_lex_node::include_global(st_select_lex_node **plink)
1442
1652
{
1443
1653
  if ((link_next= *plink))
1444
1654
    link_next->link_prev= &link_next;
1447
1657
}
1448
1658
 
1449
1659
//excluding from global list (internal function)
1450
 
void Select_Lex_Node::fast_exclude()
 
1660
void st_select_lex_node::fast_exclude()
1451
1661
{
1452
1662
  if (link_prev)
1453
1663
  {
1457
1667
  // Remove slave structure
1458
1668
  for (; slave; slave= slave->next)
1459
1669
    slave->fast_exclude();
1460
 
 
 
1670
  
1461
1671
}
1462
1672
 
1463
1673
/*
1464
1674
  excluding select_lex structure (except first (first select can't be
1465
1675
  deleted, because it is most upper select))
1466
1676
*/
1467
 
void Select_Lex_Node::exclude()
 
1677
void st_select_lex_node::exclude()
1468
1678
{
1469
1679
  //exclude from global list
1470
1680
  fast_exclude();
1471
1681
  //exclude from other structures
1472
1682
  if ((*prev= next))
1473
1683
    next->prev= prev;
1474
 
  /*
1475
 
     We do not need following statements, because prev pointer of first
 
1684
  /* 
 
1685
     We do not need following statements, because prev pointer of first 
1476
1686
     list element point to master->slave
1477
1687
     if (master->slave == this)
1478
1688
       master->slave= next;
1484
1694
  Exclude level of current unit from tree of SELECTs
1485
1695
 
1486
1696
  SYNOPSYS
1487
 
    Select_Lex_Unit::exclude_level()
 
1697
    st_select_lex_unit::exclude_level()
1488
1698
 
1489
1699
  NOTE: units which belong to current will be brought up on level of
1490
 
  currernt unit
 
1700
  currernt unit 
1491
1701
*/
1492
 
void Select_Lex_Unit::exclude_level()
 
1702
void st_select_lex_unit::exclude_level()
1493
1703
{
1494
 
  Select_Lex_Unit *units= 0, **units_last= &units;
1495
 
  for (Select_Lex *sl= first_select(); sl; sl= sl->next_select())
 
1704
  SELECT_LEX_UNIT *units= 0, **units_last= &units;
 
1705
  for (SELECT_LEX *sl= first_select(); sl; sl= sl->next_select())
1496
1706
  {
1497
1707
    // unlink current level from global SELECTs list
1498
1708
    if (sl->link_prev && (*sl->link_prev= sl->link_next))
1499
1709
      sl->link_next->link_prev= sl->link_prev;
1500
1710
 
1501
1711
    // 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())
 
1712
    SELECT_LEX_UNIT **last= 0;
 
1713
    for (SELECT_LEX_UNIT *u= sl->first_inner_unit(); u; u= u->next_unit())
1504
1714
    {
1505
1715
      u->master= master;
1506
 
      last= (Select_Lex_Unit**)&(u->next);
 
1716
      last= (SELECT_LEX_UNIT**)&(u->next);
1507
1717
    }
1508
1718
    if (last)
1509
1719
    {
1515
1725
  {
1516
1726
    // include brought up levels in place of current
1517
1727
    (*prev)= units;
1518
 
    (*units_last)= (Select_Lex_Unit*)next;
 
1728
    (*units_last)= (SELECT_LEX_UNIT*)next;
1519
1729
    if (next)
1520
 
      next->prev= (Select_Lex_Node**)units_last;
 
1730
      next->prev= (SELECT_LEX_NODE**)units_last;
1521
1731
    units->prev= prev;
1522
1732
  }
1523
1733
  else
1529
1739
  }
1530
1740
}
1531
1741
 
 
1742
 
1532
1743
/*
1533
1744
  Exclude subtree of current unit from tree of SELECTs
 
1745
 
 
1746
  SYNOPSYS
 
1747
    st_select_lex_unit::exclude_tree()
1534
1748
*/
1535
 
void Select_Lex_Unit::exclude_tree()
 
1749
void st_select_lex_unit::exclude_tree()
1536
1750
{
1537
 
  for (Select_Lex *sl= first_select(); sl; sl= sl->next_select())
 
1751
  for (SELECT_LEX *sl= first_select(); sl; sl= sl->next_select())
1538
1752
  {
1539
1753
    // unlink current level from global SELECTs list
1540
1754
    if (sl->link_prev && (*sl->link_prev= sl->link_next))
1541
1755
      sl->link_next->link_prev= sl->link_prev;
1542
1756
 
1543
1757
    // unlink underlay levels
1544
 
    for (Select_Lex_Unit *u= sl->first_inner_unit(); u; u= u->next_unit())
 
1758
    for (SELECT_LEX_UNIT *u= sl->first_inner_unit(); u; u= u->next_unit())
1545
1759
    {
1546
1760
      u->exclude_level();
1547
1761
    }
1552
1766
    next->prev= prev;
1553
1767
}
1554
1768
 
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)
 
1769
 
 
1770
/*
 
1771
  st_select_lex_node::mark_as_dependent mark all st_select_lex struct from 
 
1772
  this to 'last' as dependent
 
1773
 
 
1774
  SYNOPSIS
 
1775
    last - pointer to last st_select_lex struct, before wich all 
 
1776
           st_select_lex have to be marked as dependent
 
1777
 
 
1778
  NOTE
 
1779
    'last' should be reachable from this st_select_lex_node
 
1780
*/
 
1781
 
 
1782
void st_select_lex::mark_as_dependent(st_select_lex *last)
1563
1783
{
1564
1784
  /*
1565
1785
    Mark all selects from resolved to 1 before select where was
1566
1786
    found table as depended (of select where was found table)
1567
1787
  */
1568
 
  for (Select_Lex *s= this;
 
1788
  for (SELECT_LEX *s= this;
1569
1789
       s && s != last;
1570
1790
       s= s->outer_select())
1571
1791
  {
1572
 
    if (! (s->uncacheable.test(UNCACHEABLE_DEPENDENT)))
 
1792
    if (!(s->uncacheable & UNCACHEABLE_DEPENDENT))
1573
1793
    {
1574
1794
      // 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())
 
1795
      s->uncacheable= (s->uncacheable & ~UNCACHEABLE_UNITED) |
 
1796
                       UNCACHEABLE_DEPENDENT;
 
1797
      SELECT_LEX_UNIT *munit= s->master_unit();
 
1798
      munit->uncacheable= (munit->uncacheable & ~UNCACHEABLE_UNITED) |
 
1799
                       UNCACHEABLE_DEPENDENT;
 
1800
      for (SELECT_LEX *sl= munit->first_select(); sl ; sl= sl->next_select())
1581
1801
      {
1582
1802
        if (sl != s &&
1583
 
            ! (sl->uncacheable.test(UNCACHEABLE_DEPENDENT) && sl->uncacheable.test(UNCACHEABLE_UNITED)))
1584
 
          sl->uncacheable.set(UNCACHEABLE_UNITED);
 
1803
            !(sl->uncacheable & (UNCACHEABLE_DEPENDENT | UNCACHEABLE_UNITED)))
 
1804
          sl->uncacheable|= UNCACHEABLE_UNITED;
1585
1805
      }
1586
1806
    }
1587
1807
    s->is_correlated= true;
1591
1811
  }
1592
1812
}
1593
1813
 
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
 
 
 
1814
bool st_select_lex_node::set_braces(bool value __attribute__((unused)))
 
1815
{ return 1; }
 
1816
bool st_select_lex_node::inc_in_sum_expr()           { return 1; }
 
1817
uint32_t st_select_lex_node::get_in_sum_expr()           { return 0; }
 
1818
TableList* st_select_lex_node::get_table_list()     { return 0; }
 
1819
List<Item>* st_select_lex_node::get_item_list()      { return 0; }
 
1820
TableList *st_select_lex_node::add_table_to_list (THD *thd __attribute__((unused)),
 
1821
                                                   Table_ident *table __attribute__((unused)),
 
1822
                                                  LEX_STRING *alias __attribute__((unused)),
 
1823
                                                  uint32_t table_join_options __attribute__((unused)),
 
1824
                                                  thr_lock_type flags __attribute__((unused)),
 
1825
                                                  List<Index_hint> *hints __attribute__((unused)),
 
1826
                                                  LEX_STRING *option __attribute__((unused)))
 
1827
{
 
1828
  return 0;
 
1829
}
 
1830
uint32_t st_select_lex_node::get_table_join_options()
 
1831
{
 
1832
  return 0;
 
1833
}
1620
1834
 
1621
1835
/*
1622
1836
  prohibit using LIMIT clause
1623
1837
*/
1624
 
bool Select_Lex::test_limit()
 
1838
bool st_select_lex::test_limit()
1625
1839
{
1626
1840
  if (select_limit != 0)
1627
1841
  {
1628
1842
    my_error(ER_NOT_SUPPORTED_YET, MYF(0),
1629
1843
             "LIMIT & IN/ALL/ANY/SOME subquery");
1630
 
    return true;
 
1844
    return(1);
1631
1845
  }
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)
 
1846
  return(0);
 
1847
}
 
1848
 
 
1849
 
 
1850
st_select_lex_unit* st_select_lex_unit::master_unit()
 
1851
{
 
1852
    return this;
 
1853
}
 
1854
 
 
1855
 
 
1856
st_select_lex* st_select_lex_unit::outer_select()
 
1857
{
 
1858
  return (st_select_lex*) master;
 
1859
}
 
1860
 
 
1861
 
 
1862
bool st_select_lex::add_order_to_list(THD *thd, Item *item, bool asc)
 
1863
{
 
1864
  return add_to_list(thd, order_list, item, asc);
 
1865
}
 
1866
 
 
1867
 
 
1868
bool st_select_lex::add_item_to_list(THD *thd __attribute__((unused)),
 
1869
                                     Item *item)
1651
1870
{
1652
1871
  return(item_list.push_back(item));
1653
1872
}
1654
1873
 
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)
 
1874
 
 
1875
bool st_select_lex::add_group_to_list(THD *thd, Item *item, bool asc)
 
1876
{
 
1877
  return add_to_list(thd, group_list, item, asc);
 
1878
}
 
1879
 
 
1880
 
 
1881
st_select_lex_unit* st_select_lex::master_unit()
 
1882
{
 
1883
  return (st_select_lex_unit*) master;
 
1884
}
 
1885
 
 
1886
 
 
1887
st_select_lex* st_select_lex::outer_select()
 
1888
{
 
1889
  return (st_select_lex*) master->get_master();
 
1890
}
 
1891
 
 
1892
 
 
1893
bool st_select_lex::set_braces(bool value)
1671
1894
{
1672
1895
  braces= value;
1673
 
  return false;
 
1896
  return 0; 
1674
1897
}
1675
1898
 
1676
 
bool Select_Lex::inc_in_sum_expr()
 
1899
 
 
1900
bool st_select_lex::inc_in_sum_expr()
1677
1901
{
1678
1902
  in_sum_expr++;
1679
 
  return false;
 
1903
  return 0;
1680
1904
}
1681
1905
 
1682
 
uint32_t Select_Lex::get_in_sum_expr()
 
1906
 
 
1907
uint32_t st_select_lex::get_in_sum_expr()
1683
1908
{
1684
1909
  return in_sum_expr;
1685
1910
}
1686
1911
 
1687
 
TableList* Select_Lex::get_table_list()
 
1912
 
 
1913
TableList* st_select_lex::get_table_list()
1688
1914
{
1689
1915
  return (TableList*) table_list.first;
1690
1916
}
1691
1917
 
1692
 
List<Item>* Select_Lex::get_item_list()
 
1918
List<Item>* st_select_lex::get_item_list()
1693
1919
{
1694
1920
  return &item_list;
1695
1921
}
1696
1922
 
1697
 
 
1698
 
bool Select_Lex::setup_ref_array(Session *session, uint32_t order_group_num)
 
1923
uint32_t st_select_lex::get_table_join_options()
 
1924
{
 
1925
  return table_join_options;
 
1926
}
 
1927
 
 
1928
 
 
1929
bool st_select_lex::setup_ref_array(THD *thd, uint32_t order_group_num)
1699
1930
{
1700
1931
  if (ref_pointer_array)
1701
 
    return false;
 
1932
    return 0;
1702
1933
 
1703
1934
  return (ref_pointer_array=
1704
 
          (Item **)session->alloc(sizeof(Item*) * (n_child_sum_items +
 
1935
          (Item **)thd->alloc(sizeof(Item*) * (n_child_sum_items +
1705
1936
                                                 item_list.elements +
1706
1937
                                                 select_n_having_items +
1707
1938
                                                 select_n_where_fields +
1708
1939
                                                 order_group_num)*5)) == 0;
1709
1940
}
1710
1941
 
1711
 
void Select_Lex_Unit::print(String *str, enum_query_type query_type)
 
1942
 
 
1943
void st_select_lex_unit::print(String *str, enum_query_type query_type)
1712
1944
{
1713
1945
  bool union_all= !union_distinct;
1714
 
  for (Select_Lex *sl= first_select(); sl; sl= sl->next_select())
 
1946
  for (SELECT_LEX *sl= first_select(); sl; sl= sl->next_select())
1715
1947
  {
1716
1948
    if (sl != first_select())
1717
1949
    {
1723
1955
    }
1724
1956
    if (sl->braces)
1725
1957
      str->append('(');
1726
 
    sl->print(session, str, query_type);
 
1958
    sl->print(thd, str, query_type);
1727
1959
    if (sl->braces)
1728
1960
      str->append(')');
1729
1961
  }
1734
1966
      str->append(STRING_WITH_LEN(" order by "));
1735
1967
      fake_select_lex->print_order(
1736
1968
        str,
1737
 
        (Order *) fake_select_lex->order_list.first,
 
1969
        (order_st *) fake_select_lex->order_list.first,
1738
1970
        query_type);
1739
1971
    }
1740
 
    fake_select_lex->print_limit(session, str, query_type);
 
1972
    fake_select_lex->print_limit(thd, str, query_type);
1741
1973
  }
1742
1974
}
1743
1975
 
1744
 
void Select_Lex::print_order(String *str,
1745
 
                                Order *order,
 
1976
 
 
1977
void st_select_lex::print_order(String *str,
 
1978
                                order_st *order,
1746
1979
                                enum_query_type query_type)
1747
1980
{
1748
1981
  for (; order; order= order->next)
1761
1994
      str->append(',');
1762
1995
  }
1763
1996
}
 
1997
 
1764
1998
 
1765
 
void Select_Lex::print_limit(Session *, String *str,
 
1999
void st_select_lex::print_limit(THD *thd __attribute__((unused)),
 
2000
                                String *str,
1766
2001
                                enum_query_type query_type)
1767
2002
{
1768
 
  Select_Lex_Unit *unit= master_unit();
 
2003
  SELECT_LEX_UNIT *unit= master_unit();
1769
2004
  Item_subselect *item= unit->item;
1770
2005
 
1771
2006
  if (item && unit->global_parameters == this)
1802
2037
}
1803
2038
 
1804
2039
/**
1805
 
  @brief Restore the LEX and Session in case of a parse error.
 
2040
  @brief Restore the LEX and THD in case of a parse error.
1806
2041
 
1807
2042
  This is a clean up call that is invoked by the Bison generated
1808
 
  parser before returning an error from DRIZZLEparse. If your
 
2043
  parser before returning an error from MYSQLparse. If your
1809
2044
  semantic actions manipulate with the global thread state (which
1810
2045
  is a very bad practice and should not normally be employed) and
1811
2046
  need a clean-up in case of error, and you can not use %destructor
1812
2047
  rule in the grammar file itself, this function should be used
1813
2048
  to implement the clean up.
1814
2049
*/
1815
 
void LEX::cleanup_lex_after_parse_error(Session *)
 
2050
 
 
2051
void st_lex::cleanup_lex_after_parse_error(THD *thd __attribute__((unused)))
1816
2052
{
1817
2053
}
1818
2054
 
1833
2069
    this method to reset state of already initialized Query_tables_list
1834
2070
    so it can be used for processing of new statement.
1835
2071
*/
 
2072
 
1836
2073
void Query_tables_list::reset_query_tables_list(bool init)
1837
2074
{
1838
2075
  if (!init && query_tables)
1848
2085
  query_tables= 0;
1849
2086
  query_tables_last= &query_tables;
1850
2087
  query_tables_own_last= 0;
1851
 
}
 
2088
  if (init)
 
2089
  {
 
2090
    /*
 
2091
      We delay real initialization of hash (and therefore related
 
2092
      memory allocation) until first insertion into this hash.
 
2093
    */
 
2094
    hash_clear(&sroutines);
 
2095
  }
 
2096
  else if (sroutines.records)
 
2097
  {
 
2098
    /* Non-zero sroutines.records means that hash was initialized. */
 
2099
    my_hash_reset(&sroutines);
 
2100
  }
 
2101
  sroutines_list.empty();
 
2102
  sroutines_list_own_last= sroutines_list.next;
 
2103
  sroutines_list_own_elements= 0;
 
2104
  binlog_stmt_flags= 0;
 
2105
}
 
2106
 
 
2107
 
 
2108
/*
 
2109
  Destroy Query_tables_list object with freeing all resources used by it.
 
2110
 
 
2111
  SYNOPSIS
 
2112
    destroy_query_tables_list()
 
2113
*/
 
2114
 
 
2115
void Query_tables_list::destroy_query_tables_list()
 
2116
{
 
2117
  hash_free(&sroutines);
 
2118
}
 
2119
 
1852
2120
 
1853
2121
/*
1854
2122
  Initialize LEX object.
1855
2123
 
1856
2124
  SYNOPSIS
1857
 
    LEX::LEX()
 
2125
    st_lex::st_lex()
1858
2126
 
1859
2127
  NOTE
1860
2128
    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()
 
2129
    THD object for which one can safely call open_tables(), lock_tables()
1862
2130
    and close_thread_tables() functions. But it is not yet ready for
1863
2131
    statement parsing. On should use lex_start() function to prepare LEX
1864
2132
    for this.
1865
2133
*/
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)
 
2134
 
 
2135
st_lex::st_lex()
 
2136
  :result(0), yacc_yyss(0), yacc_yyvs(0),
 
2137
   sql_command(SQLCOM_END), option_type(OPT_DEFAULT), is_lex_started(0)
1877
2138
{
 
2139
 
 
2140
  my_init_dynamic_array2(&plugins, sizeof(plugin_ref),
 
2141
                         plugins_static_buffer,
 
2142
                         INITIAL_LEX_PLUGIN_LIST_SIZE, 
 
2143
                         INITIAL_LEX_PLUGIN_LIST_SIZE);
1878
2144
  reset_query_tables_list(true);
1879
 
  statement= NULL;
1880
 
}
 
2145
}
 
2146
 
 
2147
 
 
2148
/*
 
2149
  Check whether the merging algorithm can be used on this VIEW
 
2150
 
 
2151
  SYNOPSIS
 
2152
    st_lex::can_be_merged()
 
2153
 
 
2154
  DESCRIPTION
 
2155
    We can apply merge algorithm if it is single SELECT view  with
 
2156
    subqueries only in WHERE clause (we do not count SELECTs of underlying
 
2157
    views, and second level subqueries) and we have not grpouping, ordering,
 
2158
    HAVING clause, aggregate functions, DISTINCT clause, LIMIT clause and
 
2159
    several underlying tables.
 
2160
 
 
2161
  RETURN
 
2162
    false - only temporary table algorithm can be used
 
2163
    true  - merge algorithm can be used
 
2164
*/
 
2165
 
 
2166
bool st_lex::can_be_merged()
 
2167
{
 
2168
  // TODO: do not forget implement case when select_lex.table_list.elements==0
 
2169
 
 
2170
  /* find non VIEW subqueries/unions */
 
2171
  bool selects_allow_merge= select_lex.next_select() == 0;
 
2172
  if (selects_allow_merge)
 
2173
  {
 
2174
    for (SELECT_LEX_UNIT *tmp_unit= select_lex.first_inner_unit();
 
2175
         tmp_unit;
 
2176
         tmp_unit= tmp_unit->next_unit())
 
2177
    {
 
2178
      if (tmp_unit->first_select()->parent_lex == this &&
 
2179
          (tmp_unit->item == 0 ||
 
2180
           (tmp_unit->item->place() != IN_WHERE &&
 
2181
            tmp_unit->item->place() != IN_ON)))
 
2182
      {
 
2183
        selects_allow_merge= 0;
 
2184
        break;
 
2185
      }
 
2186
    }
 
2187
  }
 
2188
 
 
2189
  return (selects_allow_merge &&
 
2190
          select_lex.group_list.elements == 0 &&
 
2191
          select_lex.having == 0 &&
 
2192
          select_lex.with_sum_func == 0 &&
 
2193
          select_lex.table_list.elements >= 1 &&
 
2194
          !(select_lex.options & SELECT_DISTINCT) &&
 
2195
          select_lex.select_limit == 0);
 
2196
}
 
2197
 
 
2198
 
 
2199
/*
 
2200
  check if command can use VIEW with MERGE algorithm (for top VIEWs)
 
2201
 
 
2202
  SYNOPSIS
 
2203
    st_lex::can_use_merged()
 
2204
 
 
2205
  DESCRIPTION
 
2206
    Only listed here commands can use merge algorithm in top level
 
2207
    SELECT_LEX (for subqueries will be used merge algorithm if
 
2208
    st_lex::can_not_use_merged() is not true).
 
2209
 
 
2210
  RETURN
 
2211
    false - command can't use merged VIEWs
 
2212
    true  - VIEWs with MERGE algorithms can be used
 
2213
*/
 
2214
 
 
2215
bool st_lex::can_use_merged()
 
2216
{
 
2217
  switch (sql_command)
 
2218
  {
 
2219
  case SQLCOM_SELECT:
 
2220
  case SQLCOM_CREATE_TABLE:
 
2221
  case SQLCOM_UPDATE:
 
2222
  case SQLCOM_UPDATE_MULTI:
 
2223
  case SQLCOM_DELETE:
 
2224
  case SQLCOM_DELETE_MULTI:
 
2225
  case SQLCOM_INSERT:
 
2226
  case SQLCOM_INSERT_SELECT:
 
2227
  case SQLCOM_REPLACE:
 
2228
  case SQLCOM_REPLACE_SELECT:
 
2229
  case SQLCOM_LOAD:
 
2230
    return true;
 
2231
  default:
 
2232
    return false;
 
2233
  }
 
2234
}
 
2235
 
 
2236
/*
 
2237
  Check if command can't use merged views in any part of command
 
2238
 
 
2239
  SYNOPSIS
 
2240
    st_lex::can_not_use_merged()
 
2241
 
 
2242
  DESCRIPTION
 
2243
    Temporary table algorithm will be used on all SELECT levels for queries
 
2244
    listed here (see also st_lex::can_use_merged()).
 
2245
 
 
2246
  RETURN
 
2247
    false - command can't use merged VIEWs
 
2248
    true  - VIEWs with MERGE algorithms can be used
 
2249
*/
 
2250
 
 
2251
bool st_lex::can_not_use_merged()
 
2252
{
 
2253
  switch (sql_command)
 
2254
  {
 
2255
  /*
 
2256
    SQLCOM_SHOW_FIELDS is necessary to make 
 
2257
    information schema tables working correctly with views.
 
2258
    see get_schema_tables_result function
 
2259
  */
 
2260
  case SQLCOM_SHOW_FIELDS:
 
2261
    return true;
 
2262
  default:
 
2263
    return false;
 
2264
  }
 
2265
}
 
2266
 
 
2267
/*
 
2268
  Detect that we need only table structure of derived table/view
 
2269
 
 
2270
  SYNOPSIS
 
2271
    only_view_structure()
 
2272
 
 
2273
  RETURN
 
2274
    true yes, we need only structure
 
2275
    false no, we need data
 
2276
*/
 
2277
 
 
2278
bool st_lex::only_view_structure()
 
2279
{
 
2280
  switch (sql_command) {
 
2281
  case SQLCOM_SHOW_CREATE:
 
2282
  case SQLCOM_SHOW_TABLES:
 
2283
  case SQLCOM_SHOW_FIELDS:
 
2284
    return true;
 
2285
  default:
 
2286
    return false;
 
2287
  }
 
2288
}
 
2289
 
 
2290
 
 
2291
/*
 
2292
  Should Items_ident be printed correctly
 
2293
 
 
2294
  SYNOPSIS
 
2295
    need_correct_ident()
 
2296
 
 
2297
  RETURN
 
2298
    true yes, we need only structure
 
2299
    false no, we need data
 
2300
*/
 
2301
 
 
2302
 
 
2303
bool st_lex::need_correct_ident()
 
2304
{
 
2305
  switch(sql_command)
 
2306
  {
 
2307
  case SQLCOM_SHOW_CREATE:
 
2308
  case SQLCOM_SHOW_TABLES:
 
2309
    return true;
 
2310
  default:
 
2311
    return false;
 
2312
  }
 
2313
}
 
2314
 
1881
2315
 
1882
2316
/**
1883
2317
  This method should be called only during parsing.
1885
2319
  and will initialize the destination with the default
1886
2320
  database of the stored routine, rather than the default
1887
2321
  database of the connection it is parsed in.
1888
 
  E.g. if one has no current database selected, or current database
 
2322
  E.g. if one has no current database selected, or current database 
1889
2323
  set to 'bar' and then issues:
1890
2324
 
1891
2325
  CREATE PROCEDURE foo.p1() BEGIN SELECT * FROM t1 END//
1897
2331
  @return true in case of error (parsing should be aborted, false in
1898
2332
  case of success
1899
2333
*/
1900
 
bool LEX::copy_db_to(char **p_db, size_t *p_db_length) const
 
2334
 
 
2335
bool
 
2336
st_lex::copy_db_to(char **p_db, size_t *p_db_length) const
1901
2337
{
1902
 
  return session->copy_db_to(p_db, p_db_length);
 
2338
  return thd->copy_db_to(p_db, p_db_length);
1903
2339
}
1904
2340
 
1905
2341
/*
1906
2342
  initialize limit counters
1907
2343
 
1908
2344
  SYNOPSIS
1909
 
    Select_Lex_Unit::set_limit()
1910
 
    values      - Select_Lex with initial values for counters
 
2345
    st_select_lex_unit::set_limit()
 
2346
    values      - SELECT_LEX with initial values for counters
1911
2347
*/
1912
 
void Select_Lex_Unit::set_limit(Select_Lex *sl)
 
2348
 
 
2349
void st_select_lex_unit::set_limit(st_select_lex *sl)
1913
2350
{
1914
2351
  ha_rows select_limit_val;
1915
2352
  uint64_t val;
1916
2353
 
1917
2354
  val= sl->select_limit ? sl->select_limit->val_uint() : HA_POS_ERROR;
1918
2355
  select_limit_val= (ha_rows)val;
1919
 
  /*
 
2356
#ifndef BIG_TABLES
 
2357
  /* 
1920
2358
    Check for overflow : ha_rows can be smaller then uint64_t if
1921
2359
    BIG_TABLES is off.
1922
2360
    */
1923
2361
  if (val != (uint64_t)select_limit_val)
1924
2362
    select_limit_val= HA_POS_ERROR;
 
2363
#endif
1925
2364
  offset_limit_cnt= (ha_rows)(sl->offset_limit ? sl->offset_limit->val_uint() :
1926
2365
                                                 0UL);
1927
2366
  select_limit_cnt= select_limit_val + offset_limit_cnt;
1929
2368
    select_limit_cnt= HA_POS_ERROR;             // no limit
1930
2369
}
1931
2370
 
 
2371
 
1932
2372
/*
1933
2373
  Unlink the first table from the global table list and the first table from
1934
2374
  outer select (lex->select_lex) local list
1947
2387
      In this case link_to_local is set.
1948
2388
 
1949
2389
*/
1950
 
TableList *LEX::unlink_first_table(bool *link_to_local)
 
2390
TableList *st_lex::unlink_first_table(bool *link_to_local)
1951
2391
{
1952
2392
  TableList *first;
1953
2393
  if ((first= query_tables))
1966
2406
    */
1967
2407
    if ((*link_to_local= test(select_lex.table_list.first)))
1968
2408
    {
1969
 
      select_lex.context.table_list=
 
2409
      select_lex.context.table_list= 
1970
2410
        select_lex.context.first_name_resolution_table= first->next_local;
1971
2411
      select_lex.table_list.first= (unsigned char*) (first->next_local);
1972
2412
      select_lex.table_list.elements--; //safety
1981
2421
  return first;
1982
2422
}
1983
2423
 
 
2424
 
1984
2425
/*
1985
2426
  Bring first local table of first most outer select to first place in global
1986
2427
  table list
1987
2428
 
1988
2429
  SYNOPSYS
1989
 
     LEX::first_lists_tables_same()
 
2430
     st_lex::first_lists_tables_same()
1990
2431
 
1991
2432
  NOTES
1992
2433
    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
 
2434
    main SELECT_LEX have special meaning => check that it is the first table
1994
2435
    in global list and re-link to be first in the global list if it is
1995
2436
    necessary.  We need such re-linking only for queries with sub-queries in
1996
2437
    the select list, as only in this case tables of sub-queries will go to
1997
2438
    the global list first.
1998
2439
*/
1999
 
void LEX::first_lists_tables_same()
 
2440
 
 
2441
void st_lex::first_lists_tables_same()
2000
2442
{
2001
2443
  TableList *first_table= (TableList*) select_lex.table_list.first;
2002
2444
  if (query_tables != first_table && first_table != 0)
2020
2462
  }
2021
2463
}
2022
2464
 
 
2465
 
2023
2466
/*
2024
2467
  Link table back that was unlinked with unlink_first_table()
2025
2468
 
2030
2473
  RETURN
2031
2474
    global list
2032
2475
*/
2033
 
void LEX::link_first_table_back(TableList *first, bool link_to_local)
 
2476
 
 
2477
void st_lex::link_first_table_back(TableList *first,
 
2478
                                   bool link_to_local)
2034
2479
{
2035
2480
  if (first)
2036
2481
  {
2050
2495
  }
2051
2496
}
2052
2497
 
 
2498
 
 
2499
 
2053
2500
/*
2054
2501
  cleanup lex for case when we open table by table for processing
2055
2502
 
2056
2503
  SYNOPSIS
2057
 
    LEX::cleanup_after_one_table_open()
 
2504
    st_lex::cleanup_after_one_table_open()
2058
2505
 
2059
2506
  NOTE
2060
2507
    This method is mostly responsible for cleaning up of selects lists and
2061
2508
    derived tables state. To rollback changes in Query_tables_list one has
2062
2509
    to call Query_tables_list::reset_query_tables_list(false).
2063
2510
*/
2064
 
void LEX::cleanup_after_one_table_open()
 
2511
 
 
2512
void st_lex::cleanup_after_one_table_open()
2065
2513
{
2066
2514
  /*
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
 
2515
    thd->lex->derived_tables & additional units may be set if we open
 
2516
    a view. It is necessary to clear thd->lex->derived_tables flag
 
2517
    to prevent processing of derived tables during next open_and_lock_tables
2070
2518
    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
 
2519
    NOTE: all units will be connected to thd->lex->select_lex, because we
2072
2520
    have not UNION on most upper level.
2073
2521
    */
2074
2522
  if (all_selects_list != &select_lex)
2075
2523
  {
2076
2524
    derived_tables= 0;
2077
2525
    /* cleunup underlying units (units of VIEW) */
2078
 
    for (Select_Lex_Unit *un= select_lex.first_inner_unit();
 
2526
    for (SELECT_LEX_UNIT *un= select_lex.first_inner_unit();
2079
2527
         un;
2080
2528
         un= un->next_unit())
2081
2529
      un->cleanup();
2086
2534
  }
2087
2535
}
2088
2536
 
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
 
2537
 
 
2538
/*
 
2539
  Save current state of Query_tables_list for this LEX, and prepare it
 
2540
  for processing of new statemnt.
 
2541
 
 
2542
  SYNOPSIS
 
2543
    reset_n_backup_query_tables_list()
 
2544
      backup  Pointer to Query_tables_list instance to be used for backup
 
2545
*/
 
2546
 
 
2547
void st_lex::reset_n_backup_query_tables_list(Query_tables_list *backup __attribute__((unused)))
 
2548
{
 
2549
}
 
2550
 
 
2551
 
 
2552
/*
 
2553
  Restore state of Query_tables_list for this LEX from backup.
 
2554
 
 
2555
  SYNOPSIS
 
2556
    restore_backup_query_tables_list()
 
2557
      backup  Pointer to Query_tables_list instance used for backup
 
2558
*/
 
2559
 
 
2560
void st_lex::restore_backup_query_tables_list(Query_tables_list *backup __attribute__((unused)))
 
2561
{
 
2562
}
 
2563
 
 
2564
 
 
2565
/*
 
2566
  Checks for usage of routines and/or tables in a parsed statement
 
2567
 
 
2568
  SYNOPSIS
 
2569
    st_lex:table_or_sp_used()
 
2570
 
 
2571
  RETURN
 
2572
    false  No routines and tables used
 
2573
    true   Either or both routines and tables are used.
 
2574
*/
 
2575
 
 
2576
bool st_lex::table_or_sp_used()
 
2577
{
 
2578
  if (sroutines.records || query_tables)
 
2579
    return(true);
 
2580
 
 
2581
  return(false);
 
2582
}
 
2583
 
 
2584
 
 
2585
/*
 
2586
  Do end-of-prepare fixup for list of tables and their merge-VIEWed tables
 
2587
 
 
2588
  SYNOPSIS
 
2589
    fix_prepare_info_in_table_list()
 
2590
      thd  Thread handle
 
2591
      tbl  List of tables to process
 
2592
 
 
2593
  DESCRIPTION
 
2594
    Perform end-end-of prepare fixup for list of tables, if any of the tables
 
2595
    is a merge-algorithm VIEW, recursively fix up its underlying tables as
 
2596
    well.
 
2597
 
 
2598
*/
 
2599
 
 
2600
static void fix_prepare_info_in_table_list(THD *thd, TableList *tbl)
 
2601
{
 
2602
  for (; tbl; tbl= tbl->next_local)
 
2603
  {
 
2604
    if (tbl->on_expr)
 
2605
    {
 
2606
      tbl->prep_on_expr= tbl->on_expr;
 
2607
      tbl->on_expr= tbl->on_expr->copy_andor_structure(thd);
 
2608
    }
 
2609
    fix_prepare_info_in_table_list(thd, tbl->merge_underlying_list);
 
2610
  }
 
2611
}
 
2612
 
 
2613
 
 
2614
/*
 
2615
  There are st_select_lex::add_table_to_list &
 
2616
  st_select_lex::set_lock_for_tables are in sql_parse.cc
 
2617
 
 
2618
  st_select_lex::print is in sql_select.cc
 
2619
 
 
2620
  st_select_lex_unit::prepare, st_select_lex_unit::exec,
 
2621
  st_select_lex_unit::cleanup, st_select_lex_unit::reinit_exec_mechanism,
 
2622
  st_select_lex_unit::change_result
2098
2623
  are in sql_union.cc
2099
2624
*/
2100
2625
 
2108
2633
 
2109
2634
  DESCRIPTION
2110
2635
    Used in filling up the tagged hints list.
2111
 
    This list is filled by first setting the kind of the hint as a
 
2636
    This list is filled by first setting the kind of the hint as a 
2112
2637
    context variable and then adding hints of the current kind.
2113
2638
    Then the context variable index_hint_type can be reset to the
2114
2639
    next hint type.
2115
2640
*/
2116
 
void Select_Lex::set_index_hint_type(enum index_hint_type type_arg, index_clause_map clause)
2117
 
{
 
2641
void st_select_lex::set_index_hint_type(enum index_hint_type type_arg,
 
2642
                                        index_clause_map clause)
 
2643
{ 
2118
2644
  current_index_hint_type= type_arg;
2119
2645
  current_index_hint_clause= clause;
2120
2646
}
2121
2647
 
 
2648
 
2122
2649
/*
2123
2650
  Makes an array to store index usage hints (ADD/FORCE/IGNORE INDEX).
2124
2651
 
2125
2652
  SYNOPSIS
2126
2653
    alloc_index_hints()
2127
 
      session         current thread.
 
2654
      thd         current thread.
2128
2655
*/
2129
 
void Select_Lex::alloc_index_hints (Session *session)
2130
 
{
2131
 
  index_hints= new (session->mem_root) List<Index_hint>();
 
2656
 
 
2657
void st_select_lex::alloc_index_hints (THD *thd)
 
2658
{ 
 
2659
  index_hints= new (thd->mem_root) List<Index_hint>(); 
2132
2660
}
2133
2661
 
 
2662
 
 
2663
 
2134
2664
/*
2135
 
  adds an element to the array storing index usage hints
 
2665
  adds an element to the array storing index usage hints 
2136
2666
  (ADD/FORCE/IGNORE INDEX).
2137
2667
 
2138
2668
  SYNOPSIS
2139
2669
    add_index_hint()
2140
 
      session         current thread.
 
2670
      thd         current thread.
2141
2671
      str         name of the index.
2142
2672
      length      number of characters in str.
2143
2673
 
2144
2674
  RETURN VALUE
2145
2675
    0 on success, non-zero otherwise
2146
2676
*/
2147
 
bool Select_Lex::add_index_hint (Session *session, char *str, uint32_t length)
 
2677
bool st_select_lex::add_index_hint (THD *thd, char *str, uint32_t length)
2148
2678
{
2149
 
  return index_hints->push_front (new (session->mem_root)
 
2679
  return index_hints->push_front (new (thd->mem_root) 
2150
2680
                                 Index_hint(current_index_hint_type,
2151
2681
                                            current_index_hint_clause,
2152
2682
                                            str, length));
2153
2683
}
2154
 
 
2155
 
} /* namespace drizzled */