sql_lex.cc 244 KB
Newer Older
1 2
/* Copyright (c) 2000, 2019, Oracle and/or its affiliates.
   Copyright (c) 2009, 2020, MariaDB Corporation
unknown's avatar
unknown committed
3

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

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

unknown's avatar
unknown committed
13 14
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
Vicențiu Ciorbaru's avatar
Vicențiu Ciorbaru committed
15
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335  USA */
unknown's avatar
unknown committed
16 17 18 19


/* A lexical scanner on a temporary buffer with a yacc interface */

20
#define MYSQL_LEX 1
21
#include "mariadb.h"
22 23 24 25
#include "sql_priv.h"
#include "sql_class.h"                          // sql_lex.h: SQLCOM_END
#include "sql_lex.h"
#include "sql_parse.h"                          // add_to_list
unknown's avatar
unknown committed
26 27 28
#include "item_create.h"
#include <m_ctype.h>
#include <hash.h>
29
#include "sp_head.h"
30
#include "sp.h"
31
#include "sql_select.h"
32
#include "sql_cte.h"
33
#include "sql_signal.h"
34
#include "sql_partition.h"
unknown's avatar
unknown committed
35

36

37
void LEX::parse_error(uint err_number)
38
{
39
  thd->parse_error(err_number);
40 41
}

unknown's avatar
unknown committed
42

43 44 45
/**
  LEX_STRING constant for null-string to be used in parser and other places.
*/
46 47 48 49 50 51
const LEX_STRING empty_lex_str=   {(char *) "", 0};
const LEX_CSTRING null_clex_str=  {NULL, 0};
const LEX_CSTRING empty_clex_str= {"", 0};
const LEX_CSTRING star_clex_str=  {"*", 1};
const LEX_CSTRING param_clex_str= {"?", 1};

52 53 54 55 56 57 58 59 60 61
/**
  @note The order of the elements of this array must correspond to
  the order of elements in enum_binlog_stmt_unsafe.
*/
const int
Query_tables_list::binlog_stmt_unsafe_errcode[BINLOG_STMT_UNSAFE_COUNT] =
{
  ER_BINLOG_UNSAFE_LIMIT,
  ER_BINLOG_UNSAFE_INSERT_DELAYED,
  ER_BINLOG_UNSAFE_SYSTEM_TABLE,
62
  ER_BINLOG_UNSAFE_AUTOINC_COLUMNS,
63 64
  ER_BINLOG_UNSAFE_UDF,
  ER_BINLOG_UNSAFE_SYSTEM_VARIABLE,
65
  ER_BINLOG_UNSAFE_SYSTEM_FUNCTION,
66
  ER_BINLOG_UNSAFE_NONTRANS_AFTER_TRANS,
67 68
  ER_BINLOG_UNSAFE_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE,
  ER_BINLOG_UNSAFE_MIXED_STATEMENT,
69 70
  ER_BINLOG_UNSAFE_INSERT_IGNORE_SELECT,
  ER_BINLOG_UNSAFE_INSERT_SELECT_UPDATE,
71
  ER_BINLOG_UNSAFE_WRITE_AUTOINC_SELECT,
72 73 74
  ER_BINLOG_UNSAFE_REPLACE_SELECT,
  ER_BINLOG_UNSAFE_CREATE_IGNORE_SELECT,
  ER_BINLOG_UNSAFE_CREATE_REPLACE_SELECT,
75
  ER_BINLOG_UNSAFE_CREATE_SELECT_AUTOINC,
76
  ER_BINLOG_UNSAFE_UPDATE_IGNORE,
77 78
  ER_BINLOG_UNSAFE_INSERT_TWO_KEYS,
  ER_BINLOG_UNSAFE_AUTOINC_NOT_FIRST
79 80
};

81

82
/* Longest standard keyword name */
83

unknown's avatar
unknown committed
84 85
#define TOCK_NAME_LENGTH 24

86 87
/*
  The following data is based on the latin1 character set, and is only
unknown's avatar
unknown committed
88 89 90
  used when comparing keywords
*/

unknown's avatar
unknown committed
91 92
static uchar to_upper_lex[]=
{
unknown's avatar
unknown committed
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
    0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
   16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
   32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
   48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
   64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
   80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
   96, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
   80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,123,124,125,126,127,
  128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
  144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
  160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
  176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
  192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
  208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
  192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
  208,209,210,211,212,213,214,247,216,217,218,219,220,221,222,255
};

111 112 113 114 115 116 117 118 119 120 121
/* 
  Names of the index hints (for error messages). Keep in sync with 
  index_hint_type 
*/

const char * index_hint_type_name[] =
{
  "IGNORE INDEX", 
  "USE INDEX", 
  "FORCE INDEX"
};
122

unknown's avatar
unknown committed
123 124 125
inline int lex_casecmp(const char *s, const char *t, uint len)
{
  while (len-- != 0 &&
126
         to_upper_lex[(uchar) *s++] == to_upper_lex[(uchar) *t++]) ;
unknown's avatar
unknown committed
127 128 129
  return (int) len+1;
}

unknown's avatar
unknown committed
130
#include <lex_hash.h>
unknown's avatar
unknown committed
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146


void lex_init(void)
{
  uint i;
  DBUG_ENTER("lex_init");
  for (i=0 ; i < array_elements(symbols) ; i++)
    symbols[i].length=(uchar) strlen(symbols[i].name);
  for (i=0 ; i < array_elements(sql_functions) ; i++)
    sql_functions[i].length=(uchar) strlen(sql_functions[i].name);

  DBUG_VOID_RETURN;
}


void lex_free(void)
147
{                                        // Call this when daemon ends
unknown's avatar
unknown committed
148 149 150 151
  DBUG_ENTER("lex_free");
  DBUG_VOID_RETURN;
}

152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
/**
  Initialize lex object for use in fix_fields and parsing.

  SYNOPSIS
    init_lex_with_single_table()
    @param thd                 The thread object
    @param table               The table object
  @return Operation status
    @retval TRUE                An error occurred, memory allocation error
    @retval FALSE               Ok

  DESCRIPTION
    This function is used to initialize a lex object on the
    stack for use by fix_fields and for parsing. In order to
    work properly it also needs to initialize the
    Name_resolution_context object of the lexer.
    Finally it needs to set a couple of variables to ensure
    proper functioning of fix_fields.
*/

int
init_lex_with_single_table(THD *thd, TABLE *table, LEX *lex)
{
  TABLE_LIST *table_list;
  Table_ident *table_ident;
  SELECT_LEX *select_lex= &lex->select_lex;
  Name_resolution_context *context= &select_lex->context;
  /*
    We will call the parser to create a part_info struct based on the
    partition string stored in the frm file.
    We will use a local lex object for this purpose. However we also
    need to set the Name_resolution_object for this lex object. We
    do this by using add_table_to_list where we add the table that
    we're working with to the Name_resolution_context.
  */
  thd->lex= lex;
  lex_start(thd);
  context->init();
190 191 192 193 194 195 196 197
  if (unlikely((!(table_ident= new Table_ident(thd,
                                               &table->s->db,
                                               &table->s->table_name,
                                               TRUE)))) ||
      (unlikely(!(table_list= select_lex->add_table_to_list(thd,
                                                            table_ident,
                                                            NULL,
                                                            0)))))
198 199 200
    return TRUE;
  context->resolve_in_table_list_only(table_list);
  lex->use_only_table_context= TRUE;
Sergei Golubchik's avatar
Sergei Golubchik committed
201
  lex->context_analysis_only|= CONTEXT_ANALYSIS_ONLY_VCOL_EXPR;
202 203 204
  select_lex->cur_pos_in_select_list= UNDEF_POS;
  table->map= 1; //To ensure correct calculation of const item
  table_list->table= table;
Sergei Golubchik's avatar
Sergei Golubchik committed
205
  table_list->cacheable_table= false;
206
  lex->create_last_non_select_table= table_list;
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
  return FALSE;
}

/**
  End use of local lex with single table

  SYNOPSIS
    end_lex_with_single_table()
    @param thd               The thread object
    @param table             The table object
    @param old_lex           The real lex object connected to THD

  DESCRIPTION
    This function restores the real lex object after calling
    init_lex_with_single_table and also restores some table
    variables temporarily set.
*/

void
end_lex_with_single_table(THD *thd, TABLE *table, LEX *old_lex)
{
  LEX *lex= thd->lex;
  table->map= 0;
  table->get_fields_in_item_tree= FALSE;
  lex_end(lex);
  thd->lex= old_lex;
}

unknown's avatar
unknown committed
235

236 237 238 239
void
st_parsing_options::reset()
{
  allows_variable= TRUE;
240
  lookup_keywords_after_qualifier= false;
241 242
}

243 244 245 246 247

/**
  Perform initialization of Lex_input_stream instance.

  Basically, a buffer for pre-processed query. This buffer should be large
248 249
  enough to keep multi-statement query. The allocation is done once in
  Lex_input_stream::init() in order to prevent memory pollution when
250 251 252
  the server is processing large multi-statement queries.
*/

253
bool Lex_input_stream::init(THD *thd,
254 255
                            char* buff,
                            size_t length)
256
{
257 258 259
  DBUG_EXECUTE_IF("bug42064_simulate_oom",
                  DBUG_SET("+d,simulate_out_of_memory"););

260
  m_cpp_buf= (char*) thd->alloc(length + 1);
261 262 263 264 265

  DBUG_EXECUTE_IF("bug42064_simulate_oom",
                  DBUG_SET("-d,bug42064_simulate_oom");); 

  if (m_cpp_buf == NULL)
266
    return true;
267 268

  m_thd= thd;
269
  reset(buff, length);
270

271
  return false;
272 273 274 275 276 277 278 279 280 281 282 283
}


/**
  Prepare Lex_input_stream instance state for use for handling next SQL statement.

  It should be called between two statements in a multi-statement query.
  The operation resets the input stream to the beginning-of-parse state,
  but does not reallocate m_cpp_buf.
*/

void
284
Lex_input_stream::reset(char *buffer, size_t length)
285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303
{
  yylineno= 1;
  lookahead_token= -1;
  lookahead_yylval= NULL;
  m_ptr= buffer;
  m_tok_start= NULL;
  m_tok_end= NULL;
  m_end_of_query= buffer + length;
  m_tok_start_prev= NULL;
  m_buf= buffer;
  m_buf_length= length;
  m_echo= TRUE;
  m_cpp_tok_start= NULL;
  m_cpp_tok_start_prev= NULL;
  m_cpp_tok_end= NULL;
  m_body_utf8= NULL;
  m_cpp_utf8_processed_ptr= NULL;
  next_state= MY_LEX_START;
  found_semicolon= NULL;
304
  ignore_space= MY_TEST(m_thd->variables.sql_mode & MODE_IGNORE_SPACE);
305 306 307 308
  stmt_prepare_mode= FALSE;
  multi_statements= TRUE;
  in_comment=NO_COMMENT;
  m_underscore_cs= NULL;
309
  m_cpp_ptr= m_cpp_buf;
310 311 312
}


unknown's avatar
unknown committed
313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329
/**
  The operation is called from the parser in order to
  1) designate the intention to have utf8 body;
  1) Indicate to the lexer that we will need a utf8 representation of this
     statement;
  2) Determine the beginning of the body.

  @param thd        Thread context.
  @param begin_ptr  Pointer to the start of the body in the pre-processed
                    buffer.
*/

void Lex_input_stream::body_utf8_start(THD *thd, const char *begin_ptr)
{
  DBUG_ASSERT(begin_ptr);
  DBUG_ASSERT(m_cpp_buf <= begin_ptr && begin_ptr <= m_cpp_buf + m_buf_length);

330
  size_t body_utf8_length= get_body_utf8_maximum_length(thd);
unknown's avatar
unknown committed
331 332 333 334 335 336 337 338

  m_body_utf8= (char *) thd->alloc(body_utf8_length + 1);
  m_body_utf8_ptr= m_body_utf8;
  *m_body_utf8_ptr= 0;

  m_cpp_utf8_processed_ptr= begin_ptr;
}

339

340
size_t Lex_input_stream::get_body_utf8_maximum_length(THD *thd)
341 342 343 344 345 346 347 348 349 350 351 352 353 354
{
  /*
    String literals can grow during escaping:
    1a. Character string '<TAB>' can grow to '\t', 3 bytes to 4 bytes growth.
    1b. Character string '1000 times <TAB>' grows from
        1002 to 2002 bytes (including quotes), which gives a little bit
        less than 2 times growth.
    "2" should be a reasonable multiplier that safely covers escaping needs.
  */
  return (m_buf_length / thd->variables.character_set_client->mbminlen) *
          my_charset_utf8_bin.mbmaxlen * 2/*for escaping*/;
}


unknown's avatar
unknown committed
355
/**
unknown's avatar
unknown committed
356
  @brief The operation appends unprocessed part of pre-processed buffer till
unknown's avatar
unknown committed
357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
  the given pointer (ptr) and sets m_cpp_utf8_processed_ptr to end_ptr.

  The idea is that some tokens in the pre-processed buffer (like character
  set introducers) should be skipped.

  Example:
    CPP buffer: SELECT 'str1', _latin1 'str2';
    m_cpp_utf8_processed_ptr -- points at the "SELECT ...";
    In order to skip "_latin1", the following call should be made:
      body_utf8_append(<pointer to "_latin1 ...">, <pointer to " 'str2'...">)

  @param ptr      Pointer in the pre-processed buffer, which specifies the
                  end of the chunk, which should be appended to the utf8
                  body.
  @param end_ptr  Pointer in the pre-processed buffer, to which
                  m_cpp_utf8_processed_ptr will be set in the end of the
                  operation.
*/

void Lex_input_stream::body_utf8_append(const char *ptr,
                                        const char *end_ptr)
{
  DBUG_ASSERT(m_cpp_buf <= ptr && ptr <= m_cpp_buf + m_buf_length);
  DBUG_ASSERT(m_cpp_buf <= end_ptr && end_ptr <= m_cpp_buf + m_buf_length);

  if (!m_body_utf8)
    return;

  if (m_cpp_utf8_processed_ptr >= ptr)
    return;

388
  size_t bytes_to_copy= ptr - m_cpp_utf8_processed_ptr;
unknown's avatar
unknown committed
389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421

  memcpy(m_body_utf8_ptr, m_cpp_utf8_processed_ptr, bytes_to_copy);
  m_body_utf8_ptr += bytes_to_copy;
  *m_body_utf8_ptr= 0;

  m_cpp_utf8_processed_ptr= end_ptr;
}

/**
  The operation appends unprocessed part of the pre-processed buffer till
  the given pointer (ptr) and sets m_cpp_utf8_processed_ptr to ptr.

  @param ptr  Pointer in the pre-processed buffer, which specifies the end
              of the chunk, which should be appended to the utf8 body.
*/

void Lex_input_stream::body_utf8_append(const char *ptr)
{
  body_utf8_append(ptr, ptr);
}

/**
  The operation converts the specified text literal to the utf8 and appends
  the result to the utf8-body.

  @param thd      Thread context.
  @param txt      Text literal.
  @param txt_cs   Character set of the text literal.
  @param end_ptr  Pointer in the pre-processed buffer, to which
                  m_cpp_utf8_processed_ptr will be set in the end of the
                  operation.
*/

422 423 424 425
void
Lex_input_stream::body_utf8_append_ident(THD *thd,
                                         const Lex_string_with_metadata_st *txt,
                                         const char *end_ptr)
unknown's avatar
unknown committed
426 427 428 429
{
  if (!m_cpp_utf8_processed_ptr)
    return;

430
  LEX_CSTRING utf_txt;
431
  thd->make_text_string_sys(&utf_txt, txt); // QQ: check return value?
unknown's avatar
unknown committed
432 433 434 435 436 437 438 439 440

  /* NOTE: utf_txt.length is in bytes, not in symbols. */
  memcpy(m_body_utf8_ptr, utf_txt.str, utf_txt.length);
  m_body_utf8_ptr += utf_txt.length;
  *m_body_utf8_ptr= 0;

  m_cpp_utf8_processed_ptr= end_ptr;
}

441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461



extern "C" {

/**
  Escape a character. Consequently puts "escape" and "wc" characters into
  the destination utf8 string.
  @param cs     - the character set (utf8)
  @param escape - the escape character (backslash, single quote, double quote)
  @param wc     - the character to be escaped
  @param str    - the destination string
  @param end    - the end of the destination string
  @returns      - a code according to the wc_mb() convension.
*/
int my_wc_mb_utf8_with_escape(CHARSET_INFO *cs, my_wc_t escape, my_wc_t wc,
                              uchar *str, uchar *end)
{
  DBUG_ASSERT(escape > 0);
  if (str + 1 >= end)
    return MY_CS_TOOSMALL2;  // Not enough space, need at least two bytes.
462
  *str= (uchar)escape;
463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
  int cnvres= my_charset_utf8_handler.wc_mb(cs, wc, str + 1, end);
  if (cnvres > 0)
    return cnvres + 1;       // The character was normally put
  if (cnvres == MY_CS_ILUNI)
    return MY_CS_ILUNI;      // Could not encode "wc" (e.g. non-BMP character)
  DBUG_ASSERT(cnvres <= MY_CS_TOOSMALL);
  return cnvres - 1;         // Not enough space
}


/**
  Optionally escape a character.
  If "escape" is non-zero, then both "escape" and "wc" are put to
  the destination string. Otherwise, only "wc" is put.
  @param cs     - the character set (utf8)
  @param wc     - the character to be optionally escaped
  @param escape - the escape character, or 0
  @param ewc    - the escaped replacement of "wc" (e.g. 't' for '\t')
  @param str    - the destination string
  @param end    - the end of the destination string
  @returns      - a code according to the wc_mb() conversion.
*/
int my_wc_mb_utf8_opt_escape(CHARSET_INFO *cs,
                             my_wc_t wc, my_wc_t escape, my_wc_t ewc,
                             uchar *str, uchar *end)
{
  return escape ? my_wc_mb_utf8_with_escape(cs, escape, ewc, str, end) :
                  my_charset_utf8_handler.wc_mb(cs, wc, str, end);
}

/**
  Encode a character with optional backlash escaping and quote escaping.
  Quote marks are escaped using another quote mark.
  Additionally, if "escape" is non-zero, then special characters are
  also escaped using "escape".
  Otherwise (if "escape" is zero, e.g. in case of MODE_NO_BACKSLASH_ESCAPES),
  then special characters are not escaped and handled as normal characters.

  @param cs        - the character set (utf8)
  @param wc        - the character to be encoded
  @param str       - the destination string
  @param end       - the end of the destination string
  @param sep       - the string delimiter (e.g. ' or ")
  @param escape    - the escape character (backslash, or 0)
  @returns         - a code according to the wc_mb() convension.
*/
int my_wc_mb_utf8_escape(CHARSET_INFO *cs, my_wc_t wc, uchar *str, uchar *end,
                         my_wc_t sep, my_wc_t escape)
{
  DBUG_ASSERT(escape == 0 || escape == '\\');
  DBUG_ASSERT(sep == '"' || sep == '\'');
  switch (wc) {
  case 0:      return my_wc_mb_utf8_opt_escape(cs, wc, escape, '0', str, end);
  case '\t':   return my_wc_mb_utf8_opt_escape(cs, wc, escape, 't', str, end);
  case '\r':   return my_wc_mb_utf8_opt_escape(cs, wc, escape, 'r', str, end);
  case '\n':   return my_wc_mb_utf8_opt_escape(cs, wc, escape, 'n', str, end);
  case '\032': return my_wc_mb_utf8_opt_escape(cs, wc, escape, 'Z', str, end);
  case '\'':
  case '\"':
    if (wc == sep)
      return my_wc_mb_utf8_with_escape(cs, wc, wc, str, end);
  }
  return my_charset_utf8_handler.wc_mb(cs, wc, str, end); // No escaping needed
}


/** wc_mb() compatible routines for all sql_mode and delimiter combinations */
int my_wc_mb_utf8_escape_single_quote_and_backslash(CHARSET_INFO *cs,
                                                    my_wc_t wc,
                                                    uchar *str, uchar *end)
{
  return my_wc_mb_utf8_escape(cs, wc, str, end, '\'', '\\');
}


int my_wc_mb_utf8_escape_double_quote_and_backslash(CHARSET_INFO *cs,
                                                    my_wc_t wc,
                                                    uchar *str, uchar *end)
{
  return my_wc_mb_utf8_escape(cs, wc, str, end, '"', '\\');
}


int my_wc_mb_utf8_escape_single_quote(CHARSET_INFO *cs, my_wc_t wc,
                                      uchar *str, uchar *end)
{
  return my_wc_mb_utf8_escape(cs, wc, str, end, '\'', 0);
}


int my_wc_mb_utf8_escape_double_quote(CHARSET_INFO *cs, my_wc_t wc,
                                      uchar *str, uchar *end)
{
  return my_wc_mb_utf8_escape(cs, wc, str, end, '"', 0);
}

}; // End of extern "C"


/**
  Get an escaping function, depending on the current sql_mode and the
  string separator.
*/
my_charset_conv_wc_mb
Lex_input_stream::get_escape_func(THD *thd, my_wc_t sep) const
{
  return thd->backslash_escapes() ?
         (sep == '"' ? my_wc_mb_utf8_escape_double_quote_and_backslash:
                       my_wc_mb_utf8_escape_single_quote_and_backslash) :
         (sep == '"' ? my_wc_mb_utf8_escape_double_quote:
                       my_wc_mb_utf8_escape_single_quote);
}


/**
  Append a text literal to the end of m_body_utf8.
  The string is escaped according to the current sql_mode and the
  string delimiter (e.g. ' or ").

  @param thd       - current THD
  @param txt       - the string to be appended to m_body_utf8.
                     Note, the string must be already unescaped.
  @param cs        - the character set of the string
  @param end_ptr   - m_cpp_utf8_processed_ptr will be set to this value
                     (see body_utf8_append_ident for details)
  @param sep       - the string delimiter (single or double quote)
*/
void Lex_input_stream::body_utf8_append_escape(THD *thd,
591
                                               const LEX_CSTRING *txt,
592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623
                                               CHARSET_INFO *cs,
                                               const char *end_ptr,
                                               my_wc_t sep)
{
  DBUG_ASSERT(sep == '\'' || sep == '"');
  if (!m_cpp_utf8_processed_ptr)
    return;
  uint errors;
  /**
    We previously alloced m_body_utf8 to be able to store the query with all
    strings properly escaped. See get_body_utf8_maximum_length().
    So here we have guaranteedly enough space to append any string literal
    with escaping. Passing txt->length*2 as "available space" is always safe.
    For better safety purposes we could calculate get_body_utf8_maximum_length()
    every time we append a string, but this would affect performance negatively,
    so let's check that we don't get beyond the allocated buffer in
    debug build only.
  */
  DBUG_ASSERT(m_body_utf8 + get_body_utf8_maximum_length(thd) >=
              m_body_utf8_ptr + txt->length * 2);
  uint32 cnv_length= my_convert_using_func(m_body_utf8_ptr, txt->length * 2,
                                           &my_charset_utf8_general_ci,
                                           get_escape_func(thd, sep),
                                           txt->str, txt->length,
                                           cs, cs->cset->mb_wc,
                                           &errors);
  m_body_utf8_ptr+= cnv_length;
  *m_body_utf8_ptr= 0;
  m_cpp_utf8_processed_ptr= end_ptr;
}


Sergei Golubchik's avatar
Sergei Golubchik committed
624 625 626 627 628 629 630 631 632 633 634 635 636 637 638
void Lex_input_stream::add_digest_token(uint token, LEX_YYSTYPE yylval)
{
  if (m_digest != NULL)
  {
    m_digest= digest_add_token(m_digest, token, yylval);
  }
}

void Lex_input_stream::reduce_digest_token(uint token_left, uint token_right)
{
  if (m_digest != NULL)
  {
    m_digest= digest_reduce_token(m_digest, token_left, token_right);
  }
}
639

640 641 642 643 644 645 646 647
void lex_start(THD *thd)
{
  DBUG_ENTER("lex_start");
  thd->lex->start(thd);
  DBUG_VOID_RETURN;
}


648 649 650 651 652 653
/*
  This is called before every query that is to be parsed.
  Because of this, it's critical to not do too much things here.
  (We already do too much here)
*/

654
void LEX::start(THD *thd_arg)
unknown's avatar
unknown committed
655
{
656
  DBUG_ENTER("LEX::start");
657
  DBUG_PRINT("info", ("This: %p thd_arg->lex: %p", this, thd_arg->lex));
unknown's avatar
unknown committed
658

659
  thd= unit.thd= thd_arg;
660
  stmt_lex= this; // default, should be rewritten for VIEWs And CTEs
661

662
  DBUG_ASSERT(!explain);
unknown's avatar
unknown committed
663

664 665
  context_stack.empty();
  unit.init_query();
666
  current_select_number= 1;
667
  select_lex.linkage= UNSPECIFIED_TYPE;
unknown's avatar
unknown committed
668
  /* 'parent_lex' is used in init_query() so it must be before it. */
669 670 671 672 673
  select_lex.parent_lex= this;
  select_lex.init_query();
  curr_with_clause= 0;
  with_clauses_list= 0;
  with_clauses_list_last_next= &with_clauses_list;
674
  clone_spec_offset= 0;
675
  create_view= NULL;
676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722
  value_list.empty();
  update_list.empty();
  set_var_list.empty();
  param_list.empty();
  view_list.empty();
  with_column_list.empty();
  with_persistent_for_clause= FALSE;
  column_list= NULL;
  index_list= NULL;
  prepared_stmt_params.empty();
  auxiliary_table_list.empty();
  unit.next= unit.master= unit.link_next= unit.return_to= 0;
  unit.prev= unit.link_prev= 0;
  unit.slave= current_select= all_selects_list= &select_lex;
  select_lex.master= &unit;
  select_lex.prev= &unit.slave;
  select_lex.link_next= select_lex.slave= select_lex.next= 0;
  select_lex.link_prev= (st_select_lex_node**)&(all_selects_list);
  select_lex.options= 0;
  select_lex.sql_cache= SELECT_LEX::SQL_CACHE_UNSPECIFIED;
  select_lex.init_order();
  select_lex.group_list.empty();
  if (select_lex.group_list_ptrs)
    select_lex.group_list_ptrs->clear();
  describe= 0;
  analyze_stmt= 0;
  explain_json= false;
  context_analysis_only= 0;
  derived_tables= 0;
  safe_to_cache_query= 1;
  parsing_options.reset();
  empty_field_list_on_rset= 0;
  select_lex.select_number= 1;
  part_info= 0;
  select_lex.in_sum_expr=0;
  select_lex.ftfunc_list_alloc.empty();
  select_lex.ftfunc_list= &select_lex.ftfunc_list_alloc;
  select_lex.group_list.empty();
  select_lex.order_list.empty();
  select_lex.gorder_list.empty();
  m_sql_cmd= NULL;
  duplicates= DUP_ERROR;
  ignore= 0;
  spname= NULL;
  spcont= NULL;
  proc_list.first= 0;
  escape_used= FALSE;
723
  default_used= FALSE;
724 725 726 727 728 729 730 731 732
  query_tables= 0;
  reset_query_tables_list(FALSE);
  expr_allows_subselect= TRUE;
  use_only_table_context= FALSE;
  parse_vcol_expr= FALSE;
  check_exists= FALSE;
  create_info.lex_start();
  verbose= 0;

733
  name= null_clex_str;
734 735 736 737
  event_parse_data= NULL;
  profile_options= PROFILE_NONE;
  nest_level=0 ;
  select_lex.nest_level_base= &unit;
738
  allow_sum_func.clear_all();
739 740 741
  in_sum_func= NULL;

  used_tables= 0;
742
  table_type= TABLE_TYPE_UNKNOWN;
743 744 745 746 747 748 749 750 751 752 753 754 755 756 757
  reset_slave_info.all= false;
  limit_rows_examined= 0;
  limit_rows_examined_cnt= ULONGLONG_MAX;
  var_list.empty();
  stmt_var_list.empty();
  proc_list.elements=0;

  save_group_list.empty();
  save_order_list.empty();
  win_ref= NULL;
  win_frame= NULL;
  frame_top_bound= NULL;
  frame_bottom_bound= NULL;
  win_spec= NULL;

758 759
  vers_conditions.empty();

760
  is_lex_started= TRUE;
unknown's avatar
unknown committed
761
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
762 763 764 765
}

void lex_end(LEX *lex)
{
unknown's avatar
unknown committed
766
  DBUG_ENTER("lex_end");
767
  DBUG_PRINT("enter", ("lex: %p", lex));
unknown's avatar
unknown committed
768

769 770 771 772 773 774 775 776 777 778
  lex_end_stage1(lex);
  lex_end_stage2(lex);

  DBUG_VOID_RETURN;
}

void lex_end_stage1(LEX *lex)
{
  DBUG_ENTER("lex_end_stage1");

unknown's avatar
unknown committed
779
  /* release used plugins */
780 781 782 783 784
  if (lex->plugins.elements) /* No function call and no mutex if no plugins. */
  {
    plugin_unlock_list(0, (plugin_ref*)lex->plugins.buffer, 
                       lex->plugins.elements);
  }
unknown's avatar
unknown committed
785 786
  reset_dynamic(&lex->plugins);

787 788 789 790 791 792 793 794 795 796 797
  if (lex->context_analysis_only & CONTEXT_ANALYSIS_ONLY_PREPARE)
  {
    /*
      Don't delete lex->sphead, it'll be needed for EXECUTE.
      Note that of all statements that populate lex->sphead
      only SQLCOM_COMPOUND can be PREPAREd
    */
    DBUG_ASSERT(lex->sphead == 0 || lex->sql_command == SQLCOM_COMPOUND);
  }
  else
  {
798
    sp_head::destroy(lex->sphead);
799 800
    lex->sphead= NULL;
  }
801

802 803 804 805 806 807 808 809 810 811 812 813 814
  DBUG_VOID_RETURN;
}

/*
  MASTER INFO parameters (or state) is normally cleared towards the end
  of a statement. But in case of PS, the state needs to be preserved during
  its lifetime and should only be cleared on PS close or deallocation.
*/
void lex_end_stage2(LEX *lex)
{
  DBUG_ENTER("lex_end_stage2");

  /* Reset LEX_MASTER_INFO */
815
  lex->mi.reset(lex->sql_command == SQLCOM_CHANGE_MASTER);
816
  delete_dynamic(&lex->delete_gtid_domain);
817

unknown's avatar
unknown committed
818
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
819 820
}

821 822 823 824
Yacc_state::~Yacc_state()
{
  if (yacc_yyss)
  {
825 826
    my_free(yacc_yyss);
    my_free(yacc_yyvs);
827
  }
unknown's avatar
unknown committed
828 829
}

830 831
int Lex_input_stream::find_keyword(Lex_ident_cli_st *kwd,
                                   uint len, bool function)
unknown's avatar
unknown committed
832
{
833
  const char *tok= m_tok_start;
unknown's avatar
unknown committed
834

835
  SYMBOL *symbol= get_hash_symbol(tok, len, function);
unknown's avatar
unknown committed
836 837
  if (symbol)
  {
838 839 840
    kwd->set_keyword(tok, len);
    DBUG_ASSERT(tok >= get_buf());
    DBUG_ASSERT(tok < get_end_of_query());
841

842 843 844 845
    if (m_thd->variables.sql_mode & MODE_ORACLE)
    {
      switch (symbol->tok) {
      case BEGIN_MARIADB_SYM:          return BEGIN_ORACLE_SYM;
846
      case BLOB_MARIADB_SYM:           return BLOB_ORACLE_SYM;
847
      case BODY_MARIADB_SYM:           return BODY_ORACLE_SYM;
848
      case CLOB_MARIADB_SYM:           return CLOB_ORACLE_SYM;
849
      case CONTINUE_MARIADB_SYM:       return CONTINUE_ORACLE_SYM;
850
      case DECLARE_MARIADB_SYM:        return DECLARE_ORACLE_SYM;
851
      case DECODE_MARIADB_SYM:         return DECODE_ORACLE_SYM;
852
      case ELSEIF_MARIADB_SYM:         return ELSEIF_ORACLE_SYM;
853 854 855 856
      case ELSIF_MARIADB_SYM:          return ELSIF_ORACLE_SYM;
      case EXCEPTION_MARIADB_SYM:      return EXCEPTION_ORACLE_SYM;
      case EXIT_MARIADB_SYM:           return EXIT_ORACLE_SYM;
      case GOTO_MARIADB_SYM:           return GOTO_ORACLE_SYM;
857
      case NUMBER_MARIADB_SYM:         return NUMBER_ORACLE_SYM;
858 859 860
      case OTHERS_MARIADB_SYM:         return OTHERS_ORACLE_SYM;
      case PACKAGE_MARIADB_SYM:        return PACKAGE_ORACLE_SYM;
      case RAISE_MARIADB_SYM:          return RAISE_ORACLE_SYM;
861
      case RAW_MARIADB_SYM:            return RAW_ORACLE_SYM;
862 863
      case RETURN_MARIADB_SYM:         return RETURN_ORACLE_SYM;
      case ROWTYPE_MARIADB_SYM:        return ROWTYPE_ORACLE_SYM;
864
      case VARCHAR2_MARIADB_SYM:       return VARCHAR2_ORACLE_SYM;
865 866 867
      }
    }

868
    if ((symbol->tok == NOT_SYM) &&
869
        (m_thd->variables.sql_mode & MODE_HIGH_NOT_PRECEDENCE))
870
      return NOT2_SYM;
871 872 873 874 875 876
    if ((symbol->tok == OR2_SYM) &&
        (m_thd->variables.sql_mode & MODE_PIPES_AS_CONCAT))
    {
      return (m_thd->variables.sql_mode & MODE_ORACLE) ?
             ORACLE_CONCAT_SYM : MYSQL_CONCAT_SYM;
    }
877

unknown's avatar
unknown committed
878 879 880 881 882
    return symbol->tok;
  }
  return 0;
}

883 884 885 886 887
/*
  Check if name is a keyword

  SYNOPSIS
    is_keyword()
888
    name      checked name (must not be empty)
889 890 891 892 893 894 895 896 897
    len       length of checked name

  RETURN VALUES
    0         name is a keyword
    1         name isn't a keyword
*/

bool is_keyword(const char *name, uint len)
{
898
  DBUG_ASSERT(len != 0);
899 900
  return get_hash_symbol(name,len,0)!=0;
}
unknown's avatar
unknown committed
901

902 903 904 905 906
/**
  Check if name is a sql function

    @param name      checked name

907
    @return is this a native function or not
908 909 910 911
    @retval 0         name is a function
    @retval 1         name isn't a function
*/

912
bool is_lex_native_function(const LEX_CSTRING *name)
913 914
{
  DBUG_ASSERT(name != NULL);
915
  return (get_hash_symbol(name->str, (uint) name->length, 1) != 0);
916 917
}

918

919
bool is_native_function(THD *thd, const LEX_CSTRING *name)
920
{
921
  if (find_native_function_builder(thd, name))
922 923 924 925 926 927 928 929 930
    return true;

  if (is_lex_native_function(name))
    return true;

  return false;
}


931
bool is_native_function_with_warn(THD *thd, const LEX_CSTRING *name)
932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970
{
  if (!is_native_function(thd, name))
    return false;
  /*
    This warning will be printed when
    [1] A client query is parsed,
    [2] A stored function is loaded by db_load_routine.
    Printing the warning for [2] is intentional, to cover the
    following scenario:
    - A user define a SF 'foo' using MySQL 5.N
    - An application uses select foo(), and works.
    - MySQL 5.{N+1} defines a new native function 'foo', as
    part of a new feature.
    - MySQL 5.{N+1} documentation is updated, and should mention
    that there is a potential incompatible change in case of
    existing stored function named 'foo'.
    - The user deploys 5.{N+1}. At this point, 'select foo()'
    means something different, and the user code is most likely
    broken (it's only safe if the code is 'select db.foo()').
    With a warning printed when the SF is loaded (which has to
    occur before the call), the warning will provide a hint
    explaining the root cause of a later failure of 'select foo()'.
    With no warning printed, the user code will fail with no
    apparent reason.
    Printing a warning each time db_load_routine is executed for
    an ambiguous function is annoying, since that can happen a lot,
    but in practice should not happen unless there *are* name
    collisions.
    If a collision exists, it should not be silenced but fixed.
  */
  push_warning_printf(thd,
                      Sql_condition::WARN_LEVEL_NOTE,
                      ER_NATIVE_FCT_NAME_COLLISION,
                      ER_THD(thd, ER_NATIVE_FCT_NAME_COLLISION),
                      name->str);
  return true;
}


unknown's avatar
unknown committed
971 972
/* make a copy of token before ptr and set yytoklen */

973
LEX_CSTRING Lex_input_stream::get_token(uint skip, uint length)
unknown's avatar
unknown committed
974
{
975
  LEX_CSTRING tmp;
976
  yyUnget();                       // ptr points now after last token char
977
  tmp.length= length;
978
  tmp.str= m_thd->strmake(m_tok_start + skip, tmp.length);
unknown's avatar
unknown committed
979

980
  m_cpp_text_start= m_cpp_tok_start + skip;
981
  m_cpp_text_end= m_cpp_text_start + tmp.length;
unknown's avatar
unknown committed
982

unknown's avatar
unknown committed
983 984 985
  return tmp;
}

986

987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
static size_t
my_unescape(CHARSET_INFO *cs, char *to, const char *str, const char *end,
            int sep, bool backslash_escapes)
{
  char *start= to;
  for ( ; str != end ; str++)
  {
#ifdef USE_MB
    int l;
    if (use_mb(cs) && (l= my_ismbchar(cs, str, end)))
    {
      while (l--)
        *to++ = *str++;
      str--;
      continue;
    }
#endif
    if (backslash_escapes && *str == '\\' && str + 1 != end)
    {
      switch(*++str) {
      case 'n':
        *to++='\n';
        break;
      case 't':
        *to++= '\t';
        break;
      case 'r':
        *to++ = '\r';
        break;
      case 'b':
        *to++ = '\b';
        break;
      case '0':
        *to++= 0;                      // Ascii null
        break;
      case 'Z':                        // ^Z must be escaped on Win32
        *to++='\032';
        break;
      case '_':
      case '%':
        *to++= '\\';                   // remember prefix for wildcard
        /* Fall through */
      default:
        *to++= *str;
        break;
      }
    }
    else if (*str == sep)
      *to++= *str++;                // Two ' or "
    else
      *to++ = *str;
  }
  *to= 0;
  return to - start;
}


size_t
Lex_input_stream::unescape(CHARSET_INFO *cs, char *to,
                           const char *str, const char *end,
                           int sep)
{
  return my_unescape(cs, to, str, end, sep, m_thd->backslash_escapes());
}


1053 1054 1055 1056
/*
  Return an unescaped text literal without quotes
  Fix sometimes to do only one scan of the string
*/
unknown's avatar
unknown committed
1057

1058
bool Lex_input_stream::get_text(Lex_string_with_metadata_st *dst, uint sep,
1059
                                int pre_skip, int post_skip)
unknown's avatar
unknown committed
1060
{
1061
  uchar c;
unknown's avatar
unknown committed
1062
  uint found_escape=0;
1063
  CHARSET_INFO *cs= m_thd->charset();
1064
  bool is_8bit= false;
unknown's avatar
unknown committed
1065

1066
  while (! eof())
unknown's avatar
unknown committed
1067
  {
1068
    c= yyGet();
1069
    if (c & 0x80)
1070
      is_8bit= true;
unknown's avatar
unknown committed
1071
#ifdef USE_MB
1072 1073 1074
    {
      int l;
      if (use_mb(cs) &&
1075
          (l = my_ismbchar(cs,
1076 1077 1078
                           get_ptr() -1,
                           get_end_of_query()))) {
        skip_binary(l-1);
1079
        continue;
1080
      }
unknown's avatar
unknown committed
1081 1082
    }
#endif
1083
    if (c == '\\' &&
1084
        !(m_thd->variables.sql_mode & MODE_NO_BACKSLASH_ESCAPES))
1085
    {                                        // Escaped character
unknown's avatar
unknown committed
1086
      found_escape=1;
1087
      if (eof())
1088
        return true;
1089
      yySkip();
unknown's avatar
unknown committed
1090 1091 1092
    }
    else if (c == sep)
    {
1093
      if (c == yyGet())                 // Check if two separators in a row
unknown's avatar
unknown committed
1094
      {
1095
        found_escape=1;                 // duplicate. Remember for delete
1096
        continue;
unknown's avatar
unknown committed
1097 1098
      }
      else
1099
        yyUnget();
unknown's avatar
unknown committed
1100 1101

      /* Found end. Unescape and return string */
1102
      const char *str, *end;
1103
      char *to;
unknown's avatar
unknown committed
1104

1105
      str= m_tok_start;
1106
      end= get_ptr();
1107 1108 1109 1110 1111
      /* Extract the text from the token */
      str += pre_skip;
      end -= post_skip;
      DBUG_ASSERT(end >= str);

1112
      if (!(to= (char*) m_thd->alloc((uint) (end - str) + 1)))
1113
      {
1114 1115
        dst->set(&empty_clex_str, 0, '\0');
        return true;                   // Sql_alloc has set error flag
1116
      }
unknown's avatar
unknown committed
1117

1118
      m_cpp_text_start= m_cpp_tok_start + pre_skip;
1119
      m_cpp_text_end= get_cpp_ptr() - post_skip;
unknown's avatar
unknown committed
1120

unknown's avatar
unknown committed
1121 1122
      if (!found_escape)
      {
1123 1124 1125 1126
        size_t len= (end - str);
        memcpy(to, str, len);
        to[len]= '\0';
        dst->set(to, len, is_8bit, '\0');
unknown's avatar
unknown committed
1127 1128 1129
      }
      else
      {
1130 1131
        size_t len= unescape(cs, to, str, end, sep);
        dst->set(to, len, is_8bit, '\0');
unknown's avatar
unknown committed
1132
      }
1133
      return false;
unknown's avatar
unknown committed
1134 1135
    }
  }
1136
  return true;                         // unexpected end of query
unknown's avatar
unknown committed
1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154
}


/*
** Calc type of integer; long integer, longlong integer or real.
** Returns smallest type that match the string.
** When using unsigned long long values the result is converted to a real
** because else they will be unexpected sign changes because all calculation
** is done with longlong or double.
*/

static const char *long_str="2147483647";
static const uint long_len=10;
static const char *signed_long_str="-2147483648";
static const char *longlong_str="9223372036854775807";
static const uint longlong_len=19;
static const char *signed_longlong_str="-9223372036854775808";
static const uint signed_longlong_len=19;
unknown's avatar
unknown committed
1155 1156
static const char *unsigned_longlong_str="18446744073709551615";
static const uint unsigned_longlong_len=20;
unknown's avatar
unknown committed
1157

unknown's avatar
unknown committed
1158
static inline uint int_token(const char *str,uint length)
unknown's avatar
unknown committed
1159
{
1160
  if (length < long_len)                        // quick normal case
unknown's avatar
unknown committed
1161 1162 1163
    return NUM;
  bool neg=0;

1164
  if (*str == '+')                              // Remove sign and pre-zeros
unknown's avatar
unknown committed
1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185
  {
    str++; length--;
  }
  else if (*str == '-')
  {
    str++; length--;
    neg=1;
  }
  while (*str == '0' && length)
  {
    str++; length --;
  }
  if (length < long_len)
    return NUM;

  uint smaller,bigger;
  const char *cmp;
  if (neg)
  {
    if (length == long_len)
    {
1186 1187 1188
      cmp= signed_long_str + 1;
      smaller= NUM;                                   // If <= signed_long_str
      bigger= LONG_NUM;                               // If >= signed_long_str
unknown's avatar
unknown committed
1189 1190 1191 1192
    }
    else if (length < signed_longlong_len)
      return LONG_NUM;
    else if (length > signed_longlong_len)
unknown's avatar
unknown committed
1193
      return DECIMAL_NUM;
unknown's avatar
unknown committed
1194 1195
    else
    {
1196 1197
      cmp= signed_longlong_str + 1;
      smaller= LONG_NUM;                              // If <= signed_longlong_str
unknown's avatar
unknown committed
1198
      bigger=DECIMAL_NUM;
unknown's avatar
unknown committed
1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211
    }
  }
  else
  {
    if (length == long_len)
    {
      cmp= long_str;
      smaller=NUM;
      bigger=LONG_NUM;
    }
    else if (length < longlong_len)
      return LONG_NUM;
    else if (length > longlong_len)
unknown's avatar
unknown committed
1212 1213
    {
      if (length > unsigned_longlong_len)
unknown's avatar
unknown committed
1214
        return DECIMAL_NUM;
unknown's avatar
unknown committed
1215 1216
      cmp=unsigned_longlong_str;
      smaller=ULONGLONG_NUM;
unknown's avatar
unknown committed
1217
      bigger=DECIMAL_NUM;
unknown's avatar
unknown committed
1218
    }
unknown's avatar
unknown committed
1219 1220 1221 1222
    else
    {
      cmp=longlong_str;
      smaller=LONG_NUM;
1223
      bigger= ULONGLONG_NUM;
unknown's avatar
unknown committed
1224 1225 1226 1227 1228 1229
    }
  }
  while (*cmp && *cmp++ == *str++) ;
  return ((uchar) str[-1] <= (uchar) cmp[-1]) ? smaller : bigger;
}

1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242

/**
  Given a stream that is advanced to the first contained character in 
  an open comment, consume the comment.  Optionally, if we are allowed, 
  recurse so that we understand comments within this current comment.

  At this level, we do not support version-condition comments.  We might 
  have been called with having just passed one in the stream, though.  In 
  that case, we probably want to tolerate mundane comments inside.  Thus,
  the case for recursion.

  @retval  Whether EOF reached before comment is closed.
*/
1243
bool Lex_input_stream::consume_comment(int remaining_recursions_permitted)
1244
{
1245 1246 1247
  // only one level of nested comments are allowed
  DBUG_ASSERT(remaining_recursions_permitted == 0 ||
              remaining_recursions_permitted == 1);
1248
  uchar c;
1249
  while (!eof())
1250
  {
1251
    c= yyGet();
1252

1253
    if (remaining_recursions_permitted == 1)
1254
    {
1255
      if ((c == '/') && (yyPeek() == '*'))
1256
      {
1257 1258
        yyUnput('(');  // Replace nested "/*..." with "(*..."
        yySkip();      // and skip "("
1259

1260 1261
        yySkip(); /* Eat asterisk */
        if (consume_comment(0))
1262 1263
          return true;

1264 1265
        yyUnput(')');  // Replace "...*/" with "...*)"
        yySkip();      // and skip ")"
1266 1267 1268 1269 1270 1271
        continue;
      }
    }

    if (c == '*')
    {
1272
      if (yyPeek() == '/')
1273
      {
1274
        yySkip(); // Eat slash
1275 1276 1277 1278 1279
        return FALSE;
      }
    }

    if (c == '\n')
1280
      yylineno++;
1281 1282 1283 1284 1285 1286
  }

  return TRUE;
}


1287
/*
1288
  MYSQLlex remember the following states from the following MYSQLlex()
1289

1290 1291 1292
  @param yylval         [out]  semantic value of the token being parsed (yylval)
  @param thd            THD

1293 1294 1295
  - MY_LEX_EOQ                  Found end of query
  - MY_LEX_OPERATOR_OR_IDENT    Last state was an ident, text or number
                                (which can't be followed by a signed number)
1296
*/
unknown's avatar
unknown committed
1297

1298
int MYSQLlex(YYSTYPE *yylval, THD *thd)
1299
{
1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311
  return thd->m_parser_state->m_lip.lex_token(yylval, thd);
}


int ORAlex(YYSTYPE *yylval, THD *thd)
{
  return thd->m_parser_state->m_lip.lex_token(yylval, thd);
}


int Lex_input_stream::lex_token(YYSTYPE *yylval, THD *thd)
{
1312
  int token;
Galina Shalygina's avatar
Galina Shalygina committed
1313
  
1314
  if (lookahead_token >= 0)
1315 1316 1317 1318 1319
  {
    /*
      The next token was already parsed in advance,
      return it.
    */
1320 1321 1322 1323
    token= lookahead_token;
    lookahead_token= -1;
    *yylval= *(lookahead_yylval);
    lookahead_yylval= NULL;
1324 1325 1326
    return token;
  }

1327
  token= lex_one_token(yylval, thd);
1328
  add_digest_token(token, yylval);
1329 1330 1331 1332 1333 1334 1335 1336 1337 1338

  switch(token) {
  case WITH:
    /*
      Parsing 'WITH' 'ROLLUP' or 'WITH' 'CUBE' requires 2 look ups,
      which makes the grammar LALR(2).
      Replace by a single 'WITH_ROLLUP' or 'WITH_CUBE' token,
      to transform the grammar into a LALR(1) grammar,
      which sql_yacc.yy can process.
    */
1339
    token= lex_one_token(yylval, thd);
1340
    add_digest_token(token, yylval);
1341 1342 1343 1344 1345
    switch(token) {
    case CUBE_SYM:
      return WITH_CUBE_SYM;
    case ROLLUP_SYM:
      return WITH_ROLLUP_SYM;
1346 1347
    case SYSTEM:
      return WITH_SYSTEM_SYM;
1348 1349 1350 1351
    default:
      /*
        Save the token following 'WITH'
      */
1352 1353
      lookahead_yylval= yylval;
      lookahead_token= token;
1354 1355 1356
      return WITH;
    }
    break;
1357 1358 1359 1360 1361 1362 1363
  case FOR_SYM:
    /*
     * Additional look-ahead to resolve doubtful cases like:
     * SELECT ... FOR UPDATE
     * SELECT ... FOR SYSTEM_TIME ... .
     */
    token= lex_one_token(yylval, thd);
1364
    add_digest_token(token, yylval);
1365 1366 1367 1368 1369 1370 1371
    switch(token) {
    case SYSTEM_TIME_SYM:
      return FOR_SYSTEM_TIME_SYM;
    default:
      /*
        Save the token following 'FOR_SYM'
      */
1372 1373
      lookahead_yylval= yylval;
      lookahead_token= token;
1374 1375 1376
      return FOR_SYM;
    }
    break;
Galina Shalygina's avatar
Galina Shalygina committed
1377
  case VALUES:
1378 1379
    if (thd->lex->current_select->parsing_place == IN_UPDATE_ON_DUP_KEY ||
        thd->lex->current_select->parsing_place == IN_PART_FUNC)
Galina Shalygina's avatar
Galina Shalygina committed
1380 1381
      return VALUE_SYM;
    token= lex_one_token(yylval, thd);
1382
    add_digest_token(token, yylval);
Galina Shalygina's avatar
Galina Shalygina committed
1383 1384 1385 1386 1387 1388
    switch(token) {
    case LESS_SYM:
      return VALUES_LESS_SYM;
    case IN_SYM:
      return VALUES_IN_SYM;
    default:
1389 1390
      lookahead_yylval= yylval;
      lookahead_token= token;
Galina Shalygina's avatar
Galina Shalygina committed
1391 1392 1393
      return VALUES;
    }
    break;
1394 1395 1396 1397 1398 1399
  default:
    break;
  }
  return token;
}

1400

1401
int Lex_input_stream::lex_one_token(YYSTYPE *yylval, THD *thd)
unknown's avatar
unknown committed
1402
{
1403
  uchar UNINIT_VAR(c);
1404
  bool comment_closed;
1405
  int tokval;
unknown's avatar
unknown committed
1406
  uint length;
unknown's avatar
unknown committed
1407
  enum my_lex_states state;
1408
  LEX *lex= thd->lex;
1409 1410 1411
  CHARSET_INFO *const cs= thd->charset();
  const uchar *const state_map= cs->state_map;
  const uchar *const ident_map= cs->ident_map;
unknown's avatar
unknown committed
1412

1413 1414 1415
  start_token();
  state= next_state;
  next_state= MY_LEX_OPERATOR_OR_IDENT;
unknown's avatar
unknown committed
1416 1417
  for (;;)
  {
1418
    switch (state) {
1419 1420
    case MY_LEX_OPERATOR_OR_IDENT:        // Next is operator or keyword
    case MY_LEX_START:                    // Start of token
1421
      // Skip starting whitespace
1422
      while(state_map[c= yyPeek()] == MY_LEX_SKIP)
unknown's avatar
unknown committed
1423
      {
1424
        if (c == '\n')
1425
          yylineno++;
1426

1427
        yySkip();
unknown's avatar
unknown committed
1428
      }
1429 1430

      /* Start of real token */
1431 1432
      restart_token();
      c= yyGet();
1433
      state= (enum my_lex_states) state_map[c];
unknown's avatar
unknown committed
1434
      break;
1435
    case MY_LEX_ESCAPE:
1436
      if (!eof() && yyGet() == 'N')
1437 1438 1439 1440
      {                                        // Allow \N as shortcut for NULL
        yylval->lex_str.str= (char*) "\\N";
        yylval->lex_str.length= 2;
        return NULL_SYM;
unknown's avatar
unknown committed
1441
      }
1442
      /* Fall through */
1443
    case MY_LEX_CHAR:                          // Unknown or single char token
1444 1445 1446 1447 1448
      if (c == '%' && (m_thd->variables.sql_mode & MODE_ORACLE))
      {
        next_state= MY_LEX_START;
        return PERCENT_ORACLE_SYM;
      }
1449
      /* Fall through */
1450
    case MY_LEX_SKIP:                          // This should not happen
1451
      if (c != ')')
1452
        next_state= MY_LEX_START;         // Allow signed numbers
1453 1454 1455
      return((int) c);

    case MY_LEX_MINUS_OR_COMMENT:
1456 1457 1458
      if (yyPeek() == '-' &&
          (my_isspace(cs,yyPeekn(1)) ||
           my_iscntrl(cs,yyPeekn(1))))
1459 1460 1461 1462
      {
        state=MY_LEX_COMMENT;
        break;
      }
1463
      next_state= MY_LEX_START;        // Allow signed numbers
1464
      return((int) c);
1465

1466 1467 1468 1469 1470 1471 1472
    case MY_LEX_PLACEHOLDER:
      /*
        Check for a placeholder: it should not precede a possible identifier
        because of binlogging: when a placeholder is replaced with
        its value in a query for the binlog, the query must stay
        grammatically correct.
      */
1473 1474
      next_state= MY_LEX_START;        // Allow signed numbers
      if (stmt_prepare_mode && !ident_map[(uchar) yyPeek()])
1475
        return(PARAM_MARKER);
1476
      return((int) c);
1477

1478
    case MY_LEX_COMMA:
1479
      next_state= MY_LEX_START;        // Allow signed numbers
1480 1481 1482 1483 1484 1485 1486 1487 1488
      /*
        Warning:
        This is a work around, to make the "remember_name" rule in
        sql/sql_yacc.yy work properly.
        The problem is that, when parsing "select expr1, expr2",
        the code generated by bison executes the *pre* action
        remember_name (see select_item) *before* actually parsing the
        first token of expr2.
      */
1489
      restart_token();
unknown's avatar
unknown committed
1490 1491
      return((int) c);

unknown's avatar
unknown committed
1492
    case MY_LEX_IDENT_OR_NCHAR:
1493 1494
    {
      uint sep;
1495
      if (yyPeek() != '\'')
1496
      {
1497 1498
        state= MY_LEX_IDENT;
        break;
unknown's avatar
unknown committed
1499
      }
1500
      /* Found N'string' */
1501 1502
      yySkip();                         // Skip '
      if (get_text(&yylval->lex_string_with_metadata, (sep= yyGetLast()), 2, 1))
unknown's avatar
unknown committed
1503
      {
1504 1505
        state= MY_LEX_CHAR;                    // Read char by char
        break;
unknown's avatar
unknown committed
1506
      }
1507

1508 1509
      body_utf8_append(m_cpp_text_start);
      body_utf8_append_escape(thd, &yylval->lex_string_with_metadata,
1510
                                   national_charset_info,
1511
                                   m_cpp_text_end, sep);
1512
      return(NCHAR_STRING);
1513
    }
1514
    case MY_LEX_IDENT_OR_HEX:
1515
      if (yyPeek() == '\'')
1516 1517 1518
      {                                      // Found x'hex-number'
        state= MY_LEX_HEX_NUMBER;
        break;
1519
      }
1520
      /* fall through */
unknown's avatar
unknown committed
1521
    case MY_LEX_IDENT_OR_BIN:
1522
      if (yyPeek() == '\'')
unknown's avatar
unknown committed
1523 1524 1525 1526
      {                                 // Found b'bin-number'
        state= MY_LEX_BIN_NUMBER;
        break;
      }
1527
      /* fall through */
1528
    case MY_LEX_IDENT:
1529
    {
1530 1531
      tokval= scan_ident_middle(thd, &yylval->ident_cli,
                                &yylval->charset, &state);
1532 1533 1534
      if (!tokval)
        continue;
      if (tokval == UNDERSCORE_CHARSET)
1535
        m_underscore_cs= yylval->charset;
1536 1537
      return tokval;
    }
unknown's avatar
unknown committed
1538

1539
    case MY_LEX_IDENT_SEP:                  // Found ident and now '.'
1540
      yylval->lex_str.str= (char*) get_ptr();
1541
      yylval->lex_str.length= 1;
1542
      c= yyGet();                          // should be '.'
1543 1544 1545 1546
      if (lex->parsing_options.lookup_keywords_after_qualifier)
        next_state= MY_LEX_IDENT_OR_KEYWORD;
      else
        next_state= MY_LEX_IDENT_START;    // Next is ident (not keyword)
1547 1548
      if (!ident_map[(uchar) yyPeek()])    // Probably ` or "
        next_state= MY_LEX_START;
unknown's avatar
unknown committed
1549 1550
      return((int) c);

1551
    case MY_LEX_NUMBER_IDENT:                   // number or ident which num-start
1552
      if (yyGetLast() == '0')
1553
      {
1554
        c= yyGet();
1555 1556
        if (c == 'x')
        {
1557 1558
          while (my_isxdigit(cs, (c = yyGet()))) ;
          if ((yyLength() >= 3) && !ident_map[c])
1559 1560
          {
            /* skip '0x' */
1561
            yylval->lex_str= get_token(2, yyLength() - 2);
1562 1563
            return (HEX_NUM);
          }
1564
          yyUnget();
1565 1566 1567 1568 1569
          state= MY_LEX_IDENT_START;
          break;
        }
        else if (c == 'b')
        {
1570
          while ((c= yyGet()) == '0' || c == '1')
1571
            ;
1572
          if ((yyLength() >= 3) && !ident_map[c])
1573 1574
          {
            /* Skip '0b' */
1575
            yylval->lex_str= get_token(2, yyLength() - 2);
1576 1577
            return (BIN_NUM);
          }
1578
          yyUnget();
1579 1580 1581
          state= MY_LEX_IDENT_START;
          break;
        }
1582
        yyUnget();
1583 1584
      }

1585
      while (my_isdigit(cs, (c= yyGet()))) ;
unknown's avatar
unknown committed
1586
      if (!ident_map[c])
1587 1588 1589
      {                                        // Can't be identifier
        state=MY_LEX_INT_OR_REAL;
        break;
unknown's avatar
unknown committed
1590 1591 1592
      }
      if (c == 'e' || c == 'E')
      {
1593
        // The following test is written this way to allow numbers of type 1e1
1594 1595
        if (my_isdigit(cs, yyPeek()) ||
            (c=(yyGet())) == '+' || c == '-')
1596
        {                                       // Allow 1E+10
1597
          if (my_isdigit(cs, yyPeek()))         // Number must have digit after sign
1598
          {
1599 1600 1601
            yySkip();
            while (my_isdigit(cs, yyGet())) ;
            yylval->lex_str= get_token(0, yyLength());
1602 1603 1604
            return(FLOAT_NUM);
          }
        }
1605 1606 1607 1608 1609 1610 1611 1612
        /*
          We've found:
          - A sequence of digits
          - Followed by 'e' or 'E'
          - Followed by some byte XX which is not a known mantissa start,
            and it's known to be a valid identifier part.
            XX can be either a 8bit identifier character, or a multi-byte head.
        */
1613
        yyUnget();
1614
        return scan_ident_start(thd, &yylval->ident_cli);
unknown's avatar
unknown committed
1615
      }
1616 1617 1618 1619 1620 1621 1622 1623 1624 1625
      /*
        We've found:
        - A sequence of digits
        - Followed by some character XX, which is neither 'e' nor 'E',
          and it's known to be a valid identifier part.
          XX can be a 8bit identifier character, or a multi-byte head.
      */
      yyUnget();
      return scan_ident_start(thd, &yylval->ident_cli);

1626
    case MY_LEX_IDENT_START:                    // We come here after '.'
1627
      return scan_ident_start(thd, &yylval->ident_cli);
unknown's avatar
unknown committed
1628

1629
    case MY_LEX_USER_VARIABLE_DELIMITER:        // Found quote char
1630
      return scan_ident_delimited(thd, &yylval->ident_cli);
unknown's avatar
unknown committed
1631

1632
    case MY_LEX_INT_OR_REAL:                    // Complete int or incomplete real
1633
      if (c != '.' || yyPeek() == '.')
1634 1635 1636 1637 1638 1639
      {
        /*
          Found a complete integer number:
          - the number is either not followed by a dot at all, or
          - the number is followed by a double dot as in: FOR i IN 1..10
        */
1640
        yylval->lex_str= get_token(0, yyLength());
1641
        return int_token(yylval->lex_str.str, (uint) yylval->lex_str.length);
unknown's avatar
unknown committed
1642 1643
      }
      // fall through
1644
    case MY_LEX_REAL:                           // Incomplete real number
1645
      while (my_isdigit(cs, c= yyGet())) ;
unknown's avatar
unknown committed
1646 1647 1648

      if (c == 'e' || c == 'E')
      {
1649
        c= yyGet();
1650
        if (c == '-' || c == '+')
1651
          c= yyGet();                           // Skip sign
1652 1653 1654 1655 1656
        if (!my_isdigit(cs, c))
        {                                       // No digit after sign
          state= MY_LEX_CHAR;
          break;
        }
1657 1658
        while (my_isdigit(cs, yyGet())) ;
        yylval->lex_str= get_token(0, yyLength());
1659
        return(FLOAT_NUM);
unknown's avatar
unknown committed
1660
      }
1661
      yylval->lex_str= get_token(0, yyLength());
unknown's avatar
unknown committed
1662
      return(DECIMAL_NUM);
unknown's avatar
unknown committed
1663

1664
    case MY_LEX_HEX_NUMBER:             // Found x'hexstring'
1665 1666
      yySkip();                    // Accept opening '
      while (my_isxdigit(cs, (c= yyGet()))) ;
1667 1668
      if (c != '\'')
        return(ABORT_SYM);              // Illegal hex constant
1669 1670
      yySkip();                    // Accept closing '
      length= yyLength();          // Length of hexnum+3
1671 1672
      if ((length % 2) == 0)
        return(ABORT_SYM);              // odd number of hex digits
1673 1674
      yylval->lex_str= get_token(2,            // skip x'
                                 length - 3);  // don't count x' and last '
Alexander Barkov's avatar
Alexander Barkov committed
1675
      return HEX_STRING;
1676

unknown's avatar
unknown committed
1677
    case MY_LEX_BIN_NUMBER:           // Found b'bin-string'
1678 1679
      yySkip();                  // Accept opening '
      while ((c= yyGet()) == '0' || c == '1')
1680
        ;
unknown's avatar
unknown committed
1681
      if (c != '\'')
1682
        return(ABORT_SYM);            // Illegal hex constant
1683 1684 1685 1686
      yySkip();                  // Accept closing '
      length= yyLength();        // Length of bin-num + 3
      yylval->lex_str= get_token(2,           // skip b'
                                 length - 3); // don't count b' and last '
1687
      return (BIN_NUM);
unknown's avatar
unknown committed
1688

1689
    case MY_LEX_CMP_OP:                     // Incomplete comparison operator
1690 1691 1692
      next_state= MY_LEX_START;        // Allow signed numbers
      if (state_map[(uchar) yyPeek()] == MY_LEX_CMP_OP ||
          state_map[(uchar) yyPeek()] == MY_LEX_LONG_CMP_OP)
unknown's avatar
unknown committed
1693
      {
1694 1695
        yySkip();
        if ((tokval= find_keyword(&yylval->kwd, 2, 0)))
1696
          return(tokval);
1697
        yyUnget();
unknown's avatar
unknown committed
1698
      }
1699
      return(c);
unknown's avatar
unknown committed
1700

1701
    case MY_LEX_LONG_CMP_OP:                // Incomplete comparison operator
1702 1703 1704
      next_state= MY_LEX_START;
      if (state_map[(uchar) yyPeek()] == MY_LEX_CMP_OP ||
          state_map[(uchar) yyPeek()] == MY_LEX_LONG_CMP_OP)
unknown's avatar
unknown committed
1705
      {
1706 1707
        yySkip();
        if (state_map[(uchar) yyPeek()] == MY_LEX_CMP_OP)
1708
        {
1709 1710
          yySkip();
          if ((tokval= find_keyword(&yylval->kwd, 3, 0)))
1711
            return(tokval);
1712
          yyUnget();
1713
        }
1714
        if ((tokval= find_keyword(&yylval->kwd, 2, 0)))
1715
          return(tokval);
1716
        yyUnget();
unknown's avatar
unknown committed
1717
      }
1718
      return(c);
unknown's avatar
unknown committed
1719

1720
    case MY_LEX_BOOL:
1721
      if (c != yyPeek())
unknown's avatar
unknown committed
1722
      {
1723 1724
        state= MY_LEX_CHAR;
        break;
unknown's avatar
unknown committed
1725
      }
1726 1727 1728
      yySkip();
      tokval= find_keyword(&yylval->kwd, 2, 0);  // Is a bool operator
      next_state= MY_LEX_START;                  // Allow signed numbers
unknown's avatar
unknown committed
1729 1730
      return(tokval);

1731
    case MY_LEX_STRING_OR_DELIMITER:
1732
      if (thd->variables.sql_mode & MODE_ANSI_QUOTES)
1733
      {
1734 1735
        state= MY_LEX_USER_VARIABLE_DELIMITER;
        break;
1736 1737
      }
      /* " used for strings */
1738
      /* fall through */
1739
    case MY_LEX_STRING:                        // Incomplete text string
1740 1741
    {
      uint sep;
1742
      if (get_text(&yylval->lex_string_with_metadata, (sep= yyGetLast()), 1, 1))
unknown's avatar
unknown committed
1743
      {
1744 1745
        state= MY_LEX_CHAR;                     // Read char by char
        break;
unknown's avatar
unknown committed
1746
      }
1747 1748
      CHARSET_INFO *strcs= m_underscore_cs ? m_underscore_cs : cs;
      body_utf8_append(m_cpp_text_start);
unknown's avatar
unknown committed
1749

1750 1751 1752
      body_utf8_append_escape(thd, &yylval->lex_string_with_metadata,
                                   strcs, m_cpp_text_end, sep);
      m_underscore_cs= NULL;
unknown's avatar
unknown committed
1753
      return(TEXT_STRING);
1754
    }
1755
    case MY_LEX_COMMENT:                       //  Comment
unknown's avatar
unknown committed
1756
      lex->select_lex.options|= OPTION_FOUND_COMMENT;
1757 1758
      while ((c= yyGet()) != '\n' && c) ;
      yyUnget();                          // Safety against eof
1759
      state= MY_LEX_START;                     // Try again
unknown's avatar
unknown committed
1760
      break;
1761
    case MY_LEX_LONG_COMMENT:                  // Long C comment?
1762
      if (yyPeek() != '*')
unknown's avatar
unknown committed
1763
      {
1764 1765
        state= MY_LEX_CHAR;                     // Probable division
        break;
unknown's avatar
unknown committed
1766
      }
unknown's avatar
unknown committed
1767
      lex->select_lex.options|= OPTION_FOUND_COMMENT;
1768
      /* Reject '/' '*', since we might need to turn off the echo */
1769
      yyUnget();
1770

1771
      save_in_comment_state();
1772

1773 1774
      if (yyPeekn(2) == '!' ||
          (yyPeekn(2) == 'M' && yyPeekn(3) == '!'))
unknown's avatar
unknown committed
1775
      {
1776 1777
        bool maria_comment_syntax= yyPeekn(2) == 'M';
        in_comment= DISCARD_COMMENT;
1778
        /* Accept '/' '*' '!', but do not keep this marker. */
1779 1780
        set_echo(FALSE);
        yySkipn(maria_comment_syntax ? 4 : 3);
1781 1782 1783

        /*
          The special comment format is very strict:
1784
          '/' '*' '!', followed by an optional 'M' and exactly
Michael Widenius's avatar
Michael Widenius committed
1785 1786 1787 1788 1789
          1-2 digits (major), 2 digits (minor), then 2 digits (dot).
          32302  -> 3.23.02
          50032  -> 5.0.32
          50114  -> 5.1.14
          100000 -> 10.0.0
1790
        */
1791 1792 1793 1794 1795
        if (  my_isdigit(cs, yyPeekn(0))
           && my_isdigit(cs, yyPeekn(1))
           && my_isdigit(cs, yyPeekn(2))
           && my_isdigit(cs, yyPeekn(3))
           && my_isdigit(cs, yyPeekn(4))
1796 1797 1798
           )
        {
          ulong version;
1799
          uint length= 5;
1800
          char *end_ptr= (char*) get_ptr() + length;
1801
          int error;
1802
          if (my_isdigit(cs, yyPeekn(5)))
1803 1804 1805 1806 1807
          {
            end_ptr++;                          // 6 digit number
            length++;
          }

1808
          version= (ulong) my_strtoll10(get_ptr(), &end_ptr, &error);
1809

1810 1811 1812
          /*
            MySQL-5.7 has new features and might have new SQL syntax that
            MariaDB-10.0 does not understand. Ignore all versioned comments
1813
            with MySQL versions in the range 50700-999999, but
1814 1815 1816
            do not ignore MariaDB specific comments for the same versions.
          */ 
          if (version <= MYSQL_VERSION_ID &&
1817
              (version < 50700 || version > 99999 || maria_comment_syntax))
1818
          {
1819
            /* Accept 'M' 'm' 'm' 'd' 'd' */
1820
            yySkipn(length);
1821
            /* Expand the content of the special comment as real code */
1822
            set_echo(TRUE);
1823
            state=MY_LEX_START;
1824 1825 1826 1827
            break;  /* Do not treat contents as a comment.  */
          }
          else
          {
1828
#ifdef WITH_WSREP
1829 1830 1831 1832
            if (WSREP(thd) && version == 99997 && thd->wsrep_exec_mode == LOCAL_STATE)
            {
              WSREP_DEBUG("consistency check: %s", thd->query());
              thd->wsrep_consistency_check= CONSISTENCY_CHECK_DECLARED;
1833 1834
              yySkipn(5);
              set_echo(TRUE);
1835 1836 1837
              state= MY_LEX_START;
              break;  /* Do not treat contents as a comment.  */
            }
1838
#endif /* WITH_WSREP */
1839 1840 1841 1842
            /*
              Patch and skip the conditional comment to avoid it
              being propagated infinitely (eg. to a slave).
            */
1843 1844
            char *pcom= yyUnput(' ');
            comment_closed= ! consume_comment(1);
1845 1846 1847 1848
            if (! comment_closed)
            {
              *pcom= '!';
            }
1849
            /* version allowed to have one level of comment inside. */
1850 1851 1852 1853
          }
        }
        else
        {
1854
          /* Not a version comment. */
1855
          state=MY_LEX_START;
1856
          set_echo(TRUE);
1857 1858
          break;
        }
unknown's avatar
unknown committed
1859
      }
1860
      else
unknown's avatar
unknown committed
1861
      {
1862 1863 1864 1865
        in_comment= PRESERVE_COMMENT;
        yySkip();                  // Accept /
        yySkip();                  // Accept *
        comment_closed= ! consume_comment(0);
1866
        /* regular comments can have zero comments inside. */
unknown's avatar
unknown committed
1867
      }
1868 1869 1870 1871 1872
      /*
        Discard:
        - regular '/' '*' comments,
        - special comments '/' '*' '!' for a future version,
        by scanning until we find a closing '*' '/' marker.
1873 1874 1875 1876 1877 1878

        Nesting regular comments isn't allowed.  The first 
        '*' '/' returns the parser to the previous state.

        /#!VERSI oned containing /# regular #/ is allowed #/

1879 1880 1881
                Inside one versioned comment, another versioned comment
                is treated as a regular discardable comment.  It gets
                no special parsing.
1882
      */
1883

1884 1885 1886
      /* Unbalanced comments with a missing '*' '/' are a syntax error */
      if (! comment_closed)
        return (ABORT_SYM);
1887
      state = MY_LEX_START;             // Try again
1888
      restore_in_comment_state();
unknown's avatar
unknown committed
1889
      break;
1890
    case MY_LEX_END_LONG_COMMENT:
1891
      if ((in_comment != NO_COMMENT) && yyPeek() == '/')
unknown's avatar
unknown committed
1892
      {
1893
        /* Reject '*' '/' */
1894
        yyUnget();
1895
        /* Accept '*' '/', with the proper echo */
1896 1897
        set_echo(in_comment == PRESERVE_COMMENT);
        yySkipn(2);
1898
        /* And start recording the tokens again */
1899 1900
        set_echo(TRUE);
        in_comment= NO_COMMENT;
1901
        state=MY_LEX_START;
unknown's avatar
unknown committed
1902 1903
      }
      else
1904
        state= MY_LEX_CHAR;              // Return '*'
unknown's avatar
unknown committed
1905
      break;
1906
    case MY_LEX_SET_VAR:                // Check if ':='
1907
      if (yyPeek() != '=')
unknown's avatar
unknown committed
1908
      {
1909 1910 1911 1912 1913 1914 1915
        next_state= MY_LEX_START;
        if (m_thd->variables.sql_mode & MODE_ORACLE)
        {
          yylval->kwd.set_keyword(m_tok_start, 1);
          return COLON_ORACLE_SYM;
        }
        return (int) ':';
unknown's avatar
unknown committed
1916
      }
1917
      yySkip();
unknown's avatar
unknown committed
1918
      return (SET_VAR);
1919
    case MY_LEX_SEMICOLON:              // optional line terminator
1920 1921
      state= MY_LEX_CHAR;               // Return ';'
      break;
1922
    case MY_LEX_EOL:
1923
      if (eof())
unknown's avatar
unknown committed
1924
      {
1925 1926 1927 1928
        yyUnget();                 // Reject the last '\0'
        set_echo(FALSE);
        yySkip();
        set_echo(TRUE);
1929
        /* Unbalanced comments with a missing '*' '/' are a syntax error */
1930
        if (in_comment != NO_COMMENT)
1931
          return (ABORT_SYM);
1932
        next_state= MY_LEX_END;     // Mark for next loop
1933
        return(END_OF_INPUT);
unknown's avatar
unknown committed
1934 1935 1936
      }
      state=MY_LEX_CHAR;
      break;
1937
    case MY_LEX_END:
1938
      next_state= MY_LEX_END;
1939
      return(0);                        // We found end of input last time
1940

1941
      /* Actually real shouldn't start with . but allow them anyhow */
1942
    case MY_LEX_REAL_OR_POINT:
1943
      if (my_isdigit(cs, (c= yyPeek())))
1944
        state = MY_LEX_REAL;            // Real
1945 1946
      else if (c == '.')
      {
1947
        yySkip();
1948 1949
        return DOT_DOT_SYM;
      }
unknown's avatar
unknown committed
1950 1951
      else
      {
1952
        state= MY_LEX_IDENT_SEP;        // return '.'
1953
        yyUnget();                 // Put back '.'
unknown's avatar
unknown committed
1954 1955
      }
      break;
1956
    case MY_LEX_USER_END:               // end '@' of user@hostname
1957
      switch (state_map[(uchar) yyPeek()]) {
1958 1959 1960
      case MY_LEX_STRING:
      case MY_LEX_USER_VARIABLE_DELIMITER:
      case MY_LEX_STRING_OR_DELIMITER:
1961
        break;
1962
      case MY_LEX_USER_END:
1963
        next_state= MY_LEX_SYSTEM_VAR;
1964
        break;
unknown's avatar
unknown committed
1965
      default:
1966
        next_state= MY_LEX_HOSTNAME;
1967
        break;
unknown's avatar
unknown committed
1968
      }
1969 1970
      yylval->lex_str.str= (char*) get_ptr();
      yylval->lex_str.length= 1;
unknown's avatar
unknown committed
1971
      return((int) '@');
1972
    case MY_LEX_HOSTNAME:               // end '@' of user@hostname
1973
      for (c= yyGet() ;
1974
           my_isalnum(cs, c) || c == '.' || c == '_' ||  c == '$';
1975 1976
           c= yyGet()) ;
      yylval->lex_str= get_token(0, yyLength());
unknown's avatar
unknown committed
1977
      return(LEX_HOSTNAME);
1978
    case MY_LEX_SYSTEM_VAR:
1979 1980 1981 1982
      yylval->lex_str.str= (char*) get_ptr();
      yylval->lex_str.length= 1;
      yySkip();                                    // Skip '@'
      next_state= (state_map[(uchar) yyPeek()] ==
1983 1984 1985
                        MY_LEX_USER_VARIABLE_DELIMITER ?
                        MY_LEX_OPERATOR_OR_IDENT :
                        MY_LEX_IDENT_OR_KEYWORD);
unknown's avatar
unknown committed
1986
      return((int) '@');
1987
    case MY_LEX_IDENT_OR_KEYWORD:
unknown's avatar
unknown committed
1988
      /*
1989 1990 1991
        We come here when we have found two '@' in a row.
        We should now be able to handle:
        [(global | local | session) .]variable_name
unknown's avatar
unknown committed
1992
      */
1993
      return scan_ident_sysvar(thd, &yylval->ident_cli);
1994 1995 1996
    }
  }
}
1997

unknown's avatar
unknown committed
1998

1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028
bool Lex_input_stream::get_7bit_or_8bit_ident(THD *thd, uchar *last_char)
{
  uchar c;
  CHARSET_INFO *const cs= thd->charset();
  const uchar *const ident_map= cs->ident_map;
  bool is_8bit= false;
  for ( ; ident_map[c= yyGet()]; )
  {
    if (c & 0x80)
      is_8bit= true; // will convert
  }
  *last_char= c;
  return is_8bit;
}


int Lex_input_stream::scan_ident_sysvar(THD *thd, Lex_ident_cli_st *str)
{
  uchar last_char;
  uint length;
  int tokval;
  bool is_8bit;
  DBUG_ASSERT(m_tok_start == m_ptr);

  is_8bit= get_7bit_or_8bit_ident(thd, &last_char);

  if (last_char == '.')
    next_state= MY_LEX_IDENT_SEP;
  if (!(length= yyLength()))
    return ABORT_SYM;                  // Names must be nonempty.
2029
  if ((tokval= find_keyword(str, length, 0)))
2030 2031 2032 2033 2034 2035
  {
    yyUnget();                         // Put back 'c'
    return tokval;                     // Was keyword
  }

  yyUnget();                       // ptr points now after last token char
2036
  str->set_ident(m_tok_start, length, is_8bit);
2037

2038
  m_cpp_text_start= m_cpp_tok_start;
2039 2040 2041 2042 2043 2044
  m_cpp_text_end= m_cpp_text_start + length;
  body_utf8_append(m_cpp_text_start);
  body_utf8_append_ident(thd, str, m_cpp_text_end);

  return is_8bit ? IDENT_QUOTED : IDENT;
}
unknown's avatar
unknown committed
2045 2046


2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075
/*
  We can come here if different parsing stages:
  - In an identifier chain:
       SELECT t1.cccc FROM t1;
    (when the "cccc" part starts)
    In this case both m_tok_start and m_ptr point to "cccc".
  - When a sequence of digits has changed to something else,
    therefore the token becomes an identifier rather than a number:
       SELECT 12345_6 FROM t1;
    In this case m_tok_start points to the entire "12345_678",
    while m_ptr points to "678".
*/
int Lex_input_stream::scan_ident_start(THD *thd, Lex_ident_cli_st *str)
{
  uchar c;
  bool is_8bit;
  CHARSET_INFO *const cs= thd->charset();
  const uchar *const ident_map= cs->ident_map;
  DBUG_ASSERT(m_tok_start <= m_ptr);

  if (use_mb(cs))
  {
    is_8bit= true;
    while (ident_map[c= yyGet()])
    {
      int char_length= my_charlen(cs, get_ptr() - 1, get_end_of_query());
      if (char_length <= 0)
        break;
      skip_binary(char_length - 1);
unknown's avatar
unknown committed
2076 2077
    }
  }
2078 2079 2080 2081 2082 2083 2084 2085 2086
  else
  {
    is_8bit= get_7bit_or_8bit_ident(thd, &c);
  }
  if (c == '.' && ident_map[(uchar) yyPeek()])
    next_state= MY_LEX_IDENT_SEP;// Next is '.'

  uint length= yyLength();
  yyUnget(); // ptr points now after last token char
2087 2088
  str->set_ident(m_tok_start, length, is_8bit);
  m_cpp_text_start= m_cpp_tok_start;
2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132
  m_cpp_text_end= m_cpp_text_start + length;
  body_utf8_append(m_cpp_text_start);
  body_utf8_append_ident(thd, str, m_cpp_text_end);
  return is_8bit ? IDENT_QUOTED : IDENT;
}


int Lex_input_stream::scan_ident_middle(THD *thd, Lex_ident_cli_st *str,
                                        CHARSET_INFO **introducer,
                                        my_lex_states *st)
{
  CHARSET_INFO *const cs= thd->charset();
  const uchar *const ident_map= cs->ident_map;
  const uchar *const state_map= cs->state_map;
  const char *start;
  uint length;
  uchar c;
  bool is_8bit;
  bool resolve_introducer= true;
  DBUG_ASSERT(m_ptr == m_tok_start + 1); // m_ptr points to the second byte

  if (use_mb(cs))
  {
    is_8bit= true;
    int char_length= my_charlen(cs, get_ptr() - 1, get_end_of_query());
    if (char_length <= 0)
    {
      *st= MY_LEX_CHAR;
      return 0;
    }
    skip_binary(char_length - 1);

    while (ident_map[c= yyGet()])
    {
      char_length= my_charlen(cs, get_ptr() - 1, get_end_of_query());
      if (char_length <= 0)
        break;
      if (char_length > 1 || (c & 0x80))
        resolve_introducer= false;
      skip_binary(char_length - 1);
    }
  }
  else
  {
2133
    is_8bit= get_7bit_or_8bit_ident(thd, &c) || (m_tok_start[0] & 0x80);
2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152
    resolve_introducer= !is_8bit;
  }
  length= yyLength();
  start= get_ptr();
  if (ignore_space)
  {
    /*
      If we find a space then this can't be an identifier. We notice this
      below by checking start != lex->ptr.
    */
    for (; state_map[(uchar) c] == MY_LEX_SKIP ; c= yyGet())
    {
      if (c == '\n')
        yylineno++;
    }
  }
  if (start == get_ptr() && c == '.' && ident_map[(uchar) yyPeek()])
    next_state= MY_LEX_IDENT_SEP;
  else
2153
  {                                    // '(' must follow directly if function
2154 2155
    int tokval;
    yyUnget();
2156
    if ((tokval= find_keyword(str, length, c == '(')))
2157
    {
2158 2159
      next_state= MY_LEX_START;        // Allow signed numbers
      return(tokval);                  // Was keyword
2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170
    }
    yySkip();                  // next state does a unget
  }

  /*
     Note: "SELECT _bla AS 'alias'"
     _bla should be considered as a IDENT if charset haven't been found.
     So we don't use MYF(MY_WME) with get_charset_by_csname to avoid
     producing an error.
  */
  DBUG_ASSERT(length > 0);
2171
  if (resolve_introducer && m_tok_start[0] == '_')
2172 2173 2174
  {

    yyUnget();                       // ptr points now after last token char
2175
    str->set_ident(m_tok_start, length, false);
2176

2177
    m_cpp_text_start= m_cpp_tok_start;
2178
    m_cpp_text_end= m_cpp_text_start + length;
2179
    body_utf8_append(m_cpp_text_start, m_cpp_tok_start + length);
2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191
    ErrConvString csname(str->str + 1, str->length - 1, &my_charset_bin);
    CHARSET_INFO *cs= get_charset_by_csname(csname.ptr(),
                                            MY_CS_PRIMARY, MYF(0));
    if (cs)
    {
      *introducer= cs;
      return UNDERSCORE_CHARSET;
    }
    return IDENT;
  }

  yyUnget();                       // ptr points now after last token char
2192 2193
  str->set_ident(m_tok_start, length, is_8bit);
  m_cpp_text_start= m_cpp_tok_start;
2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208
  m_cpp_text_end= m_cpp_text_start + length;
  body_utf8_append(m_cpp_text_start);
  body_utf8_append_ident(thd, str, m_cpp_text_end);
  return is_8bit ? IDENT_QUOTED : IDENT;
}


int Lex_input_stream::scan_ident_delimited(THD *thd,
                                           Lex_ident_cli_st *str)
{
  CHARSET_INFO *const cs= thd->charset();
  uint double_quotes= 0;
  uchar c, quote_char= m_tok_start[0];
  DBUG_ASSERT(m_ptr == m_tok_start + 1);

2209
  for ( ; ; )
2210
  {
2211 2212 2213 2214 2215 2216 2217
    if (!(c= yyGet()))
    {
      /*
        End-of-query or straight 0x00 inside a delimited identifier.
        Return the quote character, to have the parser fail on syntax error.
      */
      m_ptr= (char *) m_tok_start + 1;
2218 2219
      if (m_echo)
        m_cpp_ptr= (char *) m_cpp_tok_start + 1;
2220 2221
      return quote_char;
    }
2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239
    int var_length= my_charlen(cs, get_ptr() - 1, get_end_of_query());
    if (var_length == 1)
    {
      if (c == quote_char)
      {
        if (yyPeek() != quote_char)
          break;
        c= yyGet();
        double_quotes++;
        continue;
      }
    }
    else if (var_length > 1)
    {
      skip_binary(var_length - 1);
    }
  }

2240
  str->set_ident_quoted(m_tok_start + 1, yyLength() - 1, true, quote_char);
2241 2242
  yyUnget();                       // ptr points now after last token char

2243
  m_cpp_text_start= m_cpp_tok_start + 1;
2244 2245 2246 2247 2248 2249 2250 2251 2252
  m_cpp_text_end= m_cpp_text_start + str->length;

  if (c == quote_char)
    yySkip();                  // Skip end `
  next_state= MY_LEX_START;
  body_utf8_append(m_cpp_text_start);
  // QQQ: shouldn't it add unescaped version ????
  body_utf8_append_ident(thd, str, m_cpp_text_end);
  return IDENT_QUOTED;
unknown's avatar
unknown committed
2253
}
unknown's avatar
unknown committed
2254

2255

2256
void trim_whitespace(CHARSET_INFO *cs, LEX_CSTRING *str, size_t * prefix_length)
2257 2258 2259 2260 2261 2262
{
  /*
    TODO:
    This code assumes that there are no multi-bytes characters
    that can be considered white-space.
  */
2263

2264
  size_t plen= 0;
2265 2266
  while ((str->length > 0) && (my_isspace(cs, str->str[0])))
  {
2267
    plen++;
2268 2269 2270
    str->length --;
    str->str ++;
  }
2271 2272
  if (prefix_length)
    *prefix_length= plen;
2273 2274 2275 2276 2277 2278 2279 2280
  /*
    FIXME:
    Also, parsing backward is not safe with multi bytes characters
  */
  while ((str->length > 0) && (my_isspace(cs, str->str[str->length-1])))
  {
    str->length --;
  }
2281 2282
}

2283

unknown's avatar
unknown committed
2284 2285 2286 2287
/*
  st_select_lex structures initialisations
*/

Eugene Kosov's avatar
Eugene Kosov committed
2288
void st_select_lex_node::init_query_common()
unknown's avatar
unknown committed
2289
{
2290
  options= 0;
2291
  sql_cache= SQL_CACHE_UNSPECIFIED;
2292
  linkage= UNSPECIFIED_TYPE;
Michael Widenius's avatar
Michael Widenius committed
2293
  no_table_names_allowed= 0;
2294
  uncacheable= 0;
unknown's avatar
unknown committed
2295 2296 2297 2298
}

void st_select_lex_unit::init_query()
{
Eugene Kosov's avatar
Eugene Kosov committed
2299
  init_query_common();
2300
  linkage= GLOBAL_OPTIONS_TYPE;
2301 2302
  select_limit_cnt= HA_POS_ERROR;
  offset_limit_cnt= 0;
2303
  union_distinct= 0;
2304
  prepared= optimized= optimized_2= executed= 0;
Igor Babaev's avatar
Igor Babaev committed
2305
  optimize_started= 0;
unknown's avatar
unknown committed
2306
  item= 0;
2307 2308
  union_result= 0;
  table= 0;
unknown's avatar
unknown committed
2309
  fake_select_lex= 0;
2310
  saved_fake_select_lex= 0;
2311
  cleaned= 0;
2312
  item_list.empty();
2313
  describe= 0;
2314
  found_rows_for_union= 0;
2315
  derived= 0;
2316
  is_view= false;
2317 2318
  with_clause= 0;
  with_element= 0;
2319
  columns_are_renamed= false;
2320
  intersect_mark= NULL;
2321
  with_wrapped_tvc= false;
unknown's avatar
unknown committed
2322 2323 2324 2325
}

void st_select_lex::init_query()
{
Eugene Kosov's avatar
Eugene Kosov committed
2326
  init_query_common();
2327
  table_list.empty();
2328 2329
  top_join_list.empty();
  join_list= &top_join_list;
2330
  embedding= 0;
Igor Babaev's avatar
Igor Babaev committed
2331
  leaf_tables_prep.empty();
2332
  leaf_tables.empty();
unknown's avatar
unknown committed
2333
  item_list.empty();
Igor Babaev's avatar
Igor Babaev committed
2334
  min_max_opt_list.empty();
unknown's avatar
unknown committed
2335
  join= 0;
2336
  having= prep_having= where= prep_where= 0;
Igor Babaev's avatar
Igor Babaev committed
2337
  cond_pushed_into_where= cond_pushed_into_having= 0;
2338
  olap= UNSPECIFIED_OLAP_TYPE;
2339
  having_fix_field= 0;
2340
  having_fix_field_for_pushed_cond= 0;
2341 2342
  context.select_lex= this;
  context.init();
unknown's avatar
unknown committed
2343 2344 2345
  /*
    Add the name resolution context of the current (sub)query to the
    stack of contexts for the whole query.
2346 2347 2348 2349 2350
    TODO:
    push_context may return an error if there is no memory for a new
    element in the stack, however this method has no return value,
    thus push_context should be moved to a place where query
    initialization is checked for failure.
unknown's avatar
unknown committed
2351
  */
2352
  parent_lex->push_context(&context, parent_lex->thd->mem_root);
2353
  cond_count= between_count= with_wild= 0;
unknown's avatar
unknown committed
2354
  max_equal_elems= 0;
2355
  ref_pointer_array.reset();
unknown's avatar
unknown committed
2356
  select_n_where_fields= 0;
unknown's avatar
unknown committed
2357
  select_n_reserved= 0;
unknown's avatar
unknown committed
2358
  select_n_having_items= 0;
2359
  n_sum_items= 0;
2360
  n_child_sum_items= 0;
2361
  hidden_bit_fields= 0;
2362
  fields_in_window_functions= 0;
2363
  subquery_in_having= explicit_limit= 0;
2364
  is_item_list_lookup= 0;
2365
  changed_elements= 0;
2366
  first_natural_join_processing= 1;
unknown's avatar
unknown committed
2367
  first_cond_optimization= 1;
2368
  parsing_place= NO_MATTER;
2369
  exclude_from_table_unique_test= no_wrap_view_item= FALSE;
unknown's avatar
unknown committed
2370
  nest_level= 0;
2371
  link_next= 0;
2372
  prep_leaf_list_state= UNINIT;
2373
  have_merged_subqueries= FALSE;
unknown's avatar
unknown committed
2374
  bzero((char*) expr_cache_may_be_used, sizeof(expr_cache_may_be_used));
2375
  select_list_tables= 0;
2376 2377
  m_non_agg_field_used= false;
  m_agg_func_used= false;
2378
  m_custom_agg_func_used= false;
2379 2380
  window_specs.empty();
  window_funcs.empty();
2381
  tvc= 0;
Galina Shalygina's avatar
Galina Shalygina committed
2382
  in_tvc= false;
2383
  versioned_tables= 0;
unknown's avatar
unknown committed
2384 2385 2386 2387
}

void st_select_lex::init_select()
{
2388
  sj_nests.empty();
Igor Babaev's avatar
Igor Babaev committed
2389
  sj_subselects.empty();
2390
  group_list.empty();
2391 2392
  if (group_list_ptrs)
    group_list_ptrs->clear();
2393 2394
  type= 0;
  db= null_clex_str;
2395 2396 2397
  having= 0;
  table_join_options= 0;
  in_sum_expr= with_wild= 0;
unknown's avatar
unknown committed
2398
  options= 0;
2399
  sql_cache= SQL_CACHE_UNSPECIFIED;
unknown's avatar
unknown committed
2400
  ftfunc_list_alloc.empty();
unknown's avatar
unknown committed
2401
  inner_sum_func_list= 0;
unknown's avatar
unknown committed
2402
  ftfunc_list= &ftfunc_list_alloc;
unknown's avatar
unknown committed
2403 2404
  order_list.elements= 0;
  order_list.first= 0;
2405
  order_list.next= &order_list.first;
2406 2407 2408
  /* Set limit and offset to default values */
  select_limit= 0;      /* denotes the default limit = HA_POS_ERROR */
  offset_limit= 0;      /* denotes the default offset = 0 */
unknown's avatar
unknown committed
2409
  with_sum_func= 0;
2410
  with_all_modifier= 0;
2411
  is_correlated= 0;
2412
  cur_pos_in_select_list= UNDEF_POS;
2413
  cond_value= having_value= Item::COND_UNDEF;
2414
  inner_refs_list.empty();
2415
  insert_tables= 0;
Igor Babaev's avatar
Igor Babaev committed
2416
  merged_into= 0;
2417 2418
  m_non_agg_field_used= false;
  m_agg_func_used= false;
2419
  m_custom_agg_func_used= false;
2420
  name_visibility_map.clear_all();
2421
  with_dep= 0;
2422
  join= 0;
2423
  lock_type= TL_READ_DEFAULT;
2424 2425
  save_many_values.empty();
  save_insert_list= 0;
2426
  tvc= 0;
2427
  in_funcs.empty();
2428
  curr_tvc_name= 0;
Galina Shalygina's avatar
Galina Shalygina committed
2429
  in_tvc= false;
2430
  versioned_tables= 0;
unknown's avatar
unknown committed
2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444
}

/*
  st_select_lex structures linking
*/

/* include on level down */
void st_select_lex_node::include_down(st_select_lex_node *upper)
{
  if ((next= upper->slave))
    next->prev= &next;
  prev= &upper->slave;
  upper->slave= this;
  master= upper;
unknown's avatar
unknown committed
2445
  slave= 0;
unknown's avatar
unknown committed
2446 2447
}

unknown's avatar
unknown committed
2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468

void st_select_lex_node::add_slave(st_select_lex_node *slave_arg)
{
  for (; slave; slave= slave->next)
    if (slave == slave_arg)
      return;

  if (slave)
  {
    st_select_lex_node *slave_arg_slave= slave_arg->slave;
    /* Insert in the front of list of slaves if any. */
    slave_arg->include_neighbour(slave);
    /* include_neighbour() sets slave_arg->slave=0, restore it. */
    slave_arg->slave= slave_arg_slave;
    /* Count on include_neighbour() setting the master. */
    DBUG_ASSERT(slave_arg->master == this);
  }
  else
  {
    slave= slave_arg;
    slave_arg->master= this;
2469 2470
    slave->prev= &master->slave;
    slave->next= 0;
unknown's avatar
unknown committed
2471 2472 2473
  }
}

2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494
/*
  @brief
    Substitute this node in select tree for a newly creates node

  @param  subst the node to substitute for

  @details
    The function substitute this node in the select tree for a newly
    created node subst. This node is just removed from the tree but all
    its link fields and the attached sub-tree remain untouched.
*/

void st_select_lex_node::substitute_in_tree(st_select_lex_node *subst)
{
  if ((subst->next= next))
    next->prev= &subst->next;
  subst->prev= prev;
  (*prev)= subst;
  subst->master= master;
}

unknown's avatar
unknown committed
2495

unknown's avatar
unknown committed
2496 2497
/*
  include on level down (but do not link)
unknown's avatar
unknown committed
2498

unknown's avatar
unknown committed
2499 2500 2501 2502 2503 2504
  SYNOPSYS
    st_select_lex_node::include_standalone()
    upper - reference on node underr which this node should be included
    ref - references on reference on this node
*/
void st_select_lex_node::include_standalone(st_select_lex_node *upper,
2505
                                            st_select_lex_node **ref)
unknown's avatar
unknown committed
2506 2507 2508 2509 2510 2511 2512
{
  next= 0;
  prev= ref;
  master= upper;
  slave= 0;
}

unknown's avatar
unknown committed
2513 2514 2515 2516 2517 2518 2519 2520
/* include neighbour (on same level) */
void st_select_lex_node::include_neighbour(st_select_lex_node *before)
{
  if ((next= before->next))
    next->prev= &next;
  prev= &before->next;
  before->next= this;
  master= before->master;
unknown's avatar
unknown committed
2521
  slave= 0;
unknown's avatar
unknown committed
2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535
}

/* including in global SELECT_LEX list */
void st_select_lex_node::include_global(st_select_lex_node **plink)
{
  if ((link_next= *plink))
    link_next->link_prev= &link_next;
  link_prev= plink;
  *plink= this;
}

//excluding from global list (internal function)
void st_select_lex_node::fast_exclude()
{
unknown's avatar
unknown committed
2536
  if (link_prev)
unknown's avatar
unknown committed
2537 2538 2539 2540
  {
    if ((*link_prev= link_next))
      link_next->link_prev= link_prev;
  }
2541 2542 2543 2544
  // Remove slave structure
  for (; slave; slave= slave->next)
    slave->fast_exclude();
  
unknown's avatar
unknown committed
2545 2546
}

2547

2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569
/**
  @brief
    Insert a new chain of nodes into another chain before a particular link

  @param in/out
    ptr_pos_to_insert  the address of the chain pointer pointing to the link
                       before which the subchain has to be inserted
  @param   
    end_chain_node     the last link of the subchain to be inserted

  @details
    The method inserts the chain of nodes starting from this node and ending
    with the node nd_chain_node into another chain of nodes before the node
    pointed to by *ptr_pos_to_insert.
    It is assumed that ptr_pos_to_insert belongs to the chain where we insert.
    So it must be updated.

  @retval
    The method returns the pointer to the first link of the inserted chain
*/

st_select_lex_node *st_select_lex_node:: insert_chain_before(
2570
                                         st_select_lex_node **ptr_pos_to_insert,
2571 2572 2573 2574 2575 2576 2577 2578
                                         st_select_lex_node *end_chain_node)
{
  end_chain_node->link_next= *ptr_pos_to_insert;
  (*ptr_pos_to_insert)->link_prev= &end_chain_node->link_next;
  this->link_prev= ptr_pos_to_insert;
  return this;
}

Igor Babaev's avatar
Igor Babaev committed
2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594

/*
  Detach the node from its master and attach it to a new master
*/

void st_select_lex_node::move_as_slave(st_select_lex_node *new_master)
{
  exclude_from_tree();
  if (new_master->slave)
  {
    st_select_lex_node *curr= new_master->slave;
    for ( ; curr->next ; curr= curr->next) ;
    prev= &curr->next;
  }
  else
    prev= &new_master->slave;
2595
  *prev= this;
Igor Babaev's avatar
Igor Babaev committed
2596 2597 2598 2599 2600
  next= 0;
  master= new_master;
}


2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612
/*
  Exclude a node from the tree lex structure, but leave it in the global
  list of nodes.
*/

void st_select_lex_node::exclude_from_tree()
{
  if ((*prev= next))
    next->prev= prev;
}


unknown's avatar
unknown committed
2613
/*
2614
  Exclude select_lex structure (except first (first select can't be
unknown's avatar
unknown committed
2615 2616 2617 2618
  deleted, because it is most upper select))
*/
void st_select_lex_node::exclude()
{
2619
  /* exclude from global list */
unknown's avatar
unknown committed
2620
  fast_exclude();
2621 2622
  /* exclude from other structures */
  exclude_from_tree();
unknown's avatar
unknown committed
2623 2624 2625 2626 2627 2628 2629
  /* 
     We do not need following statements, because prev pointer of first 
     list element point to master->slave
     if (master->slave == this)
       master->slave= next;
  */
}
2630

2631 2632 2633 2634 2635 2636 2637 2638 2639 2640

/*
  Exclude level of current unit from tree of SELECTs

  SYNOPSYS
    st_select_lex_unit::exclude_level()

  NOTE: units which belong to current will be brought up on level of
  currernt unit 
*/
unknown's avatar
unknown committed
2641 2642 2643
void st_select_lex_unit::exclude_level()
{
  SELECT_LEX_UNIT *units= 0, **units_last= &units;
unknown's avatar
unknown committed
2644
  for (SELECT_LEX *sl= first_select(); sl; sl= sl->next_select())
unknown's avatar
unknown committed
2645
  {
unknown's avatar
unknown committed
2646
    // unlink current level from global SELECTs list
unknown's avatar
unknown committed
2647 2648
    if (sl->link_prev && (*sl->link_prev= sl->link_next))
      sl->link_next->link_prev= sl->link_prev;
unknown's avatar
unknown committed
2649 2650

    // bring up underlay levels
unknown's avatar
unknown committed
2651 2652
    SELECT_LEX_UNIT **last= 0;
    for (SELECT_LEX_UNIT *u= sl->first_inner_unit(); u; u= u->next_unit())
unknown's avatar
unknown committed
2653 2654
    {
      u->master= master;
unknown's avatar
unknown committed
2655
      last= (SELECT_LEX_UNIT**)&(u->next);
unknown's avatar
unknown committed
2656
    }
unknown's avatar
unknown committed
2657 2658 2659 2660 2661 2662 2663 2664
    if (last)
    {
      (*units_last)= sl->first_inner_unit();
      units_last= last;
    }
  }
  if (units)
  {
unknown's avatar
unknown committed
2665
    // include brought up levels in place of current
unknown's avatar
unknown committed
2666 2667
    (*prev)= units;
    (*units_last)= (SELECT_LEX_UNIT*)next;
unknown's avatar
unknown committed
2668 2669 2670
    if (next)
      next->prev= (SELECT_LEX_NODE**)units_last;
    units->prev= prev;
unknown's avatar
unknown committed
2671 2672
  }
  else
unknown's avatar
unknown committed
2673 2674
  {
    // exclude currect unit from list of nodes
unknown's avatar
unknown committed
2675
    (*prev)= next;
unknown's avatar
unknown committed
2676 2677 2678
    if (next)
      next->prev= prev;
  }
2679 2680
  // Mark it excluded
  prev= NULL;
unknown's avatar
unknown committed
2681 2682
}

2683

Oleksandr Byelkin's avatar
Oleksandr Byelkin committed
2684
#if 0
2685 2686 2687 2688 2689 2690 2691 2692 2693 2694
/*
  Exclude subtree of current unit from tree of SELECTs

  SYNOPSYS
    st_select_lex_unit::exclude_tree()
*/
void st_select_lex_unit::exclude_tree()
{
  for (SELECT_LEX *sl= first_select(); sl; sl= sl->next_select())
  {
unknown's avatar
unknown committed
2695
    // unlink current level from global SELECTs list
2696 2697 2698
    if (sl->link_prev && (*sl->link_prev= sl->link_next))
      sl->link_next->link_prev= sl->link_prev;

unknown's avatar
unknown committed
2699
    // unlink underlay levels
2700 2701 2702 2703 2704
    for (SELECT_LEX_UNIT *u= sl->first_inner_unit(); u; u= u->next_unit())
    {
      u->exclude_level();
    }
  }
unknown's avatar
unknown committed
2705
  // exclude currect unit from list of nodes
2706
  (*prev)= next;
unknown's avatar
unknown committed
2707 2708
  if (next)
    next->prev= prev;
2709
}
Oleksandr Byelkin's avatar
Oleksandr Byelkin committed
2710
#endif
2711 2712


unknown's avatar
unknown committed
2713 2714 2715 2716 2717
/*
  st_select_lex_node::mark_as_dependent mark all st_select_lex struct from 
  this to 'last' as dependent

  SYNOPSIS
2718
    last - pointer to last st_select_lex struct, before which all 
unknown's avatar
unknown committed
2719 2720 2721 2722 2723 2724
           st_select_lex have to be marked as dependent

  NOTE
    'last' should be reachable from this st_select_lex_node
*/

2725 2726
bool st_select_lex::mark_as_dependent(THD *thd, st_select_lex *last,
                                      Item *dependency)
unknown's avatar
unknown committed
2727
{
2728 2729 2730

  DBUG_ASSERT(this != last);

unknown's avatar
unknown committed
2731 2732 2733 2734
  /*
    Mark all selects from resolved to 1 before select where was
    found table as depended (of select where was found table)
  */
2735 2736
  SELECT_LEX *s= this;
  do
Sergey Petrunya's avatar
Sergey Petrunya committed
2737
  {
2738
    if (!(s->uncacheable & UNCACHEABLE_DEPENDENT_GENERATED))
unknown's avatar
unknown committed
2739 2740
    {
      // Select is dependent of outer select
2741
      s->uncacheable= (s->uncacheable & ~UNCACHEABLE_UNITED) |
2742
                       UNCACHEABLE_DEPENDENT_GENERATED;
2743
      SELECT_LEX_UNIT *munit= s->master_unit();
2744
      munit->uncacheable= (munit->uncacheable & ~UNCACHEABLE_UNITED) |
2745
                       UNCACHEABLE_DEPENDENT_GENERATED;
2746 2747 2748
      for (SELECT_LEX *sl= munit->first_select(); sl ; sl= sl->next_select())
      {
        if (sl != s &&
2749 2750
            !(sl->uncacheable & (UNCACHEABLE_DEPENDENT_GENERATED |
                                 UNCACHEABLE_UNITED)))
2751 2752
          sl->uncacheable|= UNCACHEABLE_UNITED;
      }
unknown's avatar
unknown committed
2753
    }
2754 2755 2756 2757 2758

    Item_subselect *subquery_expr= s->master_unit()->item;
    if (subquery_expr && subquery_expr->mark_as_dependent(thd, last, 
                                                          dependency))
      return TRUE;
2759
  } while ((s= s->outer_select()) != last && s != 0);
2760 2761
  is_correlated= TRUE;
  this->master_unit()->item->is_correlated= TRUE;
2762
  return FALSE;
unknown's avatar
unknown committed
2763 2764
}

unknown's avatar
unknown committed
2765 2766 2767
/*
  prohibit using LIMIT clause
*/
unknown's avatar
unknown committed
2768
bool st_select_lex::test_limit()
unknown's avatar
unknown committed
2769
{
2770
  if (select_limit != 0)
unknown's avatar
unknown committed
2771 2772
  {
    my_error(ER_NOT_SUPPORTED_YET, MYF(0),
unknown's avatar
unknown committed
2773
             "LIMIT & IN/ALL/ANY/SOME subquery");
unknown's avatar
unknown committed
2774 2775 2776 2777
    return(1);
  }
  return(0);
}
2778

2779

2780

2781 2782 2783 2784 2785
st_select_lex* st_select_lex_unit::outer_select()
{
  return (st_select_lex*) master;
}

2786

2787 2788 2789 2790 2791 2792 2793
ha_rows st_select_lex::get_offset()
{
  ulonglong val= 0;

  if (offset_limit)
  {
    // see comment for st_select_lex::get_limit()
2794 2795 2796
    bool err= offset_limit->fix_fields_if_needed(master_unit()->thd, NULL);
    DBUG_ASSERT(!err);
    val= err ? HA_POS_ERROR : offset_limit->val_uint();
2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834
  }

  return (ha_rows)val;
}


ha_rows st_select_lex::get_limit()
{
  ulonglong val= HA_POS_ERROR;

  if (select_limit)
  {
    /*
      fix_fields() has not been called for select_limit. That's due to the
      historical reasons -- this item could be only of type Item_int, and
      Item_int does not require fix_fields(). Thus, fix_fields() was never
      called for select_limit.

      Some time ago, Item_splocal was also allowed for LIMIT / OFFSET clauses.
      However, the fix_fields() behavior was not updated, which led to a crash
      in some cases.

      There is no single place where to call fix_fields() for LIMIT / OFFSET
      items during the fix-fields-phase. Thus, for the sake of readability,
      it was decided to do it here, on the evaluation phase (which is a
      violation of design, but we chose the lesser of two evils).

      We can call fix_fields() here, because select_limit can be of two
      types only: Item_int and Item_splocal. Item_int::fix_fields() is trivial,
      and Item_splocal::fix_fields() (or rather Item_sp_variable::fix_fields())
      has the following properties:
        1) it does not affect other items;
        2) it does not fail.

      Nevertheless DBUG_ASSERT was added to catch future changes in
      fix_fields() implementation. Also added runtime check against a result
      of fix_fields() in order to handle error condition in non-debug build.
    */
2835 2836 2837
    bool err= select_limit->fix_fields_if_needed(master_unit()->thd, NULL);
    DBUG_ASSERT(!err);
    val= err ? HA_POS_ERROR : select_limit->val_uint();
2838 2839 2840 2841 2842 2843
  }

  return (ha_rows)val;
}


unknown's avatar
unknown committed
2844
bool st_select_lex::add_order_to_list(THD *thd, Item *item, bool asc)
unknown's avatar
unknown committed
2845
{
unknown's avatar
unknown committed
2846
  return add_to_list(thd, order_list, item, asc);
unknown's avatar
unknown committed
2847
}
2848

2849

2850 2851 2852 2853 2854
bool st_select_lex::add_gorder_to_list(THD *thd, Item *item, bool asc)
{
  return add_to_list(thd, gorder_list, item, asc);
}

2855

unknown's avatar
unknown committed
2856
bool st_select_lex::add_item_to_list(THD *thd, Item *item)
2857
{
2858
  DBUG_ENTER("st_select_lex::add_item_to_list");
2859
  DBUG_PRINT("info", ("Item: %p", item));
2860
  DBUG_RETURN(item_list.push_back(item, thd->mem_root));
2861 2862
}

2863

unknown's avatar
unknown committed
2864
bool st_select_lex::add_group_to_list(THD *thd, Item *item, bool asc)
2865
{
unknown's avatar
unknown committed
2866
  return add_to_list(thd, group_list, item, asc);
2867 2868
}

2869

2870
bool st_select_lex::add_ftfunc_to_list(THD *thd, Item_func_match *func)
2871
{
2872
  return !func || ftfunc_list->push_back(func, thd->mem_root); // end of memory?
2873 2874
}

2875

2876 2877 2878 2879 2880
st_select_lex* st_select_lex::outer_select()
{
  return (st_select_lex*) master->get_master();
}

2881

2882 2883 2884 2885 2886 2887
bool st_select_lex::inc_in_sum_expr()
{
  in_sum_expr++;
  return 0;
}

2888

2889 2890 2891 2892 2893
uint st_select_lex::get_in_sum_expr()
{
  return in_sum_expr;
}

2894

2895 2896
TABLE_LIST* st_select_lex::get_table_list()
{
2897
  return table_list.first;
2898 2899 2900 2901 2902 2903 2904
}

List<Item>* st_select_lex::get_item_list()
{
  return &item_list;
}

unknown's avatar
unknown committed
2905 2906 2907 2908 2909
ulong st_select_lex::get_table_join_options()
{
  return table_join_options;
}

2910

unknown's avatar
unknown committed
2911 2912
bool st_select_lex::setup_ref_array(THD *thd, uint order_group_num)
{
2913 2914 2915 2916

  if (!((options & SELECT_DISTINCT) && !group_list.elements))
    hidden_bit_fields= 0;

2917 2918 2919
  // find_order_in_list() may need some extra space, so multiply by two.
  order_group_num*= 2;

2920
  /*
2921
    We have to create array in prepared statement memory if it is a
2922 2923
    prepared statement
  */
unknown's avatar
unknown committed
2924
  Query_arena *arena= thd->stmt_arena;
2925 2926 2927
  const uint n_elems= (n_sum_items +
                       n_child_sum_items +
                       item_list.elements +
Sergei Golubchik's avatar
Sergei Golubchik committed
2928
                       select_n_reserved +
2929 2930
                       select_n_having_items +
                       select_n_where_fields +
2931
                       order_group_num +
2932 2933
                       hidden_bit_fields +
                       fields_in_window_functions) * 5;
2934
  if (!ref_pointer_array.is_null())
2935
  {
2936 2937 2938 2939 2940 2941 2942
    /*
      We need to take 'n_sum_items' into account when allocating the array,
      and this may actually increase during the optimization phase due to
      MIN/MAX rewrite in Item_in_subselect::single_value_transformer.
      In the usual case we can reuse the array from the prepare phase.
      If we need a bigger array, we must allocate a new one.
     */
2943
    if (ref_pointer_array.size() >= n_elems)
2944 2945 2946
      return false;
   }
  Item **array= static_cast<Item**>(arena->alloc(sizeof(Item*) * n_elems));
2947
  if (likely(array != NULL))
2948 2949 2950
    ref_pointer_array= Ref_ptr_array(array, n_elems);

  return array == NULL;
unknown's avatar
unknown committed
2951 2952
}

2953

2954
void st_select_lex_unit::print(String *str, enum_query_type query_type)
unknown's avatar
unknown committed
2955
{
2956
  bool union_all= !union_distinct;
2957 2958
  if (with_clause)
    with_clause->print(str, query_type);
unknown's avatar
unknown committed
2959 2960 2961 2962
  for (SELECT_LEX *sl= first_select(); sl; sl= sl->next_select())
  {
    if (sl != first_select())
    {
2963 2964 2965 2966
      switch (sl->linkage)
      {
      default:
        DBUG_ASSERT(0);
2967
        /* fall through */
2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979
      case UNION_TYPE:
        str->append(STRING_WITH_LEN(" union "));
        if (union_all)
          str->append(STRING_WITH_LEN("all "));
        break;
      case INTERSECT_TYPE:
        str->append(STRING_WITH_LEN(" intersect "));
        break;
      case EXCEPT_TYPE:
        str->append(STRING_WITH_LEN(" except "));
        break;
      }
2980 2981
      if (sl == union_distinct)
        union_all= TRUE;
unknown's avatar
unknown committed
2982 2983 2984
    }
    if (sl->braces)
      str->append('(');
2985
    sl->print(thd, str, query_type);
unknown's avatar
unknown committed
2986 2987 2988
    if (sl->braces)
      str->append(')');
  }
2989
  if (fake_select_lex)
unknown's avatar
unknown committed
2990 2991 2992
  {
    if (fake_select_lex->order_list.elements)
    {
2993
      str->append(STRING_WITH_LEN(" order by "));
2994 2995
      fake_select_lex->print_order(str,
        fake_select_lex->order_list.first,
2996
        query_type);
unknown's avatar
unknown committed
2997
    }
2998
    fake_select_lex->print_limit(thd, str, query_type);
unknown's avatar
unknown committed
2999
  }
3000 3001
  else if (saved_fake_select_lex)
    saved_fake_select_lex->print_limit(thd, str, query_type);
unknown's avatar
unknown committed
3002 3003 3004
}


3005 3006 3007
void st_select_lex::print_order(String *str,
                                ORDER *order,
                                enum_query_type query_type)
unknown's avatar
unknown committed
3008 3009 3010
{
  for (; order; order= order->next)
  {
3011 3012
    if (order->counter_used)
    {
3013 3014 3015 3016 3017 3018 3019 3020 3021
      char buffer[20];
      size_t length= my_snprintf(buffer, 20, "%d", order->counter);
      str->append(buffer, (uint) length);
    }
    else
    {
      /* replace numeric reference with equivalent for ORDER constant */
      if (order->item[0]->type() == Item::INT_ITEM &&
          order->item[0]->basic_const_item())
3022
      {
3023 3024
        /* make it expression instead of integer constant */
        str->append(STRING_WITH_LEN("''"));
3025 3026
      }
      else
3027
        (*order->item)->print(str, query_type);
3028
    }
3029 3030
    if (order->direction == ORDER::ORDER_DESC)
       str->append(STRING_WITH_LEN(" desc"));
unknown's avatar
unknown committed
3031 3032 3033 3034 3035
    if (order->next)
      str->append(',');
  }
}
 
3036

3037 3038 3039
void st_select_lex::print_limit(THD *thd,
                                String *str,
                                enum_query_type query_type)
unknown's avatar
unknown committed
3040
{
3041 3042
  SELECT_LEX_UNIT *unit= master_unit();
  Item_subselect *item= unit->item;
3043

3044
  if (item && unit->global_parameters() == this)
unknown's avatar
VIEW  
unknown committed
3045
  {
3046
    Item_subselect::subs_type subs_type= item->substype();
3047
    if (subs_type == Item_subselect::IN_SUBS ||
3048 3049 3050 3051
        subs_type == Item_subselect::ALL_SUBS)
    {
      return;
    }
unknown's avatar
VIEW  
unknown committed
3052
  }
3053
  if (explicit_limit && select_limit)
unknown's avatar
unknown committed
3054
  {
3055
    str->append(STRING_WITH_LEN(" limit "));
unknown's avatar
unknown committed
3056 3057
    if (offset_limit)
    {
3058
      offset_limit->print(str, query_type);
unknown's avatar
unknown committed
3059 3060
      str->append(',');
    }
3061
    select_limit->print(str, query_type);
unknown's avatar
unknown committed
3062 3063 3064
  }
}

3065

3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077
/**
  @brief Restore the LEX and THD in case of a parse error.

  This is a clean up call that is invoked by the Bison generated
  parser before returning an error from MYSQLparse. If your
  semantic actions manipulate with the global thread state (which
  is a very bad practice and should not normally be employed) and
  need a clean-up in case of error, and you can not use %destructor
  rule in the grammar file itself, this function should be used
  to implement the clean up.
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
3078
void LEX::cleanup_lex_after_parse_error(THD *thd)
3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089
{
  /*
    Delete sphead for the side effect of restoring of the original
    LEX state, thd->lex, thd->mem_root and thd->free_list if they
    were replaced when parsing stored procedure statements.  We
    will never use sphead object after a parse error, so it's okay
    to delete it only for the sake of the side effect.
    TODO: make this functionality explicit in sp_head class.
    Sic: we must nullify the member of the main lex, not the
    current one that will be thrown away
  */
3090
  if (thd->lex->sphead)
3091
  {
3092
    sp_package *pkg;
3093
    thd->lex->sphead->restore_thd_mem_root(thd);
3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104
    if ((pkg= thd->lex->sphead->m_parent))
    {
      /*
        If a syntax error happened inside a package routine definition,
        then thd->lex points to the routine sublex. We need to restore to
        the top level LEX.
      */
      DBUG_ASSERT(pkg->m_top_level_lex);
      DBUG_ASSERT(pkg == pkg->m_top_level_lex->sphead);
      pkg->restore_thd_mem_root(thd);
      LEX *top= pkg->m_top_level_lex;
3105
      sp_package::destroy(pkg);
3106 3107 3108 3109 3110
      thd->lex= top;
      thd->lex->sphead= NULL;
    }
    else
    {
3111
      sp_head::destroy(thd->lex->sphead);
3112 3113
      thd->lex->sphead= NULL;
    }
3114 3115
  }
}
unknown's avatar
VIEW  
unknown committed
3116

3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136
/*
  Initialize (or reset) Query_tables_list object.

  SYNOPSIS
    reset_query_tables_list()
      init  TRUE  - we should perform full initialization of object with
                    allocating needed memory
            FALSE - object is already initialized so we should only reset
                    its state so it can be used for parsing/processing
                    of new statement

  DESCRIPTION
    This method initializes Query_tables_list so it can be used as part
    of LEX object for parsing/processing of statement. One can also use
    this method to reset state of already initialized Query_tables_list
    so it can be used for processing of new statement.
*/

void Query_tables_list::reset_query_tables_list(bool init)
{
3137
  sql_command= SQLCOM_END;
unknown's avatar
unknown committed
3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148
  if (!init && query_tables)
  {
    TABLE_LIST *table= query_tables;
    for (;;)
    {
      delete table->view;
      if (query_tables_last == &table->next_global ||
          !(table= table->next_global))
        break;
    }
  }
3149 3150 3151 3152
  query_tables= 0;
  query_tables_last= &query_tables;
  query_tables_own_last= 0;
  if (init)
3153 3154 3155 3156 3157
  {
    /*
      We delay real initialization of hash (and therefore related
      memory allocation) until first insertion into this hash.
    */
Konstantin Osipov's avatar
Konstantin Osipov committed
3158
    my_hash_clear(&sroutines);
3159
  }
3160
  else if (sroutines.records)
3161 3162
  {
    /* Non-zero sroutines.records means that hash was initialized. */
3163
    my_hash_reset(&sroutines);
3164
  }
3165 3166 3167
  sroutines_list.empty();
  sroutines_list_own_last= sroutines_list.next;
  sroutines_list_own_elements= 0;
3168
  binlog_stmt_flags= 0;
3169
  stmt_accessed_table_flag= 0;
3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181
}


/*
  Destroy Query_tables_list object with freeing all resources used by it.

  SYNOPSIS
    destroy_query_tables_list()
*/

void Query_tables_list::destroy_query_tables_list()
{
Konstantin Osipov's avatar
Konstantin Osipov committed
3182
  my_hash_free(&sroutines);
3183 3184 3185
}


3186 3187 3188 3189
/*
  Initialize LEX object.

  SYNOPSIS
Konstantin Osipov's avatar
Konstantin Osipov committed
3190
    LEX::LEX()
3191 3192 3193 3194 3195 3196 3197 3198 3199

  NOTE
    LEX object initialized with this constructor can be used as part of
    THD object for which one can safely call open_tables(), lock_tables()
    and close_thread_tables() functions. But it is not yet ready for
    statement parsing. On should use lex_start() function to prepare LEX
    for this.
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
3200
LEX::LEX()
3201
  : explain(NULL), result(0), part_info(NULL), arena_for_set_stmt(0), mem_root_for_set_stmt(0),
3202
    option_type(OPT_DEFAULT), context_analysis_only(0), sphead(0),
3203
    default_used(0), is_lex_started(0), limit_rows_examined_cnt(ULONGLONG_MAX)
3204
{
unknown's avatar
unknown committed
3205

3206 3207 3208
  init_dynamic_array2(&plugins, sizeof(plugin_ref), plugins_static_buffer,
                      INITIAL_LEX_PLUGIN_LIST_SIZE,
                      INITIAL_LEX_PLUGIN_LIST_SIZE, 0);
3209
  reset_query_tables_list(TRUE);
3210
  mi.init();
3211
  init_dynamic_array2(&delete_gtid_domain, sizeof(uint32),
3212 3213 3214
                      gtid_domain_static_buffer,
                      initial_gtid_domain_buffer_size,
                      initial_gtid_domain_buffer_size, 0);
3215 3216 3217
}


unknown's avatar
VIEW  
unknown committed
3218
/*
3219
  Check whether the merging algorithm can be used on this VIEW
unknown's avatar
VIEW  
unknown committed
3220 3221

  SYNOPSIS
Konstantin Osipov's avatar
Konstantin Osipov committed
3222
    LEX::can_be_merged()
unknown's avatar
VIEW  
unknown committed
3223

3224
  DESCRIPTION
3225 3226 3227
    We can apply merge algorithm if it is single SELECT view  with
    subqueries only in WHERE clause (we do not count SELECTs of underlying
    views, and second level subqueries) and we have not grpouping, ordering,
3228 3229 3230
    HAVING clause, aggregate functions, DISTINCT clause, LIMIT clause and
    several underlying tables.

unknown's avatar
VIEW  
unknown committed
3231 3232 3233 3234 3235
  RETURN
    FALSE - only temporary table algorithm can be used
    TRUE  - merge algorithm can be used
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
3236
bool LEX::can_be_merged()
unknown's avatar
VIEW  
unknown committed
3237 3238 3239 3240
{
  // TODO: do not forget implement case when select_lex.table_list.elements==0

  /* find non VIEW subqueries/unions */
3241 3242 3243
  bool selects_allow_merge= (select_lex.next_select() == 0 &&
                             !(select_lex.uncacheable &
                               UNCACHEABLE_RAND));
3244 3245
  if (selects_allow_merge)
  {
3246 3247 3248
    for (SELECT_LEX_UNIT *tmp_unit= select_lex.first_inner_unit();
         tmp_unit;
         tmp_unit= tmp_unit->next_unit())
3249
    {
3250
      if (tmp_unit->first_select()->parent_lex == this &&
3251
          (tmp_unit->item != 0 &&
3252
           (tmp_unit->item->place() != IN_WHERE &&
3253 3254
            tmp_unit->item->place() != IN_ON &&
            tmp_unit->item->place() != SELECT_LIST)))
3255 3256 3257 3258 3259 3260 3261 3262
      {
        selects_allow_merge= 0;
        break;
      }
    }
  }

  return (selects_allow_merge &&
3263 3264
          select_lex.group_list.elements == 0 &&
          select_lex.having == 0 &&
3265
          select_lex.with_sum_func == 0 &&
3266 3267
          select_lex.table_list.elements >= 1 &&
          !(select_lex.options & SELECT_DISTINCT) &&
3268
          select_lex.select_limit == 0);
unknown's avatar
VIEW  
unknown committed
3269 3270
}

3271

unknown's avatar
VIEW  
unknown committed
3272
/*
3273
  check if command can use VIEW with MERGE algorithm (for top VIEWs)
unknown's avatar
VIEW  
unknown committed
3274 3275

  SYNOPSIS
Konstantin Osipov's avatar
Konstantin Osipov committed
3276
    LEX::can_use_merged()
unknown's avatar
VIEW  
unknown committed
3277

3278 3279 3280
  DESCRIPTION
    Only listed here commands can use merge algorithm in top level
    SELECT_LEX (for subqueries will be used merge algorithm if
Konstantin Osipov's avatar
Konstantin Osipov committed
3281
    LEX::can_not_use_merged() is not TRUE).
3282

unknown's avatar
VIEW  
unknown committed
3283 3284 3285 3286 3287
  RETURN
    FALSE - command can't use merged VIEWs
    TRUE  - VIEWs with MERGE algorithms can be used
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
3288
bool LEX::can_use_merged()
unknown's avatar
VIEW  
unknown committed
3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301
{
  switch (sql_command)
  {
  case SQLCOM_SELECT:
  case SQLCOM_CREATE_TABLE:
  case SQLCOM_UPDATE:
  case SQLCOM_UPDATE_MULTI:
  case SQLCOM_DELETE:
  case SQLCOM_DELETE_MULTI:
  case SQLCOM_INSERT:
  case SQLCOM_INSERT_SELECT:
  case SQLCOM_REPLACE:
  case SQLCOM_REPLACE_SELECT:
3302
  case SQLCOM_LOAD:
unknown's avatar
VIEW  
unknown committed
3303 3304 3305 3306 3307 3308
    return TRUE;
  default:
    return FALSE;
  }
}

3309
/*
3310
  Check if command can't use merged views in any part of command
3311 3312

  SYNOPSIS
Konstantin Osipov's avatar
Konstantin Osipov committed
3313
    LEX::can_not_use_merged()
3314

3315 3316
  DESCRIPTION
    Temporary table algorithm will be used on all SELECT levels for queries
Konstantin Osipov's avatar
Konstantin Osipov committed
3317
    listed here (see also LEX::can_use_merged()).
3318

3319 3320 3321 3322 3323
  RETURN
    FALSE - command can't use merged VIEWs
    TRUE  - VIEWs with MERGE algorithms can be used
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
3324
bool LEX::can_not_use_merged()
3325 3326 3327 3328 3329
{
  switch (sql_command)
  {
  case SQLCOM_CREATE_VIEW:
  case SQLCOM_SHOW_CREATE:
3330 3331 3332 3333 3334 3335
  /*
    SQLCOM_SHOW_FIELDS is necessary to make 
    information schema tables working correctly with views.
    see get_schema_tables_result function
  */
  case SQLCOM_SHOW_FIELDS:
3336 3337 3338 3339 3340 3341
    return TRUE;
  default:
    return FALSE;
  }
}

3342 3343
/**
  Detect that we need only table structure of derived table/view.
unknown's avatar
VIEW  
unknown committed
3344

3345 3346
  Also used by I_S tables (@see create_schema_table) to detect that
  they need a full table structure and cannot optimize unused columns away
unknown's avatar
VIEW  
unknown committed
3347

3348 3349
  @retval TRUE yes, we need only structure
  @retval FALSE no, we need data
unknown's avatar
VIEW  
unknown committed
3350
*/
unknown's avatar
unknown committed
3351

Konstantin Osipov's avatar
Konstantin Osipov committed
3352
bool LEX::only_view_structure()
unknown's avatar
VIEW  
unknown committed
3353
{
3354
  switch (sql_command) {
unknown's avatar
VIEW  
unknown committed
3355
  case SQLCOM_SHOW_CREATE:
3356
  case SQLCOM_CHECKSUM:
unknown's avatar
VIEW  
unknown committed
3357 3358 3359 3360 3361 3362 3363
  case SQLCOM_SHOW_TABLES:
  case SQLCOM_SHOW_FIELDS:
  case SQLCOM_REVOKE_ALL:
  case SQLCOM_REVOKE:
  case SQLCOM_GRANT:
  case SQLCOM_CREATE_VIEW:
    return TRUE;
3364 3365
  case SQLCOM_CREATE_TABLE:
    return create_info.like();
unknown's avatar
VIEW  
unknown committed
3366 3367 3368 3369 3370 3371
  default:
    return FALSE;
  }
}


unknown's avatar
unknown committed
3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383
/*
  Should Items_ident be printed correctly

  SYNOPSIS
    need_correct_ident()

  RETURN
    TRUE yes, we need only structure
    FALSE no, we need data
*/


Konstantin Osipov's avatar
Konstantin Osipov committed
3384
bool LEX::need_correct_ident()
unknown's avatar
unknown committed
3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396
{
  switch(sql_command)
  {
  case SQLCOM_SHOW_CREATE:
  case SQLCOM_SHOW_TABLES:
  case SQLCOM_CREATE_VIEW:
    return TRUE;
  default:
    return FALSE;
  }
}

3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413
/*
  Get effective type of CHECK OPTION for given view

  SYNOPSIS
    get_effective_with_check()
    view    given view

  NOTE
    It have not sense to set CHECK OPTION for SELECT satement or subqueries,
    so we do not.

  RETURN
    VIEW_CHECK_NONE      no need CHECK OPTION
    VIEW_CHECK_LOCAL     CHECK OPTION LOCAL
    VIEW_CHECK_CASCADED  CHECK OPTION CASCADED
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
3414
uint8 LEX::get_effective_with_check(TABLE_LIST *view)
3415 3416 3417 3418 3419 3420 3421
{
  if (view->select_lex->master_unit() == &unit &&
      which_check_option_applicable())
    return (uint8)view->with_check;
  return VIEW_CHECK_NONE;
}

unknown's avatar
unknown committed
3422

3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441
/**
  This method should be called only during parsing.
  It is aware of compound statements (stored routine bodies)
  and will initialize the destination with the default
  database of the stored routine, rather than the default
  database of the connection it is parsed in.
  E.g. if one has no current database selected, or current database 
  set to 'bar' and then issues:

  CREATE PROCEDURE foo.p1() BEGIN SELECT * FROM t1 END//

  t1 is meant to refer to foo.t1, not to bar.t1.

  This method is needed to support this rule.

  @return TRUE in case of error (parsing should be aborted, FALSE in
  case of success
*/

3442
bool LEX::copy_db_to(LEX_CSTRING *to)
3443
{
3444
  if (sphead && sphead->m_name.str)
3445 3446 3447 3448 3449 3450
  {
    DBUG_ASSERT(sphead->m_db.str && sphead->m_db.length);
    /*
      It is safe to assign the string by-pointer, both sphead and
      its statements reside in the same memory root.
    */
3451
    *to= sphead->m_db;
3452 3453
    return FALSE;
  }
3454
  return thd->copy_db_to(to);
3455 3456
}

3457 3458
/**
  Initialize offset and limit counters.
unknown's avatar
unknown committed
3459

3460
  @param sl SELECT_LEX to get offset and limit from.
unknown's avatar
unknown committed
3461
*/
unknown's avatar
VIEW  
unknown committed
3462

unknown's avatar
unknown committed
3463
void st_select_lex_unit::set_limit(st_select_lex *sl)
3464
{
3465
  DBUG_ASSERT(!thd->stmt_arena->is_stmt_prepare());
3466

3467 3468 3469 3470
  offset_limit_cnt= sl->get_offset();
  select_limit_cnt= sl->get_limit();
  if (select_limit_cnt + offset_limit_cnt >= select_limit_cnt)
    select_limit_cnt+= offset_limit_cnt;
3471
  else
3472 3473
    select_limit_cnt= HA_POS_ERROR;
}
3474 3475


3476 3477
/**
  Decide if a temporary table is needed for the UNION.
3478

3479 3480 3481
  @retval true  A temporary table is needed.
  @retval false A temporary table is not needed.
 */
3482

3483 3484
bool st_select_lex_unit::union_needs_tmp_table()
{
3485 3486
  if (with_element && with_element->is_recursive)
    return true;
3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499
  if (!with_wrapped_tvc)
  {
    for (st_select_lex *sl= first_select(); sl; sl=sl->next_select())
    {
      if (sl->tvc && sl->tvc->to_be_wrapped_as_with_tail())
      {
        with_wrapped_tvc= true;
        break;
      }
    }
  }
  if (with_wrapped_tvc)
    return true;
3500 3501 3502 3503 3504
  return union_distinct != NULL ||
    global_parameters()->order_list.elements != 0 ||
    thd->lex->sql_command == SQLCOM_INSERT_SELECT ||
    thd->lex->sql_command == SQLCOM_REPLACE_SELECT;
}  
unknown's avatar
unknown committed
3505

3506
/**
3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526
  @brief Set the initial purpose of this TABLE_LIST object in the list of used
    tables.

  We need to track this information on table-by-table basis, since when this
  table becomes an element of the pre-locked list, it's impossible to identify
  which SQL sub-statement it has been originally used in.

  E.g.:

  User request:                 SELECT * FROM t1 WHERE f1();
  FUNCTION f1():                DELETE FROM t2; RETURN 1;
  BEFORE DELETE trigger on t2:  INSERT INTO t3 VALUES (old.a);

  For this user request, the pre-locked list will contain t1, t2, t3
  table elements, each needed for different DML.

  The trigger event map is updated to reflect INSERT, UPDATE, DELETE,
  REPLACE, LOAD DATA, CREATE TABLE .. SELECT, CREATE TABLE ..
  REPLACE SELECT statements, and additionally ON DUPLICATE KEY UPDATE
  clause.
3527 3528
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
3529
void LEX::set_trg_event_type_for_tables()
3530
{
3531
  uint8 new_trg_event_map= 0;
3532
  DBUG_ENTER("LEX::set_trg_event_type_for_tables");
3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561

  /*
    Some auxiliary operations
    (e.g. GRANT processing) create TABLE_LIST instances outside
    the parser. Additionally, some commands (e.g. OPTIMIZE) change
    the lock type for a table only after parsing is done. Luckily,
    these do not fire triggers and do not need to pre-load them.
    For these TABLE_LISTs set_trg_event_type is never called, and
    trg_event_map is always empty. That means that the pre-locking
    algorithm will ignore triggers defined on these tables, if
    any, and the execution will either fail with an assert in
    sql_trigger.cc or with an error that a used table was not
    pre-locked, in case of a production build.

    TODO: this usage pattern creates unnecessary module dependencies
    and should be rewritten to go through the parser.
    Table list instances created outside the parser in most cases
    refer to mysql.* system tables. It is not allowed to have
    a trigger on a system table, but keeping track of
    initialization provides extra safety in case this limitation
    is circumvented.
  */

  switch (sql_command) {
  case SQLCOM_LOCK_TABLES:
  /*
    On a LOCK TABLE, all triggers must be pre-loaded for this TABLE_LIST
    when opening an associated TABLE.
  */
3562 3563
    new_trg_event_map= trg2bit(TRG_EVENT_INSERT) | trg2bit(TRG_EVENT_UPDATE) |
                       trg2bit(TRG_EVENT_DELETE);
3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592
    break;
  /*
    Basic INSERT. If there is an additional ON DUPLIATE KEY UPDATE
    clause, it will be handled later in this method.
  */
  case SQLCOM_INSERT:                           /* fall through */
  case SQLCOM_INSERT_SELECT:
  /*
    LOAD DATA ... INFILE is expected to fire BEFORE/AFTER INSERT
    triggers.
    If the statement also has REPLACE clause, it will be
    handled later in this method.
  */
  case SQLCOM_LOAD:                             /* fall through */
  /*
    REPLACE is semantically equivalent to INSERT. In case
    of a primary or unique key conflict, it deletes the old
    record and inserts a new one. So we also may need to
    fire ON DELETE triggers. This functionality is handled
    later in this method.
  */
  case SQLCOM_REPLACE:                          /* fall through */
  case SQLCOM_REPLACE_SELECT:
  /*
    CREATE TABLE ... SELECT defaults to INSERT if the table or
    view already exists. REPLACE option of CREATE TABLE ...
    REPLACE SELECT is handled later in this method.
  */
  case SQLCOM_CREATE_TABLE:
3593
  case SQLCOM_CREATE_SEQUENCE:
3594
    new_trg_event_map|= trg2bit(TRG_EVENT_INSERT);
3595 3596 3597 3598
    break;
  /* Basic update and multi-update */
  case SQLCOM_UPDATE:                           /* fall through */
  case SQLCOM_UPDATE_MULTI:
3599
    new_trg_event_map|= trg2bit(TRG_EVENT_UPDATE);
3600 3601 3602 3603
    break;
  /* Basic delete and multi-delete */
  case SQLCOM_DELETE:                           /* fall through */
  case SQLCOM_DELETE_MULTI:
3604
    new_trg_event_map|= trg2bit(TRG_EVENT_DELETE);
3605 3606 3607 3608 3609 3610 3611
    break;
  default:
    break;
  }

  switch (duplicates) {
  case DUP_UPDATE:
3612
    new_trg_event_map|= trg2bit(TRG_EVENT_UPDATE);
3613 3614
    break;
  case DUP_REPLACE:
3615
    new_trg_event_map|= trg2bit(TRG_EVENT_DELETE);
3616 3617 3618 3619 3620 3621 3622
    break;
  case DUP_ERROR:
  default:
    break;
  }


3623 3624 3625 3626 3627 3628 3629 3630
  /*
    Do not iterate over sub-selects, only the tables in the outermost
    SELECT_LEX can be modified, if any.
  */
  TABLE_LIST *tables= select_lex.get_table_list();

  while (tables)
  {
3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641
    /*
      This is a fast check to filter out statements that do
      not change data, or tables  on the right side, in case of
      INSERT .. SELECT, CREATE TABLE .. SELECT and so on.
      Here we also filter out OPTIMIZE statement and non-updateable
      views, for which lock_type is TL_UNLOCK or TL_READ after
      parsing.
    */
    if (static_cast<int>(tables->lock_type) >=
        static_cast<int>(TL_WRITE_ALLOW_WRITE))
      tables->trg_event_map= new_trg_event_map;
3642 3643
    tables= tables->next_local;
  }
3644
  DBUG_VOID_RETURN;
3645 3646 3647
}


3648
/*
3649 3650
  Unlink the first table from the global table list and the first table from
  outer select (lex->select_lex) local list
3651 3652 3653

  SYNOPSIS
    unlink_first_table()
3654
    link_to_local   Set to 1 if caller should link this table to local list
unknown's avatar
unknown committed
3655

unknown's avatar
VIEW  
unknown committed
3656
  NOTES
3657 3658
    We assume that first tables in both lists is the same table or the local
    list is empty.
3659 3660

  RETURN
3661
    0      If 'query_tables' == 0
unknown's avatar
VIEW  
unknown committed
3662
    unlinked table
3663
      In this case link_to_local is set.
unknown's avatar
unknown committed
3664

3665
*/
Konstantin Osipov's avatar
Konstantin Osipov committed
3666
TABLE_LIST *LEX::unlink_first_table(bool *link_to_local)
3667
{
unknown's avatar
VIEW  
unknown committed
3668 3669 3670 3671 3672 3673 3674 3675
  TABLE_LIST *first;
  if ((first= query_tables))
  {
    /*
      Exclude from global table list
    */
    if ((query_tables= query_tables->next_global))
      query_tables->prev_global= &query_tables;
3676 3677
    else
      query_tables_last= &query_tables;
unknown's avatar
VIEW  
unknown committed
3678 3679 3680 3681 3682
    first->next_global= 0;

    /*
      and from local list if it is not empty
    */
3683
    if ((*link_to_local= MY_TEST(select_lex.table_list.first)))
unknown's avatar
VIEW  
unknown committed
3684
    {
3685 3686
      select_lex.context.table_list= 
        select_lex.context.first_name_resolution_table= first->next_local;
3687
      select_lex.table_list.first= first->next_local;
3688
      select_lex.table_list.elements--;  //safety
unknown's avatar
VIEW  
unknown committed
3689 3690
      first->next_local= 0;
      /*
3691 3692
        Ensure that the global list has the same first table as the local
        list.
unknown's avatar
VIEW  
unknown committed
3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705
      */
      first_lists_tables_same();
    }
  }
  return first;
}


/*
  Bring first local table of first most outer select to first place in global
  table list

  SYNOPSYS
Konstantin Osipov's avatar
Konstantin Osipov committed
3706
     LEX::first_lists_tables_same()
unknown's avatar
VIEW  
unknown committed
3707 3708

  NOTES
3709 3710 3711 3712 3713 3714
    In many cases (for example, usual INSERT/DELETE/...) the first table of
    main SELECT_LEX have special meaning => check that it is the first table
    in global list and re-link to be first in the global list if it is
    necessary.  We need such re-linking only for queries with sub-queries in
    the select list, as only in this case tables of sub-queries will go to
    the global list first.
unknown's avatar
VIEW  
unknown committed
3715 3716
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
3717
void LEX::first_lists_tables_same()
unknown's avatar
VIEW  
unknown committed
3718
{
3719
  TABLE_LIST *first_table= select_lex.table_list.first;
unknown's avatar
VIEW  
unknown committed
3720 3721
  if (query_tables != first_table && first_table != 0)
  {
3722
    TABLE_LIST *next;
unknown's avatar
VIEW  
unknown committed
3723 3724
    if (query_tables_last == &first_table->next_global)
      query_tables_last= first_table->prev_global;
3725

3726 3727 3728
    if (query_tables_own_last == &first_table->next_global)
      query_tables_own_last= first_table->prev_global;

3729
    if ((next= *first_table->prev_global= first_table->next_global))
unknown's avatar
VIEW  
unknown committed
3730 3731 3732 3733
      next->prev_global= first_table->prev_global;
    /* include in new place */
    first_table->next_global= query_tables;
    /*
3734 3735 3736
       We are sure that query_tables is not 0, because first_table was not
       first table in the global list => we can use
       query_tables->prev_global without check of query_tables
unknown's avatar
VIEW  
unknown committed
3737 3738 3739 3740 3741
    */
    query_tables->prev_global= &first_table->next_global;
    first_table->prev_global= &query_tables;
    query_tables= first_table;
  }
3742 3743
}

unknown's avatar
unknown committed
3744

3745
/*
unknown's avatar
unknown committed
3746
  Link table back that was unlinked with unlink_first_table()
3747 3748 3749

  SYNOPSIS
    link_first_table_back()
3750
    link_to_local        do we need link this table to local
3751 3752 3753 3754

  RETURN
    global list
*/
unknown's avatar
VIEW  
unknown committed
3755

Konstantin Osipov's avatar
Konstantin Osipov committed
3756
void LEX::link_first_table_back(TABLE_LIST *first,
3757
                                bool link_to_local)
3758
{
unknown's avatar
VIEW  
unknown committed
3759
  if (first)
3760
  {
unknown's avatar
VIEW  
unknown committed
3761 3762
    if ((first->next_global= query_tables))
      query_tables->prev_global= &first->next_global;
3763 3764
    else
      query_tables_last= &first->next_global;
unknown's avatar
VIEW  
unknown committed
3765 3766 3767 3768
    query_tables= first;

    if (link_to_local)
    {
3769
      first->next_local= select_lex.table_list.first;
unknown's avatar
unknown committed
3770
      select_lex.context.table_list= first;
3771
      select_lex.table_list.first= first;
3772
      select_lex.table_list.elements++; //safety
unknown's avatar
VIEW  
unknown committed
3773 3774 3775 3776 3777
    }
  }
}


3778 3779 3780 3781 3782

/*
  cleanup lex for case when we open table by table for processing

  SYNOPSIS
Konstantin Osipov's avatar
Konstantin Osipov committed
3783
    LEX::cleanup_after_one_table_open()
3784 3785 3786 3787 3788

  NOTE
    This method is mostly responsible for cleaning up of selects lists and
    derived tables state. To rollback changes in Query_tables_list one has
    to call Query_tables_list::reset_query_tables_list(FALSE).
3789 3790
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
3791
void LEX::cleanup_after_one_table_open()
3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803
{
  /*
    thd->lex->derived_tables & additional units may be set if we open
    a view. It is necessary to clear thd->lex->derived_tables flag
    to prevent processing of derived tables during next open_and_lock_tables
    if next table is a real table and cleanup & remove underlying units
    NOTE: all units will be connected to thd->lex->select_lex, because we
    have not UNION on most upper level.
    */
  if (all_selects_list != &select_lex)
  {
    derived_tables= 0;
3804
    select_lex.exclude_from_table_unique_test= false;
3805 3806 3807 3808 3809 3810 3811 3812 3813 3814
    /* cleunup underlying units (units of VIEW) */
    for (SELECT_LEX_UNIT *un= select_lex.first_inner_unit();
         un;
         un= un->next_unit())
      un->cleanup();
    /* reduce all selects list to default state */
    all_selects_list= &select_lex;
    /* remove underlying units (units of VIEW) subtree */
    select_lex.cut_subtree();
  }
3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826
}


/*
  Save current state of Query_tables_list for this LEX, and prepare it
  for processing of new statemnt.

  SYNOPSIS
    reset_n_backup_query_tables_list()
      backup  Pointer to Query_tables_list instance to be used for backup
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
3827
void LEX::reset_n_backup_query_tables_list(Query_tables_list *backup)
3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845
{
  backup->set_query_tables_list(this);
  /*
    We have to perform full initialization here since otherwise we
    will damage backed up state.
  */
  this->reset_query_tables_list(TRUE);
}


/*
  Restore state of Query_tables_list for this LEX from backup.

  SYNOPSIS
    restore_backup_query_tables_list()
      backup  Pointer to Query_tables_list instance used for backup
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
3846
void LEX::restore_backup_query_tables_list(Query_tables_list *backup)
3847 3848 3849
{
  this->destroy_query_tables_list();
  this->set_query_tables_list(backup);
3850 3851 3852
}


unknown's avatar
unknown committed
3853 3854 3855 3856
/*
  Checks for usage of routines and/or tables in a parsed statement

  SYNOPSIS
Konstantin Osipov's avatar
Konstantin Osipov committed
3857
    LEX:table_or_sp_used()
unknown's avatar
unknown committed
3858 3859 3860 3861 3862 3863

  RETURN
    FALSE  No routines and tables used
    TRUE   Either or both routines and tables are used.
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
3864
bool LEX::table_or_sp_used()
unknown's avatar
unknown committed
3865 3866 3867 3868 3869 3870 3871 3872 3873 3874
{
  DBUG_ENTER("table_or_sp_used");

  if (sroutines.records || query_tables)
    DBUG_RETURN(TRUE);

  DBUG_RETURN(FALSE);
}


3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893
/*
  Do end-of-prepare fixup for list of tables and their merge-VIEWed tables

  SYNOPSIS
    fix_prepare_info_in_table_list()
      thd  Thread handle
      tbl  List of tables to process

  DESCRIPTION
    Perform end-end-of prepare fixup for list of tables, if any of the tables
    is a merge-algorithm VIEW, recursively fix up its underlying tables as
    well.

*/

static void fix_prepare_info_in_table_list(THD *thd, TABLE_LIST *tbl)
{
  for (; tbl; tbl= tbl->next_local)
  {
unknown's avatar
unknown committed
3894
    if (tbl->on_expr && !tbl->prep_on_expr)
3895
    {
unknown's avatar
unknown committed
3896
      thd->check_and_register_item_tree(&tbl->prep_on_expr, &tbl->on_expr);
3897 3898
      tbl->on_expr= tbl->on_expr->copy_andor_structure(thd);
    }
3899 3900 3901 3902 3903
    if (tbl->is_view_or_derived() && tbl->is_merged_derived())
    {
      SELECT_LEX *sel= tbl->get_single_select();
      fix_prepare_info_in_table_list(thd, sel->get_table_list());
    }
3904 3905 3906 3907
  }
}


unknown's avatar
VIEW  
unknown committed
3908
/*
3909
  Save WHERE/HAVING/ON clauses and replace them with disposable copies
unknown's avatar
VIEW  
unknown committed
3910 3911 3912

  SYNOPSIS
    st_select_lex::fix_prepare_information
3913 3914 3915 3916 3917 3918 3919 3920
      thd          thread handler
      conds        in/out pointer to WHERE condition to be met at execution
      having_conds in/out pointer to HAVING condition to be met at execution
  
  DESCRIPTION
    The passed WHERE and HAVING are to be saved for the future executions.
    This function saves it, and returns a copy which can be thrashed during
    this execution of the statement. By saving/thrashing here we mean only
3921 3922
    We also save the chain of ORDER::next in group_list, in case
    the list is modified by remove_const().
3923 3924 3925
    AND/OR trees.
    The function also calls fix_prepare_info_in_table_list that saves all
    ON expressions.    
unknown's avatar
VIEW  
unknown committed
3926 3927
*/

3928 3929
void st_select_lex::fix_prepare_information(THD *thd, Item **conds, 
                                            Item **having_conds)
unknown's avatar
VIEW  
unknown committed
3930
{
3931
  DBUG_ENTER("st_select_lex::fix_prepare_information");
3932 3933
  if (!thd->stmt_arena->is_conventional() &&
      !(changed_elements & TOUCHED_SEL_COND))
unknown's avatar
VIEW  
unknown committed
3934
  {
3935
    Query_arena_stmt on_stmt_arena(thd);
3936
    changed_elements|= TOUCHED_SEL_COND;
3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949
    if (group_list.first)
    {
      if (!group_list_ptrs)
      {
        void *mem= thd->stmt_arena->alloc(sizeof(Group_list_ptrs));
        group_list_ptrs= new (mem) Group_list_ptrs(thd->stmt_arena->mem_root);
      }
      group_list_ptrs->reserve(group_list.elements);
      for (ORDER *order= group_list.first; order; order= order->next)
      {
        group_list_ptrs->push_back(order);
      }
    }
3950 3951
    if (*conds)
    {
unknown's avatar
unknown committed
3952
      thd->check_and_register_item_tree(&prep_where, conds);
3953 3954
      *conds= where= prep_where->copy_andor_structure(thd);
    }
3955 3956
    if (*having_conds)
    {
unknown's avatar
unknown committed
3957
      thd->check_and_register_item_tree(&prep_having, having_conds);
3958 3959
      *having_conds= having= prep_having->copy_andor_structure(thd);
    }
3960
    fix_prepare_info_in_table_list(thd, table_list.first);
3961
  }
3962
  DBUG_VOID_RETURN;
3963 3964
}

unknown's avatar
unknown committed
3965

unknown's avatar
unknown committed
3966
/*
unknown's avatar
VIEW  
unknown committed
3967
  There are st_select_lex::add_table_to_list &
unknown's avatar
unknown committed
3968
  st_select_lex::set_lock_for_tables are in sql_parse.cc
unknown's avatar
unknown committed
3969

unknown's avatar
VIEW  
unknown committed
3970
  st_select_lex::print is in sql_select.cc
unknown's avatar
unknown committed
3971 3972

  st_select_lex_unit::prepare, st_select_lex_unit::exec,
3973 3974
  st_select_lex_unit::cleanup, st_select_lex_unit::reinit_exec_mechanism,
  st_select_lex_unit::change_result
unknown's avatar
unknown committed
3975
  are in sql_union.cc
unknown's avatar
unknown committed
3976
*/
3977

3978 3979 3980 3981 3982
/*
  Sets the kind of hints to be added by the calls to add_index_hint().

  SYNOPSIS
    set_index_hint_type()
3983 3984
      type_arg     The kind of hints to be added from now on.
      clause       The clause to use for hints to be added from now on.
3985 3986 3987 3988 3989 3990 3991 3992

  DESCRIPTION
    Used in filling up the tagged hints list.
    This list is filled by first setting the kind of the hint as a 
    context variable and then adding hints of the current kind.
    Then the context variable index_hint_type can be reset to the
    next hint type.
*/
3993
void st_select_lex::set_index_hint_type(enum index_hint_type type_arg,
3994 3995
                                        index_clause_map clause)
{ 
3996
  current_index_hint_type= type_arg;
3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010
  current_index_hint_clause= clause;
}


/*
  Makes an array to store index usage hints (ADD/FORCE/IGNORE INDEX).

  SYNOPSIS
    alloc_index_hints()
      thd         current thread.
*/

void st_select_lex::alloc_index_hints (THD *thd)
{ 
unknown's avatar
unknown committed
4011
  index_hints= new (thd->mem_root) List<Index_hint>(); 
4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028
}



/*
  adds an element to the array storing index usage hints 
  (ADD/FORCE/IGNORE INDEX).

  SYNOPSIS
    add_index_hint()
      thd         current thread.
      str         name of the index.
      length      number of characters in str.

  RETURN VALUE
    0 on success, non-zero otherwise
*/
4029
bool st_select_lex::add_index_hint (THD *thd, const char *str, size_t length)
4030
{
4031
  return index_hints->push_front(new (thd->mem_root) 
unknown's avatar
unknown committed
4032
                                 Index_hint(current_index_hint_type,
4033
                                            current_index_hint_clause,
4034
                                            str, length), thd->mem_root);
4035
}
4036

4037

4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054
/**
  Optimize all subqueries that have not been flattened into semi-joins.

  @details
  This functionality is a method of SELECT_LEX instead of JOIN because
  SQL statements as DELETE/UPDATE do not have a corresponding JOIN object.

  @see JOIN::optimize_unflattened_subqueries

  @param const_only  Restrict subquery optimization to constant subqueries

  @return Operation status
  @retval FALSE     success.
  @retval TRUE      error occurred.
*/

bool st_select_lex::optimize_unflattened_subqueries(bool const_only)
4055
{
4056 4057 4058 4059
  SELECT_LEX_UNIT *next_unit= NULL;
  for (SELECT_LEX_UNIT *un= first_inner_unit();
       un;
       un= next_unit ? next_unit : un->next_unit())
4060 4061
  {
    Item_subselect *subquery_predicate= un->item;
4062 4063
    next_unit= NULL;

4064 4065
    if (subquery_predicate)
    {
4066 4067
      if (!subquery_predicate->fixed)
      {
4068 4069 4070
        /*
         This subquery was excluded as part of some expression so it is
         invisible from all prepared expression.
4071
       */
4072 4073 4074 4075 4076
        next_unit= un->next_unit();
        un->exclude_level();
        if (next_unit)
          continue;
        break;
4077
      }
Sergey Petrunya's avatar
Sergey Petrunya committed
4078 4079
      if (subquery_predicate->substype() == Item_subselect::IN_SUBS)
      {
4080
        Item_in_subselect *in_subs= (Item_in_subselect*) subquery_predicate;
Sergey Petrunya's avatar
Sergey Petrunya committed
4081 4082 4083 4084
        if (in_subs->is_jtbm_merged)
          continue;
      }

4085 4086 4087 4088 4089 4090
      if (const_only && !subquery_predicate->const_item())
      {
        /* Skip non-constant subqueries if the caller asked so. */
        continue;
      }

unknown's avatar
unknown committed
4091
      bool empty_union_result= true;
4092
      bool is_correlated_unit= false;
4093 4094
      bool first= true;
      bool union_plan_saved= false;
unknown's avatar
unknown committed
4095 4096 4097 4098
      /*
        If the subquery is a UNION, optimize all the subqueries in the UNION. If
        there is no UNION, then the loop will execute once for the subquery.
      */
4099 4100 4101
      for (SELECT_LEX *sl= un->first_select(); sl; sl= sl->next_select())
      {
        JOIN *inner_join= sl->join;
4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112
        if (first)
          first= false;
        else
        {
          if (!union_plan_saved)
          {
            union_plan_saved= true;
            if (un->save_union_explain(un->thd->lex->explain))
              return true; /* Failure */
          }
        }
4113 4114
        if (!inner_join)
          continue;
4115
        SELECT_LEX *save_select= un->thd->lex->current_select;
4116
        ulonglong save_options;
4117
        int res;
4118
        /* We need only 1 row to determine existence */
4119
        un->set_limit(un->global_parameters());
4120
        un->thd->lex->current_select= sl;
4121
        save_options= inner_join->select_options;
4122
        if (options & SELECT_DESCRIBE)
4123 4124
        {
          /* Optimize the subquery in the context of EXPLAIN. */
4125
          sl->set_explain_type(FALSE);
unknown's avatar
unknown committed
4126 4127
          sl->options|= SELECT_DESCRIBE;
          inner_join->select_options|= SELECT_DESCRIBE;
4128
        }
4129 4130
        if ((res= inner_join->optimize()))
          return TRUE;
4131 4132
        if (!inner_join->cleaned)
          sl->update_used_tables();
4133 4134
        sl->update_correlated_cache();
        is_correlated_unit|= sl->is_correlated;
4135
        inner_join->select_options= save_options;
4136
        un->thd->lex->current_select= save_select;
4137

4138 4139
        Explain_query *eq;
        if ((eq= inner_join->thd->lex->explain))
4140
        {
4141 4142
          Explain_select *expl_sel;
          if ((expl_sel= eq->get_select(inner_join->select_lex->select_number)))
4143 4144
          {
            sl->set_explain_type(TRUE);
4145
            expl_sel->select_type= sl->type;
4146 4147
          }
        }
4148

unknown's avatar
unknown committed
4149 4150 4151 4152 4153 4154 4155 4156
        if (empty_union_result)
        {
          /*
            If at least one subquery in a union is non-empty, the UNION result
            is non-empty. If there is no UNION, the only subquery is non-empy.
          */
          empty_union_result= inner_join->empty_result();
        }
4157 4158 4159
        if (res)
          return TRUE;
      }
unknown's avatar
unknown committed
4160 4161
      if (empty_union_result)
        subquery_predicate->no_rows_in_result();
4162 4163 4164
      if (!is_correlated_unit)
        un->uncacheable&= ~UNCACHEABLE_DEPENDENT;
      subquery_predicate->is_correlated= is_correlated_unit;
4165 4166 4167
    }
  }
  return FALSE;
4168 4169 4170
}


4171

4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185
/**
  @brief Process all derived tables/views of the SELECT.

  @param lex    LEX of this thread
  @param phase  phases to run derived tables/views through

  @details
  This function runs specified 'phases' on all tables from the
  table_list of this select.

  @return FALSE ok.
  @return TRUE an error occur.
*/

Sergei Golubchik's avatar
Sergei Golubchik committed
4186
bool st_select_lex::handle_derived(LEX *lex, uint phases)
4187
{
4188
  return lex->handle_list_of_derived(table_list.first, phases);
4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244
}


/**
  @brief
  Returns first unoccupied table map and table number

  @param map     [out] return found map
  @param tablenr [out] return found tablenr

  @details
  Returns first unoccupied table map and table number in this select.
  Map and table are returned in *'map' and *'tablenr' accordingly.

  @retrun TRUE  no free table map/table number
  @return FALSE found free table map/table number
*/

bool st_select_lex::get_free_table_map(table_map *map, uint *tablenr)
{
  *map= 0;
  *tablenr= 0;
  TABLE_LIST *tl;
  List_iterator<TABLE_LIST> ti(leaf_tables);
  while ((tl= ti++))
  {
    if (tl->table->map > *map)
      *map= tl->table->map;
    if (tl->table->tablenr > *tablenr)
      *tablenr= tl->table->tablenr;
  }
  (*map)<<= 1;
  (*tablenr)++;
  if (*tablenr >= MAX_TABLES)
    return TRUE;
  return FALSE;
}


/**
  @brief
  Append given table to the leaf_tables list.

  @param link  Offset to which list in table structure to use
  @param table Table to append

  @details
  Append given 'table' to the leaf_tables list using the 'link' offset.
  If the 'table' is linked with other tables through next_leaf/next_local
  chains then whole list will be appended.
*/

void st_select_lex::append_table_to_list(TABLE_LIST *TABLE_LIST::*link,
                                         TABLE_LIST *table)
{
  TABLE_LIST *tl;
Igor Babaev's avatar
Igor Babaev committed
4245
  for (tl= leaf_tables.head(); tl->*link; tl= tl->*link) ;
4246 4247 4248
  tl->*link= table;
}

Igor Babaev's avatar
Igor Babaev committed
4249

4250 4251
/*
  @brief
Igor Babaev's avatar
Igor Babaev committed
4252
  Replace given table from the leaf_tables list for a list of tables 
4253

Igor Babaev's avatar
Igor Babaev committed
4254 4255
  @param table Table to replace
  @param list  List to substititute the table for
4256 4257

  @details
Igor Babaev's avatar
Igor Babaev committed
4258
  Replace 'table' from the leaf_tables list for a list of tables 'tbl_list'.
4259 4260
*/

Igor Babaev's avatar
Igor Babaev committed
4261
void st_select_lex::replace_leaf_table(TABLE_LIST *table, List<TABLE_LIST> &tbl_list)
4262 4263 4264 4265 4266 4267 4268
{
  TABLE_LIST *tl;
  List_iterator<TABLE_LIST> ti(leaf_tables);
  while ((tl= ti++))
  {
    if (tl == table)
    {
Igor Babaev's avatar
Igor Babaev committed
4269
      ti.replace(tbl_list);
4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368
      break;
    }
  }
}


/**
  @brief
  Assigns new table maps to tables in the leaf_tables list

  @param derived    Derived table to take initial table map from
  @param map        table map to begin with
  @param tablenr    table number to begin with
  @param parent_lex new parent select_lex

  @details
  Assign new table maps/table numbers to all tables in the leaf_tables list.
  'map'/'tablenr' are used for the first table and shifted to left/
  increased for each consequent table in the leaf_tables list.
  If the 'derived' table is given then it's table map/number is used for the
  first table in the list and 'map'/'tablenr' are used for the second and
  all consequent tables.
  The 'parent_lex' is set as the new parent select_lex for all tables in the
  list.
*/

void st_select_lex::remap_tables(TABLE_LIST *derived, table_map map,
                                 uint tablenr, SELECT_LEX *parent_lex)
{
  bool first_table= TRUE;
  TABLE_LIST *tl;
  table_map first_map;
  uint first_tablenr;

  if (derived && derived->table)
  {
    first_map= derived->table->map;
    first_tablenr= derived->table->tablenr;
  }
  else
  {
    first_map= map;
    map<<= 1;
    first_tablenr= tablenr++;
  }
  /*
    Assign table bit/table number.
    To the first table of the subselect the table bit/tablenr of the
    derived table is assigned. The rest of tables are getting bits
    sequentially, starting from the provided table map/tablenr.
  */
  List_iterator<TABLE_LIST> ti(leaf_tables);
  while ((tl= ti++))
  {
    if (first_table)
    {
      first_table= FALSE;
      tl->table->set_table_map(first_map, first_tablenr);
    }
    else
    {
      tl->table->set_table_map(map, tablenr);
      tablenr++;
      map<<= 1;
    }
    SELECT_LEX *old_sl= tl->select_lex;
    tl->select_lex= parent_lex;
    for(TABLE_LIST *emb= tl->embedding;
        emb && emb->select_lex == old_sl;
        emb= emb->embedding)
      emb->select_lex= parent_lex;
  }
}

/**
  @brief
  Merge a subquery into this select.

  @param derived     derived table of the subquery to be merged
  @param subq_select select_lex of the subquery
  @param map         table map for assigning to merged tables from subquery
  @param table_no    table number for assigning to merged tables from subquery

  @details
  This function merges a subquery into its parent select. In short the
  merge operation appends the subquery FROM table list to the parent's
  FROM table list. In more details:
    .) the top_join_list of the subquery is wrapped into a join_nest
       and attached to 'derived'
    .) subquery's leaf_tables list  is merged with the leaf_tables
       list of this select_lex
    .) the table maps and table numbers of the tables merged from
       the subquery are adjusted to reflect their new binding to
       this select

  @return TRUE  an error occur
  @return FALSE ok
*/

Igor Babaev's avatar
Igor Babaev committed
4369 4370
bool SELECT_LEX::merge_subquery(THD *thd, TABLE_LIST *derived,
                                SELECT_LEX *subq_select,
4371 4372 4373 4374
                                uint table_no, table_map map)
{
  derived->wrap_into_nested_join(subq_select->top_join_list);

4375
  ftfunc_list->append(subq_select->ftfunc_list);
Igor Babaev's avatar
Igor Babaev committed
4376 4377 4378
  if (join ||
      thd->lex->sql_command == SQLCOM_UPDATE_MULTI ||
      thd->lex->sql_command == SQLCOM_DELETE_MULTI)
4379
  {
Igor Babaev's avatar
Igor Babaev committed
4380 4381 4382
    List_iterator_fast<Item_in_subselect> li(subq_select->sj_subselects);
    Item_in_subselect *in_subq;
    while ((in_subq= li++))
4383
    {
4384
      sj_subselects.push_back(in_subq, thd->mem_root);
Igor Babaev's avatar
Igor Babaev committed
4385 4386
      if (in_subq->emb_on_expr_nest == NO_JOIN_NEST)
         in_subq->emb_on_expr_nest= derived;
4387
    }
4388 4389 4390 4391 4392

    uint cnt= sizeof(expr_cache_may_be_used)/sizeof(bool);
    for (uint i= 0; i < cnt; i++)
    {
      if (subq_select->expr_cache_may_be_used[i])
4393
        expr_cache_may_be_used[i]= true;
4394 4395 4396 4397 4398 4399 4400 4401 4402 4403
    }

    List_iterator_fast<Item_func_in> it(subq_select->in_funcs);
    Item_func_in *in_func;
    while ((in_func= it++))
    {
      in_funcs.push_back(in_func, thd->mem_root);
      if (in_func->emb_on_expr_nest == NO_JOIN_NEST)
        in_func->emb_on_expr_nest= derived;
    }
4404 4405 4406 4407 4408
  }

  /* Walk through child's tables and adjust table map, tablenr,
   * parent_lex */
  subq_select->remap_tables(derived, map, table_no, this);
Igor Babaev's avatar
Igor Babaev committed
4409
  subq_select->merged_into= this;
Igor Babaev's avatar
Igor Babaev committed
4410 4411 4412

  replace_leaf_table(derived, subq_select->leaf_tables);

4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449
  return FALSE;
}


/**
  @brief
  Mark tables from the leaf_tables list as belong to a derived table.

  @param derived   tables will be marked as belonging to this derived

  @details
  Run through the leaf_list and mark all tables as belonging to the 'derived'.
*/

void SELECT_LEX::mark_as_belong_to_derived(TABLE_LIST *derived)
{
  /* Mark tables as belonging to this DT */
  TABLE_LIST *tl;
  List_iterator<TABLE_LIST> ti(leaf_tables);
  while ((tl= ti++))
    tl->belong_to_derived= derived;
}


/**
  @brief
  Update used_tables cache for this select

  @details
  This function updates used_tables cache of ON expressions of all tables
  in the leaf_tables list and of the conds expression (if any).
*/

void SELECT_LEX::update_used_tables()
{
  TABLE_LIST *tl;
  List_iterator<TABLE_LIST> ti(leaf_tables);
Igor Babaev's avatar
Igor Babaev committed
4450

4451 4452
  while ((tl= ti++))
  {
Igor Babaev's avatar
Igor Babaev committed
4453
    if (tl->table && !tl->is_view_or_derived())
Igor Babaev's avatar
Igor Babaev committed
4454
    {
Igor Babaev's avatar
Igor Babaev committed
4455
      TABLE_LIST *embedding= tl->embedding;
Igor Babaev's avatar
Igor Babaev committed
4456 4457 4458
      for (embedding= tl->embedding; embedding; embedding=embedding->embedding)
      {
        if (embedding->is_view_or_derived())
4459
        {
Igor Babaev's avatar
Igor Babaev committed
4460 4461 4462 4463
          DBUG_ASSERT(embedding->is_merged_derived());
          TABLE *tab= tl->table;
          tab->covering_keys= tab->s->keys_for_keyread;
          tab->covering_keys.intersect(tab->keys_in_use_for_query);
4464 4465 4466 4467 4468 4469 4470 4471 4472
          /*
            View/derived was merged. Need to recalculate read_set/vcol_set
            bitmaps here. For example:
              CREATE VIEW v1 AS SELECT f1,f2,f3 FROM t1;
              SELECT f1 FROM v1;
            Initially, the view definition will put all f1,f2,f3 in the
            read_set for t1. But after the view is merged, only f1 should
            be in the read_set.
          */
Igor Babaev's avatar
Igor Babaev committed
4473
          bitmap_clear_all(tab->read_set);
4474 4475
          if (tab->vcol_set)
            bitmap_clear_all(tab->vcol_set);
Igor Babaev's avatar
Igor Babaev committed
4476 4477 4478 4479
          break;
        }
      }
    }
Igor Babaev's avatar
Igor Babaev committed
4480 4481 4482 4483 4484 4485
  }

  ti.rewind();
  while ((tl= ti++))
  {
    TABLE_LIST *embedding= tl;
Igor Babaev's avatar
Igor Babaev committed
4486
    do
Igor Babaev's avatar
Igor Babaev committed
4487
    {
Igor Babaev's avatar
Igor Babaev committed
4488
      bool maybe_null;
4489
      if ((maybe_null= MY_TEST(embedding->outer_join)))
Igor Babaev's avatar
Igor Babaev committed
4490
      {
4491
        tl->table->maybe_null= maybe_null;
Igor Babaev's avatar
Igor Babaev committed
4492 4493
        break;
      }
Igor Babaev's avatar
Igor Babaev committed
4494
    }
Igor Babaev's avatar
Igor Babaev committed
4495
    while ((embedding= embedding->embedding));
4496 4497 4498 4499 4500
    if (tl->on_expr)
    {
      tl->on_expr->update_used_tables();
      tl->on_expr->walk(&Item::eval_not_null_tables, 0, NULL);
    }
4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513
    /*
      - There is no need to check sj_on_expr, because merged semi-joins inject
        sj_on_expr into the parent's WHERE clase.
      - For non-merged semi-joins (aka JTBMs), we need to check their
        left_expr. There is no need to check the rest of the subselect, we know
        it is uncorrelated and so cannot refer to any tables in this select.
    */
    if (tl->jtbm_subselect)
    {
      Item *left_expr= tl->jtbm_subselect->left_expr;
      left_expr->walk(&Item::update_table_bitmaps_processor, FALSE, NULL);
    }

Igor Babaev's avatar
Igor Babaev committed
4514
    embedding= tl->embedding;
4515 4516 4517 4518 4519 4520 4521 4522 4523 4524
    while (embedding)
    {
      if (embedding->on_expr && 
          embedding->nested_join->join_list.head() == tl)
      {
        embedding->on_expr->update_used_tables();
        embedding->on_expr->walk(&Item::eval_not_null_tables, 0, NULL);
      }
      tl= embedding;
      embedding= tl->embedding;
4525
    }
4526
  }
Igor Babaev's avatar
Igor Babaev committed
4527

4528 4529 4530 4531 4532
  if (join->conds)
  {
    join->conds->update_used_tables();
    join->conds->walk(&Item::eval_not_null_tables, 0, NULL);
  }
Igor Babaev's avatar
Igor Babaev committed
4533 4534 4535 4536 4537 4538
  if (join->having)
  {
    join->having->update_used_tables();
  }

  Item *item;
4539
  List_iterator_fast<Item> it(join->all_fields);
4540
  select_list_tables= 0;
Igor Babaev's avatar
Igor Babaev committed
4541 4542 4543
  while ((item= it++))
  {
    item->update_used_tables();
4544
    select_list_tables|= item->used_tables();
Igor Babaev's avatar
Igor Babaev committed
4545 4546 4547 4548 4549 4550 4551 4552 4553 4554
  }
  Item_outer_ref *ref;
  List_iterator_fast<Item_outer_ref> ref_it(inner_refs_list);
  while ((ref= ref_it++))
  {
    item= ref->outer_ref;
    item->update_used_tables();
  }
  for (ORDER *order= group_list.first; order; order= order->next)
    (*order->item)->update_used_tables();
4555 4556
  if (!master_unit()->is_unit_op() ||
      master_unit()->global_parameters() != this)
Igor Babaev's avatar
Igor Babaev committed
4557 4558 4559
  {
    for (ORDER *order= order_list.first; order; order= order->next)
      (*order->item)->update_used_tables();
unknown's avatar
unknown committed
4560 4561
  }
  join->result->update_used_tables();
4562 4563
}

4564

4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580
/**
  @brief
  Update is_correlated cache for this select

  @details
*/

void st_select_lex::update_correlated_cache()
{
  TABLE_LIST *tl;
  List_iterator<TABLE_LIST> ti(leaf_tables);

  is_correlated= false;

  while ((tl= ti++))
  {
4581
    //    is_correlated|= tl->is_with_table_recursive_reference();
4582
    if (tl->on_expr)
4583
      is_correlated|= MY_TEST(tl->on_expr->used_tables() & OUTER_REF_TABLE_BIT);
4584 4585 4586 4587
    for (TABLE_LIST *embedding= tl->embedding ; embedding ;
         embedding= embedding->embedding)
    {
      if (embedding->on_expr)
4588 4589
        is_correlated|= MY_TEST(embedding->on_expr->used_tables() &
                                OUTER_REF_TABLE_BIT);
4590 4591 4592 4593
    }
  }

  if (join->conds)
4594
    is_correlated|= MY_TEST(join->conds->used_tables() & OUTER_REF_TABLE_BIT);
4595

4596 4597
  is_correlated|= join->having_is_correlated;

4598
  if (join->having)
4599
    is_correlated|= MY_TEST(join->having->used_tables() & OUTER_REF_TABLE_BIT);
4600 4601

  if (join->tmp_having)
4602 4603
    is_correlated|= MY_TEST(join->tmp_having->used_tables() &
                            OUTER_REF_TABLE_BIT);
4604 4605 4606 4607

  Item *item;
  List_iterator_fast<Item> it(join->fields_list);
  while ((item= it++))
4608
    is_correlated|= MY_TEST(item->used_tables() & OUTER_REF_TABLE_BIT);
4609 4610

  for (ORDER *order= group_list.first; order; order= order->next)
4611 4612
    is_correlated|= MY_TEST((*order->item)->used_tables() &
                            OUTER_REF_TABLE_BIT);
4613

4614
  if (!master_unit()->is_unit_op())
4615 4616
  {
    for (ORDER *order= order_list.first; order; order= order->next)
4617 4618
      is_correlated|= MY_TEST((*order->item)->used_tables() &
                              OUTER_REF_TABLE_BIT);
4619 4620 4621 4622 4623 4624 4625
  }

  if (!is_correlated)
    uncacheable&= ~UNCACHEABLE_DEPENDENT;
}


4626 4627
/**
  Set the EXPLAIN type for this subquery.
Sergey Petrunya's avatar
Sergey Petrunya committed
4628 4629 4630
  
  @param on_the_fly  TRUE<=> We're running a SHOW EXPLAIN command, so we must 
                     not change any variables
4631 4632
*/

4633
void st_select_lex::set_explain_type(bool on_the_fly)
4634
{
4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654
  bool is_primary= FALSE;
  if (next_select())
    is_primary= TRUE;

  if (!is_primary && first_inner_unit())
  {
    /*
      If there is at least one materialized derived|view then it's a PRIMARY select.
      Otherwise, all derived tables/views were merged and this select is a SIMPLE one.
    */
    for (SELECT_LEX_UNIT *un= first_inner_unit(); un; un= un->next_unit())
    {
      if ((!un->derived || un->derived->is_materialized_derived()))
      {
        is_primary= TRUE;
        break;
      }
    }
  }

4655 4656 4657
  if (on_the_fly && !is_primary && have_merged_subqueries)
    is_primary= TRUE;

4658 4659 4660
  SELECT_LEX *first= master_unit()->first_select();
  /* drop UNCACHEABLE_EXPLAIN, because it is for internal usage only */
  uint8 is_uncacheable= (uncacheable & ~UNCACHEABLE_EXPLAIN);
4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674
  
  bool using_materialization= FALSE;
  Item_subselect *parent_item;
  if ((parent_item= master_unit()->item) &&
      parent_item->substype() == Item_subselect::IN_SUBS)
  {
    Item_in_subselect *in_subs= (Item_in_subselect*)parent_item;
    /*
      Surprisingly, in_subs->is_set_strategy() can return FALSE here,
      even for the last invocation of this function for the select.
    */
    if (in_subs->test_strategy(SUBS_MATERIALIZATION))
      using_materialization= TRUE;
  }
4675

4676 4677 4678 4679 4680 4681 4682 4683 4684 4685
  if (&master_unit()->thd->lex->select_lex == this)
  {
     type= is_primary ? "PRIMARY" : "SIMPLE";
  }
  else
  {
    if (this == first)
    {
      /* If we're a direct child of a UNION, we're the first sibling there */
      if (linkage == DERIVED_TABLE_TYPE)
4686 4687 4688 4689 4690 4691
      {
        if (is_uncacheable & UNCACHEABLE_DEPENDENT)
          type= "LATERAL DERIVED";
        else
          type= "DERIVED";
      }
4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706
      else if (using_materialization)
        type= "MATERIALIZED";
      else
      {
         if (is_uncacheable & UNCACHEABLE_DEPENDENT)
           type= "DEPENDENT SUBQUERY";
         else
         {
           type= is_uncacheable? "UNCACHEABLE SUBQUERY" :
                                 "SUBQUERY";
         }
      }
    }
    else
    {
4707
      switch (linkage)
4708
      {
4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721
      case INTERSECT_TYPE:
        type= "INTERSECT";
        break;
      case EXCEPT_TYPE:
        type= "EXCEPT";
        break;
      default:
        /* This a non-first sibling in UNION */
        if (is_uncacheable & UNCACHEABLE_DEPENDENT)
          type= "DEPENDENT UNION";
        else if (using_materialization)
          type= "MATERIALIZED UNION";
        else
4722
        {
4723 4724 4725 4726 4727 4728 4729 4730 4731
          type= is_uncacheable ? "UNCACHEABLE UNION": "UNION";
          if (this == master_unit()->fake_select_lex)
            type= unit_operation_text[master_unit()->common_op()];
          /*
            join below may be =NULL when this functions is called at an early
            stage. It will be later called again and we will set the correct
            value.
          */
          if (join)
4732
          {
4733
            bool uses_cte= false;
4734 4735 4736 4737
            for (JOIN_TAB *tab= first_linear_tab(join, WITHOUT_BUSH_ROOTS,
                                                       WITH_CONST_TABLES);
                 tab;
                 tab= next_linear_tab(join, tab, WITHOUT_BUSH_ROOTS))
4738
            {
4739 4740 4741
              /*
                pos_in_table_list=NULL for e.g. post-join aggregation JOIN_TABs.
              */
4742 4743 4744 4745 4746
              if (!(tab->table && tab->table->pos_in_table_list))
	        continue;
              TABLE_LIST *tbl= tab->table->pos_in_table_list;
              if (tbl->with && tbl->with->is_recursive &&
                  tbl->is_with_table_recursive_reference())
4747
              {
4748 4749
                uses_cte= true;
                break;
4750
              }
4751
            }
4752 4753
            if (uses_cte)
              type= "RECURSIVE UNION";
4754 4755
          }
        }
4756
        break;
4757 4758 4759
      }
    }
  }
4760 4761

  if (!on_the_fly)
4762
    options|= SELECT_DESCRIBE;
4763
}
4764 4765


4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776
/**
  @brief
  Increase estimated number of records for a derived table/view

  @param records  number of records to increase estimate by

  @details
  This function increases estimated number of records by the 'records'
  for the derived table to which this select belongs to.
*/

Vladislav Vaintroub's avatar
Vladislav Vaintroub committed
4777
void SELECT_LEX::increase_derived_records(ha_rows records)
4778 4779 4780 4781
{
  SELECT_LEX_UNIT *unit= master_unit();
  DBUG_ASSERT(unit->derived);

Igor Babaev's avatar
Igor Babaev committed
4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794
  if (unit->with_element && unit->with_element->is_recursive)
  {
    st_select_lex *first_recursive= unit->with_element->first_recursive;
    st_select_lex *sl= unit->first_select();
    for ( ; sl != first_recursive; sl= sl->next_select())
    {
      if (sl == this)
        break;
    }
    if (sl == first_recursive)
      return; 
  }
  
4795
  select_result *result= unit->result;
4796 4797 4798 4799
  switch (linkage)
  {
  case INTERSECT_TYPE:
    // result of intersect can't be more then one of components
4800
    set_if_smaller(result->est_records, records);
4801 4802 4803 4804 4805
  case EXCEPT_TYPE:
    // in worse case none of record will be removed
    break;
  default:
    // usual UNION
4806 4807 4808 4809
    if (HA_ROWS_MAX - records > result->est_records)
      result->est_records+= records;
    else
      result->est_records= HA_ROWS_MAX;
4810 4811
    break;
  }
4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830
}


/**
  @brief
  Mark select's derived table as a const one.

  @param empty Whether select has an empty result set

  @details
  Mark derived table/view of this select as a constant one (to
  materialize it at the optimization phase) unless this select belongs to a
  union. Estimated number of rows is incremented if this select has non empty
  result set.
*/

void SELECT_LEX::mark_const_derived(bool empty)
{
  TABLE_LIST *derived= master_unit()->derived;
Igor Babaev's avatar
Igor Babaev committed
4831 4832
  /* join == NULL in  DELETE ... RETURNING */
  if (!(join && join->thd->lex->describe) && derived)
4833 4834 4835
  {
    if (!empty)
      increase_derived_records(1);
Igor Babaev's avatar
Igor Babaev committed
4836 4837
    if (!master_unit()->is_unit_op() && !derived->is_merged_derived() &&
        !(join && join->with_two_phase_optimization))
4838 4839 4840 4841
      derived->fill_me= TRUE;
  }
}

Igor Babaev's avatar
Igor Babaev committed
4842

4843 4844
bool st_select_lex::save_leaf_tables(THD *thd)
{
4845 4846
  Query_arena *arena, backup;
  arena= thd->activate_stmt_arena_if_needed(&backup);
4847 4848 4849 4850 4851

  List_iterator_fast<TABLE_LIST> li(leaf_tables);
  TABLE_LIST *table;
  while ((table= li++))
  {
4852
    if (leaf_tables_exec.push_back(table, thd->mem_root))
4853
      return 1;
4854 4855
    table->tablenr_exec= table->get_tablenr();
    table->map_exec= table->get_map();
Igor Babaev's avatar
Igor Babaev committed
4856 4857 4858
    if (join && (join->select_options & SELECT_DESCRIBE))
      table->maybe_null_exec= 0;
    else
4859
      table->maybe_null_exec= table->table?  table->table->maybe_null: 0;
4860 4861 4862 4863 4864 4865 4866
  }
  if (arena)
    thd->restore_active_arena(arena, &backup);

  return 0;
}

4867

4868
bool LEX::save_prep_leaf_tables()
Igor Babaev's avatar
Igor Babaev committed
4869 4870
{
  if (!thd->save_prep_leaf_list)
4871
    return FALSE;
Igor Babaev's avatar
Igor Babaev committed
4872 4873

  Query_arena *arena= thd->stmt_arena, backup;
4874
  arena= thd->activate_stmt_arena_if_needed(&backup);
4875 4876 4877 4878 4879 4880 4881 4882 4883
  //It is used for DETETE/UPDATE so top level has only one SELECT
  DBUG_ASSERT(select_lex.next_select() == NULL);
  bool res= select_lex.save_prep_leaf_tables(thd);

  if (arena)
    thd->restore_active_arena(arena, &backup);

  if (res)
    return TRUE;
Igor Babaev's avatar
Igor Babaev committed
4884

4885 4886 4887
  thd->save_prep_leaf_list= FALSE;
  return FALSE;
}
Igor Babaev's avatar
Igor Babaev committed
4888

4889 4890 4891

bool st_select_lex::save_prep_leaf_tables(THD *thd)
{
4892 4893 4894
  if (prep_leaf_list_state == SAVED)
    return FALSE;

Igor Babaev's avatar
Igor Babaev committed
4895 4896
  List_iterator_fast<TABLE_LIST> li(leaf_tables);
  TABLE_LIST *table;
4897 4898 4899 4900 4901 4902 4903 4904 4905 4906

  /*
    Check that the SELECT_LEX was really prepared and so tables are setup.

    It can be subquery in SET clause of UPDATE which was not prepared yet, so
    its tables are not yet setup and ready for storing.
  */
  if (prep_leaf_list_state != READY)
    return FALSE;

Igor Babaev's avatar
Igor Babaev committed
4907 4908 4909
  while ((table= li++))
  {
    if (leaf_tables_prep.push_back(table))
4910 4911
      return TRUE;
  }
4912
  prep_leaf_list_state= SAVED;
4913 4914 4915 4916 4917 4918 4919
  for (SELECT_LEX_UNIT *u= first_inner_unit(); u; u= u->next_unit())
  {
    for (SELECT_LEX *sl= u->first_select(); sl; sl= sl->next_select())
    {
      if (sl->save_prep_leaf_tables(thd))
        return TRUE;
    }
Igor Babaev's avatar
Igor Babaev committed
4920 4921
  }

4922
  return FALSE;
Igor Babaev's avatar
Igor Babaev committed
4923 4924 4925
}


4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954
/*
  Return true if this select_lex has been converted into a semi-join nest
  within 'ancestor'.

  We need a loop to check this because there could be several nested
  subselects, like

    SELECT ... FROM grand_parent 
      WHERE expr1 IN (SELECT ... FROM parent 
                        WHERE expr2 IN ( SELECT ... FROM child)

  which were converted into:
  
    SELECT ... 
    FROM grand_parent SEMI_JOIN (parent JOIN child) 
    WHERE 
      expr1 AND expr2

  In this case, both parent and child selects were merged into the parent.
*/

bool st_select_lex::is_merged_child_of(st_select_lex *ancestor)
{
  bool all_merged= TRUE;
  for (SELECT_LEX *sl= this; sl && sl!=ancestor;
       sl=sl->outer_select())
  {
    Item *subs= sl->master_unit()->item;
    if (subs && subs->type() == Item::SUBSELECT_ITEM && 
unknown's avatar
unknown committed
4955 4956
        ((Item_subselect*)subs)->substype() == Item_subselect::IN_SUBS &&
        ((Item_in_subselect*)subs)->test_strategy(SUBS_SEMI_JOIN))
4957 4958 4959
    {
      continue;
    }
4960 4961 4962 4963 4964 4965

    if (sl->master_unit()->derived &&
      sl->master_unit()->derived->is_merged_derived())
    {
      continue;
    }
4966 4967 4968 4969 4970 4971
    all_merged= FALSE;
    break;
  }
  return all_merged;
}

4972 4973 4974 4975
/* 
  This is used by SHOW EXPLAIN. It assuses query plan has been already 
  collected into QPF structures and we only need to print it out.
*/
4976

Sergey Petrunya's avatar
Sergey Petrunya committed
4977
int LEX::print_explain(select_result_sink *output, uint8 explain_flags,
Sergei Petrunia's avatar
Sergei Petrunia committed
4978
                       bool is_analyze, bool *printed_anything)
4979
{
4980
  int res;
4981
  if (explain && explain->have_query_plan())
4982
  {
Sergei Petrunia's avatar
Sergei Petrunia committed
4983
    res= explain->print_explain(output, explain_flags, is_analyze);
4984
    *printed_anything= true;
4985 4986 4987
  }
  else
  {
4988 4989
    res= 0;
    *printed_anything= false;
4990
  }
4991
  return res;
4992 4993
}

4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010

/**
  Allocates and set arena for SET STATEMENT old values.

  @param backup          where to save backup of arena.

  @retval 1 Error
  @retval 0 OK
*/

bool LEX::set_arena_for_set_stmt(Query_arena *backup)
{
  DBUG_ENTER("LEX::set_arena_for_set_stmt");
  DBUG_ASSERT(arena_for_set_stmt== 0);
  if (!mem_root_for_set_stmt)
  {
    mem_root_for_set_stmt= new MEM_ROOT();
5011
    if (unlikely(!(mem_root_for_set_stmt)))
5012
      DBUG_RETURN(1);
5013 5014
    init_sql_alloc(mem_root_for_set_stmt, "set_stmt",
                   ALLOC_ROOT_SET, ALLOC_ROOT_SET, MYF(MY_THREAD_SPECIFIC));
5015
  }
5016 5017 5018
  if (unlikely(!(arena_for_set_stmt= new(mem_root_for_set_stmt)
                 Query_arena_memroot(mem_root_for_set_stmt,
                                     Query_arena::STMT_INITIALIZED))))
5019
    DBUG_RETURN(1);
5020 5021 5022
  DBUG_PRINT("info", ("mem_root: %p  arena: %p",
                      mem_root_for_set_stmt,
                      arena_for_set_stmt));
5023 5024 5025 5026 5027 5028 5029 5030 5031 5032
  thd->set_n_backup_active_arena(arena_for_set_stmt, backup);
  DBUG_RETURN(0);
}


void LEX::reset_arena_for_set_stmt(Query_arena *backup)
{
  DBUG_ENTER("LEX::reset_arena_for_set_stmt");
  DBUG_ASSERT(arena_for_set_stmt);
  thd->restore_active_arena(arena_for_set_stmt, backup);
5033 5034 5035
  DBUG_PRINT("info", ("mem_root: %p  arena: %p",
                      arena_for_set_stmt->mem_root,
                      arena_for_set_stmt));
5036 5037 5038 5039 5040 5041 5042 5043 5044
  DBUG_VOID_RETURN;
}


void LEX::free_arena_for_set_stmt()
{
  DBUG_ENTER("LEX::free_arena_for_set_stmt");
  if (!arena_for_set_stmt)
    return;
5045 5046 5047
  DBUG_PRINT("info", ("mem_root: %p  arena: %p",
                      arena_for_set_stmt->mem_root,
                      arena_for_set_stmt));
5048 5049 5050 5051 5052 5053 5054
  arena_for_set_stmt->free_items();
  delete(arena_for_set_stmt);
  free_root(mem_root_for_set_stmt, MYF(MY_KEEP_PREALLOC));
  arena_for_set_stmt= 0;
  DBUG_VOID_RETURN;
}

5055 5056 5057 5058 5059 5060 5061 5062
void LEX::restore_set_statement_var()
{
  DBUG_ENTER("LEX::restore_set_statement_var");
  if (!old_var_list.is_empty())
  {
    DBUG_PRINT("info", ("vars: %d", old_var_list.elements));
    sql_set_variables(thd, &old_var_list, false);
    old_var_list.empty();
5063
    free_arena_for_set_stmt();
5064
  }
5065
  DBUG_ASSERT(!is_arena_for_set_stmt());
5066 5067
  DBUG_VOID_RETURN;
}
5068

5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104
unit_common_op st_select_lex_unit::common_op()
{
  SELECT_LEX *first= first_select();
  bool first_op= TRUE;
  unit_common_op operation= OP_MIX; // if no op
  for (SELECT_LEX *sl= first; sl; sl= sl->next_select())
  {
    if (sl != first)
    {
      unit_common_op op;
      switch (sl->linkage)
      {
      case INTERSECT_TYPE:
        op= OP_INTERSECT;
        break;
      case EXCEPT_TYPE:
        op= OP_EXCEPT;
        break;
      default:
        op= OP_UNION;
        break;
      }
      if (first_op)
      {
        operation= op;
        first_op= FALSE;
      }
      else
      {
        if (operation != op)
          operation= OP_MIX;
      }
    }
  }
  return operation;
}
5105
/*
5106 5107
  Save explain structures of a UNION. The only variable member is whether the 
  union has "Using filesort".
Sergey Petrunya's avatar
Sergey Petrunya committed
5108

5109
  There is also save_union_explain_part2() function, which is called before we read
Sergey Petrunya's avatar
Sergey Petrunya committed
5110
  UNION's output.
Sergey Petrunya's avatar
Sergey Petrunya committed
5111

Sergey Petrunya's avatar
Sergey Petrunya committed
5112
  The reason for it is examples like this:
Sergey Petrunya's avatar
Sergey Petrunya committed
5113

Sergey Petrunya's avatar
Sergey Petrunya committed
5114 5115 5116 5117 5118 5119
     SELECT col1 FROM t1 UNION SELECT col2 FROM t2 ORDER BY (select ... from t3 ...)

  Here, the (select ... from t3 ...) subquery must be a child of UNION's
  st_select_lex. However, it is not connected as child until a very late 
  stage in execution.
*/
Sergey Petrunya's avatar
Sergey Petrunya committed
5120

5121
int st_select_lex_unit::save_union_explain(Explain_query *output)
5122 5123
{
  SELECT_LEX *first= first_select();
5124 5125 5126 5127

  if (output->get_union(first->select_number))
    return 0; /* Already added */
    
5128 5129 5130
  Explain_union *eu= 
    new (output->mem_root) Explain_union(output->mem_root, 
                                         thd->lex->analyze_stmt);
5131 5132
  if (unlikely(!eu))
    return 0;
5133

5134 5135 5136
  if (with_element && with_element->is_recursive)
    eu->is_recursive_cte= true;
 
5137
  if (derived)
5138 5139 5140 5141 5142
    eu->connection_type= Explain_node::EXPLAIN_NODE_DERIVED;
  /* 
    Note: Non-merged semi-joins cannot be made out of UNIONs currently, so we
    dont ever set EXPLAIN_NODE_NON_MERGED_SJ.
  */
5143
  for (SELECT_LEX *sl= first; sl; sl= sl->next_select())
5144
    eu->add_select(sl->select_number);
5145

5146
  eu->fake_select_type= unit_operation_text[eu->operation= common_op()];
5147 5148
  eu->using_filesort= MY_TEST(global_parameters()->order_list.first);
  eu->using_tmp= union_needs_tmp_table();
5149

Sergey Petrunya's avatar
Sergey Petrunya committed
5150
  // Save the UNION node
5151
  output->add_node(eu);
5152

5153 5154
  if (eu->get_select_id() == 1)
    output->query_plan_ready();
5155

5156 5157 5158 5159
  return 0;
}


5160 5161 5162 5163 5164
/*
  @see  st_select_lex_unit::save_union_explain
*/

int st_select_lex_unit::save_union_explain_part2(Explain_query *output)
5165
{
5166
  Explain_union *eu= output->get_union(first_select()->select_number);
5167
  if (fake_select_lex)
5168
  {
5169 5170 5171 5172 5173
    for (SELECT_LEX_UNIT *unit= fake_select_lex->first_inner_unit(); 
         unit; unit= unit->next_unit())
    {
      if (!(unit->item && unit->item->eliminated))
      {
5174
        eu->add_child(unit->first_select()->select_number);
5175 5176
      }
    }
5177
    fake_select_lex->join->explain= &eu->fake_select_lex_explain;
5178
  }
Sergey Petrunya's avatar
Sergey Petrunya committed
5179
  return 0;
5180 5181 5182
}


5183 5184 5185 5186 5187
/**
  A routine used by the parser to decide whether we are specifying a full
  partitioning or if only partitions to add or to split.

  @note  This needs to be outside of WITH_PARTITION_STORAGE_ENGINE since it
unknown's avatar
unknown committed
5188
  is used from the sql parser that doesn't have any ifdef's
5189 5190 5191 5192 5193

  @retval  TRUE    Yes, it is part of a management partition command
  @retval  FALSE          No, not a management partition command
*/

Konstantin Osipov's avatar
Konstantin Osipov committed
5194
bool LEX::is_partition_management() const
5195 5196
{
  return (sql_command == SQLCOM_ALTER_TABLE &&
5197 5198
          (alter_info.partition_flags ==  ALTER_PARTITION_ADD ||
           alter_info.partition_flags ==  ALTER_PARTITION_REORGANIZE));
5199 5200
}

5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265

/**
  Exclude last added SELECT_LEX (current) in the UNIT and return pointer in it
  (previous become currect)

  @return detached SELECT_LEX or NULL in case of error
*/

SELECT_LEX *LEX::exclude_last_select()
{
  DBUG_ENTER("SELECT_LEX::exclude_last_select");
  SELECT_LEX *exclude= current_select;
  SELECT_LEX_UNIT *unit= exclude->master_unit();
  SELECT_LEX *sl;
  DBUG_ASSERT(unit->first_select() != exclude);
  /* we should go through the list to correctly set current_select */
  for(sl= unit->first_select();
      sl->next_select() && sl->next_select() != exclude;
      sl= sl->next_select());
  DBUG_PRINT("info", ("excl: %p  unit: %p  prev: %p", exclude, unit, sl));
  if (!sl)
    DBUG_RETURN(NULL);
  DBUG_ASSERT(exclude->next_select() == NULL);
  exclude->exclude_from_tree();
  current_select= sl;
  DBUG_RETURN(exclude);
}


/**
  Put given (new) SELECT_LEX level below after currect (last) SELECT

  LAST SELECT -> DUMMY SELECT
                     |
                     V
                 NEW UNIT
                     |
                     V
                 NEW SELECT

  SELECT (*LAST*) ... FROM (SELECT (*NEW*) ... )

  @param nselect         Select to put one level below

  @retval TRUE  Error
  @retval FALSE OK
*/

bool LEX::add_unit_in_brackets(SELECT_LEX *nselect)
{
  DBUG_ENTER("LEX::add_unit_in_brackets");
  bool distinct= nselect->master_unit()->union_distinct == nselect;
  bool rc= add_select_to_union_list(distinct, nselect->linkage, 0);
  if (rc)
    DBUG_RETURN(TRUE);
  SELECT_LEX* dummy_select= current_select;
  dummy_select->automatic_brackets= TRUE;
  dummy_select->linkage= nselect->linkage;

  /* stuff dummy SELECT * FROM (...) */
  Name_resolution_context *context= &dummy_select->context;
  context->init();

  /* add SELECT list*/
  Item *item= new (thd->mem_root)
5266
    Item_field(thd, context, NULL, NULL, &star_clex_str);
5267
  if (unlikely(item == NULL))
5268
    DBUG_RETURN(TRUE);
5269
  if (unlikely(add_item_to_list(thd, item)))
5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281
    DBUG_RETURN(TRUE);
  (dummy_select->with_wild)++;

  rc= mysql_new_select(this, 1, nselect);
  nselect->linkage= DERIVED_TABLE_TYPE;
  DBUG_ASSERT(nselect->outer_select() == dummy_select);

  current_select= dummy_select;
  current_select->nest_level--;

  SELECT_LEX_UNIT *unit= nselect->master_unit();
  Table_ident *ti= new (thd->mem_root) Table_ident(unit);
5282
  if (unlikely(ti == NULL))
5283 5284
    DBUG_RETURN(TRUE);
  char buff[10];
5285
  LEX_CSTRING alias;
5286 5287 5288
  alias.length= my_snprintf(buff, sizeof(buff),
                            "__%u", dummy_select->select_number);
  alias.str= thd->strmake(buff, alias.length);
5289
  if (unlikely(!alias.str))
5290 5291 5292
    DBUG_RETURN(TRUE);

  TABLE_LIST *table_list;
5293 5294 5295 5296
  if (unlikely(!(table_list=
                 dummy_select->add_table_to_list(thd, ti, &alias,
                                                 0, TL_READ,
                                                 MDL_SHARED_READ))))
5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328
    DBUG_RETURN(TRUE);
  context->resolve_in_table_list_only(table_list);
  dummy_select->add_joined_table(table_list);

  derived_tables|= DERIVED_SUBQUERY;

  current_select= nselect;
  current_select->nest_level++;
  DBUG_RETURN(rc);
}


/**
  Checks if we need finish "automatic brackets" mode

  INTERSECT has higher priority then UNION and EXCEPT, so when it is need we
  automatically create lower layer for INTERSECT (automatic brackets) and
  here we check if we should return back one level up during parsing procedure.
*/

void LEX::check_automatic_up(enum sub_select_type type)
{
  if (type != INTERSECT_TYPE &&
      current_select->linkage == INTERSECT_TYPE &&
      current_select->outer_select() &&
      current_select->outer_select()->automatic_brackets)
  {
    nest_level--;
    current_select= current_select->outer_select();
  }
}

5329

5330
sp_variable *LEX::sp_param_init(LEX_CSTRING *name)
5331 5332 5333
{
  if (spcont->find_variable(name, true))
  {
5334
    my_error(ER_SP_DUP_PARAM, MYF(0), name->str);
5335 5336 5337
    return NULL;
  }
  sp_variable *spvar= spcont->add_variable(thd, name);
5338
  init_last_field(&spvar->field_def, name,
5339 5340 5341 5342 5343 5344 5345
                  thd->variables.collation_database);
  return spvar;
}


bool LEX::sp_param_fill_definition(sp_variable *spvar)
{
5346
  return sphead->fill_spvar_definition(thd, last_field, &spvar->name);
5347 5348 5349
}


5350 5351 5352 5353 5354 5355 5356 5357 5358
void LEX::set_stmt_init()
{
  sql_command= SQLCOM_SET_OPTION;
  mysql_init_select(this);
  option_type= OPT_SESSION;
  autocommit= 0;
};


5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394
/**
  Find a local or a package body variable by name.
  @param IN  name    - the variable name
  @param OUT ctx     - NULL, if the variable was not found,
                       or LEX::spcont (if a local variable was found)
                       or the package top level context
                       (if a package variable was found)
  @param OUT handler - NULL, if the variable was not found,
                       or a pointer to rcontext handler
  @retval            - the variable (if found), or NULL otherwise.
*/
sp_variable *
LEX::find_variable(const LEX_CSTRING *name,
                   sp_pcontext **ctx,
                   const Sp_rcontext_handler **rh) const
{
  sp_variable *spv;
  if (spcont && (spv= spcont->find_variable(name, false)))
  {
    *ctx= spcont;
    *rh= &sp_rcontext_handler_local;
    return spv;
  }
  sp_package *pkg= sphead ? sphead->m_parent : NULL;
  if (pkg && (spv= pkg->find_package_variable(name)))
  {
    *ctx= pkg->get_parse_context()->child_context(0);
    *rh= &sp_rcontext_handler_package_body;
    return spv;
  }
  *ctx= NULL;
  *rh= NULL;
  return NULL;
}


5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409
static bool is_new(const char *str)
{
  return (str[0] == 'n' || str[0] == 'N') &&
         (str[1] == 'e' || str[1] == 'E') &&
         (str[2] == 'w' || str[2] == 'W');
}

static bool is_old(const char *str)
{
  return (str[0] == 'o' || str[0] == 'O') &&
         (str[1] == 'l' || str[1] == 'L') &&
         (str[2] == 'd' || str[2] == 'D');
}


5410
bool LEX::is_trigger_new_or_old_reference(const LEX_CSTRING *name) const
5411
{
5412
  // "name" is not necessarily NULL-terminated!
5413
  return sphead && sphead->m_handler->type() == TYPE_ENUM_TRIGGER &&
5414
         name->length == 3 && (is_new(name->str) || is_old(name->str));
5415 5416 5417
}


5418 5419
void LEX::sp_variable_declarations_init(THD *thd, int nvars)
{
5420
  sp_variable *spvar= spcont->get_last_context_variable();
5421 5422 5423

  sphead->reset_lex(thd);
  spcont->declare_var_boundary(nvars);
5424
  thd->lex->init_last_field(&spvar->field_def, &spvar->name,
5425 5426 5427
                            thd->variables.collation_database);
}

5428 5429 5430 5431 5432

bool LEX::sp_variable_declarations_set_default(THD *thd, int nvars,
                                               Item *dflt_value_item)
{
  if (!dflt_value_item &&
5433
      unlikely(!(dflt_value_item= new (thd->mem_root) Item_null(thd))))
5434 5435 5436 5437 5438 5439 5440 5441 5442 5443
    return true;

  for (uint i= 0 ; i < (uint) nvars ; i++)
  {
    sp_variable *spvar= spcont->get_last_context_variable((uint) nvars - 1 - i);
    bool last= i + 1 == (uint) nvars;
    spvar->default_value= dflt_value_item;
    /* The last instruction is responsible for freeing LEX. */
    sp_instr_set *is= new (this->thd->mem_root)
                      sp_instr_set(sphead->instructions(),
5444 5445
                                   spcont, &sp_rcontext_handler_local,
                                   spvar->offset, dflt_value_item,
5446
                                   this, last);
5447
    if (unlikely(is == NULL || sphead->add_instr(is)))
5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463
      return true;
  }
  return false;
}


bool
LEX::sp_variable_declarations_copy_type_finalize(THD *thd, int nvars,
                                                 const Column_definition &ref,
                                                 Row_definition_list *fields,
                                                 Item *default_value)
{
  for (uint i= 0 ; i < (uint) nvars; i++)
  {
    sp_variable *spvar= spcont->get_last_context_variable((uint) nvars - 1 - i);
    spvar->field_def.set_type(ref);
5464 5465 5466 5467 5468
    if (fields)
    {
      DBUG_ASSERT(ref.type_handler() == &type_handler_row);
      spvar->field_def.set_row_field_definitions(fields);
    }
5469 5470
    spvar->field_def.field_name= spvar->name;
  }
5471 5472
  if (unlikely(sp_variable_declarations_set_default(thd, nvars,
                                                    default_value)))
5473 5474 5475 5476 5477 5478
    return true;
  spcont->declare_var_boundary(0);
  return sphead->restore_lex(thd);
}


5479
bool LEX::sp_variable_declarations_finalize(THD *thd, int nvars,
5480
                                            const Column_definition *cdef,
5481 5482
                                            Item *dflt_value_item)
{
5483 5484 5485
  DBUG_ASSERT(cdef);
  Column_definition tmp(*cdef);
  if (sphead->fill_spvar_definition(thd, &tmp))
5486
    return true;
5487 5488 5489 5490
  return sp_variable_declarations_copy_type_finalize(thd, nvars, tmp, NULL,
                                                     dflt_value_item);
}

5491

5492 5493 5494 5495 5496
bool LEX::sp_variable_declarations_row_finalize(THD *thd, int nvars,
                                                Row_definition_list *row,
                                                Item *dflt_value_item)
{
  DBUG_ASSERT(row);
5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508
  /*
    Prepare all row fields.
    Note, we do it only one time outside of the below loop.
    The converted list in "row" is further reused by all variable
    declarations processed by the current call.
    Example:
      DECLARE
        a, b, c ROW(x VARCHAR(10) CHARACTER SET utf8);
      BEGIN
        ...
      END;
  */
5509
  if (sphead->row_fill_field_definitions(thd, row))
5510
    return true;
5511

5512
  for (uint i= 0 ; i < (uint) nvars ; i++)
5513
  {
5514
    sp_variable *spvar= spcont->get_last_context_variable((uint) nvars - 1 - i);
5515
    spvar->field_def.set_row_field_definitions(row);
5516
    if (sphead->fill_spvar_definition(thd, &spvar->field_def, &spvar->name))
5517 5518 5519
      return true;
  }

5520 5521
  if (sp_variable_declarations_set_default(thd, nvars, dflt_value_item))
    return true;
5522 5523 5524 5525 5526
  spcont->declare_var_boundary(0);
  return sphead->restore_lex(thd);
}


5527 5528 5529 5530 5531 5532 5533 5534 5535
/**
  Finalize a %ROWTYPE declaration, e.g.:
    DECLARE a,b,c,d t1%ROWTYPE := ROW(1,2,3);

  @param thd   - the current thd
  @param nvars - the number of variables in the declaration
  @param ref   - the table or cursor name (see comments below)
  @param def   - the default value, e.g., ROW(1,2,3), or NULL (no default).
*/
5536 5537 5538 5539 5540
bool
LEX::sp_variable_declarations_rowtype_finalize(THD *thd, int nvars,
                                               Qualified_column_ident *ref,
                                               Item *def)
{
5541 5542
  uint coffp;
  const sp_pcursor *pcursor= ref->table.str && ref->db.str ? NULL :
5543 5544
                             spcont->find_cursor(&ref->m_column, &coffp,
                                                 false);
5545 5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564
  if (pcursor)
    return sp_variable_declarations_cursor_rowtype_finalize(thd, nvars,
                                                            coffp, def);
  /*
    When parsing a qualified identifier chain, the parser does not know yet
    if it's going to be a qualified column name (for %TYPE),
    or a qualified table name (for %ROWTYPE). So it collects the chain
    into Qualified_column_ident.
    Now we know that it was actually a qualified table name (%ROWTYPE).
    Create a new Table_ident from Qualified_column_ident,
    shifting fields as follows:
    - ref->m_column becomes table_ref->table
    - ref->table    becomes table_ref->db
  */
  return sp_variable_declarations_table_rowtype_finalize(thd, nvars,
                                                         ref->table,
                                                         ref->m_column,
                                                         def);
}

5565

5566 5567 5568 5569 5570 5571 5572
bool
LEX::sp_variable_declarations_table_rowtype_finalize(THD *thd, int nvars,
                                                     const LEX_CSTRING &db,
                                                     const LEX_CSTRING &table,
                                                     Item *def)
{
  Table_ident *table_ref;
5573 5574
  if (unlikely(!(table_ref=
                 new (thd->mem_root) Table_ident(thd, &db, &table, false))))
5575 5576 5577 5578 5579 5580 5581 5582 5583
    return true;
  // Loop through all variables in the same declaration
  for (uint i= 0 ; i < (uint) nvars; i++)
  {
    sp_variable *spvar= spcont->get_last_context_variable((uint) nvars - 1 - i);
    spvar->field_def.set_table_rowtype_ref(table_ref);
    sphead->fill_spvar_definition(thd, &spvar->field_def, &spvar->name);
  }
  if (sp_variable_declarations_set_default(thd, nvars, def))
5584
    return true;
5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597
  // Make sure sp_rcontext is created using the invoker security context:
  sphead->m_flags|= sp_head::HAS_COLUMN_TYPE_REFS;
  spcont->declare_var_boundary(0);
  return sphead->restore_lex(thd);
}


bool
LEX::sp_variable_declarations_cursor_rowtype_finalize(THD *thd, int nvars,
                                                      uint offset,
                                                      Item *def)
{
  const sp_pcursor *pcursor= spcont->find_cursor(offset);
5598

5599
  // Loop through all variables in the same declaration
5600
  for (uint i= 0 ; i < (uint) nvars; i++)
5601
  {
5602
    sp_variable *spvar= spcont->get_last_context_variable((uint) nvars - 1 - i);
5603

5604
    spvar->field_def.set_cursor_rowtype_ref(offset);
5605 5606
    sp_instr_cursor_copy_struct *instr=
      new (thd->mem_root) sp_instr_cursor_copy_struct(sphead->instructions(),
5607 5608
                                                      spcont, offset,
                                                      pcursor->lex(),
5609 5610 5611 5612
                                                      spvar->offset);
    if (instr == NULL || sphead->add_instr(instr))
     return true;

5613
    sphead->fill_spvar_definition(thd, &spvar->field_def, &spvar->name);
5614
  }
5615
  if (unlikely(sp_variable_declarations_set_default(thd, nvars, def)))
5616
    return true;
5617 5618 5619 5620 5621 5622 5623
  // Make sure sp_rcontext is created using the invoker security context:
  sphead->m_flags|= sp_head::HAS_COLUMN_TYPE_REFS;
  spcont->declare_var_boundary(0);
  return sphead->restore_lex(thd);
}


5624 5625 5626 5627 5628 5629
/*
  Add declarations for table column and SP variable anchor types:
  - DECLARE spvar1 TYPE OF db1.table1.column1;
  - DECLARE spvar1 TYPE OF table1.column1;
  - DECLARE spvar1 TYPE OF spvar0;
*/
5630 5631 5632 5633
bool
LEX::sp_variable_declarations_with_ref_finalize(THD *thd, int nvars,
                                                Qualified_column_ident *ref,
                                                Item *def)
5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644
{
  return ref->db.length == 0 && ref->table.length == 0 ?
    sp_variable_declarations_vartype_finalize(thd, nvars, ref->m_column, def) :
    sp_variable_declarations_column_type_finalize(thd, nvars, ref, def);
}


bool
LEX::sp_variable_declarations_column_type_finalize(THD *thd, int nvars,
                                                   Qualified_column_ident *ref,
                                                   Item *def)
5645
{
5646
  for (uint i= 0 ; i < (uint) nvars; i++)
5647
  {
5648
    sp_variable *spvar= spcont->get_last_context_variable((uint) nvars - 1 - i);
5649
    spvar->field_def.set_column_type_ref(ref);
5650
    spvar->field_def.field_name= spvar->name;
5651 5652
  }
  sphead->m_flags|= sp_head::HAS_COLUMN_TYPE_REFS;
5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701
  if (sp_variable_declarations_set_default(thd, nvars, def))
    return true;
  spcont->declare_var_boundary(0);
  return sphead->restore_lex(thd);
}


bool
LEX::sp_variable_declarations_vartype_finalize(THD *thd, int nvars,
                                               const LEX_CSTRING &ref,
                                               Item *default_value)
{
  sp_variable *t;
  if (!spcont || !(t= spcont->find_variable(&ref, false)))
  {
    my_error(ER_SP_UNDECLARED_VAR, MYF(0), ref.str);
    return true;
  }

  if (t->field_def.is_cursor_rowtype_ref())
  {
    uint offset= t->field_def.cursor_rowtype_offset();
    return sp_variable_declarations_cursor_rowtype_finalize(thd, nvars,
                                                            offset,
                                                            default_value);
  }

  if (t->field_def.is_column_type_ref())
  {
    Qualified_column_ident *tmp= t->field_def.column_type_ref();
    return sp_variable_declarations_column_type_finalize(thd, nvars, tmp,
                                                         default_value);
  }

  if (t->field_def.is_table_rowtype_ref())
  {
    const Table_ident *tmp= t->field_def.table_rowtype_ref();
    return sp_variable_declarations_table_rowtype_finalize(thd, nvars,
                                                           tmp->db,
                                                           tmp->table,
                                                           default_value);
  }

  // A reference to a scalar or a row variable with an explicit data type
  return sp_variable_declarations_copy_type_finalize(thd, nvars,
                                                     t->field_def,
                                                     t->field_def.
                                                       row_field_definitions(),
                                                     default_value);
5702 5703 5704
}


5705 5706 5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728
/**********************************************************************
  The FOR LOOP statement

  This syntax:
    FOR i IN lower_bound .. upper_bound
    LOOP
      statements;
    END LOOP;

  is translated into:

    DECLARE
      i INT := lower_bound;
      j INT := upper_bound;
    BEGIN
      WHILE i <= j
      LOOP
        statements;
        i:= i + 1;
      END LOOP;
    END;
*/


5729
sp_variable *LEX::sp_add_for_loop_variable(THD *thd, const LEX_CSTRING *name,
5730 5731 5732 5733
                                           Item *value)
{
  sp_variable *spvar= spcont->add_variable(thd, name);
  spcont->declare_var_boundary(1);
5734
  spvar->field_def.field_name= spvar->name;
5735
  spvar->field_def.set_handler(&type_handler_longlong);
5736 5737
  type_handler_longlong.Column_definition_prepare_stage2(&spvar->field_def,
                                                         NULL, HA_CAN_GEOMETRY);
5738
  if (!value && unlikely(!(value= new (thd->mem_root) Item_null(thd))))
5739 5740 5741 5742 5743
    return NULL;

  spvar->default_value= value;
  sp_instr_set *is= new (this->thd->mem_root)
                    sp_instr_set(sphead->instructions(),
5744 5745
                                 spcont, &sp_rcontext_handler_local,
                                 spvar->offset, value,
5746
                                 this, true);
5747
  if (unlikely(is == NULL || sphead->add_instr(is)))
5748
    return NULL;
5749 5750 5751 5752 5753
  spcont->declare_var_boundary(0);
  return spvar;
}


5754 5755 5756 5757 5758 5759 5760 5761 5762 5763
bool LEX::sp_for_loop_implicit_cursor_statement(THD *thd,
                                                Lex_for_loop_bounds_st *bounds,
                                                sp_lex_cursor *cur)
{
  Item *item;
  DBUG_ASSERT(sphead);
  LEX_CSTRING name= {STRING_WITH_LEN("[implicit_cursor]") };
  if (sp_declare_cursor(thd, &name, cur, NULL, true))
    return true;
  DBUG_ASSERT(thd->lex == this);
5764 5765
  if (unlikely(!(bounds->m_index=
                 new (thd->mem_root) sp_assignment_lex(thd, this))))
5766 5767 5768 5769
    return true;
  bounds->m_index->sp_lex_in_use= true;
  sphead->reset_lex(thd, bounds->m_index);
  DBUG_ASSERT(thd->lex != this);
5770 5771 5772 5773
  if (unlikely(!(item=
                 new (thd->mem_root) Item_field(thd,
                                                thd->lex->current_context(),
                                                NullS, NullS, &name))))
5774 5775 5776 5777 5778 5779
    return true;
  bounds->m_index->set_item_and_free_list(item, NULL);
  if (thd->lex->sphead->restore_lex(thd))
    return true;
  DBUG_ASSERT(thd->lex == this);
  bounds->m_direction= 1;
5780
  bounds->m_target_bound= NULL;
5781 5782 5783 5784
  bounds->m_implicit_cursor= true;
  return false;
}

5785 5786
sp_variable *
LEX::sp_add_for_loop_cursor_variable(THD *thd,
5787
                                     const LEX_CSTRING *name,
5788
                                     const sp_pcursor *pcursor,
5789 5790 5791
                                     uint coffset,
                                     sp_assignment_lex *param_lex,
                                     Item_args *parameters)
5792 5793
{
  sp_variable *spvar= spcont->add_variable(thd, name);
5794 5795
  if (!spvar)
    return NULL;
5796
  spcont->declare_var_boundary(1);
5797
  sphead->fill_spvar_definition(thd, &spvar->field_def, &spvar->name);
5798
  if (unlikely(!(spvar->default_value= new (thd->mem_root) Item_null(thd))))
5799
    return NULL;
5800

5801
  spvar->field_def.set_cursor_rowtype_ref(coffset);
5802

5803 5804 5805
  if (unlikely(sphead->add_for_loop_open_cursor(thd, spcont, spvar, pcursor,
                                                coffset,
                                                param_lex, parameters)))
5806 5807 5808
    return NULL;

  spcont->declare_var_boundary(0);
5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823
  return spvar;
}


/**
  Generate a code for a FOR loop condition:
  - Make Item_splocal for the FOR loop index variable
  - Make Item_splocal for the FOR loop upper bound variable
  - Make a comparison function item on top of these two variables
*/
bool LEX::sp_for_loop_condition(THD *thd, const Lex_for_loop_st &loop)
{
  Item_splocal *args[2];
  for (uint i= 0 ; i < 2; i++)
  {
5824
    sp_variable *src= i == 0 ? loop.m_index : loop.m_target_bound;
5825
    args[i]= new (thd->mem_root)
5826 5827
              Item_splocal(thd, &sp_rcontext_handler_local,
                           &src->name, src->offset, src->type_handler());
5828
    if (unlikely(args[i] == NULL))
5829
      return true;
5830
#ifdef DBUG_ASSERT_EXISTS
5831 5832 5833 5834 5835 5836 5837
    args[i]->m_sp= sphead;
#endif
  }

  Item *expr= loop.m_direction > 0 ?
    (Item *) new (thd->mem_root) Item_func_le(thd, args[0], args[1]) :
    (Item *) new (thd->mem_root) Item_func_ge(thd, args[0], args[1]);
5838
  return unlikely(!expr) || unlikely(sp_while_loop_expression(thd, expr));
5839 5840 5841 5842 5843 5844
}


/**
  Generate the FOR LOOP condition code in its own lex
*/
5845 5846
bool LEX::sp_for_loop_intrange_condition_test(THD *thd,
                                              const Lex_for_loop_st &loop)
5847
{
5848
  spcont->set_for_loop(loop);
5849
  sphead->reset_lex(thd);
5850
  if (unlikely(thd->lex->sp_for_loop_condition(thd, loop)))
5851 5852 5853 5854 5855
    return true;
  return thd->lex->sphead->restore_lex(thd);
}


5856 5857 5858
bool LEX::sp_for_loop_cursor_condition_test(THD *thd,
                                            const Lex_for_loop_st &loop)
{
5859
  const LEX_CSTRING *cursor_name;
5860
  Item *expr;
5861 5862
  spcont->set_for_loop(loop);
  sphead->reset_lex(thd);
5863 5864
  cursor_name= spcont->find_cursor(loop.m_cursor_offset);
  DBUG_ASSERT(cursor_name);
5865 5866 5867 5868
  if (unlikely(!(expr=
                 new (thd->mem_root)
                 Item_func_cursor_found(thd, cursor_name,
                                        loop.m_cursor_offset))))
5869
    return true;
5870 5871 5872 5873 5874 5875 5876
  if (thd->lex->sp_while_loop_expression(thd, expr))
    return true;
  return thd->lex->sphead->restore_lex(thd);
}


bool LEX::sp_for_loop_intrange_declarations(THD *thd, Lex_for_loop_st *loop,
5877
                                            const LEX_CSTRING *index,
5878 5879
                                            const Lex_for_loop_bounds_st &bounds)
{
5880 5881 5882 5883
  if (unlikely(!(loop->m_index=
                 bounds.m_index->
                 sp_add_for_loop_variable(thd, index,
                                          bounds.m_index->get_item()))))
5884
    return true;
5885 5886 5887 5888 5889
  if (unlikely(!(loop->m_target_bound=
                 bounds.m_target_bound->
                 sp_add_for_loop_target_bound(thd,
                                              bounds.
                                              m_target_bound->get_item()))))
5890 5891 5892 5893 5894 5895 5896 5897 5898
     return true;
  loop->m_direction= bounds.m_direction;
  loop->m_implicit_cursor= 0;
  return false;
}


bool LEX::sp_for_loop_cursor_declarations(THD *thd,
                                          Lex_for_loop_st *loop,
5899
                                          const LEX_CSTRING *index,
5900 5901 5902 5903 5904
                                          const Lex_for_loop_bounds_st &bounds)
{
  Item *item= bounds.m_index->get_item();
  Item_splocal *item_splocal;
  Item_field *item_field;
5905
  Item_func_sp *item_func_sp= NULL;
5906
  LEX_CSTRING name;
5907
  uint coffs, param_count= 0;
5908 5909 5910 5911 5912 5913 5914
  const sp_pcursor *pcursor;

  if ((item_splocal= item->get_item_splocal()))
    name= item_splocal->m_name;
  else if ((item_field= item->type() == Item::FIELD_ITEM ?
                        static_cast<Item_field *>(item) : NULL) &&
           item_field->table_name == NULL)
5915
    name= item_field->field_name;
5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936
  else if (item->type() == Item::FUNC_ITEM &&
           static_cast<Item_func*>(item)->functype() == Item_func::FUNC_SP &&
           !static_cast<Item_func_sp*>(item)->get_sp_name()->m_explicit_name)
  {
    /*
      When a FOR LOOP for a cursor with parameters is parsed:
        FOR index IN cursor(1,2,3) LOOP
          statements;
        END LOOP;
      the parser scans "cursor(1,2,3)" using the "expr" rule,
      so it thinks that cursor(1,2,3) is a stored function call.
      It's not easy to implement this without using "expr" because
      of grammar conflicts.
      As a side effect, the Item_func_sp and its arguments in the parentheses
      belong to the same LEX. This is different from an explicit
      "OPEN cursor(1,2,3)" where every expression belongs to a separate LEX.
    */
    item_func_sp= static_cast<Item_func_sp*>(item);
    name= item_func_sp->get_sp_name()->m_name;
    param_count= item_func_sp->argument_count();
  }
5937 5938 5939 5940 5941
  else
  {
    thd->parse_error();
    return true;
  }
5942 5943 5944
  if (unlikely(!(pcursor= spcont->find_cursor_with_error(&name, &coffs,
                                                         false)) ||
               pcursor->check_param_count_with_error(param_count)))
5945 5946 5947
    return true;

  if (!(loop->m_index= sp_add_for_loop_cursor_variable(thd, index,
5948 5949 5950
                                                       pcursor, coffs,
                                                       bounds.m_index,
                                                       item_func_sp)))
5951
    return true;
5952
  loop->m_target_bound= NULL;
5953 5954 5955 5956 5957 5958 5959
  loop->m_direction= bounds.m_direction;
  loop->m_cursor_offset= coffs;
  loop->m_implicit_cursor= bounds.m_implicit_cursor;
  return false;
}


5960 5961 5962 5963 5964 5965
/**
  Generate a code for a FOR loop index increment
*/
bool LEX::sp_for_loop_increment(THD *thd, const Lex_for_loop_st &loop)
{
  Item_splocal *splocal= new (thd->mem_root)
5966 5967
    Item_splocal(thd, &sp_rcontext_handler_local,
                      &loop.m_index->name, loop.m_index->offset,
5968
                      loop.m_index->type_handler());
5969
  if (unlikely(splocal == NULL))
5970
    return true;
5971
#ifdef DBUG_ASSERT_EXISTS
5972 5973 5974
  splocal->m_sp= sphead;
#endif
  Item_int *inc= new (thd->mem_root) Item_int(thd, loop.m_direction);
5975
  if (unlikely(!inc))
5976 5977
    return true;
  Item *expr= new (thd->mem_root) Item_func_plus(thd, splocal, inc);
5978 5979 5980 5981
  if (unlikely(!expr) ||
      unlikely(sphead->set_local_variable(thd, spcont,
                                          &sp_rcontext_handler_local,
                                          loop.m_index, expr, this, true)))
5982 5983 5984 5985 5986
    return true;
  return false;
}


5987
bool LEX::sp_for_loop_intrange_finalize(THD *thd, const Lex_for_loop_st &loop)
5988 5989 5990 5991 5992
{
  sphead->reset_lex(thd);

  // Generate FOR LOOP index increment in its own lex
  DBUG_ASSERT(this != thd->lex);
5993 5994
  if (unlikely(thd->lex->sp_for_loop_increment(thd, loop) ||
               thd->lex->sphead->restore_lex(thd)))
5995 5996 5997 5998 5999 6000 6001 6002
    return true;

  // Generate a jump to the beginning of the loop
  DBUG_ASSERT(this == thd->lex);
  return sp_while_loop_finalize(thd);
}


6003 6004 6005 6006
bool LEX::sp_for_loop_cursor_finalize(THD *thd, const Lex_for_loop_st &loop)
{
  sp_instr_cfetch *instr=
    new (thd->mem_root) sp_instr_cfetch(sphead->instructions(),
6007
                                        spcont, loop.m_cursor_offset, false);
6008
  if (unlikely(instr == NULL) || unlikely(sphead->add_instr(instr)))
6009 6010 6011 6012 6013 6014
    return true;
  instr->add_to_varlist(loop.m_index);
  // Generate a jump to the beginning of the loop
  return sp_while_loop_finalize(thd);
}

6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034
bool LEX::sp_for_loop_outer_block_finalize(THD *thd,
                                           const Lex_for_loop_st &loop)
{
  Lex_spblock tmp;
  tmp.curs= MY_TEST(loop.m_implicit_cursor);
  if (unlikely(sp_block_finalize(thd, tmp))) // The outer DECLARE..BEGIN..END
    return true;
  if (!loop.is_for_loop_explicit_cursor())
    return false;
  /*
    Explicit cursor FOR loop must close the cursor automatically.
    Note, implicit cursor FOR loop does not need to close the cursor,
    it's closed by sp_instr_cpop.
  */
  sp_instr_cclose *ic= new (thd->mem_root)
                       sp_instr_cclose(sphead->instructions(), spcont,
                                       loop.m_cursor_offset);
  return ic == NULL || sphead->add_instr(ic);
}

6035 6036
/***************************************************************************/

6037
bool LEX::sp_declare_cursor(THD *thd, const LEX_CSTRING *name,
6038
                            sp_lex_cursor *cursor_stmt,
6039
                            sp_pcontext *param_ctx, bool add_cpush_instr)
6040 6041 6042 6043 6044 6045
{
  uint offp;
  sp_instr_cpush *i;

  if (spcont->find_cursor(name, &offp, true))
  {
6046
    my_error(ER_SP_DUP_CURS, MYF(0), name->str);
6047 6048
    return true;
  }
6049

6050
  if (unlikely(spcont->add_cursor(name, param_ctx, cursor_stmt)))
6051 6052 6053 6054 6055 6056 6057
    return true;

  if (add_cpush_instr)
  {
    i= new (thd->mem_root)
         sp_instr_cpush(sphead->instructions(), spcont, cursor_stmt,
                        spcont->current_cursor_count() - 1);
6058
    return unlikely(i == NULL) || unlikely(sphead->add_instr(i));
6059 6060
  }
  return false;
6061 6062 6063 6064 6065 6066 6067 6068 6069 6070
}


/**
  Generate an SP code for an "OPEN cursor_name" statement.
  @param thd
  @param name       - Name of the cursor
  @param parameters - Cursor parameters, e.g. OPEN c(1,2,3)
  @returns          - false on success, true on error
*/
6071
bool LEX::sp_open_cursor(THD *thd, const LEX_CSTRING *name,
6072 6073 6074 6075
                         List<sp_assignment_lex> *parameters)
{
  uint offset;
  const sp_pcursor *pcursor;
6076 6077 6078 6079
  uint param_count= parameters ? parameters->elements : 0;
  return !(pcursor= spcont->find_cursor_with_error(name, &offset, false)) ||
         pcursor->check_param_count_with_error(param_count) ||
         sphead->add_open_cursor(thd, spcont, offset,
6080
                                 pcursor->param_context(), parameters);
6081 6082 6083 6084 6085 6086 6087 6088 6089 6090 6091 6092
}


bool LEX::sp_handler_declaration_init(THD *thd, int type)
{
  sp_handler *h= spcont->add_handler(thd, (sp_handler::enum_type) type);

  spcont= spcont->push_context(thd, sp_pcontext::HANDLER_SCOPE);

  sp_instr_hpush_jump *i=
    new (thd->mem_root) sp_instr_hpush_jump(sphead->instructions(), spcont, h);

6093
  if (unlikely(i == NULL) || unlikely(sphead->add_instr(i)))
6094 6095 6096 6097
    return true;

  /* For continue handlers, mark end of handler scope. */
  if (type == sp_handler::CONTINUE &&
6098
      unlikely(sphead->push_backpatch(thd, i, spcont->last_label())))
6099 6100
    return true;

6101 6102 6103
  if (unlikely(sphead->push_backpatch(thd, i,
                                      spcont->push_label(thd, &empty_clex_str,
                                                         0))))
6104 6105 6106 6107 6108 6109 6110 6111 6112 6113 6114 6115 6116 6117
    return true;

  return false;
}


bool LEX::sp_handler_declaration_finalize(THD *thd, int type)
{
  sp_label *hlab= spcont->pop_label(); /* After this hdlr */
  sp_instr_hreturn *i;

  if (type == sp_handler::CONTINUE)
  {
    i= new (thd->mem_root) sp_instr_hreturn(sphead->instructions(), spcont);
6118 6119
    if (unlikely(i == NULL) ||
        unlikely(sphead->add_instr(i)))
6120 6121 6122 6123 6124
      return true;
  }
  else
  {  /* EXIT or UNDO handler, just jump to the end of the block */
    i= new (thd->mem_root) sp_instr_hreturn(sphead->instructions(), spcont);
6125 6126 6127
    if (unlikely(i == NULL) ||
        unlikely(sphead->add_instr(i)) ||
        unlikely(sphead->push_backpatch(thd, i, spcont->last_label()))) /* Block end */
6128 6129 6130 6131 6132 6133
      return true;
  }
  sphead->backpatch(hlab);
  spcont= spcont->pop_context();
  return false;
}
6134

6135

6136
void LEX::sp_block_init(THD *thd, const LEX_CSTRING *label)
6137
{
6138
  spcont->push_label(thd, label, sphead->instructions(), sp_label::BEGIN);
6139 6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154
  spcont= spcont->push_context(thd, sp_pcontext::REGULAR_SCOPE);
}


bool LEX::sp_block_finalize(THD *thd, const Lex_spblock_st spblock,
                                      class sp_label **splabel)
{
  sp_head *sp= sphead;
  sp_pcontext *ctx= spcont;
  sp_instr *i;

  sp->backpatch(ctx->last_label()); /* We always have a label */
  if (spblock.hndlrs)
  {
    i= new (thd->mem_root)
      sp_instr_hpop(sp->instructions(), ctx, spblock.hndlrs);
6155 6156
    if (unlikely(i == NULL) ||
        unlikely(sp->add_instr(i)))
6157 6158 6159 6160 6161 6162
      return true;
  }
  if (spblock.curs)
  {
    i= new (thd->mem_root)
      sp_instr_cpop(sp->instructions(), ctx, spblock.curs);
6163 6164
    if (unlikely(i == NULL) ||
        unlikely(sp->add_instr(i)))
6165 6166 6167 6168 6169 6170 6171 6172 6173
      return true;
  }
  spcont= ctx->pop_context();
  *splabel= spcont->pop_label();
  return false;
}


bool LEX::sp_block_finalize(THD *thd, const Lex_spblock_st spblock,
6174
                            const LEX_CSTRING *end_label)
6175 6176
{
  sp_label *splabel;
6177
  if (unlikely(sp_block_finalize(thd, spblock, &splabel)))
6178
    return true;
6179 6180 6181
  if (unlikely(end_label->str &&
               lex_string_cmp(system_charset_info,
                              end_label, &splabel->name) != 0))
6182
  {
6183
    my_error(ER_SP_LABEL_MISMATCH, MYF(0), end_label->str);
6184 6185 6186 6187 6188 6189
    return true;
  }
  return false;
}


6190
sp_name *LEX::make_sp_name(THD *thd, const LEX_CSTRING *name)
6191 6192
{
  sp_name *res;
6193
  LEX_CSTRING db;
6194 6195 6196
  if (unlikely(check_routine_name(name)) ||
      unlikely(copy_db_to(&db)) ||
      unlikely((!(res= new (thd->mem_root) sp_name(&db, name, false)))))
6197 6198 6199 6200 6201
    return NULL;
  return res;
}


6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216 6217
/**
  When a package routine name is stored in memory in Database_qualified_name,
  the dot character is used to delimit package name from the routine name,
  e.g.:
    m_db=   'test';   -- database 'test'
    m_name= 'p1.p1';  -- package 'p1', routine 'p1'
  See database_qualified_name::make_package_routine_name() for details.
  Disallow package routine names with dots,
  to avoid ambiguity when interpreting m_name='p1.p1.p1', between:
    a.  package 'p1.p1' + routine 'p1'
    b.  package 'p1'    + routine 'p1.p1'
  m_name='p1.p1.p1' will always mean (a).
*/
sp_name *LEX::make_sp_name_package_routine(THD *thd, const LEX_CSTRING *name)
{
  sp_name *res= make_sp_name(thd, name);
6218
  if (likely(res) && unlikely(strchr(res->m_name.str, '.')))
6219 6220 6221 6222 6223 6224 6225 6226
  {
    my_error(ER_SP_WRONG_NAME, MYF(0), res->m_name.str);
    res= NULL;
  }
  return res;
}


6227 6228
sp_name *LEX::make_sp_name(THD *thd, const LEX_CSTRING *name1,
                                     const LEX_CSTRING *name2)
6229 6230
{
  sp_name *res;
6231
  LEX_CSTRING norm_name1;
6232 6233 6234 6235
  if (unlikely(!name1->str) ||
      unlikely(!thd->make_lex_string(&norm_name1, name1->str,
                                     name1->length)) ||
      unlikely(check_db_name((LEX_STRING *) &norm_name1)))
6236
  {
6237
    my_error(ER_WRONG_DB_NAME, MYF(0), name1->str);
6238 6239
    return NULL;
  }
6240 6241
  if (unlikely(check_routine_name(name2)) ||
      unlikely(!(res= new (thd->mem_root) sp_name(&norm_name1, name2, true))))
6242 6243 6244 6245 6246
    return NULL;
  return res;
}


6247 6248
sp_head *LEX::make_sp_head(THD *thd, const sp_name *name,
                           const Sp_handler *sph)
6249
{
6250
  sp_package *package= get_sp_package();
6251 6252 6253
  sp_head *sp;

  /* Order is important here: new - reset - init */
6254
  if (likely((sp= sp_head::create(package, sph))))
6255 6256 6257 6258
  {
    sp->reset_thd_mem_root(thd);
    sp->init(this);
    if (name)
6259 6260 6261 6262 6263 6264 6265 6266 6267 6268
    {
      if (package)
        sp->make_package_routine_name(sp->get_main_mem_root(),
                                      package->m_db,
                                      package->m_name,
                                      name->m_name);
      else
        sp->init_sp_name(name);
      sp->make_qname(sp->get_main_mem_root(), &sp->m_qname);
    }
6269 6270
    sphead= sp;
  }
6271
  sp_chistics.init();
6272 6273 6274 6275
  return sp;
}


6276 6277 6278 6279 6280 6281 6282 6283 6284 6285 6286 6287 6288 6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300
sp_head *LEX::make_sp_head_no_recursive(THD *thd, const sp_name *name,
                                        const Sp_handler *sph)
{
  sp_package *package= thd->lex->get_sp_package();
  /*
    Sp_handler::sp_clone_and_link_routine() generates a standalone-alike
    statement to clone package routines for recursion, e.g.:
      CREATE PROCEDURE p1 AS BEGIN NULL; END;
    Translate a standalone routine handler to the corresponding
    package routine handler if we're cloning a package routine, e.g.:
      sp_handler_procedure -> sp_handler_package_procedure
      sp_handler_function  -> sp_handler_package_function
  */
  if (package && package->m_is_cloning_routine)
    sph= sph->package_routine_handler();
  if (!sphead ||
      (package &&
       (sph == &sp_handler_package_procedure ||
        sph == &sp_handler_package_function)))
    return make_sp_head(thd, name, sph);
  my_error(ER_SP_NO_RECURSIVE_CREATE, MYF(0), sph->type_str());
  return NULL;
}


6301 6302 6303 6304 6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326
bool LEX::sp_body_finalize_procedure(THD *thd)
{
  if (sphead->check_unresolved_goto())
    return true;
  sphead->set_stmt_end(thd);
  sphead->restore_thd_mem_root(thd);
  return false;
}


bool LEX::sp_body_finalize_function(THD *thd)
{
  if (sphead->is_not_allowed_in_function("function"))
    return true;
  if (!(sphead->m_flags & sp_head::HAS_RETURN))
  {
    my_error(ER_SP_NORETURN, MYF(0), ErrConvDQName(sphead).ptr());
    return true;
  }
  if (sp_body_finalize_procedure(thd))
    return true;
  (void) is_native_function_with_warn(thd, &sphead->m_name);
  return false;
}


6327 6328 6329 6330 6331 6332 6333 6334 6335 6336 6337 6338 6339 6340 6341 6342 6343
bool LEX::sp_block_with_exceptions_finalize_declarations(THD *thd)
{
  /*
    [ DECLARE declarations ]
    BEGIN executable_section
    [ EXCEPTION exceptions ]
    END

    We are now at the "BEGIN" keyword.
    We have collected all declarations, including DECLARE HANDLER directives.
    But there will be possibly more handlers in the EXCEPTION section.

    Generate a forward jump from the end of the DECLARE section to the
    beginning of the EXCEPTION section, over the executable section.
  */
  return sphead->add_instr_jump(thd, spcont);
}
6344 6345


6346 6347 6348 6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361 6362 6363 6364 6365 6366 6367 6368
bool
LEX::sp_block_with_exceptions_finalize_executable_section(THD *thd,
                                         uint executable_section_ip)
{
  /*
    We're now at the end of "executable_section" of the block,
    near the "EXCEPTION" or the "END" keyword.
    Generate a jump to the END of the block over the EXCEPTION section.
  */
  if (sphead->add_instr_jump_forward_with_backpatch(thd, spcont))
    return true;
  /*
    Set the destination for the jump that we added in
    sp_block_with_exceptions_finalize_declarations().
  */
  sp_instr *instr= sphead->get_instr(executable_section_ip - 1);
  instr->backpatch(sphead->instructions(), spcont);
  return false;
}


bool
LEX::sp_block_with_exceptions_finalize_exceptions(THD *thd,
6369 6370
                                                  uint executable_section_ip,
                                                  uint exception_count)
6371
{
6372 6373 6374 6375 6376 6377 6378 6379 6380 6381 6382
  if (!exception_count)
  {
    /*
      The jump from the end of DECLARE section to
      the beginning of the EXCEPTION section that we added in
      sp_block_with_exceptions_finalize_declarations() is useless
      if there were no exceptions.
      Replace it to "no operation".
    */
    return sphead->replace_instr_to_nop(thd, executable_section_ip - 1);
  }
6383 6384 6385 6386 6387 6388 6389
  /*
    Generate a jump from the end of the EXCEPTION code
    to the executable section.
  */
  return sphead->add_instr_jump(thd, spcont, executable_section_ip);
}

6390

6391 6392 6393 6394 6395 6396 6397 6398
bool LEX::sp_block_with_exceptions_add_empty(THD *thd)
{
  uint ip= sphead->instructions();
  return sp_block_with_exceptions_finalize_executable_section(thd, ip) ||
         sp_block_with_exceptions_finalize_exceptions(thd, ip, 0);
}


6399 6400 6401 6402 6403 6404 6405
bool LEX::sp_change_context(THD *thd, const sp_pcontext *ctx, bool exclusive)
{
  uint n;
  uint ip= sphead->instructions();
  if ((n= spcont->diff_handlers(ctx, exclusive)))
  {
    sp_instr_hpop *hpop= new (thd->mem_root) sp_instr_hpop(ip++, spcont, n);
6406
    if (unlikely(hpop == NULL) || unlikely(sphead->add_instr(hpop)))
6407 6408 6409 6410 6411
      return true;
  }
  if ((n= spcont->diff_cursors(ctx, exclusive)))
  {
    sp_instr_cpop *cpop= new (thd->mem_root) sp_instr_cpop(ip++, spcont, n);
6412
    if (unlikely(cpop == NULL) || unlikely(sphead->add_instr(cpop)))
6413 6414 6415 6416 6417 6418
      return true;
  }
  return false;
}


6419
bool LEX::sp_leave_statement(THD *thd, const LEX_CSTRING *label_name)
6420 6421
{
  sp_label *lab= spcont->find_label(label_name);
6422
  if (unlikely(!lab))
6423
  {
6424
    my_error(ER_SP_LILABEL_MISMATCH, MYF(0), "LEAVE", label_name->str);
6425 6426
    return true;
  }
6427
  return sp_exit_block(thd, lab, NULL);
6428 6429
}

6430
bool LEX::sp_goto_statement(THD *thd, const LEX_CSTRING *label_name)
halfspawn's avatar
halfspawn committed
6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444 6445 6446 6447 6448 6449 6450 6451 6452 6453 6454 6455 6456
{
  sp_label *lab= spcont->find_goto_label(label_name);
  if (!lab || lab->ip == 0)
  {
    sp_label *delayedlabel;
    if (!lab)
    {
      // Label not found --> add forward jump to an unknown label
      spcont->push_goto_label(thd, label_name, 0, sp_label::GOTO);
      delayedlabel= spcont->last_goto_label();
    }
    else
    {
      delayedlabel= lab;
    }
    return sphead->push_backpatch_goto(thd, spcont, delayedlabel);
  }
  else
  {
    // Label found (backward goto)
    return sp_change_context(thd, lab->ctx, false) ||
           sphead->add_instr_jump(thd, spcont, lab->ip); /* Jump back */
  }
  return false;
}

6457
bool LEX::sp_push_goto_label(THD *thd, const LEX_CSTRING *label_name)
halfspawn's avatar
halfspawn committed
6458 6459 6460 6461
{
  sp_label *lab= spcont->find_goto_label(label_name, false);
  if (lab)
  {
6462
    if (unlikely(lab->ip != 0))
halfspawn's avatar
halfspawn committed
6463
    {
6464
      my_error(ER_SP_LABEL_REDEFINE, MYF(0), label_name->str);
halfspawn's avatar
halfspawn committed
6465 6466 6467 6468
      return true;
    }
    lab->ip= sphead->instructions();

6469
    sp_label *beginblocklabel= spcont->find_label(&empty_clex_str);
halfspawn's avatar
halfspawn committed
6470 6471 6472 6473 6474 6475 6476 6477
    sphead->backpatch_goto(thd, lab, beginblocklabel);
  }
  else
  {
    spcont->push_goto_label(thd, label_name, sphead->instructions());
  }
  return false;
}
6478

6479 6480
bool LEX::sp_exit_block(THD *thd, sp_label *lab)
{
6481 6482 6483 6484 6485 6486 6487 6488 6489 6490 6491 6492 6493 6494
  /*
    When jumping to a BEGIN-END block end, the target jump
    points to the block hpop/cpop cleanup instructions,
    so we should exclude the block context here.
    When jumping to something else (i.e., SP_LAB_ITER),
    there are no hpop/cpop at the jump destination,
    so we should include the block context here for cleanup.
  */
  bool exclusive= (lab->type == sp_label::BEGIN);
  return sp_change_context(thd, lab->ctx, exclusive) ||
         sphead->add_instr_jump_forward_with_backpatch(thd, spcont, lab);
}


6495 6496 6497 6498 6499 6500 6501 6502 6503 6504 6505
bool LEX::sp_exit_block(THD *thd, sp_label *lab, Item *when)
{
  if (!when)
    return sp_exit_block(thd, lab);

  DBUG_ASSERT(sphead == thd->lex->sphead);
  DBUG_ASSERT(spcont == thd->lex->spcont);
  sp_instr_jump_if_not *i= new (thd->mem_root)
                           sp_instr_jump_if_not(sphead->instructions(),
                                                spcont,
                                                when, thd->lex);
6506 6507 6508
  if (unlikely(i == NULL) ||
      unlikely(sphead->add_instr(i)) ||
      unlikely(sp_exit_block(thd, lab)))
6509 6510 6511 6512 6513 6514 6515
    return true;
  i->backpatch(sphead->instructions(), spcont);
  return false;
}


bool LEX::sp_exit_statement(THD *thd, Item *item)
6516 6517
{
  sp_label *lab= spcont->find_label_current_loop_start();
6518
  if (unlikely(!lab))
6519 6520 6521 6522 6523
  {
    my_error(ER_SP_LILABEL_MISMATCH, MYF(0), "EXIT", "");
    return true;
  }
  DBUG_ASSERT(lab->type == sp_label::ITERATION);
6524
  return sp_exit_block(thd, lab, item);
6525 6526 6527
}


6528
bool LEX::sp_exit_statement(THD *thd, const LEX_CSTRING *label_name, Item *item)
6529 6530
{
  sp_label *lab= spcont->find_label(label_name);
6531
  if (unlikely(!lab || lab->type != sp_label::ITERATION))
6532
  {
6533
    my_error(ER_SP_LILABEL_MISMATCH, MYF(0), "EXIT", label_name->str);
6534 6535
    return true;
  }
6536
  return sp_exit_block(thd, lab, item);
6537 6538 6539
}


6540
bool LEX::sp_iterate_statement(THD *thd, const LEX_CSTRING *label_name)
6541 6542
{
  sp_label *lab= spcont->find_label(label_name);
6543
  if (unlikely(!lab || lab->type != sp_label::ITERATION))
6544
  {
6545
    my_error(ER_SP_LILABEL_MISMATCH, MYF(0), "ITERATE", label_name->str);
6546 6547
    return true;
  }
6548 6549 6550 6551 6552 6553
  return sp_continue_loop(thd, lab);
}


bool LEX::sp_continue_loop(THD *thd, sp_label *lab)
{
6554 6555 6556 6557 6558 6559 6560 6561 6562
  if (lab->ctx->for_loop().m_index)
  {
    // We're in a FOR loop, increment the index variable before backward jump
    sphead->reset_lex(thd);
    DBUG_ASSERT(this != thd->lex);
    if (thd->lex->sp_for_loop_increment(thd, lab->ctx->for_loop()) ||
        thd->lex->sphead->restore_lex(thd))
      return true;
  }
6563 6564 6565 6566 6567
  return sp_change_context(thd, lab->ctx, false) ||
         sphead->add_instr_jump(thd, spcont, lab->ip); /* Jump back */
}


6568 6569 6570 6571 6572 6573 6574 6575 6576 6577 6578
bool LEX::sp_continue_loop(THD *thd, sp_label *lab, Item *when)
{
  if (!when)
    return sp_continue_loop(thd, lab);

  DBUG_ASSERT(sphead == thd->lex->sphead);
  DBUG_ASSERT(spcont == thd->lex->spcont);
  sp_instr_jump_if_not *i= new (thd->mem_root)
                           sp_instr_jump_if_not(sphead->instructions(),
                                                spcont,
                                                when, thd->lex);
6579 6580 6581
  if (unlikely(i == NULL) ||
      unlikely(sphead->add_instr(i)) ||
      unlikely(sp_continue_loop(thd, lab)))
6582 6583 6584 6585 6586 6587 6588 6589 6590
    return true;
  i->backpatch(sphead->instructions(), spcont);
  return false;
}


bool LEX::sp_continue_statement(THD *thd, Item *when)
{
  sp_label *lab= spcont->find_label_current_loop_start();
6591
  if (unlikely(!lab))
6592 6593 6594 6595 6596 6597 6598 6599 6600
  {
    my_error(ER_SP_LILABEL_MISMATCH, MYF(0), "CONTINUE", "");
    return true;
  }
  DBUG_ASSERT(lab->type == sp_label::ITERATION);
  return sp_continue_loop(thd, lab, when);
}


6601 6602
bool LEX::sp_continue_statement(THD *thd, const LEX_CSTRING *label_name,
                                Item *when)
6603 6604 6605 6606
{
  sp_label *lab= spcont->find_label(label_name);
  if (!lab || lab->type != sp_label::ITERATION)
  {
6607
    my_error(ER_SP_LILABEL_MISMATCH, MYF(0), "CONTINUE", label_name->str);
6608 6609 6610 6611 6612 6613
    return true;
  }
  return sp_continue_loop(thd, lab, when);
}


6614 6615 6616 6617
bool LEX::maybe_start_compound_statement(THD *thd)
{
  if (!sphead)
  {
6618
    if (!make_sp_head(thd, NULL, &sp_handler_procedure))
6619
      return true;
6620
    sphead->set_suid(SP_IS_NOT_SUID);
6621 6622 6623 6624 6625 6626
    sphead->set_body_start(thd, thd->m_parser_state->m_lip.get_cpp_ptr());
  }
  return false;
}


6627
bool LEX::sp_push_loop_label(THD *thd, const LEX_CSTRING *label_name)
6628 6629 6630 6631
{
  sp_label *lab= spcont->find_label(label_name);
  if (lab)
  {
6632
    my_error(ER_SP_LABEL_REDEFINE, MYF(0), label_name->str);
6633 6634
    return true;
  }
6635 6636
  spcont->push_label(thd, label_name, sphead->instructions(),
                     sp_label::ITERATION);
6637 6638 6639 6640 6641 6642 6643 6644 6645
  return false;
}


bool LEX::sp_push_loop_empty_label(THD *thd)
{
  if (maybe_start_compound_statement(thd))
    return true;
  /* Unlabeled controls get an empty label. */
6646
  spcont->push_label(thd, &empty_clex_str, sphead->instructions(),
6647
                     sp_label::ITERATION);
6648 6649 6650 6651
  return false;
}


6652
bool LEX::sp_pop_loop_label(THD *thd, const LEX_CSTRING *label_name)
6653 6654 6655
{
  sp_label *lab= spcont->pop_label();
  sphead->backpatch(lab);
6656
  if (label_name->str &&
6657 6658
      lex_string_cmp(system_charset_info, label_name,
                     &lab->name) != 0)
6659
  {
6660
    my_error(ER_SP_LABEL_MISMATCH, MYF(0), label_name->str);
6661 6662 6663 6664 6665 6666 6667 6668 6669 6670 6671 6672 6673 6674
    return true;
  }
  return false;
}


void LEX::sp_pop_loop_empty_label(THD *thd)
{
  sp_label *lab= spcont->pop_label();
  sphead->backpatch(lab);
  DBUG_ASSERT(lab->name.length == 0);
}


6675 6676 6677 6678
bool LEX::sp_while_loop_expression(THD *thd, Item *expr)
{
  sp_instr_jump_if_not *i= new (thd->mem_root)
    sp_instr_jump_if_not(sphead->instructions(), spcont, expr, this);
6679 6680 6681 6682 6683
  return (unlikely(i == NULL) ||
          /* Jumping forward */
          unlikely(sphead->push_backpatch(thd, i, spcont->last_label())) ||
          unlikely(sphead->new_cont_backpatch(i)) ||
          unlikely(sphead->add_instr(i)));
6684 6685 6686 6687 6688 6689 6690 6691
}


bool LEX::sp_while_loop_finalize(THD *thd)
{
  sp_label *lab= spcont->last_label();  /* Jumping back */
  sp_instr_jump *i= new (thd->mem_root)
    sp_instr_jump(sphead->instructions(), spcont, lab->ip);
6692 6693
  if (unlikely(i == NULL) ||
      unlikely(sphead->add_instr(i)))
6694 6695 6696 6697 6698 6699
    return true;
  sphead->do_cont_backpatch();
  return false;
}


6700 6701 6702
Item *LEX::create_and_link_Item_trigger_field(THD *thd,
                                              const LEX_CSTRING *name,
                                              bool new_row)
6703 6704 6705
{
  Item_trigger_field *trg_fld;

6706
  if (unlikely(trg_chistics.event == TRG_EVENT_INSERT && !new_row))
6707 6708 6709 6710 6711
  {
    my_error(ER_TRG_NO_SUCH_ROW_IN_TRG, MYF(0), "OLD", "on INSERT");
    return NULL;
  }

6712
  if (unlikely(trg_chistics.event == TRG_EVENT_DELETE && new_row))
6713 6714 6715 6716 6717 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730 6731 6732 6733
  {
    my_error(ER_TRG_NO_SUCH_ROW_IN_TRG, MYF(0), "NEW", "on DELETE");
    return NULL;
  }

  DBUG_ASSERT(!new_row ||
              (trg_chistics.event == TRG_EVENT_INSERT ||
               trg_chistics.event == TRG_EVENT_UPDATE));

  const bool tmp_read_only=
    !(new_row && trg_chistics.action_time == TRG_ACTION_BEFORE);
  trg_fld= new (thd->mem_root)
             Item_trigger_field(thd, current_context(),
                                new_row ?
                                  Item_trigger_field::NEW_ROW:
                                  Item_trigger_field::OLD_ROW,
                                name, SELECT_ACL, tmp_read_only);
  /*
    Let us add this item to list of all Item_trigger_field objects
    in trigger.
  */
6734 6735
  if (likely(trg_fld))
    trg_table_fields.link_in_list(trg_fld, &trg_fld->next_trg_field);
6736 6737 6738 6739 6740

  return trg_fld;
}


6741
Item *LEX::make_item_colon_ident_ident(THD *thd,
6742 6743
                                       const Lex_ident_cli_st *ca,
                                       const Lex_ident_cli_st *cb)
6744
{
6745 6746 6747 6748
  Lex_ident_sys a(thd, ca), b(thd, cb);
  if (a.is_null() || b.is_null())
    return NULL; // OEM
  if (!is_trigger_new_or_old_reference(&a))
6749 6750 6751 6752
  {
    thd->parse_error();
    return NULL;
  }
6753 6754
  bool new_row= (a.str[0] == 'N' || a.str[0] == 'n');
  return create_and_link_Item_trigger_field(thd, &b, new_row);
6755 6756 6757
}


6758 6759 6760 6761 6762 6763 6764 6765 6766 6767 6768 6769 6770 6771 6772 6773 6774 6775 6776 6777 6778 6779 6780 6781
Item *LEX::make_item_plsql_cursor_attr(THD *thd, const LEX_CSTRING *name,
                                       plsql_cursor_attr_t attr)
{
  uint offset;
  if (unlikely(!spcont || !spcont->find_cursor(name, &offset, false)))
  {
    my_error(ER_SP_CURSOR_MISMATCH, MYF(0), name->str);
    return NULL;
  }
  switch (attr) {
  case PLSQL_CURSOR_ATTR_ISOPEN:
    return new (thd->mem_root) Item_func_cursor_isopen(thd, name, offset);
  case PLSQL_CURSOR_ATTR_FOUND:
    return new (thd->mem_root) Item_func_cursor_found(thd, name, offset);
  case PLSQL_CURSOR_ATTR_NOTFOUND:
    return new (thd->mem_root) Item_func_cursor_notfound(thd, name, offset);
  case PLSQL_CURSOR_ATTR_ROWCOUNT:
    return new (thd->mem_root) Item_func_cursor_rowcount(thd, name, offset);
  }
  DBUG_ASSERT(0);
  return NULL;
}


6782 6783 6784 6785 6786 6787 6788 6789 6790 6791 6792 6793 6794 6795 6796 6797 6798 6799 6800 6801 6802 6803 6804 6805 6806
Item *LEX::make_item_sysvar(THD *thd,
                            enum_var_type type,
                            const LEX_CSTRING *name,
                            const LEX_CSTRING *component)

{
  Item *item;
  DBUG_ASSERT(name->str);
  /*
    "SELECT @@global.global.variable" is not allowed
    Note, "global" can come through TEXT_STRING_sys.
  */
  if (component->str && unlikely(check_reserved_words(name)))
  {
    thd->parse_error();
    return NULL;
  }
  if (unlikely(!(item= get_system_var(thd, type, name, component))))
    return NULL;
  if (!((Item_func_get_system_var*) item)->is_written_to_binlog())
    set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_VARIABLE);
  return item;
}


6807 6808 6809 6810 6811 6812 6813 6814
static bool param_push_or_clone(THD *thd, LEX *lex, Item_param *item)
{
  return !lex->clone_spec_offset ?
         lex->param_list.push_back(item, thd->mem_root) :
         item->add_as_clone(thd);
}


6815
Item_param *LEX::add_placeholder(THD *thd, const LEX_CSTRING *name,
6816
                                 const char *start, const char *end)
6817
{
6818
  if (unlikely(!thd->m_parser_state->m_lip.stmt_prepare_mode))
6819 6820 6821 6822
  {
    thd->parse_error(ER_SYNTAX_ERROR, start);
    return NULL;
  }
6823
  if (unlikely(!parsing_options.allows_variable))
6824 6825 6826 6827
  {
    my_error(ER_VIEW_SELECT_VARIABLE, MYF(0));
    return NULL;
  }
6828 6829

  Query_fragment pos(thd, sphead, start, end);
6830
  Item_param *item= new (thd->mem_root) Item_param(thd, name,
6831
                                                   pos.pos(), pos.length());
6832
  if (unlikely(!item) || unlikely(param_push_or_clone(thd, this, item)))
6833 6834 6835 6836 6837 6838 6839 6840
  {
    my_error(ER_OUT_OF_RESOURCES, MYF(0));
    return NULL;
  }
  return item;
}


6841 6842 6843 6844 6845 6846 6847 6848 6849 6850 6851 6852 6853 6854 6855 6856 6857 6858
bool LEX::add_signal_statement(THD *thd, const sp_condition_value *v)
{
  Yacc_state *state= &thd->m_parser_state->m_yacc;
  sql_command= SQLCOM_SIGNAL;
  m_sql_cmd= new (thd->mem_root) Sql_cmd_signal(v, state->m_set_signal_info);
  return m_sql_cmd == NULL;
}


bool LEX::add_resignal_statement(THD *thd, const sp_condition_value *v)
{
  Yacc_state *state= &thd->m_parser_state->m_yacc;
  sql_command= SQLCOM_RESIGNAL;
  m_sql_cmd= new (thd->mem_root) Sql_cmd_resignal(v, state->m_set_signal_info);
  return m_sql_cmd == NULL;
}


6859
Item *LEX::create_item_ident_nospvar(THD *thd,
6860 6861
                                     const Lex_ident_sys_st *a,
                                     const Lex_ident_sys_st *b)
6862 6863 6864 6865 6866 6867 6868 6869 6870
{
  DBUG_ASSERT(this == thd->lex);
  /*
    FIXME This will work ok in simple_ident_nospvar case because
    we can't meet simple_ident_nospvar in trigger now. But it
    should be changed in future.
  */
  if (is_trigger_new_or_old_reference(a))
  {
6871
    bool new_row= (a->str[0]=='N' || a->str[0]=='n');
6872

6873
    return create_and_link_Item_trigger_field(thd, b, new_row);
6874 6875
  }

6876
  if (unlikely(current_select->no_table_names_allowed))
6877
  {
6878
    my_error(ER_TABLENAME_NOT_ALLOWED_HERE, MYF(0), a->str, thd->where);
6879 6880 6881 6882 6883
    return NULL;
  }
  if ((current_select->parsing_place != IN_HAVING) ||
      (current_select->get_in_sum_expr() > 0))
    return new (thd->mem_root) Item_field(thd, current_context(),
6884
                                          NullS, a->str, b);
6885
  return new (thd->mem_root) Item_ref(thd, current_context(),
6886
                                      NullS, a->str, b);
6887 6888 6889
}


6890
Item_splocal *LEX::create_item_spvar_row_field(THD *thd,
6891
                                               const Sp_rcontext_handler *rh,
6892 6893
                                               const Lex_ident_sys *a,
                                               const Lex_ident_sys *b,
6894
                                               sp_variable *spv,
6895 6896
                                               const char *start,
                                               const char *end)
6897
{
6898
  if (unlikely(!parsing_options.allows_variable))
6899 6900 6901 6902 6903
  {
    my_error(ER_VIEW_SELECT_VARIABLE, MYF(0));
    return NULL;
  }

6904
  Query_fragment pos(thd, sphead, start, end);
6905
  Item_splocal *item;
6906 6907
  if (spv->field_def.is_table_rowtype_ref() ||
      spv->field_def.is_cursor_rowtype_ref())
6908
  {
6909 6910 6911 6912
    if (unlikely(!(item= new (thd->mem_root)
                   Item_splocal_row_field_by_name(thd, rh, a, b, spv->offset,
                                                  &type_handler_null,
                                                  pos.pos(), pos.length()))))
6913 6914 6915 6916 6917 6918
      return NULL;
  }
  else
  {
    uint row_field_offset;
    const Spvar_definition *def;
6919
    if (unlikely(!(def= spv->find_row_field(a, b, &row_field_offset))))
6920
      return NULL;
6921

6922 6923 6924 6925 6926
    if (unlikely(!(item= new (thd->mem_root)
                   Item_splocal_row_field(thd, rh, a, b,
                                          spv->offset, row_field_offset,
                                          def->type_handler(),
                                          pos.pos(), pos.length()))))
6927 6928
      return NULL;
  }
6929
#ifdef DBUG_ASSERT_EXISTS
6930 6931 6932 6933 6934 6935 6936
  item->m_sp= sphead;
#endif
  safe_to_cache_query=0;
  return item;
}


6937 6938 6939 6940
my_var *LEX::create_outvar(THD *thd, const LEX_CSTRING *name)
{
  const Sp_rcontext_handler *rh;
  sp_variable *spv;
6941
  if (likely((spv= find_variable(name, &rh))))
6942 6943 6944 6945 6946 6947 6948 6949 6950
    return result ? new (thd->mem_root)
                    my_var_sp(rh, name, spv->offset,
                              spv->type_handler(), sphead) :
                    NULL /* EXPLAIN */;
  my_error(ER_SP_UNDECLARED_VAR, MYF(0), name->str);
  return NULL;
}


6951
my_var *LEX::create_outvar(THD *thd,
6952 6953
                           const LEX_CSTRING *a,
                           const LEX_CSTRING *b)
6954
{
6955
  const Sp_rcontext_handler *rh;
6956
  sp_variable *t;
6957
  if (unlikely(!(t= find_variable(a, &rh))))
6958
  {
6959
    my_error(ER_SP_UNDECLARED_VAR, MYF(0), a->str);
6960 6961 6962 6963 6964 6965
    return NULL;
  }
  uint row_field_offset;
  if (!t->find_row_field(a, b, &row_field_offset))
    return NULL;
  return result ?
6966
    new (thd->mem_root) my_var_sp_row_field(rh, a, b, t->offset,
6967
                                            row_field_offset, sphead) :
6968
    NULL /* EXPLAIN */;
6969 6970 6971
}


6972 6973 6974
Item *LEX::create_item_func_nextval(THD *thd, Table_ident *table_ident)
{
  TABLE_LIST *table;
6975 6976 6977 6978
  if (unlikely(!(table= current_select->add_table_to_list(thd, table_ident, 0,
                                                          TL_OPTION_SEQUENCE,
                                                          TL_WRITE_ALLOW_WRITE,
                                                          MDL_SHARED_WRITE))))
6979
    return NULL;
6980
  thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION);
6981 6982 6983 6984 6985 6986 6987
  return new (thd->mem_root) Item_func_nextval(thd, table);
}


Item *LEX::create_item_func_lastval(THD *thd, Table_ident *table_ident)
{
  TABLE_LIST *table;
6988 6989 6990 6991
  if (unlikely(!(table= current_select->add_table_to_list(thd, table_ident, 0,
                                                          TL_OPTION_SEQUENCE,
                                                          TL_READ,
                                                          MDL_SHARED_READ))))
6992
    return NULL;
6993
  thd->lex->set_stmt_unsafe(LEX::BINLOG_STMT_UNSAFE_SYSTEM_FUNCTION);
6994 6995 6996 6997 6998
  return new (thd->mem_root) Item_func_lastval(thd, table);
}


Item *LEX::create_item_func_nextval(THD *thd,
6999 7000
                                    const LEX_CSTRING *db,
                                    const LEX_CSTRING *name)
7001 7002
{
  Table_ident *table_ident;
7003 7004
  if (unlikely(!(table_ident=
                 new (thd->mem_root) Table_ident(thd, db, name, false))))
7005 7006 7007 7008 7009 7010
    return NULL;
  return create_item_func_nextval(thd, table_ident);
}


Item *LEX::create_item_func_lastval(THD *thd,
7011 7012
                                    const LEX_CSTRING *db,
                                    const LEX_CSTRING *name)
7013 7014
{
  Table_ident *table_ident;
7015 7016
  if (unlikely(!(table_ident=
                 new (thd->mem_root) Table_ident(thd, db, name, false))))
7017 7018 7019 7020 7021
    return NULL;
  return create_item_func_lastval(thd, table_ident);
}


7022 7023 7024 7025 7026
Item *LEX::create_item_func_setval(THD *thd, Table_ident *table_ident,
                                   longlong nextval, ulonglong round,
                                   bool is_used)
{
  TABLE_LIST *table;
7027 7028 7029 7030
  if (unlikely(!(table= current_select->add_table_to_list(thd, table_ident, 0,
                                                          TL_OPTION_SEQUENCE,
                                                          TL_WRITE_ALLOW_WRITE,
                                                          MDL_SHARED_WRITE))))
7031 7032 7033 7034 7035 7036
    return NULL;
  return new (thd->mem_root) Item_func_setval(thd, table, nextval, round,
                                              is_used);
}


7037
Item *LEX::create_item_ident(THD *thd,
7038 7039
                             const Lex_ident_cli_st *ca,
                             const Lex_ident_cli_st *cb)
7040
{
7041 7042
  const char *start= ca->pos();
  const char *end= cb->end();
7043
  const Sp_rcontext_handler *rh;
7044
  sp_variable *spv;
7045 7046 7047 7048 7049 7050 7051
  DBUG_ASSERT(thd->m_parser_state->m_lip.get_buf() <= start);
  DBUG_ASSERT(start <= end);
  DBUG_ASSERT(end <= thd->m_parser_state->m_lip.get_end_of_query());
  Lex_ident_sys a(thd, ca), b(thd, cb);
  if (a.is_null() || b.is_null())
    return NULL; // OEM
  if ((spv= find_variable(&a, &rh)) &&
7052 7053 7054
      (spv->field_def.is_row() ||
       spv->field_def.is_table_rowtype_ref() ||
       spv->field_def.is_cursor_rowtype_ref()))
7055
    return create_item_spvar_row_field(thd, rh, &a, &b, spv, start, end);
7056

7057
  if ((thd->variables.sql_mode & MODE_ORACLE) && b.length == 7)
7058 7059
  {
    if (!my_strnncoll(system_charset_info,
7060
                      (const uchar *) b.str, 7,
7061
                      (const uchar *) "NEXTVAL", 7))
7062
      return create_item_func_nextval(thd, &null_clex_str, &a);
7063
    else if (!my_strnncoll(system_charset_info,
7064
                          (const uchar *) b.str, 7,
7065
                          (const uchar *) "CURRVAL", 7))
7066
      return create_item_func_lastval(thd, &null_clex_str, &a);
7067 7068
  }

7069
  return create_item_ident_nospvar(thd, &a, &b);
7070 7071 7072
}


7073
Item *LEX::create_item_ident(THD *thd,
7074 7075 7076
                             const Lex_ident_sys_st *a,
                             const Lex_ident_sys_st *b,
                             const Lex_ident_sys_st *c)
7077 7078
{
  const char *schema= (thd->client_capabilities & CLIENT_NO_SCHEMA ?
7079
                       NullS : a->str);
7080

7081
  if ((thd->variables.sql_mode & MODE_ORACLE) && c->length == 7)
7082 7083
  {
    if (!my_strnncoll(system_charset_info,
7084
                      (const uchar *) c->str, 7,
7085 7086 7087
                      (const uchar *) "NEXTVAL", 7))
      return create_item_func_nextval(thd, a, b);
    else if (!my_strnncoll(system_charset_info,
7088
                          (const uchar *) c->str, 7,
7089 7090 7091 7092 7093 7094
                          (const uchar *) "CURRVAL", 7))
      return create_item_func_lastval(thd, a, b);
  }

  if (current_select->no_table_names_allowed)
  {
7095
    my_error(ER_TABLENAME_NOT_ALLOWED_HERE, MYF(0), b->str, thd->where);
7096 7097 7098 7099 7100
    return NULL;
  }
  if (current_select->parsing_place != IN_HAVING ||
      current_select->get_in_sum_expr() > 0)
    return new (thd->mem_root) Item_field(thd, current_context(),
7101
                                          schema, b->str, c);
7102
  return new (thd->mem_root) Item_ref(thd, current_context(),
7103
                                      schema, b->str, c);
7104 7105
}

7106

7107
Item *LEX::create_item_limit(THD *thd, const Lex_ident_cli_st *ca)
7108
{
7109 7110 7111 7112
  DBUG_ASSERT(thd->m_parser_state->m_lip.get_buf() <= ca->pos());
  DBUG_ASSERT(ca->pos() <= ca->end());
  DBUG_ASSERT(ca->end() <= thd->m_parser_state->m_lip.get_end_of_query());

7113
  const Sp_rcontext_handler *rh;
7114
  sp_variable *spv;
7115 7116 7117 7118
  Lex_ident_sys sa(thd, ca);
  if (sa.is_null())
    return NULL; // EOM
  if (!(spv= find_variable(&sa, &rh)))
7119
  {
7120
    my_error(ER_SP_UNDECLARED_VAR, MYF(0), sa.str);
7121 7122 7123
    return NULL;
  }

7124
  Query_fragment pos(thd, sphead, ca->pos(), ca->end());
7125
  Item_splocal *item;
7126 7127 7128
  if (unlikely(!(item= new (thd->mem_root)
                 Item_splocal(thd, rh, &sa,
                              spv->offset, spv->type_handler(),
7129 7130
                              clone_spec_offset ? 0 : pos.pos(),
                              clone_spec_offset ? 0 : pos.length()))))
7131
    return NULL;
7132
#ifdef DBUG_ASSERT_EXISTS
7133 7134 7135 7136
  item->m_sp= sphead;
#endif
  safe_to_cache_query= 0;

7137
  if (unlikely(item->type() != Item::INT_ITEM))
7138 7139 7140 7141 7142 7143 7144 7145 7146 7147
  {
    my_error(ER_WRONG_SPVAR_TYPE_IN_LIMIT, MYF(0));
    return NULL;
  }
  item->limit_clause_param= true;
  return item;
}


Item *LEX::create_item_limit(THD *thd,
7148 7149
                             const Lex_ident_cli_st *ca,
                             const Lex_ident_cli_st *cb)
7150
{
7151 7152 7153 7154
  DBUG_ASSERT(thd->m_parser_state->m_lip.get_buf() <= ca->pos());
  DBUG_ASSERT(ca->pos() <= cb->end());
  DBUG_ASSERT(cb->end() <= thd->m_parser_state->m_lip.get_end_of_query());

7155
  const Sp_rcontext_handler *rh;
7156
  sp_variable *spv;
7157
  Lex_ident_sys sa(thd, ca), sb(thd, cb);
7158
  if (unlikely(sa.is_null() || sb.is_null()))
7159 7160
    return NULL; // EOM
  if (!(spv= find_variable(&sa, &rh)))
7161
  {
7162
    my_error(ER_SP_UNDECLARED_VAR, MYF(0), sa.str);
7163 7164 7165 7166 7167
    return NULL;
  }
  // Qualified %TYPE variables are not possible
  DBUG_ASSERT(!spv->field_def.column_type_ref());
  Item_splocal *item;
7168 7169
  if (unlikely(!(item= create_item_spvar_row_field(thd, rh, &sa, &sb, spv,
                                                   ca->pos(), cb->end()))))
7170
    return NULL;
7171
  if (unlikely(item->type() != Item::INT_ITEM))
7172 7173 7174 7175 7176 7177 7178 7179 7180
  {
    my_error(ER_WRONG_SPVAR_TYPE_IN_LIMIT, MYF(0));
    return NULL;
  }
  item->limit_clause_param= true;
  return item;
}


7181 7182 7183 7184
bool LEX::set_user_variable(THD *thd, const LEX_CSTRING *name, Item *val)
{
  Item_func_set_user_var *item;
  set_var_user *var;
7185 7186 7187 7188 7189
  if (unlikely(!(item= new (thd->mem_root) Item_func_set_user_var(thd, name,
                                                                  val))) ||
      unlikely(!(var= new (thd->mem_root) set_var_user(item))))
    return true;
  if (unlikely(var_list.push_back(var, thd->mem_root)))
7190 7191 7192 7193 7194
    return true;
  return false;
}


7195
Item *LEX::create_item_ident_nosp(THD *thd, Lex_ident_sys_st *name)
7196 7197 7198 7199
{
  if (current_select->parsing_place != IN_HAVING ||
      current_select->get_in_sum_expr() > 0)
    return new (thd->mem_root) Item_field(thd, current_context(),
7200
                                          NullS, NullS, name);
7201 7202

  return new (thd->mem_root) Item_ref(thd, current_context(),
7203
                                      NullS, NullS, name);
7204 7205 7206
}


7207
Item *LEX::create_item_ident_sp(THD *thd, Lex_ident_sys_st *name,
7208 7209
                                const char *start,
                                const char *end)
7210
{
7211 7212 7213 7214
  DBUG_ASSERT(thd->m_parser_state->m_lip.get_buf() <= start);
  DBUG_ASSERT(start <= end);
  DBUG_ASSERT(end <= thd->m_parser_state->m_lip.get_end_of_query());

7215
  const Sp_rcontext_handler *rh;
7216 7217
  sp_variable *spv;
  DBUG_ASSERT(spcont);
7218
  DBUG_ASSERT(sphead);
7219
  if ((spv= find_variable(name, &rh)))
7220 7221 7222 7223 7224 7225 7226 7227
  {
    /* We're compiling a stored procedure and found a variable */
    if (!parsing_options.allows_variable)
    {
      my_error(ER_VIEW_SELECT_VARIABLE, MYF(0));
      return NULL;
    }

7228
    Query_fragment pos(thd, sphead, start, end);
7229 7230
    uint f_pos= clone_spec_offset ? 0 : pos.pos();
    uint f_length= clone_spec_offset ? 0 : pos.length();
7231
    Item_splocal *splocal= spv->field_def.is_column_type_ref() ?
7232
      new (thd->mem_root) Item_splocal_with_delayed_data_type(thd, rh, name,
7233
                                                              spv->offset,
7234
                                                              f_pos, f_length) :
7235
      new (thd->mem_root) Item_splocal(thd, rh, name,
7236
                                       spv->offset, spv->type_handler(),
7237
                                       f_pos, f_length);
7238
    if (unlikely(splocal == NULL))
7239
      return NULL;
7240
#ifdef DBUG_ASSERT_EXISTS
7241 7242 7243 7244 7245 7246 7247 7248
    splocal->m_sp= sphead;
#endif
    safe_to_cache_query= 0;
    return splocal;
  }

  if (thd->variables.sql_mode & MODE_ORACLE)
  {
7249
    if (lex_string_eq(name, STRING_WITH_LEN("SQLCODE")))
7250
      return new (thd->mem_root) Item_func_sqlcode(thd);
7251
    if (lex_string_eq(name, STRING_WITH_LEN("SQLERRM")))
7252 7253 7254 7255 7256 7257
      return new (thd->mem_root) Item_func_sqlerrm(thd);
  }
  return create_item_ident_nosp(thd, name);
}


7258 7259 7260 7261 7262 7263 7264 7265 7266 7267 7268

bool LEX::set_variable(const LEX_CSTRING *name, Item *item)
{
  sp_pcontext *ctx;
  const Sp_rcontext_handler *rh;
  sp_variable *spv= find_variable(name, &ctx, &rh);
  return spv ? sphead->set_local_variable(thd, ctx, rh, spv, item, this, true) :
               set_system_variable(option_type, name, item);
}


7269 7270 7271 7272
/**
  Generate instructions for:
    SET x.y= expr;
*/
7273 7274
bool LEX::set_variable(const LEX_CSTRING *name1,
                       const LEX_CSTRING *name2,
7275 7276
                       Item *item)
{
7277 7278
  const Sp_rcontext_handler *rh;
  sp_pcontext *ctx;
7279
  sp_variable *spv;
7280
  if (spcont && (spv= find_variable(name1, &ctx, &rh)))
7281
  {
7282 7283
    if (spv->field_def.is_table_rowtype_ref() ||
        spv->field_def.is_cursor_rowtype_ref())
7284 7285
      return sphead->set_local_variable_row_field_by_name(thd, ctx,
                                                          rh,
7286 7287
                                                          spv, name2,
                                                          item, this);
7288 7289 7290
    // A field of a ROW variable
    uint row_field_offset;
    return !spv->find_row_field(name1, name2, &row_field_offset) ||
7291
           sphead->set_local_variable_row_field(thd, ctx, rh,
7292 7293 7294 7295
                                                spv, row_field_offset,
                                                item, this);
  }

7296 7297 7298 7299 7300 7301 7302 7303 7304 7305 7306 7307 7308 7309 7310
  if (is_trigger_new_or_old_reference(name1))
    return set_trigger_field(name1, name2, item);

  return set_system_variable(thd, option_type, name1, name2, item);
}


bool LEX::set_default_system_variable(enum_var_type var_type,
                                      const LEX_CSTRING *name,
                                      Item *val)
{
  static LEX_CSTRING default_base_name= {STRING_WITH_LEN("default")};
  sys_var *var= find_sys_var(thd, name->str, name->length);
  if (!var)
    return true;
7311
  if (unlikely(!var->is_struct()))
7312
  {
7313
    my_error(ER_VARIABLE_IS_NOT_STRUCT, MYF(0), name->str);
7314 7315
    return true;
  }
7316 7317 7318 7319 7320 7321 7322 7323 7324 7325
  return set_system_variable(var_type, var, &default_base_name, val);
}


bool LEX::set_system_variable(enum_var_type var_type,
                              const LEX_CSTRING *name,
                              Item *val)
{
  sys_var *var= find_sys_var(thd, name->str, name->length);
  DBUG_ASSERT(thd->is_error() || var != NULL);
7326
  return likely(var) ? set_system_variable(var_type, var, &null_clex_str, val) : true;
7327 7328 7329 7330 7331 7332 7333 7334 7335
}


bool LEX::set_system_variable(THD *thd, enum_var_type var_type,
                              const LEX_CSTRING *name1,
                              const LEX_CSTRING *name2,
                              Item *val)
{
  sys_var *tmp;
7336
  if (unlikely(check_reserved_words(name1)) ||
Sergey Vojtovich's avatar
Sergey Vojtovich committed
7337
      unlikely(!(tmp= find_sys_var(thd, name2->str, name2->length, true))))
7338 7339 7340 7341 7342
  {
    my_error(ER_UNKNOWN_STRUCTURED_VARIABLE, MYF(0),
             (int) name1->length, name1->str);
    return true;
  }
7343
  if (unlikely(!tmp->is_struct()))
7344
  {
7345
    my_error(ER_VARIABLE_IS_NOT_STRUCT, MYF(0), name2->str);
7346 7347
    return true;
  }
7348 7349 7350 7351 7352 7353 7354 7355
  return set_system_variable(var_type, tmp, name1, val);
}


bool LEX::set_trigger_field(const LEX_CSTRING *name1, const LEX_CSTRING *name2,
                            Item *val)
{
  DBUG_ASSERT(is_trigger_new_or_old_reference(name1));
7356
  if (unlikely(name1->str[0]=='O' || name1->str[0]=='o'))
7357 7358 7359 7360
  {
    my_error(ER_TRG_CANT_CHANGE_ROW, MYF(0), "OLD", "");
    return true;
  }
7361
  if (unlikely(trg_chistics.event == TRG_EVENT_DELETE))
7362 7363 7364 7365
  {
    my_error(ER_TRG_NO_SUCH_ROW_IN_TRG, MYF(0), "NEW", "on DELETE");
    return true;
  }
7366
  if (unlikely(trg_chistics.action_time == TRG_ACTION_AFTER))
7367 7368 7369 7370 7371
  {
    my_error(ER_TRG_CANT_CHANGE_ROW, MYF(0), "NEW", "after ");
    return true;
  }
  return set_trigger_new_row(name2, val);
7372 7373 7374
}


7375 7376 7377 7378 7379
#ifdef MYSQL_SERVER
uint binlog_unsafe_map[256];

#define UNSAFE(a, b, c) \
  { \
7380
  DBUG_PRINT("unsafe_mixed_statement", ("SETTING BASE VALUES: %s, %s, %02X", \
7381 7382 7383 7384 7385 7386 7387 7388 7389 7390 7391 7392 7393 7394 7395 7396 7397 7398 7399 7400 7401 7402 7403 7404 7405 7406 7407 7408 7409 7410 7411 7412 7413 7414 7415 7416 7417 7418 7419 7420 7421 7422 7423 7424 7425 7426 7427 7428 7429 7430 7431 7432 7433 7434 7435 7436 7437 7438 7439 7440 7441 7442 7443 7444 7445 7446 7447 7448 7449 7450 7451 7452 7453 7454 7455 7456 7457 7458 7459 7460 7461 7462 7463 7464 7465 7466 7467 7468 7469 7470 7471 7472 7473 7474 7475 7476 7477 7478 7479 7480 7481 7482 7483 7484 7485 7486 7487 7488 7489 7490 7491 7492 7493 7494 7495 7496 7497 7498 7499 7500 7501 7502 7503 7504 7505 7506 7507 7508 7509 7510 7511 7512 7513 7514 7515 7516 7517 7518 7519 7520
    LEX::stmt_accessed_table_string(a), \
    LEX::stmt_accessed_table_string(b), \
    c)); \
  unsafe_mixed_statement(a, b, c); \
  }

/*
  Sets the combination given by "a" and "b" and automatically combinations
  given by other types of access, i.e. 2^(8 - 2), as unsafe.

  It may happen a colision when automatically defining a combination as unsafe.
  For that reason, a combination has its unsafe condition redefined only when
  the new_condition is greater then the old. For instance,
  
     . (BINLOG_DIRECT_ON & TRX_CACHE_NOT_EMPTY) is never overwritten by 
     . (BINLOG_DIRECT_ON | BINLOG_DIRECT_OFF).
*/
void unsafe_mixed_statement(LEX::enum_stmt_accessed_table a,
                            LEX::enum_stmt_accessed_table b, uint condition)
{
  int type= 0;
  int index= (1U << a) | (1U << b);
  
  
  for (type= 0; type < 256; type++)
  {
    if ((type & index) == index)
    {
      binlog_unsafe_map[type] |= condition;
    }
  }
}
/*
  The BINLOG_* AND TRX_CACHE_* values can be combined by using '&' or '|',
  which means that both conditions need to be satisfied or any of them is
  enough. For example, 
    
    . BINLOG_DIRECT_ON & TRX_CACHE_NOT_EMPTY means that the statment is
    unsafe when the option is on and trx-cache is not empty;

    . BINLOG_DIRECT_ON | BINLOG_DIRECT_OFF means the statement is unsafe
    in all cases.

    . TRX_CACHE_EMPTY | TRX_CACHE_NOT_EMPTY means the statement is unsafe
    in all cases. Similar as above.
*/
void binlog_unsafe_map_init()
{
  memset((void*) binlog_unsafe_map, 0, sizeof(uint) * 256);

  /*
    Classify a statement as unsafe when there is a mixed statement and an
    on-going transaction at any point of the execution if:

      1. The mixed statement is about to update a transactional table and
      a non-transactional table.

      2. The mixed statement is about to update a transactional table and
      read from a non-transactional table.

      3. The mixed statement is about to update a non-transactional table
      and temporary transactional table.

      4. The mixed statement is about to update a temporary transactional
      table and read from a non-transactional table.

      5. The mixed statement is about to update a transactional table and
      a temporary non-transactional table.
     
      6. The mixed statement is about to update a transactional table and
      read from a temporary non-transactional table.

      7. The mixed statement is about to update a temporary transactional
      table and temporary non-transactional table.

      8. The mixed statement is about to update a temporary transactional
      table and read from a temporary non-transactional table.

    After updating a transactional table if:

      9. The mixed statement is about to update a non-transactional table
      and read from a transactional table.

      10. The mixed statement is about to update a non-transactional table
      and read from a temporary transactional table.

      11. The mixed statement is about to update a temporary non-transactional
      table and read from a transactional table.
      
      12. The mixed statement is about to update a temporary non-transactional
      table and read from a temporary transactional table.

      13. The mixed statement is about to update a temporary non-transactional
      table and read from a non-transactional table.

    The reason for this is that locks acquired may not protected a concurrent
    transaction of interfering in the current execution and by consequence in
    the result.
  */
  /* Case 1. */
  UNSAFE(LEX::STMT_WRITES_TRANS_TABLE, LEX::STMT_WRITES_NON_TRANS_TABLE,
    BINLOG_DIRECT_ON | BINLOG_DIRECT_OFF);
  /* Case 2. */
  UNSAFE(LEX::STMT_WRITES_TRANS_TABLE, LEX::STMT_READS_NON_TRANS_TABLE,
    BINLOG_DIRECT_ON | BINLOG_DIRECT_OFF);
  /* Case 3. */
  UNSAFE(LEX::STMT_WRITES_NON_TRANS_TABLE, LEX::STMT_WRITES_TEMP_TRANS_TABLE,
    BINLOG_DIRECT_ON | BINLOG_DIRECT_OFF);
  /* Case 4. */
  UNSAFE(LEX::STMT_WRITES_TEMP_TRANS_TABLE, LEX::STMT_READS_NON_TRANS_TABLE,
    BINLOG_DIRECT_ON | BINLOG_DIRECT_OFF);
  /* Case 5. */
  UNSAFE(LEX::STMT_WRITES_TRANS_TABLE, LEX::STMT_WRITES_TEMP_NON_TRANS_TABLE,
    BINLOG_DIRECT_ON);
  /* Case 6. */
  UNSAFE(LEX::STMT_WRITES_TRANS_TABLE, LEX::STMT_READS_TEMP_NON_TRANS_TABLE,
    BINLOG_DIRECT_ON);
  /* Case 7. */
  UNSAFE(LEX::STMT_WRITES_TEMP_TRANS_TABLE, LEX::STMT_WRITES_TEMP_NON_TRANS_TABLE,
    BINLOG_DIRECT_ON);
  /* Case 8. */
  UNSAFE(LEX::STMT_WRITES_TEMP_TRANS_TABLE, LEX::STMT_READS_TEMP_NON_TRANS_TABLE,
    BINLOG_DIRECT_ON);
  /* Case 9. */
  UNSAFE(LEX::STMT_WRITES_NON_TRANS_TABLE, LEX::STMT_READS_TRANS_TABLE,
    (BINLOG_DIRECT_ON | BINLOG_DIRECT_OFF) & TRX_CACHE_NOT_EMPTY);
  /* Case 10 */
  UNSAFE(LEX::STMT_WRITES_NON_TRANS_TABLE, LEX::STMT_READS_TEMP_TRANS_TABLE,
    (BINLOG_DIRECT_ON | BINLOG_DIRECT_OFF) & TRX_CACHE_NOT_EMPTY);
  /* Case 11. */
  UNSAFE(LEX::STMT_WRITES_TEMP_NON_TRANS_TABLE, LEX::STMT_READS_TRANS_TABLE,
    BINLOG_DIRECT_ON & TRX_CACHE_NOT_EMPTY);
  /* Case 12. */
  UNSAFE(LEX::STMT_WRITES_TEMP_NON_TRANS_TABLE, LEX::STMT_READS_TEMP_TRANS_TABLE,
    BINLOG_DIRECT_ON & TRX_CACHE_NOT_EMPTY);
  /* Case 13. */
  UNSAFE(LEX::STMT_WRITES_TEMP_NON_TRANS_TABLE, LEX::STMT_READS_NON_TRANS_TABLE,
     BINLOG_DIRECT_OFF & TRX_CACHE_NOT_EMPTY);
}
#endif
7521

7522 7523 7524 7525 7526 7527 7528 7529 7530 7531 7532 7533

/**
  @brief
  Finding fiels that are used in the GROUP BY of this st_select_lex
    
  @param thd  The thread handle

  @details
    This method looks through the fields which are used in the GROUP BY of this 
    st_select_lex and saves this fields. 
*/

7534 7535
void st_select_lex::collect_grouping_fields(THD *thd,
                                            ORDER *grouping_list) 
7536
{
7537
  grouping_tmp_fields.empty();
7538 7539 7540 7541
  List_iterator<Item> li(join->fields_list);
  Item *item= li++;
  for (uint i= 0; i < master_unit()->derived->table->s->fields; i++, (item=li++))
  {
7542
    for (ORDER *ord= grouping_list; ord; ord= ord->next)
7543 7544 7545
    {
      if ((*ord->item)->eq((Item*)item, 0))
      {
7546 7547 7548
        Grouping_tmp_field *grouping_tmp_field=
          new Grouping_tmp_field(master_unit()->derived->table->field[i], item);
        grouping_tmp_fields.push_back(grouping_tmp_field);
7549 7550 7551 7552 7553 7554 7555 7556 7557 7558 7559 7560 7561 7562 7563 7564 7565 7566 7567 7568 7569 7570 7571 7572 7573 7574 7575 7576
      }
    }
  }
}

/**
  @brief
   For a condition check possibility of exraction a formula over grouping fields 
  
  @param cond  The condition whose subformulas are to be analyzed
  
  @details
    This method traverses the AND-OR condition cond and for each subformula of
    the condition it checks whether it can be usable for the extraction of a
    condition over the grouping fields of this select. The method uses
    the call-back parameter check_processor to ckeck whether a primary formula
    depends only on grouping fields.
    The subformulas that are not usable are marked with the flag NO_EXTRACTION_FL.
    The subformulas that can be entierly extracted are marked with the flag 
    FULL_EXTRACTION_FL.
  @note
    This method is called before any call of extract_cond_for_grouping_fields.
    The flag NO_EXTRACTION_FL set in a subformula allows to avoid building clone
    for the subformula when extracting the pushable condition.
    The flag FULL_EXTRACTION_FL allows to delete later all top level conjuncts
    from cond.
*/ 

Igor Babaev's avatar
Igor Babaev committed
7577 7578 7579
void 
st_select_lex::check_cond_extraction_for_grouping_fields(Item *cond,
                                                         TABLE_LIST *derived)
7580 7581 7582 7583 7584 7585 7586 7587 7588 7589 7590 7591
{
  cond->clear_extraction_flag();
  if (cond->type() == Item::COND_ITEM)
  {
    bool and_cond= ((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC;
    List<Item> *arg_list=  ((Item_cond*) cond)->argument_list();
    List_iterator<Item> li(*arg_list);
    uint count= 0;         // to count items not containing NO_EXTRACTION_FL
    uint count_full= 0;    // to count items with FULL_EXTRACTION_FL
    Item *item;
    while ((item=li++))
    {
Igor Babaev's avatar
Igor Babaev committed
7592
      check_cond_extraction_for_grouping_fields(item, derived);
7593 7594 7595 7596 7597 7598 7599 7600 7601 7602 7603 7604 7605 7606 7607 7608 7609 7610 7611 7612
      if (item->get_extraction_flag() !=  NO_EXTRACTION_FL)
      {
        count++;
        if (item->get_extraction_flag() == FULL_EXTRACTION_FL)
          count_full++;
      }
      else if (!and_cond)
        break;
    }
    if ((and_cond && count == 0) || item)
      cond->set_extraction_flag(NO_EXTRACTION_FL);
    if (count_full == arg_list->elements)
      cond->set_extraction_flag(FULL_EXTRACTION_FL);
    if (cond->get_extraction_flag() != 0)
    {
      li.rewind();
      while ((item=li++))
        item->clear_extraction_flag();
    }
  }
Igor Babaev's avatar
Igor Babaev committed
7613 7614 7615 7616 7617 7618
  else
  {
    int fl= cond->excl_dep_on_grouping_fields(this) ?
      FULL_EXTRACTION_FL : NO_EXTRACTION_FL;
    cond->set_extraction_flag(fl);
  }
7619 7620 7621 7622 7623 7624 7625 7626 7627 7628 7629 7630 7631 7632 7633 7634 7635 7636 7637 7638 7639 7640 7641 7642 7643 7644 7645 7646 7647 7648 7649 7650 7651 7652 7653
}


/**
  @brief
  Build condition extractable from the given one depended on grouping fields
 
  @param thd           The thread handle
  @param cond          The condition from which the condition depended 
                       on grouping fields is to be extracted
  @param no_top_clones If it's true then no clones for the top fully 
                       extractable conjuncts are built

  @details
    For the given condition cond this method finds out what condition depended
    only on the grouping fields can be extracted from cond. If such condition C
    exists the method builds the item for it.
    This method uses the flags NO_EXTRACTION_FL and FULL_EXTRACTION_FL set by the
    preliminary call of st_select_lex::check_cond_extraction_for_grouping_fields
    to figure out whether a subformula depends only on these fields or not.
  @note
    The built condition C is always implied by the condition cond
    (cond => C). The method tries to build the most restictive such
    condition (i.e. for any other condition C' such that cond => C'
    we have C => C').
  @note
    The build item is not ready for usage: substitution for the field items
    has to be done and it has to be re-fixed.
  
  @retval
    the built condition depended only on grouping fields if such a condition exists
    NULL if there is no such a condition
*/ 

Item *st_select_lex::build_cond_for_grouping_fields(THD *thd, Item *cond,
7654
                                                    bool no_top_clones)
7655 7656 7657 7658 7659 7660
{
  if (cond->get_extraction_flag() == FULL_EXTRACTION_FL)
  {
    if (no_top_clones)
      return cond;
    cond->clear_extraction_flag();
7661
    return cond->build_clone(thd);
7662 7663 7664 7665 7666 7667 7668 7669 7670 7671 7672 7673
  }
  if (cond->type() == Item::COND_ITEM)
  {
    bool cond_and= false;
    Item_cond *new_cond;
    if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)
    {
      cond_and= true;
      new_cond=  new (thd->mem_root) Item_cond_and(thd);
    }
    else
      new_cond= new (thd->mem_root) Item_cond_or(thd);
7674
    if (unlikely(!new_cond))
7675
      return 0;
7676 7677 7678 7679 7680 7681
    List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
    Item *item;
    while ((item=li++))
    {
      if (item->get_extraction_flag() == NO_EXTRACTION_FL)
      {
7682 7683 7684
        DBUG_ASSERT(cond_and);
        item->clear_extraction_flag();
        continue;
7685 7686
      }
      Item *fix= build_cond_for_grouping_fields(thd, item,
7687
                                                no_top_clones & cond_and);
7688
      if (unlikely(!fix))
7689
      {
7690 7691 7692
        if (cond_and)
          continue;
        break;
7693 7694 7695 7696 7697 7698 7699
      }
      new_cond->argument_list()->push_back(fix, thd->mem_root);
    }
    
    if (!cond_and && item)
    {
      while((item= li++))
7700
        item->clear_extraction_flag();
7701 7702 7703 7704 7705
      return 0;
    }
    switch (new_cond->argument_list()->elements) 
    {
    case 0:
7706
      return 0;
7707 7708 7709 7710 7711 7712 7713 7714
    case 1:
      return new_cond->argument_list()->head();
    default:
      return new_cond;
    }
  }
  return 0;
}
7715 7716 7717 7718 7719 7720


int set_statement_var_if_exists(THD *thd, const char *var_name,
                                size_t var_name_length, ulonglong value)
{
  sys_var *sysvar;
7721
  if (unlikely(thd->lex->sql_command == SQLCOM_CREATE_VIEW))
7722 7723 7724 7725
  {
    my_error(ER_VIEW_SELECT_CLAUSE, MYF(0), "[NO]WAIT");
    return 1;
  }
7726
  if (unlikely(thd->lex->sphead))
7727 7728 7729 7730
  {
    my_error(ER_SP_BADSTATEMENT, MYF(0), "[NO]WAIT");
    return 1;
  }
Sergey Vojtovich's avatar
Sergey Vojtovich committed
7731
  if ((sysvar= find_sys_var(thd, var_name, var_name_length, true)))
7732 7733 7734
  {
    Item *item= new (thd->mem_root) Item_uint(thd, value);
    set_var *var= new (thd->mem_root) set_var(thd, OPT_SESSION, sysvar,
7735
                                              &null_clex_str, item);
7736

7737 7738
    if (unlikely(!item) || unlikely(!var) ||
        unlikely(thd->lex->stmt_var_list.push_back(var, thd->mem_root)))
7739 7740 7741 7742 7743 7744 7745
    {
      my_error(ER_OUT_OF_RESOURCES, MYF(0));
      return 1;
    }
  }
  return 0;
}
7746 7747


7748
bool LEX::sp_add_cfetch(THD *thd, const LEX_CSTRING *name)
7749 7750 7751 7752 7753 7754
{
  uint offset;
  sp_instr_cfetch *i;

  if (!spcont->find_cursor(name, &offset, false))
  {
7755
    my_error(ER_SP_CURSOR_MISMATCH, MYF(0), name->str);
7756 7757 7758
    return true;
  }
  i= new (thd->mem_root)
7759 7760
    sp_instr_cfetch(sphead->instructions(), spcont, offset,
                    !(thd->variables.sql_mode & MODE_ORACLE));
7761
  if (unlikely(i == NULL) || unlikely(sphead->add_instr(i)))
7762 7763 7764
    return true;
  return false;
}
7765 7766 7767 7768 7769 7770


bool LEX::create_or_alter_view_finalize(THD *thd, Table_ident *table_ident)
{
  sql_command= SQLCOM_CREATE_VIEW;
  /* first table in list is target VIEW name */
7771 7772 7773 7774
  if (unlikely(!select_lex.add_table_to_list(thd, table_ident, NULL,
                                             TL_OPTION_UPDATING,
                                             TL_IGNORE,
                                             MDL_EXCLUSIVE)))
7775 7776 7777 7778 7779 7780 7781 7782 7783 7784
    return true;
  query_tables->open_strategy= TABLE_LIST::OPEN_STUB;
  return false;
}


bool LEX::add_alter_view(THD *thd, uint16 algorithm,
                         enum_view_suid suid,
                         Table_ident *table_ident)
{
7785
  if (unlikely(sphead))
7786 7787 7788 7789
  {
    my_error(ER_SP_BADSTATEMENT, MYF(0), "ALTER VIEW");
    return true;
  }
7790 7791
  if (unlikely(!(create_view= new (thd->mem_root)
                 Create_view_info(VIEW_ALTER, algorithm, suid))))
7792 7793 7794 7795 7796 7797 7798 7799 7800
    return true;
  return create_or_alter_view_finalize(thd, table_ident);
}


bool LEX::add_create_view(THD *thd, DDL_options_st ddl,
                          uint16 algorithm, enum_view_suid suid,
                          Table_ident *table_ident)
{
7801
  if (unlikely(set_create_options_with_check(ddl)))
7802
    return true;
7803 7804 7805 7806 7807
  if (unlikely(!(create_view= new (thd->mem_root)
                 Create_view_info(ddl.or_replace() ?
                                  VIEW_CREATE_OR_REPLACE :
                                  VIEW_CREATE_NEW,
                                  algorithm, suid))))
7808 7809 7810
    return true;
  return create_or_alter_view_finalize(thd, table_ident);
}
7811 7812 7813 7814


bool LEX::call_statement_start(THD *thd, sp_name *name)
{
7815 7816
  Database_qualified_name pkgname(&null_clex_str, &null_clex_str);
  const Sp_handler *sph= &sp_handler_procedure;
7817 7818
  sql_command= SQLCOM_CALL;
  value_list.empty();
7819 7820
  if (unlikely(sph->sp_resolve_package_routine(thd, thd->lex->sphead,
                                               name, &sph, &pkgname)))
7821
    return true;
7822
  if (unlikely(!(m_sql_cmd= new (thd->mem_root) Sql_cmd_call(name, sph))))
7823
    return true;
7824 7825 7826
  sph->add_used_routine(this, thd, name);
  if (pkgname.m_name.length)
    sp_handler_package_body.add_used_routine(this, thd, &pkgname);
7827 7828 7829 7830 7831 7832 7833
  return false;
}


bool LEX::call_statement_start(THD *thd, const LEX_CSTRING *name)
{
  sp_name *spname= make_sp_name(thd, name);
7834
  return unlikely(!spname) || call_statement_start(thd, spname);
7835 7836 7837 7838 7839 7840 7841
}


bool LEX::call_statement_start(THD *thd, const LEX_CSTRING *name1,
                                         const LEX_CSTRING *name2)
{
  sp_name *spname= make_sp_name(thd, name1, name2);
7842
  return unlikely(!spname) || call_statement_start(thd, spname);
7843 7844 7845
}


7846 7847 7848 7849 7850 7851 7852 7853 7854 7855 7856 7857 7858
sp_package *LEX::get_sp_package() const
{
  return sphead ? sphead->get_package() : NULL;
}


sp_package *LEX::create_package_start(THD *thd,
                                      enum_sql_command command,
                                      const Sp_handler *sph,
                                      const sp_name *name_arg,
                                      DDL_options_st options)
{
  sp_package *pkg;
7859 7860

  if (unlikely(sphead))
7861 7862 7863 7864
  {
    my_error(ER_SP_NO_RECURSIVE_CREATE, MYF(0), sph->type_str());
    return NULL;
  }
7865
  if (unlikely(set_command_with_check(command, options)))
7866 7867 7868 7869 7870 7871 7872 7873 7874 7875 7876 7877 7878 7879 7880 7881 7882 7883 7884 7885 7886
    return NULL;
  if (sph->type() == TYPE_ENUM_PACKAGE_BODY)
  {
    /*
      If we start parsing a "CREATE PACKAGE BODY", we need to load
      the corresponding "CREATE PACKAGE", for the following reasons:
      1. "CREATE PACKAGE BODY" is allowed only if "CREATE PACKAGE"
         was done earlier for the same package name.
         So if "CREATE PACKAGE" does not exist, we throw an error here.
      2. When parsing "CREATE PACKAGE BODY", we need to know all package
         public and private routine names, to translate procedure and
         function calls correctly.
         For example, this statement inside a package routine:
           CALL p;
         can be translated to:
           CALL db.pkg.p; -- p is a known (public or private) package routine
           CALL db.p;     -- p is not a known package routine
    */
    sp_head *spec;
    int ret= sp_handler_package_spec.
               sp_cache_routine_reentrant(thd, name_arg, &spec);
7887
    if (unlikely(!spec))
7888 7889 7890 7891 7892 7893 7894
    {
      if (!ret)
        my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 "PACKAGE", ErrConvDQName(name_arg).ptr());
      return 0;
    }
  }
7895
  if (unlikely(!(pkg= sp_package::create(this, name_arg, sph))))
7896 7897 7898 7899 7900 7901 7902 7903 7904 7905 7906 7907 7908 7909 7910 7911 7912 7913 7914 7915 7916 7917 7918 7919 7920 7921 7922
    return NULL;
  pkg->reset_thd_mem_root(thd);
  pkg->init(this);
  pkg->make_qname(pkg->get_main_mem_root(), &pkg->m_qname);
  sphead= pkg;
  return pkg;
}


bool LEX::create_package_finalize(THD *thd,
                                  const sp_name *name,
                                  const sp_name *name2,
                                  const char *body_start,
                                  const char *body_end)
{
  if (name2 &&
      (name2->m_explicit_name != name->m_explicit_name ||
       strcmp(name2->m_db.str, name->m_db.str) ||
       !Sp_handler::eq_routine_name(name2->m_name, name->m_name)))
  {
    bool exp= name2->m_explicit_name || name->m_explicit_name;
    my_error(ER_END_IDENTIFIER_DOES_NOT_MATCH, MYF(0),
             exp ? ErrConvDQName(name2).ptr() : name2->m_name.str,
             exp ? ErrConvDQName(name).ptr() : name->m_name.str);
    return true;
  }
  sphead->m_body.length= body_end - body_start;
7923 7924
  if (unlikely(!(sphead->m_body.str= thd->strmake(body_start,
                                                  sphead->m_body.length))))
7925 7926 7927 7928 7929 7930 7931 7932 7933 7934 7935 7936 7937 7938 7939
    return true;

  size_t not_used;
  Lex_input_stream *lip= & thd->m_parser_state->m_lip;
  sphead->m_defstr.length= lip->get_cpp_ptr() - lip->get_cpp_buf();
  sphead->m_defstr.str= thd->strmake(lip->get_cpp_buf(), sphead->m_defstr.length);
  trim_whitespace(thd->charset(), &sphead->m_defstr, &not_used);

  sphead->restore_thd_mem_root(thd);
  sp_package *pkg= sphead->get_package();
  DBUG_ASSERT(pkg);
  return pkg->validate_after_parser(thd);
}


7940 7941 7942 7943 7944 7945 7946 7947 7948 7949 7950 7951
bool LEX::add_grant_command(THD *thd, enum_sql_command sql_command_arg,
                            stored_procedure_type type_arg)
{
  if (columns.elements)
  {
    thd->parse_error();
    return true;
  }
  sql_command= sql_command_arg,
  type= type_arg;
  return false;
}
7952 7953


7954 7955 7956 7957 7958 7959 7960 7961 7962 7963 7964 7965 7966 7967 7968 7969
Item *LEX::make_item_func_substr(THD *thd, Item *a, Item *b, Item *c)
{
  return (thd->variables.sql_mode & MODE_ORACLE) ?
    new (thd->mem_root) Item_func_substr_oracle(thd, a, b, c) :
    new (thd->mem_root) Item_func_substr(thd, a, b, c);
}


Item *LEX::make_item_func_substr(THD *thd, Item *a, Item *b)
{
  return (thd->variables.sql_mode & MODE_ORACLE) ?
    new (thd->mem_root) Item_func_substr_oracle(thd, a, b) :
    new (thd->mem_root) Item_func_substr(thd, a, b);
}


7970 7971 7972 7973 7974 7975 7976 7977 7978
Item *LEX::make_item_func_replace(THD *thd,
                                  Item *org,
                                  Item *find,
                                  Item *replace)
{
  return (thd->variables.sql_mode & MODE_ORACLE) ?
    new (thd->mem_root) Item_func_replace_oracle(thd, org, find, replace) :
    new (thd->mem_root) Item_func_replace(thd, org, find, replace);
}
7979 7980


7981 7982
bool SELECT_LEX::vers_push_field(THD *thd, TABLE_LIST *table,
                                 const LEX_CSTRING field_name)
7983
{
7984
  DBUG_ASSERT(field_name.str);
7985
  Item_field *fld= new (thd->mem_root) Item_field(thd, &context,
7986 7987 7988 7989
                                                  table->db.str,
                                                  table->alias.str,
                                                  &field_name);
  if (unlikely(!fld) || unlikely(item_list.push_back(fld)))
7990 7991 7992 7993
    return true;

  if (thd->lex->view_list.elements)
  {
7994
    LEX_CSTRING *l;
7995 7996 7997
    if (unlikely(!(l= thd->make_clex_string(field_name.str,
                                            field_name.length))) ||
        unlikely(thd->lex->view_list.push_back(l)))
7998 7999 8000 8001 8002
      return true;
  }

  return false;
}
8003

8004 8005 8006 8007 8008 8009 8010 8011 8012 8013 8014 8015 8016 8017 8018 8019 8020 8021 8022 8023 8024 8025 8026 8027 8028 8029 8030 8031 8032 8033 8034 8035 8036 8037 8038 8039 8040 8041 8042 8043 8044 8045 8046 8047 8048 8049 8050 8051 8052 8053 8054 8055 8056 8057 8058 8059 8060 8061 8062 8063 8064

Item *Lex_trim_st::make_item_func_trim_std(THD *thd) const
{
  if (m_remove)
  {
    switch (m_spec) {
    case TRIM_BOTH:
      return new (thd->mem_root) Item_func_trim(thd, m_source, m_remove);
    case TRIM_LEADING:
      return new (thd->mem_root) Item_func_ltrim(thd, m_source, m_remove);
    case TRIM_TRAILING:
     return new (thd->mem_root) Item_func_rtrim(thd, m_source, m_remove);
    }
  }

  switch (m_spec) {
  case TRIM_BOTH:
    return new (thd->mem_root) Item_func_trim(thd, m_source);
  case TRIM_LEADING:
    return new (thd->mem_root) Item_func_ltrim(thd, m_source);
  case TRIM_TRAILING:
   return new (thd->mem_root) Item_func_rtrim(thd, m_source);
  }
  DBUG_ASSERT(0);
  return NULL;
}


Item *Lex_trim_st::make_item_func_trim_oracle(THD *thd) const
{
  if (m_remove)
  {
    switch (m_spec) {
    case TRIM_BOTH:
      return new (thd->mem_root) Item_func_trim_oracle(thd, m_source, m_remove);
    case TRIM_LEADING:
      return new (thd->mem_root) Item_func_ltrim_oracle(thd, m_source, m_remove);
    case TRIM_TRAILING:
     return new (thd->mem_root) Item_func_rtrim_oracle(thd, m_source, m_remove);
    }
  }

  switch (m_spec) {
  case TRIM_BOTH:
    return new (thd->mem_root) Item_func_trim_oracle(thd, m_source);
  case TRIM_LEADING:
    return new (thd->mem_root) Item_func_ltrim_oracle(thd, m_source);
  case TRIM_TRAILING:
   return new (thd->mem_root) Item_func_rtrim_oracle(thd, m_source);
  }
  DBUG_ASSERT(0);
  return NULL;
}


Item *Lex_trim_st::make_item_func_trim(THD *thd) const
{
  return (thd->variables.sql_mode & MODE_ORACLE) ?
         make_item_func_trim_oracle(thd) :
         make_item_func_trim_std(thd);
}
8065 8066 8067 8068 8069 8070 8071 8072 8073 8074 8075 8076 8077 8078 8079 8080 8081 8082 8083 8084 8085 8086 8087 8088 8089 8090 8091 8092 8093 8094 8095 8096 8097 8098 8099 8100 8101 8102 8103 8104 8105 8106 8107 8108 8109 8110 8111 8112 8113 8114 8115 8116 8117 8118 8119 8120 8121 8122 8123 8124 8125 8126 8127 8128 8129 8130 8131 8132 8133 8134 8135 8136 8137 8138 8139 8140 8141 8142 8143 8144 8145 8146 8147 8148 8149 8150 8151 8152 8153 8154 8155 8156 8157 8158 8159 8160 8161 8162 8163 8164 8165 8166 8167 8168 8169 8170


Item *LEX::make_item_func_call_generic(THD *thd, Lex_ident_cli_st *cdb,
                                       Lex_ident_cli_st *cname, List<Item> *args)
{
  Lex_ident_sys db(thd, cdb), name(thd, cname);
  if (db.is_null() || name.is_null())
    return NULL; // EOM
  /*
    The following in practice calls:
    <code>Create_sp_func::create()</code>
    and builds a stored function.

    However, it's important to maintain the interface between the
    parser and the implementation in item_create.cc clean,
    since this will change with WL#2128 (SQL PATH):
    - INFORMATION_SCHEMA.version() is the SQL 99 syntax for the native
    function version(),
    - MySQL.version() is the SQL 2003 syntax for the native function
    version() (a vendor can specify any schema).
  */

  if (!name.str || check_db_name((LEX_STRING*) static_cast<LEX_CSTRING*>(&db)))
  {
    my_error(ER_WRONG_DB_NAME, MYF(0), db.str);
    return NULL;
  }
  if (check_routine_name(&name))
    return NULL;

  Create_qfunc *builder= find_qualified_function_builder(thd);
  DBUG_ASSERT(builder);
  return builder->create_with_db(thd, &db, &name, true, args);
}


Item *LEX::create_item_qualified_asterisk(THD *thd,
                                          const Lex_ident_sys_st *name)
{
  Item *item;
  if (!(item= new (thd->mem_root) Item_field(thd, current_context(),
                                             NullS, name->str,
                                             &star_clex_str)))
    return NULL;
  current_select->with_wild++;
  return item;
}


Item *LEX::create_item_qualified_asterisk(THD *thd,
                                          const Lex_ident_sys_st *a,
                                          const Lex_ident_sys_st *b)
{
  Item *item;
  const char* schema= thd->client_capabilities & CLIENT_NO_SCHEMA ?
                      NullS : a->str;
  if (!(item= new (thd->mem_root) Item_field(thd, current_context(),
                                             schema, b->str,
                                             &star_clex_str)))
   return NULL;
  current_select->with_wild++;
  return item;
}


bool Lex_ident_sys_st::copy_ident_cli(THD *thd, const Lex_ident_cli_st *str)
{
  return thd->to_ident_sys_alloc(this, str);
}

bool Lex_ident_sys_st::copy_keyword(THD *thd, const Lex_ident_cli_st *str)
{
  return thd->make_lex_string(static_cast<LEX_CSTRING*>(this),
                              str->str, str->length) == NULL;
}

bool Lex_ident_sys_st::copy_or_convert(THD *thd,
                                       const Lex_ident_cli_st *src,
                                       CHARSET_INFO *cs)
{
  if (!src->is_8bit())
    return copy_keyword(thd, src); // 7bit string makes a wellformed identifier
  return convert(thd, src, cs);
}


bool Lex_ident_sys_st::copy_sys(THD *thd, const LEX_CSTRING *src)
{
  if (thd->check_string_for_wellformedness(src->str, src->length,
                                           system_charset_info))
    return true;
  return thd->make_lex_string(this, src->str, src->length) == NULL;
}


bool Lex_ident_sys_st::convert(THD *thd,
                               const LEX_CSTRING *src, CHARSET_INFO *cs)
{
  LEX_STRING tmp;
  if (thd->convert_with_error(system_charset_info, &tmp, cs,
                              src->str, src->length))
    return true;
  str=    tmp.str;
  length= tmp.length;
  return false;
}
8171 8172


8173
bool Lex_ident_sys_st::to_size_number(ulonglong *to) const
8174 8175 8176 8177 8178 8179 8180 8181 8182 8183 8184 8185 8186 8187 8188 8189 8190 8191 8192 8193 8194 8195 8196 8197 8198 8199 8200 8201 8202 8203 8204 8205 8206 8207 8208 8209 8210 8211 8212 8213 8214 8215 8216 8217 8218 8219 8220 8221 8222 8223 8224 8225 8226 8227 8228 8229 8230 8231 8232 8233
{
  ulonglong number;
  uint text_shift_number= 0;
  longlong prefix_number;
  const char *start_ptr= str;
  size_t str_len= length;
  const char *end_ptr= start_ptr + str_len;
  int error;
  prefix_number= my_strtoll10(start_ptr, (char**) &end_ptr, &error);
  if (likely((start_ptr + str_len - 1) == end_ptr))
  {
    switch (end_ptr[0])
    {
      case 'g':
      case 'G': text_shift_number+=30; break;
      case 'm':
      case 'M': text_shift_number+=20; break;
      case 'k':
      case 'K': text_shift_number+=10; break;
      default:
        my_error(ER_WRONG_SIZE_NUMBER, MYF(0));
        return true;
    }
    if (unlikely(prefix_number >> 31))
    {
      my_error(ER_SIZE_OVERFLOW_ERROR, MYF(0));
      return true;
    }
    number= prefix_number << text_shift_number;
  }
  else
  {
    my_error(ER_WRONG_SIZE_NUMBER, MYF(0));
    return true;
  }
  *to= number;
  return false;
}


bool LEX::part_values_current(THD *thd)
{
  partition_element *elem= part_info->curr_part_elem;
  if (!is_partition_management())
  {
    if (unlikely(part_info->part_type != VERSIONING_PARTITION))
    {
      my_error(ER_PARTITION_WRONG_TYPE, MYF(0), "SYSTEM_TIME");
      return true;
    }
  }
  else
  {
    DBUG_ASSERT(create_last_non_select_table);
    DBUG_ASSERT(create_last_non_select_table->table_name.str);
    // FIXME: other ALTER commands?
    my_error(ER_VERS_WRONG_PARTS, MYF(0),
             create_last_non_select_table->table_name.str);
    return true;
  }
8234
  elem->type= partition_element::CURRENT;
8235 8236 8237 8238 8239 8240 8241 8242 8243 8244 8245 8246 8247 8248 8249 8250 8251 8252 8253 8254 8255 8256 8257 8258 8259 8260 8261 8262 8263 8264 8265
  DBUG_ASSERT(part_info->vers_info);
  part_info->vers_info->now_part= elem;
  return false;
}


bool LEX::part_values_history(THD *thd)
{
  partition_element *elem= part_info->curr_part_elem;
  if (!is_partition_management())
  {
    if (unlikely(part_info->part_type != VERSIONING_PARTITION))
    {
      my_error(ER_PARTITION_WRONG_TYPE, MYF(0), "SYSTEM_TIME");
      return true;
    }
  }
  else
  {
    part_info->vers_init_info(thd);
    elem->id= UINT_MAX32;
  }
  DBUG_ASSERT(part_info->vers_info);
  if (unlikely(part_info->vers_info->now_part))
  {
    DBUG_ASSERT(create_last_non_select_table);
    DBUG_ASSERT(create_last_non_select_table->table_name.str);
    my_error(ER_VERS_WRONG_PARTS, MYF(0),
             create_last_non_select_table->table_name.str);
    return true;
  }
8266
  elem->type= partition_element::HISTORY;
8267 8268 8269 8270 8271 8272 8273 8274 8275 8276 8277 8278 8279 8280 8281 8282 8283 8284 8285 8286 8287 8288 8289 8290 8291 8292 8293 8294 8295 8296 8297 8298 8299 8300 8301 8302 8303 8304 8305 8306
  return false;
}


bool LEX::last_field_generated_always_as_row_start_or_end(Lex_ident *p,
                                                          const char *type,
                                                          uint flag)
{
  if (unlikely(p->str))
  {
    my_error(ER_VERS_DUPLICATE_ROW_START_END, MYF(0), type,
             last_field->field_name.str);
    return true;
  }
  last_field->flags|= (flag | NOT_NULL_FLAG);
  DBUG_ASSERT(p);
  *p= last_field->field_name;
  return false;
}



bool LEX::last_field_generated_always_as_row_start()
{
  Vers_parse_info &info= vers_get_info();
  Lex_ident *p= &info.as_row.start;
  return last_field_generated_always_as_row_start_or_end(p, "START",
                                                         VERS_SYS_START_FLAG);
}


bool LEX::last_field_generated_always_as_row_end()
{
  Vers_parse_info &info= vers_get_info();
  Lex_ident *p= &info.as_row.end;
  return last_field_generated_always_as_row_start_or_end(p, "END",
                                                         VERS_SYS_END_FLAG);
}


8307 8308 8309 8310 8311 8312 8313 8314 8315 8316 8317 8318 8319 8320 8321 8322 8323 8324 8325 8326 8327 8328 8329 8330 8331 8332 8333 8334 8335 8336 8337 8338 8339 8340 8341 8342 8343
void LEX::save_values_list_state()
{
  current_select->save_many_values= many_values;
  current_select->save_insert_list= insert_list;
}


void LEX::restore_values_list_state()
{
  many_values= current_select->save_many_values;
  insert_list= current_select->save_insert_list;
}


void LEX::tvc_start()
{
  if (current_select == &select_lex)
    mysql_init_select(this);
  else
    save_values_list_state();
  many_values.empty();
  insert_list= 0;
}


bool LEX::tvc_start_derived()
{
  if (current_select->linkage == GLOBAL_OPTIONS_TYPE ||
      unlikely(mysql_new_select(this, 1, NULL)))
    return true;
  save_values_list_state();
  many_values.empty();
  insert_list= 0;
  return false;
}


8344 8345 8346 8347 8348 8349 8350 8351
bool LEX::tvc_finalize()
{
  if (unlikely(!(current_select->tvc=
               new (thd->mem_root)
               table_value_constr(many_values,
                                  current_select,
                                  current_select->options))))
    return true;
8352
  restore_values_list_state();
8353 8354
  if (!current_select->master_unit()->fake_select_lex)
    current_select->master_unit()->add_fake_select_lex(thd);
8355 8356 8357 8358 8359 8360 8361 8362 8363 8364 8365 8366 8367 8368 8369
  return false;
}


bool LEX::tvc_finalize_derived()
{
  derived_tables|= DERIVED_SUBQUERY;
  if (unlikely(!expr_allows_subselect || sql_command == (int)SQLCOM_PURGE))
  {
    thd->parse_error();
    return true;
  }
  current_select->linkage= DERIVED_TABLE_TYPE;
  return tvc_finalize();
}
8370 8371 8372 8373 8374 8375 8376 8377 8378 8379 8380 8381 8382 8383 8384 8385 8386 8387 8388 8389 8390 8391 8392 8393 8394 8395 8396 8397


bool LEX::map_data_type(const Lex_ident_sys_st &schema_name,
                        Lex_field_type_st *type) const
{
  const Schema *schema= schema_name.str ?
                        Schema::find_by_name(schema_name) :
                        Schema::find_implied(thd);
  if (!schema)
  {
    char buf[128];
    const Name type_name= type->type_handler()->name();
    my_snprintf(buf, sizeof(buf), "%.*s.%.*s",
                (int) schema_name.length, schema_name.str,
                (int) type_name.length(), type_name.ptr());
#if MYSQL_VERSION_ID > 100500
#error Please remove the old code
    my_error(ER_UNKNOWN_DATA_TYPE, MYF(0), buf);
#else
    my_printf_error(ER_UNKNOWN_ERROR, "Unknown data type: '%-.64s'",
                    MYF(0), buf);
#endif
    return true;
  }
  const Type_handler *mapped= schema->map_data_type(thd, type->type_handler());
  type->set_handler(mapped);
  return false;
}