sql_lex.h
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:24k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. /* YACC and LEX Definitions */
  14. /* These may not be declared yet */
  15. class Table_ident;
  16. class sql_exchange;
  17. class LEX_COLUMN;
  18. /*
  19.   The following hack is needed because mysql_yacc.cc does not define
  20.   YYSTYPE before including this file
  21. */
  22. #include "set_var.h"
  23. #ifdef MYSQL_YACC
  24. #define LEX_YYSTYPE void *
  25. #else
  26. #include "lex_symbol.h"
  27. #include "sql_yacc.h"
  28. #define LEX_YYSTYPE YYSTYPE *
  29. #endif
  30. /*
  31.   When a command is added here, be sure it's also added in mysqld.cc
  32.   in "struct show_var_st status_vars[]= {" ...
  33. */
  34. enum enum_sql_command {
  35.   SQLCOM_SELECT, SQLCOM_CREATE_TABLE, SQLCOM_CREATE_INDEX, SQLCOM_ALTER_TABLE,
  36.   SQLCOM_UPDATE, SQLCOM_INSERT, SQLCOM_INSERT_SELECT,
  37.   SQLCOM_DELETE, SQLCOM_TRUNCATE, SQLCOM_DROP_TABLE, SQLCOM_DROP_INDEX,
  38.   SQLCOM_SHOW_DATABASES, SQLCOM_SHOW_TABLES, SQLCOM_SHOW_FIELDS,
  39.   SQLCOM_SHOW_KEYS, SQLCOM_SHOW_VARIABLES, SQLCOM_SHOW_LOGS, SQLCOM_SHOW_STATUS,
  40.   SQLCOM_SHOW_INNODB_STATUS,SQLCOM_SHOW_NDBCLUSTER_STATUS,
  41.   SQLCOM_SHOW_PROCESSLIST, SQLCOM_SHOW_MASTER_STAT, SQLCOM_SHOW_SLAVE_STAT,
  42.   SQLCOM_SHOW_GRANTS, SQLCOM_SHOW_CREATE, SQLCOM_SHOW_CHARSETS,
  43.   SQLCOM_SHOW_COLLATIONS, SQLCOM_SHOW_CREATE_DB,
  44.   SQLCOM_LOAD,SQLCOM_SET_OPTION,SQLCOM_LOCK_TABLES,SQLCOM_UNLOCK_TABLES,
  45.   SQLCOM_GRANT,
  46.   SQLCOM_CHANGE_DB, SQLCOM_CREATE_DB, SQLCOM_DROP_DB, SQLCOM_ALTER_DB,
  47.   SQLCOM_REPAIR, SQLCOM_REPLACE, SQLCOM_REPLACE_SELECT,
  48.   SQLCOM_CREATE_FUNCTION, SQLCOM_DROP_FUNCTION,
  49.   SQLCOM_REVOKE,SQLCOM_OPTIMIZE, SQLCOM_CHECK, 
  50.   SQLCOM_ASSIGN_TO_KEYCACHE, SQLCOM_PRELOAD_KEYS,
  51.   SQLCOM_FLUSH, SQLCOM_KILL, SQLCOM_ANALYZE,
  52.   SQLCOM_ROLLBACK, SQLCOM_ROLLBACK_TO_SAVEPOINT,
  53.   SQLCOM_COMMIT, SQLCOM_SAVEPOINT,
  54.   SQLCOM_SLAVE_START, SQLCOM_SLAVE_STOP,
  55.   SQLCOM_BEGIN, SQLCOM_LOAD_MASTER_TABLE, SQLCOM_CHANGE_MASTER,
  56.   SQLCOM_RENAME_TABLE, SQLCOM_BACKUP_TABLE, SQLCOM_RESTORE_TABLE,
  57.   SQLCOM_RESET, SQLCOM_PURGE, SQLCOM_PURGE_BEFORE, SQLCOM_SHOW_BINLOGS,
  58.   SQLCOM_SHOW_OPEN_TABLES, SQLCOM_LOAD_MASTER_DATA,
  59.   SQLCOM_HA_OPEN, SQLCOM_HA_CLOSE, SQLCOM_HA_READ,
  60.   SQLCOM_SHOW_SLAVE_HOSTS, SQLCOM_DELETE_MULTI, SQLCOM_UPDATE_MULTI,
  61.   SQLCOM_SHOW_BINLOG_EVENTS, SQLCOM_SHOW_NEW_MASTER, SQLCOM_DO,
  62.   SQLCOM_SHOW_WARNS, SQLCOM_EMPTY_QUERY, SQLCOM_SHOW_ERRORS,
  63.   SQLCOM_SHOW_COLUMN_TYPES, SQLCOM_SHOW_STORAGE_ENGINES, SQLCOM_SHOW_PRIVILEGES,
  64.   SQLCOM_HELP, SQLCOM_DROP_USER, SQLCOM_REVOKE_ALL, SQLCOM_CHECKSUM,
  65.   SQLCOM_PREPARE, SQLCOM_EXECUTE, SQLCOM_DEALLOCATE_PREPARE,
  66.   /* This should be the last !!! */
  67.   SQLCOM_END
  68. };
  69. // describe/explain types
  70. #define DESCRIBE_NORMAL 1
  71. #define DESCRIBE_EXTENDED 2
  72. typedef List<Item> List_item;
  73. typedef struct st_lex_master_info
  74. {
  75.   char *host, *user, *password, *log_file_name;
  76.   uint port, connect_retry;
  77.   ulonglong pos;
  78.   ulong server_id;
  79.   /* 
  80.      Variable for MASTER_SSL option.
  81.      MASTER_SSL=0 in CHANGE MASTER TO corresponds to SSL_DISABLE
  82.      MASTER_SSL=1 corresponds to SSL_ENABLE
  83.   */
  84.   enum {SSL_UNCHANGED=0, SSL_DISABLE, SSL_ENABLE} ssl; 
  85.   char *ssl_key, *ssl_cert, *ssl_ca, *ssl_capath, *ssl_cipher;
  86.   char *relay_log_name;
  87.   ulong relay_log_pos;
  88. } LEX_MASTER_INFO;
  89. enum sub_select_type
  90. {
  91.   UNSPECIFIED_TYPE,UNION_TYPE, INTERSECT_TYPE,
  92.   EXCEPT_TYPE, GLOBAL_OPTIONS_TYPE, DERIVED_TABLE_TYPE, OLAP_TYPE
  93. };
  94. enum olap_type 
  95. {
  96.   UNSPECIFIED_OLAP_TYPE, CUBE_TYPE, ROLLUP_TYPE
  97. };
  98. enum tablespace_op_type
  99. {
  100.   NO_TABLESPACE_OP, DISCARD_TABLESPACE, IMPORT_TABLESPACE
  101. };
  102. /* 
  103.   The state of the lex parsing for selects 
  104.    
  105.    master and slaves are pointers to select_lex.
  106.    master is pointer to upper level node.
  107.    slave is pointer to lower level node
  108.    select_lex is a SELECT without union
  109.    unit is container of either
  110.      - One SELECT
  111.      - UNION of selects
  112.    select_lex and unit are both inherited form select_lex_node
  113.    neighbors are two select_lex or units on the same level
  114.    All select describing structures linked with following pointers:
  115.    - list of neighbors (next/prev) (prev of first element point to slave
  116.      pointer of upper structure)
  117.      - For select this is a list of UNION's (or one element list)
  118.      - For units this is a list of sub queries for the upper level select
  119.    - pointer to master (master), which is
  120.      If this is a unit
  121.        - pointer to outer select_lex
  122.      If this is a select_lex
  123.        - pointer to outer unit structure for select
  124.    - pointer to slave (slave), which is either:
  125.      If this is a unit:
  126.        - first SELECT that belong to this unit
  127.      If this is a select_lex
  128.        - first unit that belong to this SELECT (subquries or derived tables)
  129.    - list of all select_lex (link_next/link_prev)
  130.      This is to be used for things like derived tables creation, where we
  131.      go through this list and create the derived tables.
  132.    If unit contain several selects (UNION now, INTERSECT etc later)
  133.    then it have special select_lex called fake_select_lex. It used for
  134.    storing global parameters (like ORDER BY, LIMIT) and executing union.
  135.    Subqueries used in global ORDER BY clause will be attached to this
  136.    fake_select_lex, which will allow them correctly resolve fields of
  137.    'upper' UNION and outer selects.
  138.    For example for following query:
  139.    select *
  140.      from table1
  141.      where table1.field IN (select * from table1_1_1 union
  142.                             select * from table1_1_2)
  143.      union
  144.    select *
  145.      from table2
  146.      where table2.field=(select (select f1 from table2_1_1_1_1
  147.                                    where table2_1_1_1_1.f2=table2_1_1.f3)
  148.                            from table2_1_1
  149.                            where table2_1_1.f1=table2.f2)
  150.      union
  151.    select * from table3;
  152.    we will have following structure:
  153.    select1: (select * from table1 ...)
  154.    select2: (select * from table2 ...)
  155.    select3: (select * from table3)
  156.    select1.1.1: (select * from table1_1_1)
  157.    ...
  158.      main unit
  159.      fake0
  160.      select1 select2 select3
  161.      |^^     |^
  162.     s|||     ||master
  163.     l|||     |+---------------------------------+
  164.     a|||     +---------------------------------+|
  165.     v|||master                         slave   ||
  166.     e||+-------------------------+             ||
  167.      V|            neighbor      |             V|
  168.      unit1.1<+==================>unit1.2       unit2.1
  169.      fake1.1
  170.      select1.1.1 select 1.1.2    select1.2.1   select2.1.1
  171.                                                |^
  172.                                                ||
  173.                                                V|
  174.                                                unit2.1.1.1
  175.                                                select2.1.1.1.1
  176.    relation in main unit will be following:
  177.    (bigger picture for:
  178.       main unit
  179.       fake0
  180.       select1 select2 select3
  181.    in the above picture)
  182.          main unit
  183.          |^^^^|fake_select_lex
  184.          |||||+--------------------------------------------+
  185.          ||||+--------------------------------------------+|
  186.          |||+------------------------------+              ||
  187.          ||+--------------+                |              ||
  188.     slave||master         |                |              ||
  189.          V|      neighbor |       neighbor |        master|V
  190.          select1<========>select2<========>select3        fake0
  191.     list of all select_lex will be following (as it will be constructed by
  192.     parser):
  193.     select1->select2->select3->select2.1.1->select 2.1.2->select2.1.1.1.1-+
  194.                                                                           |
  195.     +---------------------------------------------------------------------+
  196.     |
  197.     +->select1.1.1->select1.1.2
  198. */
  199. /* 
  200.     Base class for st_select_lex (SELECT_LEX) & 
  201.     st_select_lex_unit (SELECT_LEX_UNIT)
  202. */
  203. struct st_lex;
  204. class st_select_lex;
  205. class st_select_lex_unit;
  206. class st_select_lex_node {
  207. protected:
  208.   st_select_lex_node *next, **prev,   /* neighbor list */
  209.     *master, *slave,                  /* vertical links */
  210.     *link_next, **link_prev;          /* list of whole SELECT_LEX */
  211. public:
  212.   ulong options;
  213.   /*
  214.     result of this query can't be cached, bit field, can be :
  215.       UNCACHEABLE_DEPENDENT
  216.       UNCACHEABLE_RAND
  217.       UNCACHEABLE_SIDEEFFECT
  218.       UNCACHEABLE_EXPLAIN
  219.       UNCACHEABLE_PREPARE
  220.   */
  221.   uint8 uncacheable;
  222.   enum sub_select_type linkage;
  223.   bool no_table_names_allowed; /* used for global order by */
  224.   bool no_error; /* suppress error message (convert it to warnings) */
  225.   static void *operator new(size_t size)
  226.   {
  227.     return (void*) sql_alloc((uint) size);
  228.   }
  229.   static void *operator new(size_t size, MEM_ROOT *mem_root)
  230.   { return (void*) alloc_root(mem_root, (uint) size); }
  231.   static void operator delete(void *ptr,size_t size) {}
  232.   static void operator delete(void *ptr, MEM_ROOT *mem_root) {}
  233.   st_select_lex_node(): linkage(UNSPECIFIED_TYPE) {}
  234.   virtual ~st_select_lex_node() {}
  235.   inline st_select_lex_node* get_master() { return master; }
  236.   virtual void init_query();
  237.   virtual void init_select();
  238.   void include_down(st_select_lex_node *upper);
  239.   void include_neighbour(st_select_lex_node *before);
  240.   void include_standalone(st_select_lex_node *sel, st_select_lex_node **ref);
  241.   void include_global(st_select_lex_node **plink);
  242.   void exclude();
  243.   virtual st_select_lex_unit* master_unit()= 0;
  244.   virtual st_select_lex* outer_select()= 0;
  245.   virtual st_select_lex* return_after_parsing()= 0;
  246.   virtual bool set_braces(bool value);
  247.   virtual bool inc_in_sum_expr();
  248.   virtual uint get_in_sum_expr();
  249.   virtual TABLE_LIST* get_table_list();
  250.   virtual List<Item>* get_item_list();
  251.   virtual List<String>* get_use_index();
  252.   virtual List<String>* get_ignore_index();
  253.   virtual ulong get_table_join_options();
  254.   virtual TABLE_LIST *add_table_to_list(THD *thd, Table_ident *table,
  255. LEX_STRING *alias,
  256. ulong table_options,
  257. thr_lock_type flags= TL_UNLOCK,
  258. List<String> *use_index= 0,
  259. List<String> *ignore_index= 0,
  260.                                         LEX_STRING *option= 0);
  261.   virtual void set_lock_for_tables(thr_lock_type lock_type) {}
  262.   friend class st_select_lex_unit;
  263.   friend bool mysql_new_select(struct st_lex *lex, bool move_down);
  264. private:
  265.   void fast_exclude();
  266. };
  267. typedef class st_select_lex_node SELECT_LEX_NODE;
  268. /* 
  269.    SELECT_LEX_UNIT - unit of selects (UNION, INTERSECT, ...) group 
  270.    SELECT_LEXs
  271. */
  272. struct st_lex;
  273. class THD;
  274. class select_result;
  275. class JOIN;
  276. class select_union;
  277. class Procedure;
  278. class st_select_lex_unit: public st_select_lex_node {
  279. protected:
  280.   TABLE_LIST result_table_list;
  281.   select_union *union_result;
  282.   TABLE *table; /* temporary table using for appending UNION results */
  283.   select_result *result;
  284.   int res;
  285.   ulong found_rows_for_union;
  286.   bool  prepared, // prepare phase already performed for UNION (unit)
  287.     optimized, // optimize phase already performed for UNION (unit)
  288.     executed, // already executed
  289.     cleaned;
  290. public:
  291.   // list of fields which points to temporary table for union
  292.   List<Item> item_list;
  293.   /*
  294.     list of types of items inside union (used for union & derived tables)
  295.     
  296.     Item_type_holders from which this list consist may have pointers to Field,
  297.     pointers is valid only after preparing SELECTS of this unit and before
  298.     any SELECT of this unit execution
  299.   */
  300.   List<Item> types;
  301.   /*
  302.     Pointer to 'last' select or pointer to unit where stored
  303.     global parameters for union
  304.   */
  305.   st_select_lex *global_parameters;
  306.   //node on wich we should return current_select pointer after parsing subquery
  307.   st_select_lex *return_to;
  308.   /* LIMIT clause runtime counters */
  309.   ha_rows select_limit_cnt, offset_limit_cnt;
  310.   /* not NULL if unit used in subselect, point to subselect item */
  311.   Item_subselect *item;
  312.   /* thread handler */
  313.   THD *thd;
  314.   /*
  315.     SELECT_LEX for hidden SELECT in onion which process global
  316.     ORDER BY and LIMIT
  317.   */
  318.   st_select_lex *fake_select_lex;
  319.   st_select_lex *union_distinct; /* pointer to the last UNION DISTINCT */
  320.   bool describe; /* union exec() called for EXPLAIN */
  321.   Procedure *last_procedure;  /* Pointer to procedure, if such exists */
  322.   void init_query();
  323.   bool create_total_list(THD *thd, st_lex *lex, TABLE_LIST **result);
  324.   st_select_lex_unit* master_unit();
  325.   st_select_lex* outer_select();
  326.   st_select_lex* first_select()
  327.   {
  328.     return my_reinterpret_cast(st_select_lex*)(slave);
  329.   }
  330.   st_select_lex* first_select_in_union() 
  331.   { 
  332.     return my_reinterpret_cast(st_select_lex*)(slave);
  333.   }
  334.   st_select_lex_unit* next_unit()
  335.   {
  336.     return my_reinterpret_cast(st_select_lex_unit*)(next);
  337.   }
  338.   st_select_lex* return_after_parsing() { return return_to; }
  339.   void exclude_level();
  340.   void exclude_tree();
  341.   /* UNION methods */
  342.   int prepare(THD *thd, select_result *result, ulong additional_options,
  343.               const char *tmp_table_alias);
  344.   int exec();
  345.   int cleanup();
  346.   inline void unclean() { cleaned= 0; }
  347.   void reinit_exec_mechanism();
  348.   bool check_updateable(char *db, char *table);
  349.   void print(String *str);
  350.   ulong init_prepare_fake_select_lex(THD *thd);
  351.   int change_result(select_subselect *result, select_subselect *old_result);
  352.   inline bool is_prepared() { return prepared; }
  353.   friend void lex_start(THD *thd, uchar *buf, uint length);
  354.   friend int subselect_union_engine::exec();
  355. private:
  356.   bool create_total_list_n_last_return(THD *thd, st_lex *lex,
  357.        TABLE_LIST ***result);
  358. };
  359. typedef class st_select_lex_unit SELECT_LEX_UNIT;
  360. /*
  361.   SELECT_LEX - store information of parsed SELECT statment
  362. */
  363. class st_select_lex: public st_select_lex_node
  364. {
  365. public:
  366.   char *db, *db1, *table1, *db2, *table2;       /* For outer join using .. */
  367.   Item *where, *having;                         /* WHERE & HAVING clauses */
  368.   Item *prep_where; /* saved WHERE clause for prepared statement processing */
  369.   enum olap_type olap;
  370.   SQL_LIST       table_list, group_list;   /* FROM & GROUP BY clauses */
  371.   List<Item>          item_list; /* list of fields & expressions */
  372.   List<String>        interval_list, use_index, *use_index_ptr,
  373.       ignore_index, *ignore_index_ptr;
  374.   bool               is_item_list_lookup;
  375.   /* 
  376.     Usualy it is pointer to ftfunc_list_alloc, but in union used to create fake
  377.     select_lex for calling mysql_select under results of union
  378.   */
  379.   List<Item_func_match> *ftfunc_list;
  380.   List<Item_func_match> ftfunc_list_alloc;
  381.   JOIN *join; /* after JOIN::prepare it is pointer to corresponding JOIN */
  382.   const char *type; /* type of select for EXPLAIN */
  383.   SQL_LIST order_list;                /* ORDER clause */
  384.   List<List_item>     expr_list;
  385.   List<List_item>     when_list;      /* WHEN clause (expression) */
  386.   SQL_LIST *gorder_list;
  387.   ha_rows select_limit, offset_limit; /* LIMIT clause parameters */
  388.   // Arrays of pointers to top elements of all_fields list
  389.   Item **ref_pointer_array;
  390.   /*
  391.     number of items in select_list and HAVING clause used to get number
  392.     bigger then can be number of entries that will be added to all item
  393.     list during split_sum_func
  394.   */
  395.   uint select_n_having_items;
  396.   uint cond_count;      /* number of arguments of and/or/xor in where/having */
  397.   enum_parsing_place parsing_place; /* where we are parsing expression */
  398.   bool with_sum_func;   /* sum function indicator */
  399.   ulong table_join_options;
  400.   uint in_sum_expr;
  401.   uint select_number; /* number of select (used for EXPLAIN) */
  402.   uint with_wild; /* item list contain '*' */
  403.   bool  braces;    /* SELECT ... UNION (SELECT ... ) <- this braces */
  404.   /* TRUE when having fix field called in processing of this SELECT */
  405.   bool having_fix_field;
  406.   /* explicit LIMIT clause was used */
  407.   bool explicit_limit;
  408.   /*
  409.     there are subquery in HAVING clause => we can't close tables before
  410.     query processing end even if we use temporary table
  411.   */
  412.   bool subquery_in_having;
  413.   /* 
  414.      SELECT for SELECT command st_select_lex. Used to privent scaning
  415.      item_list of non-SELECT st_select_lex (no sense find to finding
  416.      reference in it (all should be in tables, it is dangerouse due
  417.      to order of fix_fields calling for non-SELECTs commands (item list
  418.      can be not fix_fieldsd)). This value will be assigned for
  419.      primary select (sql_yac.yy) and for any subquery and
  420.      UNION SELECT (sql_parse.cc mysql_new_select())
  421.      INSERT for primary st_select_lex structure of simple INSERT/REPLACE
  422.      (used for name resolution, see Item_fiels & Item_ref fix_fields,
  423.      FALSE for INSERT/REPLACE ... SELECT, because it's
  424.      st_select_lex->table_list will be preprocessed (first table removed)
  425.      before passing to handle_select)
  426.      NOMATTER for other
  427.   */
  428.   enum {NOMATTER_MODE, SELECT_MODE, INSERT_MODE} resolve_mode;
  429.   void init_query();
  430.   void init_select();
  431.   st_select_lex_unit* master_unit();
  432.   st_select_lex_unit* first_inner_unit() 
  433.   { 
  434.     return (st_select_lex_unit*) slave; 
  435.   }
  436.   st_select_lex* outer_select();
  437.   st_select_lex* next_select() { return (st_select_lex*) next; }
  438.   st_select_lex* next_select_in_list() 
  439.   {
  440.     return (st_select_lex*) link_next;
  441.   }
  442.   st_select_lex_node** next_select_in_list_addr()
  443.   {
  444.     return &link_next;
  445.   }
  446.   st_select_lex* return_after_parsing()
  447.   {
  448.     return master_unit()->return_after_parsing();
  449.   }
  450.   void mark_as_dependent(st_select_lex *last);
  451.   bool set_braces(bool value);
  452.   bool inc_in_sum_expr();
  453.   uint get_in_sum_expr();
  454.   bool add_item_to_list(THD *thd, Item *item);
  455.   bool add_group_to_list(THD *thd, Item *item, bool asc);
  456.   bool add_ftfunc_to_list(Item_func_match *func);
  457.   bool add_order_to_list(THD *thd, Item *item, bool asc);
  458.   TABLE_LIST* add_table_to_list(THD *thd, Table_ident *table,
  459. LEX_STRING *alias,
  460. ulong table_options,
  461. thr_lock_type flags= TL_UNLOCK,
  462. List<String> *use_index= 0,
  463. List<String> *ignore_index= 0,
  464.                                 LEX_STRING *option= 0);
  465.   TABLE_LIST* get_table_list();
  466.   List<Item>* get_item_list();
  467.   List<String>* get_use_index();
  468.   List<String>* get_ignore_index();
  469.   ulong get_table_join_options();
  470.   void set_lock_for_tables(thr_lock_type lock_type);
  471.   inline void init_order()
  472.   {
  473.     order_list.elements= 0;
  474.     order_list.first= 0;
  475.     order_list.next= (byte**) &order_list.first;
  476.   }
  477.   
  478.   bool test_limit();
  479.   friend void lex_start(THD *thd, uchar *buf, uint length);
  480.   st_select_lex() {}
  481.   void make_empty_select()
  482.   {
  483.     init_query();
  484.     init_select();
  485.   }
  486.   bool setup_ref_array(THD *thd, uint order_group_num);
  487.   bool check_updateable(char *db, char *table);
  488.   bool check_updateable_in_subqueries(char *db, char *table);
  489.   void print(THD *thd, String *str);
  490.   static void print_order(String *str, ORDER *order);
  491.   void print_limit(THD *thd, String *str);
  492. };
  493. typedef class st_select_lex SELECT_LEX;
  494. #define ALTER_ADD_COLUMN 1
  495. #define ALTER_DROP_COLUMN 2
  496. #define ALTER_CHANGE_COLUMN 4
  497. #define ALTER_ADD_INDEX 8
  498. #define ALTER_DROP_INDEX 16
  499. #define ALTER_RENAME 32
  500. #define ALTER_ORDER 64
  501. #define ALTER_OPTIONS 128
  502. typedef struct st_alter_info
  503. {
  504.   List<Alter_drop>            drop_list;
  505.   List<Alter_column>          alter_list;
  506.   uint                        flags;
  507.   enum enum_enable_or_disable keys_onoff;
  508.   enum tablespace_op_type     tablespace_op;
  509.   bool                        is_simple;
  510.   st_alter_info(){clear();}
  511.   void clear(){keys_onoff= LEAVE_AS_IS;tablespace_op= NO_TABLESPACE_OP;}
  512.   void reset(){drop_list.empty();alter_list.empty();clear();}
  513. } ALTER_INFO;
  514. /* The state of the lex parsing. This is saved in the THD struct */
  515. typedef struct st_lex
  516. {
  517.   uint  yylineno,yytoklen; /* Simulate lex */
  518.   LEX_YYSTYPE yylval;
  519.   SELECT_LEX_UNIT unit;                         /* most upper unit */
  520.   SELECT_LEX select_lex;                        /* first SELECT_LEX */
  521.   /* current SELECT_LEX in parsing */
  522.   SELECT_LEX *current_select;
  523.   /* list of all SELECT_LEX */
  524.   SELECT_LEX *all_selects_list;
  525.   uchar *ptr,*tok_start,*tok_end,*end_of_query;
  526.   char *length,*dec,*change,*name;
  527.   char *help_arg;
  528.   char *backup_dir; /* For RESTORE/BACKUP */
  529.   char* to_log;                                 /* For PURGE MASTER LOGS TO */
  530.   time_t purge_time;                            /* For PURGE MASTER LOGS BEFORE */
  531.   char* x509_subject,*x509_issuer,*ssl_cipher;
  532.   char* found_colon;                            /* For multi queries - next query */
  533.   String *wild;
  534.   sql_exchange *exchange;
  535.   select_result *result;
  536.   Item *default_value, *on_update_value;
  537.   LEX_STRING *comment, name_and_length;
  538.   LEX_USER *grant_user;
  539.   gptr yacc_yyss,yacc_yyvs;
  540.   THD *thd;
  541.   CHARSET_INFO *charset;
  542.   List<key_part_spec> col_list;
  543.   List<key_part_spec> ref_list;
  544.   List<String>       interval_list;
  545.   List<LEX_USER>      users_list;
  546.   List<LEX_COLUMN>    columns;
  547.   List<Key>       key_list;
  548.   List<create_field>  create_list;
  549.   List<Item>       *insert_list,field_list,value_list,update_list;
  550.   List<List_item>     many_values;
  551.   List<set_var_base>  var_list;
  552.   List<Item_param>    param_list;
  553.   SQL_LIST       proc_list, auxilliary_table_list, save_list;
  554.   create_field       *last_field;
  555.   char       *savepoint_name; // Transaction savepoint id
  556.   udf_func udf;
  557.   HA_CHECK_OPT   check_opt; // check/repair options
  558.   HA_CREATE_INFO create_info;
  559.   LEX_MASTER_INFO mi; // used by CHANGE MASTER
  560.   USER_RESOURCES mqh;
  561.   ulong thread_id,type;
  562.   enum_sql_command sql_command;
  563.   thr_lock_type lock_option, multi_lock_option;
  564.   enum SSL_type ssl_type; /* defined in violite.h */
  565.   enum my_lex_states next_state;
  566.   enum enum_duplicates duplicates;
  567.   enum enum_tx_isolation tx_isolation;
  568.   enum enum_ha_read_modes ha_read_mode;
  569.   enum ha_rkey_function ha_rkey_mode;
  570.   enum enum_var_type option_type;
  571.   uint uint_geom_type;
  572.   uint grant, grant_tot_col, which_columns;
  573.   uint fk_delete_opt, fk_update_opt, fk_match_option;
  574.   uint slave_thd_opt, start_transaction_opt;
  575.   uint8 describe;
  576.   bool drop_if_exists, drop_temporary, local_file, one_shot_set;
  577.   bool in_comment, ignore_space, verbose, no_write_to_binlog;
  578.   bool derived_tables;
  579.   bool safe_to_cache_query;
  580.   bool subqueries, ignore;
  581.   ALTER_INFO alter_info;
  582.   /* Prepared statements SQL syntax:*/
  583.   LEX_STRING prepared_stmt_name; /* Statement name (in all queries) */
  584.   /* 
  585.     Prepared statement query text or name of variable that holds the
  586.     prepared statement (in PREPARE ... queries)
  587.   */
  588.   LEX_STRING prepared_stmt_code; 
  589.   /* If true, prepared_stmt_code is a name of variable that holds the query */
  590.   bool prepared_stmt_code_is_varref;
  591.   /* Names of user variables holding parameters (in EXECUTE) */
  592.   List<LEX_STRING> prepared_stmt_params; 
  593.   /*
  594.     If points to fake_time_zone_tables_list indicates that time zone
  595.     tables are implicitly used by statement, also is used for holding
  596.     list of those tables after they are opened.
  597.   */
  598.   TABLE_LIST *time_zone_tables_used;
  599.   st_lex();
  600.   inline void uncacheable(uint8 cause)
  601.   {
  602.     safe_to_cache_query= 0;
  603.     /*
  604.       There are no sense to mark select_lex and union fields of LEX,
  605.       but we should merk all subselects as uncacheable from current till
  606.       most upper
  607.     */
  608.     SELECT_LEX *sl;
  609.     SELECT_LEX_UNIT *un;
  610.     for (sl= current_select, un= sl->master_unit();
  611.  un != &unit;
  612.  sl= sl->outer_select(), un= sl->master_unit())
  613.     {
  614.       sl->uncacheable|= cause;
  615.       un->uncacheable|= cause;
  616.     }
  617.   }
  618.   TABLE_LIST *unlink_first_table(TABLE_LIST *tables,
  619.  TABLE_LIST **global_first,
  620.  TABLE_LIST **local_first);
  621.   TABLE_LIST *link_first_table_back(TABLE_LIST *tables,
  622.     TABLE_LIST *global_first,
  623.     TABLE_LIST *local_first);
  624. } LEX;
  625. extern TABLE_LIST fake_time_zone_tables_list;
  626. void lex_init(void);
  627. void lex_free(void);
  628. void lex_start(THD *thd, uchar *buf,uint length);
  629. void lex_end(LEX *lex);
  630. extern pthread_key(LEX*,THR_LEX);
  631. #define current_lex (current_thd->lex)