开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
sql_lex.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：45k
源码类别：

MySQL数据库

开发平台：

Visual C++

sql_lex.cpp：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  18. /* A lexical scanner on a temporary buffer with a yacc interface */
  20. #include "mysql_priv.h"
  21. #include "item_create.h"
  22. #include <m_ctype.h>
  23. #include <hash.h>
  26. /*
  27.   Fake table list object, pointer to which is used as special value for
  28.   st_lex::time_zone_tables_used indicating that we implicitly use time
  29.   zone tables in this statement but real table list was not yet created.
  30.   Pointer to it is also returned by my_tz_get_tables_list() as indication
  31.   of transient error;
  32. */
  33. TABLE_LIST fake_time_zone_tables_list;
  35. /* Macros to look like lex */
  37. #define yyGet() *(lex->ptr++)
  38. #define yyGetLast() lex->ptr[-1]
  39. #define yyPeek() lex->ptr[0]
  40. #define yyPeek2() lex->ptr[1]
  41. #define yyUnget() lex->ptr--
  42. #define yySkip() lex->ptr++
  43. #define yyLength() ((uint) (lex->ptr - lex->tok_start)-1)
  45. #if MYSQL_VERSION_ID < 32300
  46. #define FLOAT_NUM REAL_NUM
  47. #endif
  49. pthread_key(LEX*,THR_LEX);
  51. /* Longest standard keyword name */
  52. #define TOCK_NAME_LENGTH 24
  54. /*
  55.   The following data is based on the latin1 character set, and is only
  56.   used when comparing keywords
  57. */
  59. uchar to_upper_lex[] = {
  60.     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
  61.    16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
  62.    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
  63.    48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
  64.    64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
  65.    80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
  66.    96, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
  67.    80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,123,124,125,126,127,
  68.   128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
  69.   144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
  70.   160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,
  71.   176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
  72.   192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
  73.   208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,
  74.   192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,
  75.   208,209,210,211,212,213,214,247,216,217,218,219,220,221,222,255
  76. };
  79. inline int lex_casecmp(const char *s, const char *t, uint len)
  80. {
  81.   while (len-- != 0 &&
  82.  to_upper_lex[(uchar) *s++] == to_upper_lex[(uchar) *t++]) ;
  83.   return (int) len+1;
  84. }
  86. #include "lex_hash.h"
  89. void lex_init(void)
  90. {
  91.   uint i;
  92.   DBUG_ENTER("lex_init");
  93.   for (i=0 ; i < array_elements(symbols) ; i++)
  94.     symbols[i].length=(uchar) strlen(symbols[i].name);
  95.   for (i=0 ; i < array_elements(sql_functions) ; i++)
  96.     sql_functions[i].length=(uchar) strlen(sql_functions[i].name);
  98.   VOID(pthread_key_create(&THR_LEX,NULL));
  100.   DBUG_VOID_RETURN;
  101. }
  104. void lex_free(void)
  105. { // Call this when daemon ends
  106.   DBUG_ENTER("lex_free");
  107.   DBUG_VOID_RETURN;
  108. }
  111. /*
  112.   This is called before every query that is to be parsed.
  113.   Because of this, it's critical to not do too much things here.
  114.   (We already do too much here)
  115. */
  117. void lex_start(THD *thd, uchar *buf,uint length)
  118. {
  119.   LEX *lex= thd->lex;
  120.   lex->unit.init_query();
  121.   lex->unit.init_select();
  122.   lex->thd= thd;
  123.   lex->unit.thd= thd;
  124.   lex->select_lex.init_query();
  125.   lex->value_list.empty();
  126.   lex->update_list.empty();
  127.   lex->param_list.empty();
  128.   lex->unit.next= lex->unit.master=
  129.     lex->unit.link_next= lex->unit.return_to= 0;
  130.   lex->unit.prev= lex->unit.link_prev= 0;
  131.   lex->unit.slave= lex->unit.global_parameters= lex->current_select=
  132.     lex->all_selects_list= &lex->select_lex;
  133.   lex->select_lex.master= &lex->unit;
  134.   lex->select_lex.prev= &lex->unit.slave;
  135.   lex->select_lex.link_next= lex->select_lex.slave= lex->select_lex.next= 0;
  136.   lex->select_lex.link_prev= (st_select_lex_node**)&(lex->all_selects_list);
  137.   lex->select_lex.options= 0;
  138.   lex->describe= 0;
  139.   lex->subqueries= lex->derived_tables= FALSE;
  140.   lex->lock_option= TL_READ;
  141.   lex->found_colon= 0;
  142.   lex->safe_to_cache_query= 1;
  143.   lex->time_zone_tables_used= 0;
  144.   lex->select_lex.select_number= 1;
  145.   lex->next_state=MY_LEX_START;
  146.   lex->end_of_query=(lex->ptr=buf)+length;
  147.   lex->yylineno = 1;
  148.   lex->in_comment=0;
  149.   lex->length=0;
  150.   lex->select_lex.in_sum_expr=0;
  151.   lex->select_lex.expr_list.empty();
  152.   lex->select_lex.ftfunc_list_alloc.empty();
  153.   lex->select_lex.ftfunc_list= &lex->select_lex.ftfunc_list_alloc;
  154.   lex->select_lex.group_list.empty();
  155.   lex->select_lex.order_list.empty();
  156.   lex->current_select= &lex->select_lex;
  157.   lex->yacc_yyss=lex->yacc_yyvs=0;
  158.   lex->ignore_space=test(thd->variables.sql_mode & MODE_IGNORE_SPACE);
  159.   lex->sql_command=SQLCOM_END;
  160.   lex->duplicates= DUP_ERROR;
  161.   lex->ignore= 0;
  162.   lex->proc_list.first= 0;
  163. }
  165. void lex_end(LEX *lex)
  166. {
  167.   for (SELECT_LEX *sl= lex->all_selects_list;
  168.        sl;
  169.        sl= sl->next_select_in_list())
  170.     sl->expr_list.delete_elements(); // If error when parsing sql-varargs
  171.   x_free(lex->yacc_yyss);
  172.   x_free(lex->yacc_yyvs);
  173. }
  176. static int find_keyword(LEX *lex, uint len, bool function)
  177. {
  178.   uchar *tok=lex->tok_start;
  180.   SYMBOL *symbol = get_hash_symbol((const char *)tok,len,function);
  181.   if (symbol)
  182.   {
  183.     lex->yylval->symbol.symbol=symbol;
  184.     lex->yylval->symbol.str= (char*) tok;
  185.     lex->yylval->symbol.length=len;
  186.     return symbol->tok;
  187.   }
  188. #ifdef HAVE_DLOPEN
  189.   udf_func *udf;
  190.   if (function && using_udf_functions && (udf=find_udf((char*) tok, len)))
  191.   {
  192.     lex->safe_to_cache_query=0;
  193.     lex->yylval->udf=udf;
  194.     switch (udf->returns) {
  195.     case STRING_RESULT:
  196.       return (udf->type == UDFTYPE_FUNCTION) ? UDF_CHAR_FUNC : UDA_CHAR_SUM;
  197.     case REAL_RESULT:
  198.       return (udf->type == UDFTYPE_FUNCTION) ? UDF_FLOAT_FUNC : UDA_FLOAT_SUM;
  199.     case INT_RESULT:
  200.       return (udf->type == UDFTYPE_FUNCTION) ? UDF_INT_FUNC : UDA_INT_SUM;
  201.     case ROW_RESULT:
  202.     default:
  203.       // This case should never be choosen
  204.       DBUG_ASSERT(0);
  205.       return 0;
  206.     }
  207.   }
  208. #endif
  209.   return 0;
  210. }
  212. /*
  213.   Check if name is a keyword
  215.   SYNOPSIS
  216.     is_keyword()
  217.     name      checked name
  218.     len       length of checked name
  220.   RETURN VALUES
  221.     0         name is a keyword
  222.     1         name isn't a keyword
  223. */
  225. bool is_keyword(const char *name, uint len)
  226. {
  227.   return get_hash_symbol(name,len,0)!=0;
  228. }
  230. /* make a copy of token before ptr and set yytoklen */
  232. static LEX_STRING get_token(LEX *lex,uint length)
  233. {
  234.   LEX_STRING tmp;
  235.   yyUnget(); // ptr points now after last token char
  236.   tmp.length=lex->yytoklen=length;
  237.   tmp.str=(char*) lex->thd->strmake((char*) lex->tok_start,tmp.length);
  238.   return tmp;
  239. }
  241. /* 
  242.  todo: 
  243.    There are no dangerous charsets in mysql for function 
  244.    get_quoted_token yet. But it should be fixed in the 
  245.    future to operate multichar strings (like ucs2)
  246. */
  248. static LEX_STRING get_quoted_token(LEX *lex,uint length, char quote)
  249. {
  250.   LEX_STRING tmp;
  251.   byte *from, *to, *end;
  252.   yyUnget(); // ptr points now after last token char
  253.   tmp.length=lex->yytoklen=length;
  254.   tmp.str=(char*) lex->thd->alloc(tmp.length+1);
  255.   for (from= (byte*) lex->tok_start, to= (byte*) tmp.str, end= to+length ;
  256.        to != end ;
  257.        )
  258.   {
  259.     if ((*to++= *from++) == quote)
  260.       from++; // Skip double quotes
  261.   }
  262.   *to= 0; // End null for safety
  263.   return tmp;
  264. }
  267. /*
  268.   Return an unescaped text literal without quotes
  269.   Fix sometimes to do only one scan of the string
  270. */
  272. static char *get_text(LEX *lex)
  273. {
  274.   reg1 uchar c,sep;
  275.   uint found_escape=0;
  276.   CHARSET_INFO *cs= lex->thd->charset();
  278.   sep= yyGetLast(); // String should end with this
  279.   //lex->tok_start=lex->ptr-1; // Remember '
  280.   while (lex->ptr != lex->end_of_query)
  281.   {
  282.     c = yyGet();
  283. #ifdef USE_MB
  284.     int l;
  285.     if (use_mb(cs) &&
  286.         (l = my_ismbchar(cs,
  287.                          (const char *)lex->ptr-1,
  288.                          (const char *)lex->end_of_query))) {
  289. lex->ptr += l-1;
  290. continue;
  291.     }
  292. #endif
  293.     if (c == '\')
  294.     { // Escaped character
  295.       found_escape=1;
  296.       if (lex->ptr == lex->end_of_query)
  297. return 0;
  298. #ifdef USE_MB
  299.       int l;
  300.       if (use_mb(cs) &&
  301.           (l = my_ismbchar(cs,
  302.                            (const char *)lex->ptr,
  303.                            (const char *)lex->end_of_query))) {
  304.           lex->ptr += l;
  305.           continue;
  306.       }
  307.       else
  308. #endif
  309.         yySkip();
  310.     }
  311.     else if (c == sep)
  312.     {
  313.       if (c == yyGet()) // Check if two separators in a row
  314.       {
  315. found_escape=1; // dupplicate. Remember for delete
  316. continue;
  317.       }
  318.       else
  319. yyUnget();
  321.       /* Found end. Unescape and return string */
  322.       uchar *str,*end,*start;
  324.       str=lex->tok_start+1;
  325.       end=lex->ptr-1;
  326.       if (!(start=(uchar*) lex->thd->alloc((uint) (end-str)+1)))
  327. return (char*) ""; // Sql_alloc has set error flag
  328.       if (!found_escape)
  329.       {
  330. lex->yytoklen=(uint) (end-str);
  331. memcpy(start,str,lex->yytoklen);
  332. start[lex->yytoklen]=0;
  333.       }
  334.       else
  335.       {
  336. uchar *to;
  338.         /* Re-use found_escape for tracking state of escapes */
  339.         found_escape= 0;
  341. for (to=start ; str != end ; str++)
  342. {
  343. #ifdef USE_MB
  344.   int l;
  345.   if (use_mb(cs) &&
  346.               (l = my_ismbchar(cs,
  347.                                (const char *)str, (const char *)end))) {
  348.       while (l--)
  349.   *to++ = *str++;
  350.       str--;
  351.       continue;
  352.   }
  353. #endif
  354.   if (!found_escape && *str == '\' && str+1 != end)
  355.   {
  356.     switch(*++str) {
  357.     case 'n':
  358.       *to++='n';
  359.       break;
  360.     case 't':
  361.       *to++= 't';
  362.       break;
  363.     case 'r':
  364.       *to++ = 'r';
  365.       break;
  366.     case 'b':
  367.       *to++ = 'b';
  368.       break;
  369.     case '0':
  370.       *to++= 0; // Ascii null
  371.       break;
  372.     case 'Z': // ^Z must be escaped on Win32
  373.       *to++='32';
  374.       break;
  375.     case '_':
  376.     case '%':
  377.       *to++= '\'; // remember prefix for wildcard
  378.       /* Fall through */
  379.     default:
  380.               found_escape= 1;
  381.               str--;
  382.       break;
  383.     }
  384.   }
  385.   else if (!found_escape && *str == sep)
  386.           {
  387.             found_escape= 1;
  388.           }
  389.   else
  390.           {
  391.     *to++ = *str;
  392.             found_escape= 0;
  393.           }
  394. }
  395. *to=0;
  396. lex->yytoklen=(uint) (to-start);
  397.       }
  398.       return (char*) start;
  399.     }
  400.   }
  401.   return 0; // unexpected end of query
  402. }
  405. /*
  406. ** Calc type of integer; long integer, longlong integer or real.
  407. ** Returns smallest type that match the string.
  408. ** When using unsigned long long values the result is converted to a real
  409. ** because else they will be unexpected sign changes because all calculation
  410. ** is done with longlong or double.
  411. */
  413. static const char *long_str="2147483647";
  414. static const uint long_len=10;
  415. static const char *signed_long_str="-2147483648";
  416. static const char *longlong_str="9223372036854775807";
  417. static const uint longlong_len=19;
  418. static const char *signed_longlong_str="-9223372036854775808";
  419. static const uint signed_longlong_len=19;
  420. static const char *unsigned_longlong_str="18446744073709551615";
  421. static const uint unsigned_longlong_len=20;
  423. static inline uint int_token(const char *str,uint length)
  424. {
  425.   if (length < long_len) // quick normal case
  426.     return NUM;
  427.   bool neg=0;
  429.   if (*str == '+') // Remove sign and pre-zeros
  430.   {
  431.     str++; length--;
  432.   }
  433.   else if (*str == '-')
  434.   {
  435.     str++; length--;
  436.     neg=1;
  437.   }
  438.   while (*str == '0' && length)
  439.   {
  440.     str++; length --;
  441.   }
  442.   if (length < long_len)
  443.     return NUM;
  445.   uint smaller,bigger;
  446.   const char *cmp;
  447.   if (neg)
  448.   {
  449.     if (length == long_len)
  450.     {
  451.       cmp= signed_long_str+1;
  452.       smaller=NUM; // If <= signed_long_str
  453.       bigger=LONG_NUM; // If >= signed_long_str
  454.     }
  455.     else if (length < signed_longlong_len)
  456.       return LONG_NUM;
  457.     else if (length > signed_longlong_len)
  458.       return REAL_NUM;
  459.     else
  460.     {
  461.       cmp=signed_longlong_str+1;
  462.       smaller=LONG_NUM; // If <= signed_longlong_str
  463.       bigger=REAL_NUM;
  464.     }
  465.   }
  466.   else
  467.   {
  468.     if (length == long_len)
  469.     {
  470.       cmp= long_str;
  471.       smaller=NUM;
  472.       bigger=LONG_NUM;
  473.     }
  474.     else if (length < longlong_len)
  475.       return LONG_NUM;
  476.     else if (length > longlong_len)
  477.     {
  478.       if (length > unsigned_longlong_len)
  479. return REAL_NUM;
  480.       cmp=unsigned_longlong_str;
  481.       smaller=ULONGLONG_NUM;
  482.       bigger=REAL_NUM;
  483.     }
  484.     else
  485.     {
  486.       cmp=longlong_str;
  487.       smaller=LONG_NUM;
  488.       bigger= ULONGLONG_NUM;
  489.     }
  490.   }
  491.   while (*cmp && *cmp++ == *str++) ;
  492.   return ((uchar) str[-1] <= (uchar) cmp[-1]) ? smaller : bigger;
  493. }
  495. /*
  496.   yylex remember the following states from the following yylex()
  498.   - MY_LEX_EOQ Found end of query
  499.   - MY_LEX_OPERATOR_OR_IDENT Last state was an ident, text or number
  500. (which can't be followed by a signed number)
  501. */
  503. int yylex(void *arg, void *yythd)
  504. {
  505.   reg1 uchar c;
  506.   int tokval, result_state;
  507.   uint length;
  508.   enum my_lex_states state;
  509.   LEX *lex= ((THD *)yythd)->lex;
  510.   YYSTYPE *yylval=(YYSTYPE*) arg;
  511.   CHARSET_INFO *cs= ((THD *) yythd)->charset();
  512.   uchar *state_map= cs->state_map;
  513.   uchar *ident_map= cs->ident_map;
  515.   lex->yylval=yylval; // The global state
  516.   lex->tok_start=lex->tok_end=lex->ptr;
  517.   state=lex->next_state;
  518.   lex->next_state=MY_LEX_OPERATOR_OR_IDENT;
  519.   LINT_INIT(c);
  520.   for (;;)
  521.   {
  522.     switch (state) {
  523.     case MY_LEX_OPERATOR_OR_IDENT: // Next is operator or keyword
  524.     case MY_LEX_START: // Start of token
  525.       // Skip startspace
  526.       for (c=yyGet() ; (state_map[c] == MY_LEX_SKIP) ; c= yyGet())
  527.       {
  528. if (c == 'n')
  529.   lex->yylineno++;
  530.       }
  531.       lex->tok_start=lex->ptr-1; // Start of real token
  532.       state= (enum my_lex_states) state_map[c];
  533.       break;
  534.     case MY_LEX_ESCAPE:
  535.       if (yyGet() == 'N')
  536.       { // Allow N as shortcut for NULL
  537. yylval->lex_str.str=(char*) "\N";
  538. yylval->lex_str.length=2;
  539. return NULL_SYM;
  540.       }
  541.     case MY_LEX_CHAR: // Unknown or single char token
  542.     case MY_LEX_SKIP: // This should not happen
  543.       if (c == '-' && yyPeek() == '-' &&
  544.           (my_isspace(cs,yyPeek2()) || 
  545.            my_iscntrl(cs,yyPeek2())))
  546.       {
  547.         state=MY_LEX_COMMENT;
  548.         break;
  549.       }
  550.       yylval->lex_str.str=(char*) (lex->ptr=lex->tok_start);// Set to first chr
  551.       yylval->lex_str.length=1;
  552.       c=yyGet();
  553.       if (c != ')')
  554. lex->next_state= MY_LEX_START; // Allow signed numbers
  555.       if (c == ',')
  556. lex->tok_start=lex->ptr; // Let tok_start point at next item
  557.       /*
  558.         Check for a placeholder: it should not precede a possible identifier
  559.         because of binlogging: when a placeholder is replaced with
  560.         its value in a query for the binlog, the query must stay
  561.         grammatically correct.
  562.       */
  563.       else if (c == '?' && ((THD*) yythd)->command == COM_PREPARE &&
  564.                !ident_map[yyPeek()])
  565.         return(PARAM_MARKER);
  566.       return((int) c);
  568.     case MY_LEX_IDENT_OR_NCHAR:
  569.       if (yyPeek() != ''')
  570.       { // Found x'hex-number'
  571. state= MY_LEX_IDENT;
  572. break;
  573.       }
  574.       yyGet(); // Skip '
  575.       while ((c = yyGet()) && (c !=''')) ;
  576.       length=(lex->ptr - lex->tok_start); // Length of hexnum+3
  577.       if (c != ''')
  578.       {
  579. return(ABORT_SYM); // Illegal hex constant
  580.       }
  581.       yyGet(); // get_token makes an unget
  582.       yylval->lex_str=get_token(lex,length);
  583.       yylval->lex_str.str+=2; // Skip x'
  584.       yylval->lex_str.length-=3; // Don't count x' and last '
  585.       lex->yytoklen-=3;
  586.       return (NCHAR_STRING);
  588.     case MY_LEX_IDENT_OR_HEX:
  589.       if (yyPeek() == ''')
  590.       { // Found x'hex-number'
  591. state= MY_LEX_HEX_NUMBER;
  592. break;
  593.       }
  594.       /* Fall through */
  595.     case MY_LEX_IDENT_OR_BIN: // TODO: Add binary string handling
  596.     case MY_LEX_IDENT:
  597.       uchar *start;
  598. #if defined(USE_MB) && defined(USE_MB_IDENT)
  599.       if (use_mb(cs))
  600.       {
  601. result_state= IDENT_QUOTED;
  602.         if (my_mbcharlen(cs, yyGetLast()) > 1)
  603.         {
  604.           int l = my_ismbchar(cs,
  605.                               (const char *)lex->ptr-1,
  606.                               (const char *)lex->end_of_query);
  607.           if (l == 0) {
  608.             state = MY_LEX_CHAR;
  609.             continue;
  610.           }
  611.           lex->ptr += l - 1;
  612.         }
  613.         while (ident_map[c=yyGet()])
  614.         {
  615.           if (my_mbcharlen(cs, c) > 1)
  616.           {
  617.             int l;
  618.             if ((l = my_ismbchar(cs,
  619.                               (const char *)lex->ptr-1,
  620.                               (const char *)lex->end_of_query)) == 0)
  621.               break;
  622.             lex->ptr += l-1;
  623.           }
  624.         }
  625.       }
  626.       else
  627. #endif
  628.       {
  629.         for (result_state= c; ident_map[c= yyGet()]; result_state|= c);
  630.         /* If there were non-ASCII characters, mark that we must convert */
  631.         result_state= result_state & 0x80 ? IDENT_QUOTED : IDENT;
  632.       }
  633.       length= (uint) (lex->ptr - lex->tok_start)-1;
  634.       start= lex->ptr;
  635.       if (lex->ignore_space)
  636.       {
  637.         /*
  638.           If we find a space then this can't be an identifier. We notice this
  639.           below by checking start != lex->ptr.
  640.         */
  641.         for (; state_map[c] == MY_LEX_SKIP ; c= yyGet());
  642.       }
  643.       if (start == lex->ptr && c == '.' && ident_map[yyPeek()])
  644. lex->next_state=MY_LEX_IDENT_SEP;
  645.       else
  646.       { // '(' must follow directly if function
  647. yyUnget();
  648. if ((tokval = find_keyword(lex,length,c == '(')))
  649. {
  650.   lex->next_state= MY_LEX_START; // Allow signed numbers
  651.   return(tokval); // Was keyword
  652. }
  653. yySkip(); // next state does a unget
  654.       }
  655.       yylval->lex_str=get_token(lex,length);
  657.       /* 
  658.          Note: "SELECT _bla AS 'alias'"
  659.          _bla should be considered as a IDENT if charset haven't been found.
  660.          So we don't use MYF(MY_WME) with get_charset_by_csname to avoid 
  661.          producing an error.
  662.       */
  664.       if ((yylval->lex_str.str[0]=='_') && 
  665.           (lex->charset=get_charset_by_csname(yylval->lex_str.str+1,
  666.       MY_CS_PRIMARY,MYF(0))))
  667.         return(UNDERSCORE_CHARSET);
  668.       return(result_state); // IDENT or IDENT_QUOTED
  670.     case MY_LEX_IDENT_SEP: // Found ident and now '.'
  671.       yylval->lex_str.str=(char*) lex->ptr;
  672.       yylval->lex_str.length=1;
  673.       c=yyGet(); // should be '.'
  674.       lex->next_state= MY_LEX_IDENT_START;// Next is an ident (not a keyword)
  675.       if (!ident_map[yyPeek()]) // Probably ` or "
  676. lex->next_state= MY_LEX_START;
  677.       return((int) c);
  679.     case MY_LEX_NUMBER_IDENT: // number or ident which num-start
  680.       while (my_isdigit(cs,(c = yyGet()))) ;
  681.       if (!ident_map[c])
  682.       { // Can't be identifier
  683. state=MY_LEX_INT_OR_REAL;
  684. break;
  685.       }
  686.       if (c == 'e' || c == 'E')
  687.       {
  688. // The following test is written this way to allow numbers of type 1e1
  689. if (my_isdigit(cs,yyPeek()) || 
  690.             (c=(yyGet())) == '+' || c == '-')
  691. { // Allow 1E+10
  692.   if (my_isdigit(cs,yyPeek())) // Number must have digit after sign
  693.   {
  694.     yySkip();
  695.     while (my_isdigit(cs,yyGet())) ;
  696.     yylval->lex_str=get_token(lex,yyLength());
  697.     return(FLOAT_NUM);
  698.   }
  699. }
  700. yyUnget(); /* purecov: inspected */
  701.       }
  702.       else if (c == 'x' && (lex->ptr - lex->tok_start) == 2 &&
  703.   lex->tok_start[0] == '0' )
  704.       { // Varbinary
  705. while (my_isxdigit(cs,(c = yyGet()))) ;
  706. if ((lex->ptr - lex->tok_start) >= 4 && !ident_map[c])
  707. {
  708.   yylval->lex_str=get_token(lex,yyLength());
  709.   yylval->lex_str.str+=2; // Skip 0x
  710.   yylval->lex_str.length-=2;
  711.   lex->yytoklen-=2;
  712.   return (HEX_NUM);
  713. }
  714. yyUnget();
  715.       }
  716.       // fall through
  717.     case MY_LEX_IDENT_START: // We come here after '.'
  718.       result_state= IDENT;
  719. #if defined(USE_MB) && defined(USE_MB_IDENT)
  720.       if (use_mb(cs))
  721.       {
  722. result_state= IDENT_QUOTED;
  723.         while (ident_map[c=yyGet()])
  724.         {
  725.           if (my_mbcharlen(cs, c) > 1)
  726.           {
  727.             int l;
  728.             if ((l = my_ismbchar(cs,
  729.                                  (const char *)lex->ptr-1,
  730.                                  (const char *)lex->end_of_query)) == 0)
  731.               break;
  732.             lex->ptr += l-1;
  733.           }
  734.         }
  735.       }
  736.       else
  737. #endif
  738.       {
  739.         for (result_state=0; ident_map[c= yyGet()]; result_state|= c);
  740.         /* If there were non-ASCII characters, mark that we must convert */
  741.         result_state= result_state & 0x80 ? IDENT_QUOTED : IDENT;
  742.       }
  743.       if (c == '.' && ident_map[yyPeek()])
  744. lex->next_state=MY_LEX_IDENT_SEP;// Next is '.'
  746.       yylval->lex_str= get_token(lex,yyLength());
  747.       return(result_state);
  749.     case MY_LEX_USER_VARIABLE_DELIMITER: // Found quote char
  750.     {
  751.       uint double_quotes= 0;
  752.       char quote_char= c;                       // Used char
  753.       lex->tok_start=lex->ptr; // Skip first `
  754.       while ((c=yyGet()))
  755.       {
  756. int length;
  757. if ((length= my_mbcharlen(cs, c)) == 1)
  758. {
  759.   if (c == (uchar) NAMES_SEP_CHAR)
  760.     break; /* Old .frm format can't handle this char */
  761.   if (c == quote_char)
  762.   {
  763.     if (yyPeek() != quote_char)
  764.       break;
  765.     c=yyGet();
  766.     double_quotes++;
  767.     continue;
  768.   }
  769. }
  770. #ifdef USE_MB
  771. else if (length < 1)
  772.   break; // Error
  773. lex->ptr+= length-1;
  774. #endif
  775.       }
  776.       if (double_quotes)
  777. yylval->lex_str=get_quoted_token(lex,yyLength() - double_quotes,
  778.  quote_char);
  779.       else
  780. yylval->lex_str=get_token(lex,yyLength());
  781.       if (c == quote_char)
  782. yySkip(); // Skip end `
  783.       lex->next_state= MY_LEX_START;
  784.       return(IDENT_QUOTED);
  785.     }
  786.     case MY_LEX_INT_OR_REAL: // Compleat int or incompleat real
  787.       if (c != '.')
  788.       { // Found complete integer number.
  789. yylval->lex_str=get_token(lex,yyLength());
  790. return int_token(yylval->lex_str.str,yylval->lex_str.length);
  791.       }
  792.       // fall through
  793.     case MY_LEX_REAL: // Incomplete real number
  794.       while (my_isdigit(cs,c = yyGet())) ;
  796.       if (c == 'e' || c == 'E')
  797.       {
  798. c = yyGet();
  799. if (c == '-' || c == '+')
  800.   c = yyGet(); // Skip sign
  801. if (!my_isdigit(cs,c))
  802. { // No digit after sign
  803.   state= MY_LEX_CHAR;
  804.   break;
  805. }
  806. while (my_isdigit(cs,yyGet())) ;
  807. yylval->lex_str=get_token(lex,yyLength());
  808. return(FLOAT_NUM);
  809.       }
  810.       yylval->lex_str=get_token(lex,yyLength());
  811.       return(REAL_NUM);
  813.     case MY_LEX_HEX_NUMBER: // Found x'hexstring'
  814.       yyGet(); // Skip '
  815.       while (my_isxdigit(cs,(c = yyGet()))) ;
  816.       length=(lex->ptr - lex->tok_start); // Length of hexnum+3
  817.       if (!(length & 1) || c != ''')
  818.       {
  819. return(ABORT_SYM); // Illegal hex constant
  820.       }
  821.       yyGet(); // get_token makes an unget
  822.       yylval->lex_str=get_token(lex,length);
  823.       yylval->lex_str.str+=2; // Skip x'
  824.       yylval->lex_str.length-=3; // Don't count x' and last '
  825.       lex->yytoklen-=3;
  826.       return (HEX_NUM);
  828.     case MY_LEX_CMP_OP: // Incomplete comparison operator
  829.       if (state_map[yyPeek()] == MY_LEX_CMP_OP ||
  830.   state_map[yyPeek()] == MY_LEX_LONG_CMP_OP)
  831. yySkip();
  832.       if ((tokval = find_keyword(lex,(uint) (lex->ptr - lex->tok_start),0)))
  833.       {
  834. lex->next_state= MY_LEX_START; // Allow signed numbers
  835. return(tokval);
  836.       }
  837.       state = MY_LEX_CHAR; // Something fishy found
  838.       break;
  840.     case MY_LEX_LONG_CMP_OP: // Incomplete comparison operator
  841.       if (state_map[yyPeek()] == MY_LEX_CMP_OP ||
  842.   state_map[yyPeek()] == MY_LEX_LONG_CMP_OP)
  843.       {
  844. yySkip();
  845. if (state_map[yyPeek()] == MY_LEX_CMP_OP)
  846.   yySkip();
  847.       }
  848.       if ((tokval = find_keyword(lex,(uint) (lex->ptr - lex->tok_start),0)))
  849.       {
  850. lex->next_state= MY_LEX_START; // Found long op
  851. return(tokval);
  852.       }
  853.       state = MY_LEX_CHAR; // Something fishy found
  854.       break;
  856.     case MY_LEX_BOOL:
  857.       if (c != yyPeek())
  858.       {
  859. state=MY_LEX_CHAR;
  860. break;
  861.       }
  862.       yySkip();
  863.       tokval = find_keyword(lex,2,0); // Is a bool operator
  864.       lex->next_state= MY_LEX_START; // Allow signed numbers
  865.       return(tokval);
  867.     case MY_LEX_STRING_OR_DELIMITER:
  868.       if (((THD *) yythd)->variables.sql_mode & MODE_ANSI_QUOTES)
  869.       {
  870. state= MY_LEX_USER_VARIABLE_DELIMITER;
  871. break;
  872.       }
  873.       /* " used for strings */
  874.     case MY_LEX_STRING: // Incomplete text string
  875.       if (!(yylval->lex_str.str = get_text(lex)))
  876.       {
  877. state= MY_LEX_CHAR; // Read char by char
  878. break;
  879.       }
  880.       yylval->lex_str.length=lex->yytoklen;
  881.       return(TEXT_STRING);
  883.     case MY_LEX_COMMENT: //  Comment
  884.       lex->select_lex.options|= OPTION_FOUND_COMMENT;
  885.       while ((c = yyGet()) != 'n' && c) ;
  886.       yyUnget(); // Safety against eof
  887.       state = MY_LEX_START; // Try again
  888.       break;
  889.     case MY_LEX_LONG_COMMENT: /* Long C comment? */
  890.       if (yyPeek() != '*')
  891.       {
  892. state=MY_LEX_CHAR; // Probable division
  893. break;
  894.       }
  895.       yySkip(); // Skip '*'
  896.       lex->select_lex.options|= OPTION_FOUND_COMMENT;
  897.       if (yyPeek() == '!') // MySQL command in comment
  898.       {
  899. ulong version=MYSQL_VERSION_ID;
  900. yySkip();
  901. state=MY_LEX_START;
  902. if (my_isdigit(cs,yyPeek()))
  903. { // Version number
  904.   version=strtol((char*) lex->ptr,(char**) &lex->ptr,10);
  905. }
  906. if (version <= MYSQL_VERSION_ID)
  907. {
  908.   lex->in_comment=1;
  909.   break;
  910. }
  911.       }
  912.       while (lex->ptr != lex->end_of_query &&
  913.      ((c=yyGet()) != '*' || yyPeek() != '/'))
  914.       {
  915. if (c == 'n')
  916.   lex->yylineno++;
  917.       }
  918.       if (lex->ptr != lex->end_of_query)
  919. yySkip(); // remove last '/'
  920.       state = MY_LEX_START; // Try again
  921.       break;
  922.     case MY_LEX_END_LONG_COMMENT:
  923.       if (lex->in_comment && yyPeek() == '/')
  924.       {
  925. yySkip();
  926. lex->in_comment=0;
  927. state=MY_LEX_START;
  928.       }
  929.       else
  930. state=MY_LEX_CHAR; // Return '*'
  931.       break;
  932.     case MY_LEX_SET_VAR: // Check if ':='
  933.       if (yyPeek() != '=')
  934.       {
  935. state=MY_LEX_CHAR; // Return ':'
  936. break;
  937.       }
  938.       yySkip();
  939.       return (SET_VAR);
  940.     case MY_LEX_SEMICOLON: // optional line terminator
  941.       if (yyPeek())
  942.       {
  943.         THD* thd= (THD*)yythd;
  944.         if ((thd->client_capabilities & CLIENT_MULTI_STATEMENTS) && 
  945.             (thd->command != COM_PREPARE))
  946.         {
  947.   lex->safe_to_cache_query=0;
  948.           lex->found_colon=(char*)lex->ptr;
  949.           thd->server_status |= SERVER_MORE_RESULTS_EXISTS;
  950.           lex->next_state=MY_LEX_END;
  951.           return(END_OF_INPUT);
  952.         }
  953.         else
  954.     state=MY_LEX_CHAR; // Return ';'
  955. break;
  956.       }
  957.       /* fall true */
  958.     case MY_LEX_EOL:
  959.       if (lex->ptr >= lex->end_of_query)
  960.       {
  961. lex->next_state=MY_LEX_END; // Mark for next loop
  962. return(END_OF_INPUT);
  963.       }
  964.       state=MY_LEX_CHAR;
  965.       break;
  966.     case MY_LEX_END:
  967.       lex->next_state=MY_LEX_END;
  968.       return(0); // We found end of input last time
  969.       
  970.       /* Actually real shouldn't start with . but allow them anyhow */
  971.     case MY_LEX_REAL_OR_POINT:
  972.       if (my_isdigit(cs,yyPeek()))
  973. state = MY_LEX_REAL; // Real
  974.       else
  975.       {
  976. state= MY_LEX_IDENT_SEP; // return '.'
  977. yyUnget(); // Put back '.'
  978.       }
  979.       break;
  980.     case MY_LEX_USER_END: // end '@' of user@hostname
  981.       switch (state_map[yyPeek()]) {
  982.       case MY_LEX_STRING:
  983.       case MY_LEX_USER_VARIABLE_DELIMITER:
  984.       case MY_LEX_STRING_OR_DELIMITER:
  985. break;
  986.       case MY_LEX_USER_END:
  987. lex->next_state=MY_LEX_SYSTEM_VAR;
  988. break;
  989.       default:
  990. lex->next_state=MY_LEX_HOSTNAME;
  991. break;
  992.       }
  993.       yylval->lex_str.str=(char*) lex->ptr;
  994.       yylval->lex_str.length=1;
  995.       return((int) '@');
  996.     case MY_LEX_HOSTNAME: // end '@' of user@hostname
  997.       for (c=yyGet() ; 
  998.    my_isalnum(cs,c) || c == '.' || c == '_' ||  c == '$';
  999.    c= yyGet()) ;
  1000.       yylval->lex_str=get_token(lex,yyLength());
  1001.       return(LEX_HOSTNAME);
  1002.     case MY_LEX_SYSTEM_VAR:
  1003.       yylval->lex_str.str=(char*) lex->ptr;
  1004.       yylval->lex_str.length=1;
  1005.       yySkip(); // Skip '@'
  1006.       lex->next_state= (state_map[yyPeek()] ==
  1007. MY_LEX_USER_VARIABLE_DELIMITER ?
  1008. MY_LEX_OPERATOR_OR_IDENT :
  1009. MY_LEX_IDENT_OR_KEYWORD);
  1010.       return((int) '@');
  1011.     case MY_LEX_IDENT_OR_KEYWORD:
  1012.       /*
  1013. We come here when we have found two '@' in a row.
  1014. We should now be able to handle:
  1015. [(global | local | session) .]variable_name
  1016.       */
  1017.       
  1018.       for (result_state= 0; ident_map[c= yyGet()]; result_state|= c);
  1019.       /* If there were non-ASCII characters, mark that we must convert */
  1020.       result_state= result_state & 0x80 ? IDENT_QUOTED : IDENT;
  1021.       
  1022.       if (c == '.')
  1023. lex->next_state=MY_LEX_IDENT_SEP;
  1024.       length= (uint) (lex->ptr - lex->tok_start)-1;
  1025.       if ((tokval= find_keyword(lex,length,0)))
  1026.       {
  1027. yyUnget(); // Put back 'c'
  1028. return(tokval); // Was keyword
  1029.       }
  1030.       yylval->lex_str=get_token(lex,length);
  1031.       return(result_state);
  1032.     }
  1033.   }
  1034. }
  1036. /*
  1037.   st_select_lex structures initialisations
  1038. */
  1040. void st_select_lex_node::init_query()
  1041. {
  1042.   options= 0;
  1043.   linkage= UNSPECIFIED_TYPE;
  1044.   no_error= no_table_names_allowed= 0;
  1045.   uncacheable= 0;
  1046. }
  1048. void st_select_lex_node::init_select()
  1049. {
  1050. }
  1052. void st_select_lex_unit::init_query()
  1053. {
  1054.   st_select_lex_node::init_query();
  1055.   linkage= GLOBAL_OPTIONS_TYPE;
  1056.   global_parameters= first_select();
  1057.   select_limit_cnt= HA_POS_ERROR;
  1058.   offset_limit_cnt= 0;
  1059.   union_distinct= 0;
  1060.   prepared= optimized= executed= 0;
  1061.   item= 0;
  1062.   union_result= 0;
  1063.   table= 0;
  1064.   fake_select_lex= 0;
  1065.   cleaned= 0;
  1066.   item_list.empty();
  1067.   describe= 0;
  1068. }
  1070. void st_select_lex::init_query()
  1071. {
  1072.   st_select_lex_node::init_query();
  1073.   table_list.empty();
  1074.   item_list.empty();
  1075.   join= 0;
  1076.   where= 0;
  1077.   olap= UNSPECIFIED_OLAP_TYPE;
  1078.   having_fix_field= 0;
  1079.   resolve_mode= NOMATTER_MODE;
  1080.   cond_count= with_wild= 0;
  1081.   ref_pointer_array= 0;
  1082.   select_n_having_items= 0;
  1083.   prep_where= 0;
  1084.   subquery_in_having= explicit_limit= 0;
  1085.   parsing_place= NO_MATTER;
  1086.   is_item_list_lookup= 0;
  1087. }
  1089. void st_select_lex::init_select()
  1090. {
  1091.   st_select_lex_node::init_select();
  1092.   group_list.empty();
  1093.   type= db= db1= table1= db2= table2= 0;
  1094.   having= 0;
  1095.   use_index_ptr= ignore_index_ptr= 0;
  1096.   table_join_options= 0;
  1097.   in_sum_expr= with_wild= 0;
  1098.   options= 0;
  1099.   braces= 0;
  1100.   when_list.empty();
  1101.   expr_list.empty();
  1102.   interval_list.empty();
  1103.   use_index.empty();
  1104.   ftfunc_list_alloc.empty();
  1105.   ftfunc_list= &ftfunc_list_alloc;
  1106.   linkage= UNSPECIFIED_TYPE;
  1107.   order_list.elements= 0;
  1108.   order_list.first= 0;
  1109.   order_list.next= (byte**) &order_list.first;
  1110.   select_limit= HA_POS_ERROR;
  1111.   offset_limit= 0;
  1112.   with_sum_func= 0;
  1114. }
  1116. /*
  1117.   st_select_lex structures linking
  1118. */
  1120. /* include on level down */
  1121. void st_select_lex_node::include_down(st_select_lex_node *upper)
  1122. {
  1123.   if ((next= upper->slave))
  1124.     next->prev= &next;
  1125.   prev= &upper->slave;
  1126.   upper->slave= this;
  1127.   master= upper;
  1128.   slave= 0;
  1129. }
  1131. /*
  1132.   include on level down (but do not link)
  1134.   SYNOPSYS
  1135.     st_select_lex_node::include_standalone()
  1136.     upper - reference on node underr which this node should be included
  1137.     ref - references on reference on this node
  1138. */
  1139. void st_select_lex_node::include_standalone(st_select_lex_node *upper,
  1140.     st_select_lex_node **ref)
  1141. {
  1142.   next= 0;
  1143.   prev= ref;
  1144.   master= upper;
  1145.   slave= 0;
  1146. }
  1148. /* include neighbour (on same level) */
  1149. void st_select_lex_node::include_neighbour(st_select_lex_node *before)
  1150. {
  1151.   if ((next= before->next))
  1152.     next->prev= &next;
  1153.   prev= &before->next;
  1154.   before->next= this;
  1155.   master= before->master;
  1156.   slave= 0;
  1157. }
  1159. /* including in global SELECT_LEX list */
  1160. void st_select_lex_node::include_global(st_select_lex_node **plink)
  1161. {
  1162.   if ((link_next= *plink))
  1163.     link_next->link_prev= &link_next;
  1164.   link_prev= plink;
  1165.   *plink= this;
  1166. }
  1168. //excluding from global list (internal function)
  1169. void st_select_lex_node::fast_exclude()
  1170. {
  1171.   if (link_prev)
  1172.   {
  1173.     if ((*link_prev= link_next))
  1174.       link_next->link_prev= link_prev;
  1175.   }
  1176.   // Remove slave structure
  1177.   for (; slave; slave= slave->next)
  1178.     slave->fast_exclude();
  1179.   
  1180. }
  1182. /*
  1183.   excluding select_lex structure (except first (first select can't be
  1184.   deleted, because it is most upper select))
  1185. */
  1186. void st_select_lex_node::exclude()
  1187. {
  1188.   //exclude from global list
  1189.   fast_exclude();
  1190.   //exclude from other structures
  1191.   if ((*prev= next))
  1192.     next->prev= prev;
  1193.   /* 
  1194.      We do not need following statements, because prev pointer of first 
  1195.      list element point to master->slave
  1196.      if (master->slave == this)
  1197.        master->slave= next;
  1198.   */
  1199. }
  1202. /*
  1203.   Exclude level of current unit from tree of SELECTs
  1205.   SYNOPSYS
  1206.     st_select_lex_unit::exclude_level()
  1208.   NOTE: units which belong to current will be brought up on level of
  1209.   currernt unit 
  1210. */
  1211. void st_select_lex_unit::exclude_level()
  1212. {
  1213.   SELECT_LEX_UNIT *units= 0, **units_last= &units;
  1214.   for (SELECT_LEX *sl= first_select(); sl; sl= sl->next_select())
  1215.   {
  1216.     // unlink current level from global SELECTs list
  1217.     if (sl->link_prev && (*sl->link_prev= sl->link_next))
  1218.       sl->link_next->link_prev= sl->link_prev;
  1220.     // bring up underlay levels
  1221.     SELECT_LEX_UNIT **last= 0;
  1222.     for (SELECT_LEX_UNIT *u= sl->first_inner_unit(); u; u= u->next_unit())
  1223.     {
  1224.       u->master= master;
  1225.       last= (SELECT_LEX_UNIT**)&(u->next);
  1226.     }
  1227.     if (last)
  1228.     {
  1229.       (*units_last)= sl->first_inner_unit();
  1230.       units_last= last;
  1231.     }
  1232.   }
  1233.   if (units)
  1234.   {
  1235.     // include brought up levels in place of current
  1236.     (*prev)= units;
  1237.     (*units_last)= (SELECT_LEX_UNIT*)next;
  1238.     if (next)
  1239.       next->prev= (SELECT_LEX_NODE**)units_last;
  1240.     units->prev= prev;
  1241.   }
  1242.   else
  1243.   {
  1244.     // exclude currect unit from list of nodes
  1245.     (*prev)= next;
  1246.     if (next)
  1247.       next->prev= prev;
  1248.   }
  1249. }
  1252. /*
  1253.   Exclude subtree of current unit from tree of SELECTs
  1255.   SYNOPSYS
  1256.     st_select_lex_unit::exclude_tree()
  1257. */
  1258. void st_select_lex_unit::exclude_tree()
  1259. {
  1260.   for (SELECT_LEX *sl= first_select(); sl; sl= sl->next_select())
  1261.   {
  1262.     // unlink current level from global SELECTs list
  1263.     if (sl->link_prev && (*sl->link_prev= sl->link_next))
  1264.       sl->link_next->link_prev= sl->link_prev;
  1266.     // unlink underlay levels
  1267.     for (SELECT_LEX_UNIT *u= sl->first_inner_unit(); u; u= u->next_unit())
  1268.     {
  1269.       u->exclude_level();
  1270.     }
  1271.   }
  1272.   // exclude currect unit from list of nodes
  1273.   (*prev)= next;
  1274.   if (next)
  1275.     next->prev= prev;
  1276. }
  1279. /*
  1280.   st_select_lex_node::mark_as_dependent mark all st_select_lex struct from 
  1281.   this to 'last' as dependent
  1283.   SYNOPSIS
  1284.     last - pointer to last st_select_lex struct, before wich all 
  1285.            st_select_lex have to be marked as dependent
  1287.   NOTE
  1288.     'last' should be reachable from this st_select_lex_node
  1289. */
  1291. void st_select_lex::mark_as_dependent(SELECT_LEX *last)
  1292. {
  1293.   /*
  1294.     Mark all selects from resolved to 1 before select where was
  1295.     found table as depended (of select where was found table)
  1296.   */
  1297.   for (SELECT_LEX *s= this;
  1298.        s && s != last;
  1299.        s= s->outer_select())
  1300.     if (!(s->uncacheable & UNCACHEABLE_DEPENDENT))
  1301.     {
  1302.       // Select is dependent of outer select
  1303.       s->uncacheable|= UNCACHEABLE_DEPENDENT;
  1304.       SELECT_LEX_UNIT *munit= s->master_unit();
  1305.       munit->uncacheable|= UNCACHEABLE_DEPENDENT;
  1306.     }
  1307. }
  1309. bool st_select_lex_node::set_braces(bool value)      { return 1; }
  1310. bool st_select_lex_node::inc_in_sum_expr()           { return 1; }
  1311. uint st_select_lex_node::get_in_sum_expr()           { return 0; }
  1312. TABLE_LIST* st_select_lex_node::get_table_list()     { return 0; }
  1313. List<Item>* st_select_lex_node::get_item_list()      { return 0; }
  1314. List<String>* st_select_lex_node::get_use_index()    { return 0; }
  1315. List<String>* st_select_lex_node::get_ignore_index() { return 0; }
  1316. TABLE_LIST *st_select_lex_node::add_table_to_list(THD *thd, Table_ident *table,
  1317.   LEX_STRING *alias,
  1318.   ulong table_join_options,
  1319.   thr_lock_type flags,
  1320.   List<String> *use_index,
  1321.   List<String> *ignore_index,
  1322.                                                   LEX_STRING *option)
  1323. {
  1324.   return 0;
  1325. }
  1326. ulong st_select_lex_node::get_table_join_options()
  1327. {
  1328.   return 0;
  1329. }
  1331. /*
  1332.   prohibit using LIMIT clause
  1333. */
  1334. bool st_select_lex::test_limit()
  1335. {
  1336.   if (select_limit != HA_POS_ERROR)
  1337.   {
  1338.     my_error(ER_NOT_SUPPORTED_YET, MYF(0),
  1339.          "LIMIT & IN/ALL/ANY/SOME subquery");
  1340.     return(1);
  1341.   }
  1342.   // We need only 1 row to determinate existence
  1343.   select_limit= 1;
  1344.   // no sense in ORDER BY without LIMIT
  1345.   order_list.empty();
  1346.   return(0);
  1347. }
  1349. /*  
  1350.   Interface method of table list creation for query
  1351.   
  1352.   SYNOPSIS
  1353.     st_select_lex_unit::create_total_list()
  1354.     thd            THD pointer
  1355.     result         pointer on result list of tables pointer
  1356.     check_derived  force derived table chacking (used for creating 
  1357.                    table list for derived query)
  1358.   DESCRIPTION
  1359.     This is used for UNION & subselect to create a new table list of all used 
  1360.     tables.
  1361.     The table_list->table entry in all used tables are set to point
  1362.     to the entries in this list.
  1364.   RETURN
  1365.     0 - OK
  1366.     !0 - error
  1367. */
  1368. bool st_select_lex_unit::create_total_list(THD *thd_arg, st_lex *lex,
  1369.    TABLE_LIST **result_arg)
  1370. {
  1371.   *result_arg= 0;
  1372.   if (!(res= create_total_list_n_last_return(thd_arg, lex, &result_arg)))
  1373.   {
  1374.     /*
  1375.       If time zone tables were used implicitly in statement we should add
  1376.       them to global table list.
  1377.     */
  1378.     if (lex->time_zone_tables_used)
  1379.     {
  1380.       /*
  1381.         Altough we are modifying lex data, it won't raise any problem in
  1382.         case when this lex belongs to some prepared statement or stored
  1383.         procedure: such modification does not change any invariants imposed
  1384.         by requirement to reuse the same lex for multiple executions.
  1385.       */
  1386.       if ((lex->time_zone_tables_used= my_tz_get_table_list(thd)) !=
  1387.           &fake_time_zone_tables_list)
  1388.       {
  1389.         *result_arg= lex->time_zone_tables_used;
  1390.       }
  1391.       else
  1392.       {
  1393.         send_error(thd, 0);
  1394.         res= 1;
  1395.       }
  1396.     }
  1397.   }
  1398.   return res;
  1399. }
  1401. /*  
  1402.   Table list creation for query
  1403.   
  1404.   SYNOPSIS
  1405.     st_select_lex_unit::create_total_list()
  1406.     thd            THD pointer
  1407.     lex            pointer on LEX stricture
  1408.     result         pointer on pointer on result list of tables pointer
  1410.   DESCRIPTION
  1411.     This is used for UNION & subselect to create a new table list of all used 
  1412.     tables.
  1413.     The table_list->table_list in all tables of global list are set to point
  1414.     to the local SELECT_LEX entries.
  1416.   RETURN
  1417.     0 - OK
  1418.     !0 - error
  1419. */
  1420. bool st_select_lex_unit::
  1421. create_total_list_n_last_return(THD *thd_arg,
  1422. st_lex *lex,
  1423. TABLE_LIST ***result_arg)
  1424. {
  1425.   TABLE_LIST *slave_list_first=0, **slave_list_last= &slave_list_first;
  1426.   TABLE_LIST **new_table_list= *result_arg, *aux;
  1427.   SELECT_LEX *sl= (SELECT_LEX*)slave;
  1428.   
  1429.   /*
  1430.     iterate all inner selects + fake_select (if exists),
  1431.     fake_select->next_select() always is 0
  1432.   */
  1433.   for (;
  1434.        sl;
  1435.        sl= (sl->next_select() ?
  1436.     sl->next_select() :
  1437.     (sl == fake_select_lex ?
  1438.      0 :
  1439.      fake_select_lex)))
  1440.   {
  1441.     // check usage of ORDER BY in union
  1442.     if (sl->order_list.first && sl->next_select() && !sl->braces &&
  1443. sl->linkage != GLOBAL_OPTIONS_TYPE)
  1444.     {
  1445.       net_printf(thd_arg,ER_WRONG_USAGE,"UNION","ORDER BY");
  1446.       return 1;
  1447.     }
  1449.     for (SELECT_LEX_UNIT *inner=  sl->first_inner_unit();
  1450.  inner;
  1451.  inner= inner->next_unit())
  1452.     {
  1453.       if (inner->create_total_list_n_last_return(thd, lex,
  1454.  &slave_list_last))
  1455. return 1;
  1456.     }
  1458.     if ((aux= (TABLE_LIST*) sl->table_list.first))
  1459.     {
  1460.       TABLE_LIST *next_table;
  1461.       for (; aux; aux= next_table)
  1462.       {
  1463. TABLE_LIST *cursor;
  1464. next_table= aux->next;
  1465. /* Add to the total table list */
  1466. if (!(cursor= (TABLE_LIST *) thd->memdup((char*) aux,
  1467.  sizeof(*aux))))
  1468. {
  1469.   send_error(thd,0);
  1470.   return 1;
  1471. }
  1472. *new_table_list= cursor;
  1473. cursor->table_list= aux;
  1474. new_table_list= &cursor->next;
  1475. *new_table_list= 0; // end result list
  1476. aux->table_list= cursor;
  1477.       }
  1478.     }
  1479.   }
  1481.   if (slave_list_first)
  1482.   {
  1483.     *new_table_list= slave_list_first;
  1484.     new_table_list= slave_list_last;
  1485.   }
  1486.   *result_arg= new_table_list;
  1487.   return 0;
  1488. }
  1491. st_select_lex_unit* st_select_lex_unit::master_unit()
  1492. {
  1493.     return this;
  1494. }
  1497. st_select_lex* st_select_lex_unit::outer_select()
  1498. {
  1499.   return (st_select_lex*) master;
  1500. }
  1503. bool st_select_lex::add_order_to_list(THD *thd, Item *item, bool asc)
  1504. {
  1505.   return add_to_list(thd, order_list, item, asc);
  1506. }
  1509. bool st_select_lex::add_item_to_list(THD *thd, Item *item)
  1510. {
  1511.   return item_list.push_back(item);
  1512. }
  1515. bool st_select_lex::add_group_to_list(THD *thd, Item *item, bool asc)
  1516. {
  1517.   return add_to_list(thd, group_list, item, asc);
  1518. }
  1521. bool st_select_lex::add_ftfunc_to_list(Item_func_match *func)
  1522. {
  1523.   return !func || ftfunc_list->push_back(func); // end of memory?
  1524. }
  1527. st_select_lex_unit* st_select_lex::master_unit()
  1528. {
  1529.   return (st_select_lex_unit*) master;
  1530. }
  1533. st_select_lex* st_select_lex::outer_select()
  1534. {
  1535.   return (st_select_lex*) master->get_master();
  1536. }
  1539. bool st_select_lex::set_braces(bool value)
  1540. {
  1541.   braces= value;
  1542.   return 0; 
  1543. }
  1546. bool st_select_lex::inc_in_sum_expr()
  1547. {
  1548.   in_sum_expr++;
  1549.   return 0;
  1550. }
  1553. uint st_select_lex::get_in_sum_expr()
  1554. {
  1555.   return in_sum_expr;
  1556. }
  1559. TABLE_LIST* st_select_lex::get_table_list()
  1560. {
  1561.   return (TABLE_LIST*) table_list.first;
  1562. }
  1564. List<Item>* st_select_lex::get_item_list()
  1565. {
  1566.   return &item_list;
  1567. }
  1570. List<String>* st_select_lex::get_use_index()
  1571. {
  1572.   return use_index_ptr;
  1573. }
  1576. List<String>* st_select_lex::get_ignore_index()
  1577. {
  1578.   return ignore_index_ptr;
  1579. }
  1582. ulong st_select_lex::get_table_join_options()
  1583. {
  1584.   return table_join_options;
  1585. }
  1588. bool st_select_lex::setup_ref_array(THD *thd, uint order_group_num)
  1589. {
  1590.   if (ref_pointer_array)
  1591.     return 0;
  1593.   /*
  1594.     We have to create array in prepared statement memory if it is
  1595.     prepared statement
  1596.   */
  1597.   Item_arena *arena= thd->current_arena;
  1598.   return (ref_pointer_array= 
  1599.   (Item **)arena->alloc(sizeof(Item*) *
  1600.        (item_list.elements +
  1601. select_n_having_items +
  1602. order_group_num)* 5)) == 0;
  1603. }
  1606. /*
  1607.   Find db.table which will be updated in this unit
  1609.   SYNOPSIS
  1610.     st_select_lex_unit::check_updateable()
  1611.     db - data base name
  1612.     table - real table name
  1614.   RETURN
  1615.     1 - found
  1616.     0 - OK (table did not found)
  1617. */
  1619. bool st_select_lex_unit::check_updateable(char *db, char *table)
  1620. {
  1621.   for (SELECT_LEX *sl= first_select(); sl; sl= sl->next_select())
  1622.     if (sl->check_updateable(db, table))
  1623.       return 1;
  1624.   return 0;
  1625. }
  1628. /*
  1629.   Find db.table which will be updated in this select and
  1630.   underlying ones (except derived tables)
  1632.   SYNOPSIS
  1633.     st_select_lex::check_updateable()
  1634.     db - data base name
  1635.     table - real table name
  1637.   RETURN
  1638.     1 - found
  1639.     0 - OK (table did not found)
  1640. */
  1642. bool st_select_lex::check_updateable(char *db, char *table)
  1643. {
  1644.   if (find_real_table_in_list(get_table_list(), db, table))
  1645.     return 1;
  1647.   return check_updateable_in_subqueries(db, table);
  1648. }
  1650. /*
  1651.    Find db.table which will be updated in underlying subqueries
  1653.    SYNOPSIS
  1654.     st_select_lex::check_updateable_in_subqueries()
  1655.     db - data base name
  1656.     table - real table name
  1658.   RETURN
  1659.     1 - found
  1660.     0 - OK (table did not found)
  1661. */
  1663. bool st_select_lex::check_updateable_in_subqueries(char *db, char *table)
  1664. {
  1665.   for (SELECT_LEX_UNIT *un= first_inner_unit();
  1666.        un;
  1667.        un= un->next_unit())
  1668.   {
  1669.     if (un->first_select()->linkage != DERIVED_TABLE_TYPE &&
  1670. un->check_updateable(db, table))
  1671.       return 1;
  1672.   }
  1673.   return 0;
  1674. }
  1677. void st_select_lex_unit::print(String *str)
  1678. {
  1679.   for (SELECT_LEX *sl= first_select(); sl; sl= sl->next_select())
  1680.   {
  1681.     if (sl != first_select())
  1682.     {
  1683.       str->append(" union ", 7);
  1684.       if (!union_distinct)
  1685. str->append("all ", 4);
  1686.     }
  1687.     if (sl->braces)
  1688.       str->append('(');
  1689.     sl->print(thd, str);
  1690.     if (sl->braces)
  1691.       str->append(')');
  1692.   }
  1693.   if (fake_select_lex == global_parameters)
  1694.   {
  1695.     if (fake_select_lex->order_list.elements)
  1696.     {
  1697.       str->append(" order by ", 10);
  1698.       fake_select_lex->print_order(str,
  1699.    (ORDER *) fake_select_lex->
  1700.    order_list.first);
  1701.     }
  1702.     fake_select_lex->print_limit(thd, str);
  1703.   }
  1704. }
  1707. void st_select_lex::print_order(String *str, ORDER *order)
  1708. {
  1709.   for (; order; order= order->next)
  1710.   {
  1711.     (*order->item)->print(str);
  1712.     if (!order->asc)
  1713.       str->append(" desc", 5);
  1714.     if (order->next)
  1715.       str->append(',');
  1716.   }
  1717. }
  1718.  
  1720. void st_select_lex::print_limit(THD *thd, String *str)
  1721. {
  1722.   if (explicit_limit)
  1723.   {
  1724.     str->append(" limit ", 7);
  1725.     char buff[20];
  1726.     // latin1 is good enough for numbers
  1727.     String st(buff, sizeof(buff),  &my_charset_latin1);
  1728.     st.set((ulonglong)select_limit, &my_charset_latin1);
  1729.     str->append(st);
  1730.     if (offset_limit)
  1731.     {
  1732.       str->append(',');
  1733.       st.set((ulonglong)select_limit, &my_charset_latin1);
  1734.       str->append(st);
  1735.     }
  1736.   }
  1737. }
  1740. st_lex::st_lex()
  1741.   :result(0)
  1742. {}
  1745. /*
  1746.   Unlink first table from global table list and first table from outer select
  1747.   list (lex->select_lex)
  1749.   SYNOPSIS
  1750.     unlink_first_table()
  1751.     tables Global table list
  1752.     global_first Save first global table here
  1753.     local_first Save first local table here
  1755.   NOTES
  1756.     This function assumes that outer select list is non-empty.
  1758.   RETURN
  1759.     global list without first table
  1761. */
  1762. TABLE_LIST *st_lex::unlink_first_table(TABLE_LIST *tables,
  1763.        TABLE_LIST **global_first,
  1764.        TABLE_LIST **local_first)
  1765. {
  1766.   DBUG_ASSERT(select_lex.table_list.first != 0);
  1767.   /*
  1768.     Save pointers to first elements of global table list and list
  1769.     of tables used in outer select. It does not harm if these lists
  1770.     are the same.
  1771.   */
  1772.   *global_first= tables;
  1773.   *local_first= (TABLE_LIST*)select_lex.table_list.first;
  1775.   /* Exclude first elements from these lists */
  1776.   select_lex.table_list.first= (byte*) (*local_first)->next;
  1777.   tables= tables->next;
  1778.   (*global_first)->next= 0;
  1779.   return tables;
  1780. }
  1783. /*
  1784.   Link table which was unlinked with unlink_first_table() back.
  1786.   SYNOPSIS
  1787.     link_first_table_back()
  1788.     tables Global table list
  1789.     global_first Saved first global table
  1790.     local_first Saved first local table
  1792.   RETURN
  1793.     global list
  1794. */
  1795. TABLE_LIST *st_lex::link_first_table_back(TABLE_LIST *tables,
  1796.   TABLE_LIST *global_first,
  1797.   TABLE_LIST *local_first)
  1798. {
  1799.   global_first->next= tables;
  1800.   select_lex.table_list.first= (byte*) local_first;
  1801.   return global_first;
  1802. }
  1804. /*
  1805.   There are st_select_lex::add_table_to_list & 
  1806.   st_select_lex::set_lock_for_tables are in sql_parse.cc
  1808.   st_select_lex::print is in sql_select.h
  1810.   st_select_lex_unit::prepare, st_select_lex_unit::exec,
  1811.   st_select_lex_unit::cleanup, st_select_lex_unit::reinit_exec_mechanism,
  1812.   st_select_lex_unit::change_result
  1813.   are in sql_union.cc
  1814. */