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

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. #ifndef _opt_range_h
  15. #define _opt_range_h
  16. #ifdef USE_PRAGMA_INTERFACE
  17. #pragma interface /* gcc class implementation */
  18. #endif
  19. #define NO_MIN_RANGE 1
  20. #define NO_MAX_RANGE 2
  21. #define NEAR_MIN 4
  22. #define NEAR_MAX 8
  23. #define UNIQUE_RANGE 16
  24. #define EQ_RANGE 32
  25. #define NULL_RANGE 64
  26. #define GEOM_FLAG      128
  27. typedef struct st_key_part {
  28.   uint16           key,part, store_length, length;
  29.   uint8            null_bit;
  30.   Field            *field;
  31.   Field::imagetype image_type;
  32. } KEY_PART;
  33. class QUICK_RANGE :public Sql_alloc {
  34.  public:
  35.   char *min_key,*max_key;
  36.   uint16 min_length,max_length,flag;
  37. #ifdef HAVE_purify
  38.   uint16 dummy; /* Avoid warnings on 'flag' */
  39. #endif
  40.   QUICK_RANGE(); /* Full range */
  41.   QUICK_RANGE(const char *min_key_arg,uint min_length_arg,
  42.       const char *max_key_arg,uint max_length_arg,
  43.       uint flag_arg)
  44.     : min_key((char*) sql_memdup(min_key_arg,min_length_arg+1)),
  45.       max_key((char*) sql_memdup(max_key_arg,max_length_arg+1)),
  46.       min_length((uint16) min_length_arg),
  47.       max_length((uint16) max_length_arg),
  48.       flag((uint16) flag_arg)
  49.     {
  50. #ifdef HAVE_purify
  51.       dummy=0;
  52. #endif
  53.     }
  54. };
  55. class QUICK_SELECT {
  56. public:
  57.   bool next,dont_free,sorted;
  58.   int error;
  59.   uint index, max_used_key_length, used_key_parts;
  60.   TABLE *head;
  61.   handler *file;
  62.   byte    *record;
  63.   List<QUICK_RANGE> ranges;
  64.   List_iterator<QUICK_RANGE> it;
  65.   QUICK_RANGE *range;
  66.   MEM_ROOT alloc;
  67.   KEY_PART *key_parts;
  68.   KEY_PART_INFO *key_part_info;
  69.   ha_rows records;
  70.   double read_time;
  71.   QUICK_SELECT(THD *thd, TABLE *table,uint index_arg,bool no_alloc=0);
  72.   virtual ~QUICK_SELECT();
  73.   void reset(void) { next=0; it.rewind(); }
  74.   int init()
  75.   {
  76.     key_part_info= head->key_info[index].key_part;
  77.     return error=file->ha_index_init(index);
  78.   }
  79.   virtual int get_next();
  80.   virtual bool reverse_sorted() { return 0; }
  81.   bool unique_key_range();
  82. };
  83. class QUICK_SELECT_GEOM: public QUICK_SELECT
  84. {
  85. public:
  86.   QUICK_SELECT_GEOM(THD *thd, TABLE *table, uint index_arg, bool no_alloc)
  87.     :QUICK_SELECT(thd, table, index_arg, no_alloc)
  88.     {};
  89.   virtual int get_next();
  90. };
  91. class QUICK_SELECT_DESC: public QUICK_SELECT
  92. {
  93. public:
  94.   QUICK_SELECT_DESC(QUICK_SELECT *q, uint used_key_parts);
  95.   int get_next();
  96.   bool reverse_sorted() { return 1; }
  97. private:
  98.   int cmp_prev(QUICK_RANGE *range);
  99.   bool range_reads_after_key(QUICK_RANGE *range);
  100. #ifdef NOT_USED
  101.   bool test_if_null_range(QUICK_RANGE *range, uint used_key_parts);
  102. #endif
  103.   void reset(void) { next=0; rev_it.rewind(); }
  104.   List<QUICK_RANGE> rev_ranges;
  105.   List_iterator<QUICK_RANGE> rev_it;
  106. };
  107. class SQL_SELECT :public Sql_alloc {
  108.  public:
  109.   QUICK_SELECT *quick; // If quick-select used
  110.   COND *cond; // where condition
  111.   TABLE *head;
  112.   IO_CACHE file; // Positions to used records
  113.   ha_rows records; // Records in use if read from file
  114.   double read_time; // Time to read rows
  115.   key_map quick_keys; // Possible quick keys
  116.   key_map needed_reg; // Possible quick keys after prev tables.
  117.   table_map const_tables,read_tables;
  118.   bool free_cond;
  119.   SQL_SELECT();
  120.   ~SQL_SELECT();
  121.   void cleanup();
  122.   bool check_quick(THD *thd, bool force_quick_range, ha_rows limit)
  123.   {
  124.     key_map tmp;
  125.     tmp.set_all();
  126.     return test_quick_select(thd, tmp, 0, limit, force_quick_range) < 0;
  127.   }
  128.   inline bool skip_record() { return cond ? cond->val_int() == 0 : 0; }
  129.   int test_quick_select(THD *thd, key_map keys, table_map prev_tables,
  130. ha_rows limit, bool force_quick_range);
  131. };
  132. class FT_SELECT: public QUICK_SELECT {
  133. public:
  134.   FT_SELECT(THD *thd, TABLE *table, uint key):
  135.     QUICK_SELECT (thd, table, key, 1) { init(); }
  136.   ~FT_SELECT() { file->ft_end(); }
  137.   int init() { return error= file->ft_init(); }
  138.   int get_next() { return error= file->ft_read(record); }
  139. };
  140. QUICK_SELECT *get_quick_select_for_ref(THD *thd, TABLE *table,
  141.        struct st_table_ref *ref);
  142. uint get_index_for_order(TABLE *table, ORDER *order, ha_rows limit);
  143. #endif