home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / sql / sql_select.h < prev    next >
C/C++ Source or Header  |  2000-10-14  |  8KB  |  292 lines
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  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.
  7.    
  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.
  12.    
  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 */
  16.  
  17.  
  18. /* classes to use when handling where clause */
  19.  
  20. #ifdef __GNUC__
  21. #pragma interface            /* gcc class implementation */
  22. #endif
  23.  
  24. #include "procedure.h"
  25. #include <myisam.h>
  26.  
  27. typedef struct keyuse_t {
  28.   TABLE *table;
  29.   Item    *val;                /* or value if no field */
  30.   uint    key,keypart;
  31.   table_map used_tables;
  32. } KEYUSE;
  33.  
  34. class store_key;
  35.  
  36. typedef struct st_table_ref
  37. {
  38.   bool        key_err;
  39.   uint          key_parts;                // num of ...
  40.   uint          key_length;               // length of key_buff
  41.   int           key;                      // key no
  42.   byte          *key_buff;                // value to look for with key
  43.   byte          *key_buff2;               // key_buff+key_length
  44.   store_key     **key_copy;               //
  45.   Item          **items;                  // val()'s for each keypart
  46.   table_map    depend_map;          // Table depends on these tables.
  47. } TABLE_REF;
  48.  
  49. /*
  50. ** CACHE_FIELD and JOIN_CACHE is used on full join to cache records in outer
  51. ** table
  52. */
  53.  
  54.  
  55. typedef struct st_cache_field {
  56.   char *str;
  57.   uint length,blob_length;
  58.   Field_blob *blob_field;
  59.   bool strip;
  60. } CACHE_FIELD;
  61.  
  62.  
  63. typedef struct st_join_cache {
  64.   uchar *buff,*pos,*end;
  65.   uint records,record_nr,ptr_record,fields,length,blobs;
  66.   CACHE_FIELD *field,**blob_ptr;
  67.   SQL_SELECT *select;
  68. } JOIN_CACHE;
  69.  
  70.  
  71. /*
  72. ** The structs which holds the join connections and join states
  73. */
  74.  
  75. enum join_type { JT_UNKNOWN,JT_SYSTEM,JT_CONST,JT_EQ_REF,JT_REF,JT_MAYBE_REF,
  76.          JT_ALL, JT_RANGE, JT_NEXT, JT_FT};
  77.  
  78. class JOIN;
  79.  
  80. typedef struct st_join_table {
  81.   TABLE        *table;
  82.   KEYUSE    *keyuse;            /* pointer to first used key */
  83.   SQL_SELECT    *select;
  84.   COND        *select_cond;
  85.   QUICK_SELECT    *quick;
  86.   Item        *on_expr;
  87.   const char    *info;
  88.   int        (*read_first_record)(struct st_join_table *tab);
  89.   int        (*next_select)(JOIN *,struct st_join_table *,bool);
  90.   READ_RECORD    read_record;
  91.   double    worst_seeks;
  92.   key_map    const_keys;            /* Keys with constant part */
  93.   key_map    checked_keys;            /* Keys checked in find_best */
  94.   key_map    needed_reg;
  95.   ha_rows    records,found_records,read_time;
  96.   table_map    dependent,key_dependent;
  97.   uint        keys;                /* all keys with can be used */
  98.   uint        use_quick,index;
  99.   uint        status;                // Save status for cache
  100.   uint        used_fields,used_fieldlength,used_blobs;
  101.   enum join_type type;
  102.   bool        cached_eq_ref_table,eq_ref_table,not_used_in_distinct;
  103.   TABLE_REF    ref;
  104.   JOIN_CACHE    cache;
  105. } JOIN_TAB;
  106.  
  107.  
  108. typedef struct st_position {            /* Used in find_best */
  109.   double records_read;
  110.   JOIN_TAB *table;
  111.   KEYUSE *key;
  112. } POSITION;
  113.  
  114.  
  115. /* Param to create temporary tables when doing SELECT:s */
  116.  
  117. class TMP_TABLE_PARAM {
  118.  public:
  119.   List<Item> copy_funcs;
  120.   Copy_field *copy_field;
  121.   byte        *group_buff;
  122.   Item_result_field **funcs;
  123.   MI_COLUMNDEF *recinfo,*start_recinfo;
  124.   KEY *keyinfo;
  125.   ha_rows end_write_records;
  126.   uint    copy_field_count,field_count,sum_func_count,func_count;
  127.   uint    group_parts,group_length;
  128.   uint    quick_group;
  129.  
  130.   TMP_TABLE_PARAM() :copy_field(0), group_parts(0), group_length(0) {}
  131.   ~TMP_TABLE_PARAM()
  132.   {
  133.     cleanup();
  134.   }
  135.   inline void cleanup(void)
  136.   {
  137.     delete [] copy_field;
  138.     copy_field=0;
  139.   }
  140. };
  141.  
  142.  
  143. class JOIN {
  144.  public:
  145.   JOIN_TAB *join_tab,**best_ref,**map2table;
  146.   TABLE    **table,**all_tables,*sort_by_table;
  147.   uint       tables,const_tables;
  148.   uint       send_group_parts;
  149.   bool       sort_and_group,first_record,full_join,group, no_field_update;
  150.   table_map const_table_map,outer_join;
  151.   ha_rows  send_records,found_records;
  152.   POSITION positions[MAX_TABLES+1],best_positions[MAX_TABLES+1];
  153.   double   best_read;
  154.   List<Item> *fields;
  155.   List<Item_buff> group_fields;
  156.   TABLE    *tmp_table;
  157.   THD       *thd;
  158.   Item_sum  **sum_funcs;
  159.   Procedure *procedure;
  160.   Item        *having;
  161.   uint        select_options;
  162.   select_result *result;
  163.   TMP_TABLE_PARAM tmp_table_param;
  164.   MYSQL_LOCK *lock;
  165. };
  166.  
  167.  
  168. typedef struct st_select_check {
  169.   uint const_ref,reg_ref;
  170. } SELECT_CHECK;
  171.  
  172. extern const char *join_type_str[];
  173. void TEST_join(JOIN *join);
  174.  
  175. /* Extern functions in sql_select.cc */
  176. bool store_val_in_field(Field *field,Item *val);
  177. TABLE *create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
  178.             ORDER *group, bool distinct, bool save_sum_fields,
  179.             bool allow_distinct_limit, uint select_options);
  180. void free_tmp_table(THD *thd, TABLE *entry);
  181. void count_field_types(TMP_TABLE_PARAM *param, List<Item> &fields);
  182. bool setup_copy_fields(TMP_TABLE_PARAM *param,List<Item> &fields);
  183. void copy_fields(TMP_TABLE_PARAM *param);
  184. void copy_funcs(Item_result_field **func_ptr);
  185. bool create_myisam_from_heap(TABLE *table, TMP_TABLE_PARAM *param, int error,
  186.                  bool ignore_last_dupp_error);
  187.  
  188. /* functions from opt_sum.cc */
  189. int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds);
  190.  
  191.  
  192. /* class to copying an field/item to a key struct */
  193.  
  194. class store_key :public Sql_alloc
  195. {
  196.  protected:
  197.   Field *to_field;                // Store data here
  198.   Field *key_field;                // Copy of key field
  199.   char *null_ptr;
  200.   char err;
  201.  public:
  202.   store_key(Field *field_arg, char *ptr, char *null, uint length)
  203.     :null_ptr(null),err(0)
  204.   {
  205.     if (field_arg->type() == FIELD_TYPE_BLOB)
  206.       to_field=new Field_varstring(ptr, length, (uchar*) null, 1, 
  207.                    Field::NONE, field_arg->field_name,
  208.                    field_arg->table, field_arg->binary());
  209.     else
  210.     {
  211.       to_field=field_arg->new_field(field_arg->table);
  212.       if (to_field)
  213.     to_field->move_field(ptr, (uchar*) null, 1);
  214.     }
  215.   }
  216.   virtual ~store_key() {}            /* Not actually needed */
  217.   virtual bool copy()=0;
  218.   virtual const char *name() const=0;
  219. };
  220.  
  221.  
  222. class store_key_field: public store_key
  223. {
  224.   Copy_field copy_field;
  225.   const char *field_name;
  226.  public:
  227.   store_key_field(Field *to_field_arg, char *ptr, char *null_ptr_arg,
  228.           uint length, Field *from_field, const char *name_arg)
  229.     :store_key(to_field_arg,ptr,
  230.            null_ptr_arg ? null_ptr_arg : from_field->maybe_null() ? &err
  231.            : NullS,length), field_name(name_arg)
  232.   {
  233.     if (to_field)
  234.     {
  235.       copy_field.set(to_field,from_field,0);
  236.     }
  237.   }
  238.  bool copy()
  239.  {
  240.    copy_field.do_copy(©_field);
  241.    return err != 0;
  242.  }
  243.  const char *name() const { return field_name; }
  244. };
  245.  
  246.  
  247. class store_key_item :public store_key
  248. {
  249.  protected:
  250.   Item *item;
  251. public:
  252.   store_key_item(Field *to_field_arg, char *ptr, char *null_ptr_arg,
  253.          uint length, Item *item_arg)
  254.     :store_key(to_field_arg,ptr,
  255.            null_ptr_arg ? null_ptr_arg : item_arg->maybe_null ?
  256.            &err : NullS, length), item(item_arg)
  257.   {}
  258.   bool copy()
  259.   {
  260.     item->save_in_field(to_field);
  261.     return err != 0;
  262.   }
  263.   const char *name() const { return "func"; }
  264. };
  265.  
  266.  
  267. class store_key_const_item :public store_key_item
  268. {
  269.   bool inited;
  270. public:
  271.   store_key_const_item(Field *to_field_arg, char *ptr,
  272.                char *null_ptr_arg, uint length,
  273.                Item *item_arg)
  274.     :store_key_item(to_field_arg,ptr,
  275.             null_ptr_arg ? null_ptr_arg : item_arg->maybe_null ?
  276.             &err : NullS, length, item_arg), inited(0)
  277.   {
  278.   }
  279.   bool copy()
  280.   {
  281.     if (!inited)
  282.     {
  283.       inited=1;
  284.       item->save_in_field(to_field);
  285.     }
  286.     return err != 0;
  287.   }
  288.   const char *name() const { return "const"; }
  289. };
  290.  
  291. bool cp_buffer_from_ref(TABLE_REF *ref);
  292.