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

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. /* classes to use when handling where clause */
  14. #ifdef USE_PRAGMA_INTERFACE
  15. #pragma interface /* gcc class implementation */
  16. #endif
  17. #include "procedure.h"
  18. #include <myisam.h>
  19. typedef struct keyuse_t {
  20.   TABLE *table;
  21.   Item *val; /* or value if no field */
  22.   table_map used_tables;
  23.   uint key, keypart, optimize;
  24.   key_part_map keypart_map;
  25.   ha_rows      ref_table_rows;
  26.   /* 
  27.     If true, the comparison this value was created from will not be
  28.     satisfied if val has NULL 'value'.
  29.   */
  30.   bool null_rejecting;
  31. } KEYUSE;
  32. class store_key;
  33. typedef struct st_table_ref
  34. {
  35.   bool key_err;
  36.   uint          key_parts;                // num of ...
  37.   uint          key_length;               // length of key_buff
  38.   int           key;                      // key no
  39.   byte          *key_buff;                // value to look for with key
  40.   byte          *key_buff2;               // key_buff+key_length
  41.   store_key     **key_copy;               //
  42.   Item          **items;                  // val()'s for each keypart
  43.   /*
  44.     (null_rejecting & (1<<i)) means the condition is '=' and no matching
  45.     rows will be produced if items[i] IS NULL (see add_not_null_conds())
  46.   */
  47.   key_part_map  null_rejecting;
  48.   table_map depend_map;   // Table depends on these tables.
  49.   byte          *null_ref_key;   // null byte position in the key_buf.
  50.      // used for REF_OR_NULL optimization.
  51. } TABLE_REF;
  52. /*
  53. ** CACHE_FIELD and JOIN_CACHE is used on full join to cache records in outer
  54. ** table
  55. */
  56. typedef struct st_cache_field {
  57.   char *str;
  58.   uint length,blob_length;
  59.   Field_blob *blob_field;
  60.   bool strip;
  61. } CACHE_FIELD;
  62. typedef struct st_join_cache {
  63.   uchar *buff,*pos,*end;
  64.   uint records,record_nr,ptr_record,fields,length,blobs;
  65.   CACHE_FIELD *field,**blob_ptr;
  66.   SQL_SELECT *select;
  67. } JOIN_CACHE;
  68. /*
  69. ** The structs which holds the join connections and join states
  70. */
  71. enum join_type { JT_UNKNOWN,JT_SYSTEM,JT_CONST,JT_EQ_REF,JT_REF,JT_MAYBE_REF,
  72.  JT_ALL, JT_RANGE, JT_NEXT, JT_FT, JT_REF_OR_NULL,
  73.  JT_UNIQUE_SUBQUERY, JT_INDEX_SUBQUERY};
  74. class JOIN;
  75. typedef struct st_join_table {
  76.   TABLE *table;
  77.   KEYUSE *keyuse; /* pointer to first used key */
  78.   SQL_SELECT *select;
  79.   COND *select_cond;
  80.   QUICK_SELECT *quick;
  81.   Item *on_expr;
  82.   const char *info;
  83.   int (*read_first_record)(struct st_join_table *tab);
  84.   int (*next_select)(JOIN *,struct st_join_table *,bool);
  85.   READ_RECORD read_record;
  86.   double worst_seeks;
  87.   key_map const_keys; /* Keys with constant part */
  88.   key_map checked_keys; /* Keys checked in find_best */
  89.   key_map needed_reg;
  90.   key_map       keys;                           /* all keys with can be used */
  91.   ha_rows records,found_records,read_time;
  92.   table_map dependent,key_dependent;
  93.   uint use_quick,index;
  94.   uint status; // Save status for cache
  95.   uint used_fields,used_fieldlength,used_blobs;
  96.   enum join_type type;
  97.   bool cached_eq_ref_table,eq_ref_table,not_used_in_distinct;
  98.   TABLE_REF ref;
  99.   JOIN_CACHE cache;
  100.   JOIN *join;
  101.   void cleanup();
  102. } JOIN_TAB;
  103. typedef struct st_position /* Used in find_best */
  104. {
  105.   double records_read;
  106.   JOIN_TAB *table;
  107.   KEYUSE *key;
  108. } POSITION;
  109. typedef struct st_rollup
  110. {
  111.   enum State { STATE_NONE, STATE_INITED, STATE_READY };
  112.   State state;
  113.   Item_null_result **null_items;
  114.   Item ***ref_pointer_arrays;
  115.   List<Item> *fields;
  116. } ROLLUP;
  117. class JOIN :public Sql_alloc
  118. {
  119.  public:
  120.   JOIN_TAB *join_tab,**best_ref,**map2table;
  121.   JOIN_TAB *join_tab_save; //saved join_tab for subquery reexecution
  122.   TABLE    **table,**all_tables,*sort_by_table;
  123.   uint    tables,const_tables;
  124.   uint    send_group_parts;
  125.   bool    sort_and_group,first_record,full_join,group, no_field_update;
  126.   bool    do_send_rows;
  127.   table_map const_table_map,found_const_table_map,outer_join;
  128.   ha_rows  send_records,found_records,examined_rows,row_limit, select_limit;
  129.   POSITION positions[MAX_TABLES+1],best_positions[MAX_TABLES+1];
  130.   double   best_read;
  131.   List<Item> *fields;
  132.   List<Item_buff> group_fields, group_fields_cache;
  133.   TABLE    *tmp_table;
  134.   // used to store 2 possible tmp table of SELECT
  135.   TABLE    *exec_tmp_table1, *exec_tmp_table2;
  136.   THD    *thd;
  137.   Item_sum  **sum_funcs, ***sum_funcs_end;
  138.   /* second copy of sumfuncs (for queries with 2 temporary tables */
  139.   Item_sum  **sum_funcs2, ***sum_funcs_end2;
  140.   Procedure *procedure;
  141.   Item     *having;
  142.   Item      *tmp_having; // To store having when processed temporary table
  143.   Item      *having_history; // Store having for explain
  144.   uint     select_options;
  145.   select_result *result;
  146.   TMP_TABLE_PARAM tmp_table_param;
  147.   MYSQL_LOCK *lock;
  148.   // unit structure (with global parameters) for this select
  149.   SELECT_LEX_UNIT *unit;
  150.   // select that processed
  151.   SELECT_LEX *select_lex;
  152.   
  153.   JOIN *tmp_join; // copy of this JOIN to be used with temporary tables
  154.   ROLLUP rollup; // Used with rollup
  155.   bool select_distinct; // Set if SELECT DISTINCT
  156.   /*
  157.     simple_xxxxx is set if ORDER/GROUP BY doesn't include any references
  158.     to other tables than the first non-constant table in the JOIN.
  159.     It's also set if ORDER/GROUP BY is empty.
  160.   */
  161.   bool simple_order, simple_group;
  162.   /*
  163.     Is set only in case if we have a GROUP BY clause
  164.     and no ORDER BY after constant elimination of 'order'.
  165.   */
  166.   bool no_order;
  167.   /* Is set if we have a GROUP BY and we have ORDER BY on a constant. */
  168.   bool          skip_sort_order;
  169.   bool need_tmp, hidden_group_fields, buffer_result;
  170.   DYNAMIC_ARRAY keyuse;
  171.   Item::cond_result cond_value;
  172.   List<Item> all_fields; // to store all fields that used in query
  173.   //Above list changed to use temporary table
  174.   List<Item> tmp_all_fields1, tmp_all_fields2, tmp_all_fields3;
  175.   //Part, shared with list above, emulate following list
  176.   List<Item> tmp_fields_list1, tmp_fields_list2, tmp_fields_list3;
  177.   List<Item> &fields_list; // hold field list passed to mysql_select
  178.   List<Item> procedure_fields_list;
  179.   int error;
  180.   ORDER *order, *group_list, *proc_param; //hold parameters of mysql_select
  181.   COND *conds;                            // ---"---
  182.   Item *conds_history;                    // store WHERE for explain
  183.   TABLE_LIST *tables_list;           //hold 'tables' parameter of mysql_selec
  184.   SQL_SELECT *select;                //created in optimisation phase
  185.   Item **ref_pointer_array; //used pointer reference for this select
  186.   // Copy of above to be used with different lists
  187.   Item **items0, **items1, **items2, **items3, **current_ref_pointer_array;
  188.   uint ref_pointer_array_size; // size of above in bytes
  189.   const char *zero_result_cause; // not 0 if exec must return zero result
  190.   
  191.   bool union_part; // this subselect is part of union 
  192.   bool optimized; // flag to avoid double optimization in EXPLAIN
  193.   JOIN(THD *thd_arg, List<Item> &fields_arg, ulong select_options_arg,
  194.        select_result *result_arg)
  195.     :fields_list(fields_arg)
  196.   {
  197.     init(thd_arg, fields_arg, select_options_arg, result_arg);
  198.   }
  199.   
  200.   void init(THD *thd_arg, List<Item> &fields_arg, ulong select_options_arg,
  201.        select_result *result_arg)
  202.   {
  203.     join_tab= join_tab_save= 0;
  204.     table= 0;
  205.     tables= 0;
  206.     const_tables= 0;
  207.     sort_and_group= 0;
  208.     first_record= 0;
  209.     do_send_rows= 1;
  210.     send_records= 0;
  211.     found_records= 0;
  212.     examined_rows= 0;
  213.     exec_tmp_table1= 0;
  214.     exec_tmp_table2= 0;
  215.     thd= thd_arg;
  216.     sum_funcs= sum_funcs2= 0;
  217.     procedure= 0;
  218.     having= tmp_having= having_history= 0;
  219.     select_options= select_options_arg;
  220.     result= result_arg;
  221.     lock= thd_arg->lock;
  222.     select_lex= 0; //for safety
  223.     tmp_join= 0;
  224.     select_distinct= test(select_options & SELECT_DISTINCT);
  225.     no_order= 0;
  226.     simple_order= 0;
  227.     simple_group= 0;
  228.     skip_sort_order= 0;
  229.     need_tmp= 0;
  230.     hidden_group_fields= 0; /*safety*/
  231.     buffer_result= test(select_options & OPTION_BUFFER_RESULT) &&
  232.       !test(select_options & OPTION_FOUND_ROWS);
  233.     all_fields= fields_arg;
  234.     fields_list= fields_arg;
  235.     error= 0;
  236.     select= 0;
  237.     ref_pointer_array= items0= items1= items2= items3= 0;
  238.     ref_pointer_array_size= 0;
  239.     zero_result_cause= 0;
  240.     optimized= 0;
  241.     fields_list= fields_arg;
  242.     bzero((char*) &keyuse,sizeof(keyuse));
  243.     tmp_table_param.copy_field=0;
  244.     tmp_table_param.end_write_records= HA_POS_ERROR;
  245.     rollup.state= ROLLUP::STATE_NONE;
  246.   }
  247.   int prepare(Item ***rref_pointer_array, TABLE_LIST *tables, uint wind_num,
  248.       COND *conds, uint og_num, ORDER *order, ORDER *group,
  249.       Item *having, ORDER *proc_param, SELECT_LEX *select,
  250.       SELECT_LEX_UNIT *unit);
  251.   int optimize();
  252.   int reinit();
  253.   void exec();
  254.   int cleanup();
  255.   void restore_tmp();
  256.   bool alloc_func_list();
  257.   bool make_sum_func_list(List<Item> &all_fields, List<Item> &send_fields,
  258.   bool before_group_by);
  259.   inline void set_items_ref_array(Item **ptr)
  260.   {
  261.     memcpy((char*) ref_pointer_array, (char*) ptr, ref_pointer_array_size);
  262.     current_ref_pointer_array= ptr;
  263.   }
  264.   inline void init_items_ref_array()
  265.   {
  266.     items0= ref_pointer_array + all_fields.elements;
  267.     memcpy(items0, ref_pointer_array, ref_pointer_array_size);
  268.     current_ref_pointer_array= items0;
  269.   }
  270.   bool rollup_init();
  271.   bool rollup_make_fields(List<Item> &all_fields, List<Item> &fields,
  272.   Item_sum ***func);
  273.   int rollup_send_data(uint idx);
  274.   int rollup_write_data(uint idx, TABLE *table);
  275.   bool test_in_subselect(Item **where);
  276.   void join_free(bool full);
  277.   void clear();
  278.   bool save_join_tab();
  279.   bool send_row_on_empty_set()
  280.   {
  281.     return (do_send_rows && tmp_table_param.sum_func_count != 0 &&
  282.     !group_list);
  283.   }
  284.   int change_result(select_result *result);
  285. };
  286. typedef struct st_select_check {
  287.   uint const_ref,reg_ref;
  288. } SELECT_CHECK;
  289. extern const char *join_type_str[];
  290. void TEST_join(JOIN *join);
  291. /* Extern functions in sql_select.cc */
  292. bool store_val_in_field(Field *field,Item *val);
  293. TABLE *create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
  294. ORDER *group, bool distinct, bool save_sum_fields,
  295. ulong select_options, ha_rows rows_limit,
  296. char* alias);
  297. void free_tmp_table(THD *thd, TABLE *entry);
  298. void count_field_types(TMP_TABLE_PARAM *param, List<Item> &fields,
  299.        bool reset_with_sum_func);
  300. bool setup_copy_fields(THD *thd, TMP_TABLE_PARAM *param,
  301.        Item **ref_pointer_array,
  302.        List<Item> &new_list1, List<Item> &new_list2,
  303.        uint elements, List<Item> &fields);
  304. void copy_fields(TMP_TABLE_PARAM *param);
  305. void copy_funcs(Item **func_ptr);
  306. bool create_myisam_from_heap(THD *thd, TABLE *table, TMP_TABLE_PARAM *param,
  307.      int error, bool ignore_last_dupp_error);
  308. /* functions from opt_sum.cc */
  309. int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds);
  310. /* class to copying an field/item to a key struct */
  311. class store_key :public Sql_alloc
  312. {
  313.  protected:
  314.   Field *to_field; // Store data here
  315.   char *null_ptr;
  316.   char err;
  317.  public:
  318.   enum store_key_result { STORE_KEY_OK, STORE_KEY_FATAL, STORE_KEY_CONV };
  319.   store_key(THD *thd, Field *field_arg, char *ptr, char *null, uint length)
  320.     :null_ptr(null),err(0)
  321.   {
  322.     if (field_arg->type() == FIELD_TYPE_BLOB)
  323.       to_field=new Field_varstring(ptr, length, (uchar*) null, 1, 
  324.    Field::NONE, field_arg->field_name,
  325.    field_arg->table, field_arg->charset());
  326.     else
  327.     {
  328.       to_field=field_arg->new_field(thd->mem_root,field_arg->table);
  329.       if (to_field)
  330. to_field->move_field(ptr, (uchar*) null, 1);
  331.     }
  332.   }
  333.   virtual ~store_key() {} /* Not actually needed */
  334.   virtual enum store_key_result copy()=0;
  335.   virtual const char *name() const=0;
  336. };
  337. class store_key_field: public store_key
  338. {
  339.   Copy_field copy_field;
  340.   const char *field_name;
  341.  public:
  342.   store_key_field(THD *thd, Field *to_field_arg, char *ptr, char *null_ptr_arg,
  343.   uint length, Field *from_field, const char *name_arg)
  344.     :store_key(thd, to_field_arg,ptr,
  345.        null_ptr_arg ? null_ptr_arg : from_field->maybe_null() ? &err
  346.        : NullS,length), field_name(name_arg)
  347.   {
  348.     if (to_field)
  349.     {
  350.       copy_field.set(to_field,from_field,0);
  351.     }
  352.   }
  353.   enum store_key_result copy()
  354.   {
  355.     copy_field.do_copy(&copy_field);
  356.     return err != 0 ? STORE_KEY_FATAL : STORE_KEY_OK;
  357.   }
  358.   const char *name() const { return field_name; }
  359. };
  360. class store_key_item :public store_key
  361. {
  362.  protected:
  363.   Item *item;
  364. public:
  365.   store_key_item(THD *thd, Field *to_field_arg, char *ptr, char *null_ptr_arg,
  366.  uint length, Item *item_arg)
  367.     :store_key(thd, to_field_arg,ptr,
  368.        null_ptr_arg ? null_ptr_arg : item_arg->maybe_null ?
  369.        &err : NullS, length), item(item_arg)
  370.   {}
  371.   enum store_key_result copy()
  372.   {
  373.     int res= item->save_in_field(to_field, 1);
  374.     return (err != 0 || res > 2 ? STORE_KEY_FATAL : (store_key_result) res); 
  375.                  
  376.   }
  377.   const char *name() const { return "func"; }
  378. };
  379. class store_key_const_item :public store_key_item
  380. {
  381.   bool inited;
  382. public:
  383.   store_key_const_item(THD *thd, Field *to_field_arg, char *ptr,
  384.        char *null_ptr_arg, uint length,
  385.        Item *item_arg)
  386.     :store_key_item(thd, to_field_arg,ptr,
  387.     null_ptr_arg ? null_ptr_arg : item_arg->maybe_null ?
  388.     &err : NullS, length, item_arg), inited(0)
  389.   {
  390.   }
  391.   enum store_key_result copy()
  392.   {
  393.     int res;
  394.     if (!inited)
  395.     {
  396.       inited=1;
  397.       if ((res= item->save_in_field(to_field, 1)))
  398.       {       
  399.         if (!err)
  400.           err= res;
  401.       }
  402.     }
  403.     return (err > 2 ?  STORE_KEY_FATAL : (store_key_result) err);
  404.   }
  405.   const char *name() const { return "const"; }
  406. };
  407. bool cp_buffer_from_ref(THD *thd, TABLE_REF *ref);
  408. bool error_if_full_join(JOIN *join);
  409. int report_error(TABLE *table, int error);
  410. int safe_index_read(JOIN_TAB *tab);
  411. COND *remove_eq_conds(THD *thd, COND *cond, Item::cond_result *cond_value);